Entregable U2
Entregable U2
Entregable U2
Objetivo:
● Modelar clases con UML y generar código Java con la estructura básica del proyecto.
● Crear y utilizar constructores y sobrecarga de constructores
● Utilizar la palabra reservada this();, para invocar constructores dentro de otro constructor de la
misma clase
● Utilizar métodos get, set, toString y otros métodos asociados al dominio del problema.
● Crear objetos y demostrar el uso de las clases creadas.
1. Considere el escenario de una empresa que puede optar por contratar personal mediante tres casos
posibles:
a. El empleado es contratado y se conocen todos sus datos completos: apellido1, apellido2,
nombres, código, puesto.
b. Se genera el empleado únicamente con los datos básicos del puesto, dado que está pendiente la
asignación a una vacante a un trabajador en específico, por lo tanto se tiene definido el código y el
puesto, el resto de los datos no están definidos.
c. Se generan empleados para actividades temporales, para este tercer caso únicamente se
requiere los datos relativos al nombre: apellido1, apellido2, nombres
nombre la clase
imagen de la clase
Empleado.java
package Uno;
this.apellido2="No definido";
this.nombres="No definido";
this.codigo=codigo;
this.puesto=puesto;
}
// Constructor para Empleado temporal
public Empleado(String apellido1, String apellido2, String nombres){
this.apellido1=apellido1;
this.apellido2=apellido2;
this.nombres=nombres;
this.codigo=0;
this.puesto="No definido";
}
//Metodo getter y metodos setter
//toString
@Override
public String toString() {
Nombre: Díaz Medina Omar Alberto
System.out.println(emp1.toString());
System.out.println(emp2.toString());
System.out.println(emp3.toString());
}
}
MainEmpleado.java
package Uno;
public class MainEmpleado {
public static void main(String[] args) {
System.out.println(x.toString());
System.out.println(y.toString());
System.out.println(z.toString());
}
2. Desarrolle un programa que contemple la clase Estudiante, con los siguientes atributos: apellido1,
apellido2, nombres, domicilio, edad, y cel. Considere los siguientes aspectos.
a. En la mayoría de los casos se conocen todos los datos del Estudiante.
b. En algunos casos el estudiante no cuenta domicilio y omite dicho datos.
c. En casos menores el estudiante no proporciona el domicilio y el número de celular.
nombre la clase
imagen de la clase
Estudiante
package Dos;
Nombre: Díaz Medina Omar Alberto
//Contructor default
public Estudiante(){
this("Por definir", "Por definir", "Por definir", "Por definir", -1 , "Por
definir");
}
//Constructor completo
public Estudiante(String apellido1, String apellido2, String names, String
domicilio, int age, String cel){
this(apellido1, apellido2, names, age, cel);
this.domicilio = "Por definir";
}
@Override
public String toString() {
return "APELLIDO 1 : " + this.apellido1 + "\n" +
"APELLIDO 2 : " + this.apellido2 + "\n" +
"NOMBRE (S) : "+ this.nombres + "\n" +
"DOMICILIO : " + this.domicilio + "\n" +
"EDAD : " + this.age + "\n" +
"CELULAR : " + this.cel + "\n" ;
}
MainEstudiante.java
package Dos;
System.out.println(x.toString());
System.out.println(y.toString());
System.out.println(z.toString());
}
Nombre: Díaz Medina Omar Alberto
3. Un taller mecánico atiende diversos tipos de clientes por fallas mecánicas o de carrocería
a. Para clientes particulares requiere registrar datos relativos a; apellido1, apellido2, nombres, cel,
mail, rfc;
b. Para clientes empresariales requiere únicamente rfc y mail;
c. Existe un tercer tipo de cliente atendidos en la zona de servicio express (para servicios menores),
de quienes únicamente se requieren:apellido1, apellido2, nombres.
Nombre: Díaz Medina Omar Alberto
nombre la clase
imagen de la clase
Taller.java
package Tres;
//Empresariales
private String mail;
private String rfc;
//Express
//apellido 1, 2 y nombres
private String nombres;
//Default
Taller(){
this("Sin definir", "Sin definir", 0,
"Sin definir", "Sin definir", "Sin definir");
}
//Completo
Taller(String apellido1, String apellido2, int cel, String mail, String rfc,
String nombres){
//Empresariales
Taller(String mail, String rfc){
this.apellido1="Sin definir";
this.apellido2="Sin definir";
this.cel=0;
this.nombres="Sin definir";
this.mail=mail;
this.rfc=rfc;
}
//Express
Taller(String apellido1, String apellido2, int cel) {
this.apellido1=apellido1;
Nombre: Díaz Medina Omar Alberto
this.apellido2=apellido2;
this.cel=cel;
}
//Getters y Setters
public String getApellido1(){
return this.apellido1;
}
//toString
@Override
public String toString(){
StringBuilder x= new StringBuilder("<--Taller AutoFix-->\n")
.append("Apellido1:"+this.apellido1).append("\nApellido2: "+this.apellido2)
.append("\nNombre (S): "+this.nombres).append("\nCelular: "+this.cel)
.append("\nMail: "+this.mail).append("\nRFC: "+this.rfc);
Nombre: Díaz Medina Omar Alberto
return x.toString();
}
MainTaller.java
package Tres;
x.asignNS();
System.out.println("Servicio "+x.retNS()+"\n"+(x.toString()));
y.asignNS();
System.out.println("\nServicio "+y.retNS()+"\n"+(y.toString()));
z.asignNS();
System.out.println("\nServicio "+z.retNS()+"\n"+(z.toString()));
}
}
● Modelar clases con UML y generar código Java con la estructura básica del proyecto.
● Uso de constructores
● Crear y utilizar miembros estáticos de clase (atributos y métodos estáticos)
● Crear objetos y demostrar el uso de las clases creadas.
4. Un taller mecánico atiende diversos tipos de clientes por fallas mecánicas o de carrocería
a. Para clientes particulares requiere registrar datos relativos a; apellido1, apellido2, nombres, cel,
mail, rfc;
b. Para clientes empresariales requiere únicamente rfc y mail;
c. Existe un tercer tipo de cliente atendidos en la zona de servicio express (para servicios menores),
de quienes únicamente se requieren:apellido1, apellido2, nombres.
d. Cada servicio tiene un costo, el administrador requiere saber la cantidad de servicios realizados y
el costo total (acumulado) generado por los servicios realizados.
nombre la clase
imagen de la clase
TallerSP.java
package Cuatro;
Nombre: Díaz Medina Omar Alberto
TallerSP.cantidadServicios=TallerSP.cantidadServicios+1;
TallerSP.costoTotal=TallerSP.costoTotal+costo;
}
@Override
public String toString() {
StringBuilder datos = new StringBuilder("<-- DATOS DEL CLIENTE -->\n");
datos.append("APELLIDO PATERNO: ").append(this.apellido1).append("\n");
datos.append("APELLIDO MATERNO: ").append(this.apellido2).append("\n");
datos.append("NOMBRE(S): ").append(this.nombres).append("\n");
datos.append("CELULAR: ").append(this.celular).append("\n");
datos.append("MAIL: ").append(this.mail).append("\n");
datos.append("RFC: ").append(this.rfc).append("\n");
datos.append("COSTO: ").append(this.costo).append("\n");
return datos.toString();
}
}
MainTallerSP.java
package Cuatro;
5. Una empresa turística ha instalado máquinas expendedoras de boletos para transporte público recreativo
en diversas zonas de la ciudad. Cada máquina cuenta con un id (consecutivo de número de boleto), una
ubicación (dirección), el costo del boleto es de 20 pesos. La empresa requiere que se contabilice cada
boleto vendido y además poder obtener el total en pesos de los boletos vendidos. Cada boleto vendido
debe tener el siguiente formato. e indicar el id del boleto.
TRANSPORTES TORTUGA
BOLETO No: +id
.--------------------------|
/| _ .---. .---. .---. .---.|
|j||||___| |___| |___| |___||
|=|||=======================|
[_|j||(O)|__________|(O)|___]
nombre la clase
imagen de la clase
Boleto.java
package Cinco;
/*5
* Una empresa turística ha instalado máquinas expendedoras de
* boletos para transporte público recreativo en diversas zonas
* de la ciudad. Cada máquina cuenta con un id
* (consecutivo de número de boleto), una ubicación (dirección),
* el costo del boleto es de 20 pesos.
* La empresa requiere que se contabilice cada boleto vendido
* y además poder obtener el total en pesos de los boletos
* vendidos. Cada boleto vendido debe tener el siguiente formato.
* e indicar el id del boleto.
*/
public class Boleto {
private int id;
private String ubicacion;
this.ubicacion=ubicacion;
}
//Get
public int obtenerId(){
return id;
}
MainBoleto.java
package Cinco;
boletox.showBoletos();
boletox.showBoletos();
6. Desarrolle una clase que resuelva una ecuación de segundo grado utilizando la fórmula general de las
cuadráticas. De solución al caso utilizando el constructor. Considere un método para determinar el
discriminante e indique los tipos de raíces con que cuenta la ecuación.
Nombre: Díaz Medina Omar Alberto
nombre la clase
imagen de la clase
Formula.java
package Seis;
calDiscriminante();
if (this.discriminante == 0) {
// Raíz real repetida
calcularUnaRaiz();
}
if (this.discriminante > 0) {
// Dos raices reales
calcularDosRaices();
}
if (this.discriminante < 0) {
// La ecuacion no tiene solucion en numeros reales
this.resultado = "<-- LA ECUACION NO TIENE RESULTADO EN NUMERO REAL --
>";
}
showResultado();
Nombre: Díaz Medina Omar Alberto
MainFormula.java
package Seis;
x.showResultado();
y.showResultado();
z.showResultado();
}
}
7. Desarrolle una clase que resuelva una ecuación de segundo grado utilizando la fórmula general de las
cuadráticas. Considere únicamente métodos estáticos y miembros de clase estáticos. Considere un
método para determinar el discriminante e indique los tipos de raíces con que cuenta la ecuación.
Considere métodos estáticos adicionales para la resolución de la fórmula.
Nombre: Díaz Medina Omar Alberto
nombre la clase
imagen de la clase
Cuadratica.java
package Siete;
if(Cuadratica.discriminante>0){
//Dos raices
Cuadratica.calcDosRaices();
}
if(Cuadratica.discriminante==0){
//Raices repetidas
Cuadratica.calcUnaRaiz();
}
if(Cuadratica.discriminante<0){
//No tiene solucion en R
Cuadratica.resultado="La ecuacion no tiene solucion en los numeros
reales";
}
Cuadratica.showResultado();
Cuadratica.discriminante=(Cuadratica.b*Cuadratica.b)-
(4*Cuadratica.a*Cuadratica.c);
}
MainCuadratica.java
package Siete;
public class MainCuadratica {
public static void main(String[] args) {
Cuadratica.calcCuadratica(1,-2,-24);
}
}
● Modelar clases con UML y generar código Java con la estructura básica del proyecto.
● Uso de constructores
● Sobrecarga de métodos
● Crear objetos y demostrar el uso de las clases creadas.
8. Una empresa editorial de publicaciones en versiones en físico de lujo, maneja la producción de libros y
revistas. De cada producto (libro o revista) cuenta con un id, titulo, costo y autor. La empresa editorial
debe enviar productos tanto en el ámbito, local, nacional yl extranjero. Para el envío debe generarse una
etiqueta del producto indicando lo siguiente:
a. Cantidad y detalles del producto enviado, así como calle, número y cp para envíos locales.
b. Cantidad y detalles del producto enviado, así como calle, número, cp, ciudad y estado, para envíos
en el ámbito nacional.
Nombre: Díaz Medina Omar Alberto
c. Cantidad y detalles del producto enviado, así como calle, número, cp, país, ciudad y estado para
envíos en el ámbito internacional.
nombre la clase
imagen de la clase
Editorial.java
package Ocho;
//Locales
private String calle;
private int n;
private String cp;
//Nacional
private String ciudad;
private String estado;
//Internacional
private String pais;
public String getLocal(int id, String titulo, int costo, String nacional, String
foreign, String calle, int n, String cp){
this.id=id;
this.titulo=titulo;
this.costo=costo;
this.nacional=nacional;
this.foreign=foreign;
this.calle=calle;
this.n=n;
this.cp=cp;
public String getNacional(int id, String titulo, int costo, String nacional,
Nombre: Díaz Medina Omar Alberto
//definir
this.id=id;
this.titulo=titulo;
this.costo=costo;
this.nacional=nacional;
this.foreign=foreign;
this.calle=calle;
this.n=n;
this.cp=cp;
this.ciudad=ciudad;
this.estado=estado;
this.pais=pais;
//StringBuilder
StringBuilder z= new StringBuilder("<- Internacional->\n")
.append("Id: "+this.id).append("\n")
.append("Título: "+this.titulo).append("\n")
.append("Costo: "+this.costo).append("\n")
.append("Nacional: "+this.nacional).append("\n")
.append("Extranjero: "+this.foreign).append("\n")
.append("Calle: "+this.calle).append("\n")
.append("Número: "+this.n).append("\n")
.append("Código Postal: "+this.cp).append("\n")
.append("Ciudad: "+this.ciudad).append("\n")
.append("Estado: "+this.estado).append("\n")
.append("País: "+this.pais).append("\n")
;
Nombre: Díaz Medina Omar Alberto
return z.toString();
}
public static void main(String[] args) {
String data= new Editorial().getLocal(143, "Don quijote de la Mancha", 800,
"NO",
"Sí", "INSURGENTES", 3, "63000");
System.out.println(data+"\n"+datax+"\n"+dataz);
}
}
MainEditoria.java
package Ocho;
System.out.println(data+"\n"+datax+"\n"+dataz);
}
}
9. Un almacén de un supermercado recibe una amplia gama de productos que debe trasladar
inmediatamente a las diversas zonas de ventas. Todos los productos que recibe se cuentan con id,
nombre, descripción y precio de venta. Para cada producto recibido debe generar una orden de salida
para que los responsables de cada departamento pasen por su mercancía y la pongan en su área de
venta. De forma general las órdenes de salida de almacén indican lo siguiente:
a. Detalles del producto, cantidad, fecha de venta y fecha de retiro del área de venta, para el caso
de productos perecederos.
b. Detalles del producto, cantidad y fecha de venta para productos no-perecederos.
c. Detalles del producto, y cantidad para productos de alta demanda y no perecederos
Nombre: Díaz Medina Omar Alberto
nombre la clase
imagen de la clase
Productos.java
package Nueve;
return x;
//Detalles
public String getProductos(String id, String nombre, String descripcion, int
precio) {
this.id = id;
this.nombre = nombre;
this.descripcion = descripcion;
this.precio = precio;
return x.toString();
}
this.descripcion = descripcion;
this.precio = precio;
this.cantidad = cantidad;
this.fechaVenta = fechaVenta;
this.fechaRetiro = fechaRetiro;
return this.getDatos("PERECEDEROS").toString();
}
this.cantidad = cantidad;
this.fechaVenta = fechaVenta;
MainProductos.java
package Nueve;
//PERECEDEROS
String maiz = new Productos().getProductos("3443","MAÍZ", "TOSTADO", 60,
4, "23/06/2008", "20/08/2009");
//NO PERECEDEROS
String leche = new Productos().getProductos("443de4", "LECHE", "LECHE
PASTEURIZADA", 35, 5, "01/02/2011");
//ALTA DEMANDA
String huevos = new Productos().getProductos("dfr456", "HUEVOS BLANCOS
(CARTERA) ", "DE GRANJA", 60);
System.out.println(maiz);
Nombre: Díaz Medina Omar Alberto
System.out.println(leche);
System.out.println(huevos);
}
}
10. Desarrolle una clase con métodos estáticos y métodos sobrecargados que permitan: sumar: 2, 3 y 4
números pasados como parámetros. Multiplicar 2, 3 y 4 números pasados como parámetros.
nombre la clase
imagen de la clase
Numeros.java
package Diez;
//cont
public static int getSumaCont() {
return contador;
}
// Suma
public static int sumarNumeros(int a, int b) {
//public static double res;
//Numeros.res = a+b;
//return Numeros.res;
contador++;
return a + b;
}
contador++;
return a + b + c;
}
// Multiplicar
public static int multiplicarNumeros(int a, int b) {
multiplicacionContador++;
return a * b;
}
MainNumeros.java
package Diez;
}
}
● Modelar clases con UML y generar código Java con la estructura básica del proyecto.
● Uso de constructores
● Paso de objetos como parámetros, en constructores y métodos.
Nombre: Díaz Medina Omar Alberto
c. Demuestre el uso de las clases anteriores en una tercera clase que contenga el método main()
nombre la clase
imagen de la clase
Punto.java
private double x;
private double y;
this.x=x;
this.y=y;
@Override
public String toString(){
.append("X= "+this.x).append("\n")
.append("Y= "+this.y).append("\n");
return x.toString();
}
public static void main(String[] args) {
}
}
PuntoDistancia.java
package Once;
public class PuntoDistancia {
//a(x1, y1)^2
//b(x2, y2)^2
this.a=a;
this.b=b;
//Notación punto
this.ans=Math.sqrt((Math.pow(this.b.getX()-this.a.getX(), 2))+
(Math.pow(b.getY()-a.getY()+b.getY()-a.getY(), 2)));
@Override
public String toString(){
StringBuilder x= new StringBuilder("Distancia entre 2 puntos ")
//Con las referencias del mismo tipo ya hechas ya nos permite usar el
toString()
.append(this.a.toString()).append("\n")
.append(this.b.toString()).append("\n")
.append("Distancia: ").append(this.ans).append("\n");
//.append(": ").append(this.ans).append("\n");
return x.toString();
Nombre: Díaz Medina Omar Alberto
MainPuntoDistancia.java
package Once;
public class MainPuntoDistancia {
public static void main(String[] args) {
Punto a= new Punto(2, 2);
Punto b= new Punto(5, 5);
a.setX(-1);
a.setY(-1);
System.out.println(a.toString());
}
}
12. Un fabricante de bicicletas, arma bicicletas para venta directa en dos modalidades Ruta y MTB. Cuando
un cliente realiza un pedido en línea específica si requiere una Bicicleta MTB o de Ruta y el fabricante
solicita a sus proveedores el cuadro (Ruta o MTB), el fabricante aplica el acabado solicitado por el cliente
(color), adicionalmente solicita a otro proveedor el tipo de equipamiento de la bicicleta que en ambos
casos (Ruta o MTB), es estándar, competición, o profesional.
a. El objeto Bicicleta cuenta entre sus atributos, con número de serie, y debe recibir como
parámetros objetos de tipo cuadro, y equipamiento.
b. El objeto Cuadro está compuesto por id, y tipo (Ruta o MTB)
c. El objeto Equipamiento está compuesto por id, y tipo (estándar, competición o profesional)
d. Demuestre el uso de las clases anteriores en una clase adicional que contenga el método main()
- Quitar este
Nombre: Díaz Medina Omar Alberto
13. Resuelva el caso anterior considerando “agregación-composición” en lugar de pasar objetos como
parámetros.
nombre la clase
imagen de la clase
Bicicleta.java
package Trece;
// constructor
public Bicicleta(String nSerie, String color, Cuadro cuadro, Equipamiento
equipamiento) {
this.nSerie = nSerie;
this.color = color;
this.cuadro = cuadro;
this.equipamiento = equipamiento;
}
// getters y setters
public String getnSerie() {
return nSerie;
}
this.equipamiento = equipamiento;
}
@Override
public String toString() {
StringBuilder datos = new StringBuilder("<-- DATOS -->\n");
datos.append("No. Serie: ").append(this.nSerie).append("\n");
datos.append("Color: ").append(this.color).append("\n");
datos.append("Cuadro: ").append(getCuadro().getTipo()).append("\n");
datos.append("Equipamiento: ").append(getEquipamiento().getTipo()).append("\
n");
return datos.toString();
}
Cuadro.java
package Trece;
//Getters y Setters
return obj.toString();
}
Nombre: Díaz Medina Omar Alberto
Equipamiento.java
package Trece;
@Override
public String toString(){
StringBuilder x= new StringBuilder("Datos del Equipamiento")
.append("Id del equipamiento"+this.id).append("\n")
.append("Tipo del equipamiento"+this.tipo).append("\n");
return x.toString();
MainBicicleta.java
package Trece;
Nombre: Díaz Medina Omar Alberto
//crear objetos
Bicicleta x = new Bicicleta("3354", "Morado", mtb, competicion);
System.out.println(x.toString());
}
}
14. Utilizando el criterio de agregación-composición, considere la clase vehículo, que está compuesta por la
clase motor, carrocería, y equipamiento. Determine los atributos convenientes para motor, carrocería y
equipamiento.
a. Demuestre el uso de las clases anteriores en una clase adicional que contenga el método main()
nombre la clase
imagen de la clase
Vehiculo.java
package Catorce;
// Getter y Setter
public String getMarca() {
return marca;
}
@Override
public String toString() {
StringBuilder cadena = new StringBuilder("DATOS DEL VEHICULO").append("\n")
.append("MARCA: ").append(this.marca).append("\n")
.append("MODELO: ").append(this.modelo).append("\n")
.append(this.motor.toString()).append("\n")
.append(this.carroceria.toString()).append("\n")
.append(this.equipamiento.toString()).append("\n");
return cadena.toString();
}
}
Motor.java
Nombre: Díaz Medina Omar Alberto
package Catorce;
//Getter y Setter
public int getPotencia() {
return potencia;
}
@Override
public String toString() {
StringBuilder cadena = new StringBuilder("<-- DATOS DEL MOTOR --
>").append("\n")
.append("POTENCIA: ").append(this.potencia).append("\n")
.append("TIPO DE COMBUSTIBLE: ").append(this.tipoMotor).append("\n")
.append("Cilindrada: ").append(this.cc).append("\n");
return cadena.toString();
}
}
Carroceria.java
package Catorce;
// Getter y Setter
public int getcPuertas() {
return cPuertas;
}
@Override
public String toString() {
StringBuilder cadena = new StringBuilder("DATOS DE CARROCERÍA").append("\n")
.append("CANTIDAD DE PUERTAS: ").append(this.cPuertas).append("\n")
.append("TIPO DE CARROCERIA: ").append(this.tipoCarroceria).append("\n")
.append("COLOR: ").append(this.color).append("\n")
.append("MATERIAL: ").append(this.material).append("\n");
return cadena.toString();
}
}
Nombre: Díaz Medina Omar Alberto
Equipamiento.java
package Catorce;
// Getters y Setters
public String getSistemaSonido() {
return sistemaSonido;
}
@Override
public String toString(){
StringBuilder x = new StringBuilder("DATOS DEL EQUIPAMIENTO").append("\n")
.append("Sistemas de sonido: ").append(this.sistemaSonido).append("\n")
.append("Aire acondicionado: ").append(this.aireAcondicionado).append("\n")
.append("Airbag: ").append(this.airbag).append("\n");
return x.toString();
}
}
DatosVehiculo.java
package Catorce;
Nombre: Díaz Medina Omar Alberto
// Motor
int potencia = Leer.leerEntero("Potencia :?");
String tipoMotor = Leer.LeerString("Tipo de combustible :?");
double cc = Leer.leerDouble("Cilindrada :?");
Motor x = new Motor(potencia, tipoMotor, cc);
// Carroceria
int cPuertas = Leer.leerEntero("Cantidad de puertas :?");
String tipoCarroceria = Leer.LeerString("Tipo de carroceria :?");
String color = Leer.LeerString("Color :?");
String material = Leer.LeerString("Material :?");
Carroceria y = new Carroceria(cPuertas, tipoCarroceria, color, material);
// Equipamiento
String sistemaSonido = Leer.LeerString("Sistema de sonido :?");
boolean aireAcondicionado = Leer.leerBoolean("Aire acondicionado :?");
boolean airbag = Leer.leerBoolean("Airbag :?");
Equipamiento z = new Equipamiento(sistemaSonido, aireAcondicionado, airbag);
Leer.java
package Catorce;
Main.java
package Catorce;
x.setMarca("Mustang Shelby");
x.setModelo("GT500");
x.getCarroceria().setColor("Negro");
x.getMotor().setPotencia(2000);
x.getEquipamiento().setAirbag(false);
Leer.showDatos(x.toString());
}
}
● Modelar clases con UML y generar código Java con la estructura básica del proyecto.
● Uso de constructores
● Paso de arreglos de objetos como parámetros, en constructores y métodos.
● Crear objetos y demostrar el uso de las clases creadas.
15. Desarrolle un programa que contemple la clase Estudiante, con los siguientes atributos: nombre,
apellidos, calificación , edad. Considere los siguientes aspectos.
a. Desarrolle la clase estudiante.
b. Contemple una segunda clase que procese un arreglo de objetos de tipo estudiante y obtenga el
promedio del grupo (considere un arreglo de cinco elementos)
c. Demuestre el uso de las clases anteriores en una clase adicional que contemple el método main.
nombre la clase
imagen de la clase
Estudiante.java
package Quince;
this.nombre = nombre;
this.apellido = apellido;
this.calificacion = calificacion;
this.edad = edad;
}
@Override
public String toString() {
StringBuilder x = new StringBuilder()
.append("ESTUDIANTE { NOMBRE: ").append(this.nombre)
.append(", APELLIDO: ").append(this.apellido)
.append(", CALIFICACION: ").append(this.calificacion)
.append(", EDAD: ").append(this.edad)
.append("}");
return x.toString();
}
}
PromedioGrupo.java
package Quince;
public PromedioGrupo(Estudiante[] x) {
this.x=x;
}
Main.java
package Quince;
16. Un almacén de un supermercado recibe una amplia gama de productos que debe trasladar
inmediatamente a las diversas zonas de ventas. Todos los productos que recibe se cuentan con id,
nombre, descripción y precio de venta.
Nombre: Díaz Medina Omar Alberto
nombre la clase
imagen de la clase
Producto.java
package Diesciseis;
// 04 Getter y Setter
public String getId() {
return id;
}
// 05 Metodo toString()
@Override
public String toString() {
StringBuilder cadena = new StringBuilder();
cadena.append("PRODUCTO {id: ").append(this.id);
cadena.append("NOMBRE: ").append(this.nombre);
cadena.append("DESCRIPCIÓN: ").append(this.descripcion);
cadena.append("PRECIO DE VENTA: ").append(this.precioVenta);
cadena.append("}");
return cadena.toString();
}
TotalMercancias.java
package Diesciseis;
public TotalMercancias(Producto[] x) {
this.x = x;
}
Main.java
package Diesciseis;
17. Una empresa editorial de publicaciones en versiones en físico de lujo, maneja la producción de libros. De
cada producto (libro) cuenta con un id, titulo, precio de venta, autor y porcentaje de regalías a entregar al
autor por cada venta.
a. Desarrolle la clase Libro.
b. Contemple una segunda clase que procese un arreglo de objetos de tipo Libro y obtenga el total
de productos en venta. Contenga un método que genere un reporte financiero que indique título
del libro, precio de venta y cantidad en regalías a otorgar al autor por la venta del libro (cantidad
monetaria), (considere un arreglo de cinco elementos)
c. Demuestre el uso de las clases anteriores en una clase adicional que contemple el método main.
nombre la clase
imagen de la clase
Editorial.java
package Diescisiete;
private Libro[] x;
private int cont=0;
public Editoral(Libro[] x) {
this.x=x;
}
Libro.java
package Diescisiete;
public Libro(int id, String titulo, double precioVenta, String autor, double p)
{
this.id=id;
this.titulo=titulo;
this.precioVenta=precioVenta;
this.autor=autor;
this.p=p;
}
// Getter y Setter
// 05 Metodo toString()
@Override
public String toString() {
}
}
Nombre: Díaz Medina Omar Alberto
Main.java
package Diescisiete;
var.showArray();
var.getReporte();
var.getTotal();
}
● Modelar clases con UML y generar código Java con la estructura básica del proyecto.
● Incorpora en esta sección los laboratorios. Únicamente los laboratorios entregados.
18. Lab 01
19. Lab 02
20. Lab 03
21. Lab 04