Java NetBeans código diagrama UML clases herencia encapsulamiento polimorfismo

[merymoom@hotmail.com]

Hola, espero esten bien. soy nueva en el foro y me interesa aprender a programar al 100%.

En estos momentos tengo un ejercicio de Java, entorno Netbeans, alguien que me pueda ayudar por favor. A partir de un diagrama UML que ejemplifica, herencia, encapsulamiento y polimorfismo y relizar los siguientes puntos.

Con base en el diagrama de clases realice la aplicación en Java:

• Deben existir cuatro empleados
• Deben existir 3 personas o clientes
• Deben existir 4 productos diferentes
• Deben existir facturas registradas
• La aplicación debe permitir consultar cuantas facturas ha pagado un mismo cliente
• La aplicación debe permitir consultar los datos de los empleados, productos y personas

Adjunto la imagen del diagrama de clase donde estan las tablas con sus atributo.
Muchas gracias

[Kabuto]

Hola, lo primero es escribir las clases y entender como se relacionan entre ellas.

La clase más importante es FACTURA que se relaciona con, es decir, tendrá entre sus atributos, las siguientes clases:
- PERSONA, que es quien cancela (paga) la FACTURA.

- DETALLE, que a su vez se relaciona con el PRODUCTO facturado e indica su cantidad.
PRODUCTO además, se relaciona con CHEF, el EMPLEADO que cocinó el PRODUCTO

- MESERO, otro tipo de EMPLEADO que es quien entrega la FACTURA

Empezamos escribiendo la clase PERSONA que es la más básica y sencilla.
Podemos hacerle un constructor
que pida los atributos que consideremos obligatorios para crear un objeto PERSONA
Además, si queremos, podemos sobrescribir el método equals() para poder comparar objetos Persona y saber si son iguales o no. En este caso, podemos considerar que dos personas son iguales o equivalentes si tienen la misma cédula.
También sobrescribiremos el método toString() para indicar como queremos mostrar en pantalla los datos de esta PERSONA. Esto también lo haremos para el resto de clases para facilitar mostrar sus datos en pantalla.

Código: [Seleccionar]

public class Persona {

private String cedula;
private String nombre;
private String e_mail;
private String telefono;
private String direccion;

//Constructor con atributos obligados
public Persona(String cedula, String nombre, String e_mail) {
this.cedula = cedula;
this.nombre = nombre;
this.e_mail = e_mail;
telefono = "";
direccion = "";
}

public String getCedula() {
return cedula;
}

public void setCedula(String cedula) {
this.cedula = cedula;
}

public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {
this.nombre = nombre;
}

public String getE_mail() {
return e_mail;
}

public void setE_mail(String e_mail) {
this.e_mail = e_mail;
}

public String getTelefono() {
return telefono;
}

public void setTelefono(String telefono) {
this.telefono = telefono;
}

public String getDireccion() {
return direccion;
}

public void setDireccion(String direccion) {
this.direccion = direccion;
}

@Override
public boolean equals(Object objeto) {
if (objeto instanceof Persona) {
Persona otraPersona = (Persona)objeto;
//Dos Persona serán iguales si tienen la misma cedula
return cedula.equals(otraPersona.getCedula());
}
else
return false;
}

@Override
public String toString() {
StringBuilder sb= new StringBuilder();
sb.append("\nCédula : " + cedula);
sb.append("\nNombre: " + nombre);
sb.append("\nE-Mail: " + e_mail);
sb.append("\nTeléfono: " + telefono);
sb.append("\nDirección: " + direccion);
return sb.toString();
}

}
Vamos a pasar ahora a los EMPLEADOS. Hay dos tipos, CHEF y MESERO, quienes tienen los mismos atributos, ya que los van a heredar de la clase EMPLEADO.
Aunque no es obligatorio, podemos definir la clase EMPLEADO como abstracta, ya que en principio no vamos a querer trabajar con objetos EMPLEADO, si no con los objetos "hijo" de EMPLEADO, es decir, CHEF y MESERO

Así que toda la declaración de atributos y métodos la haremos en EMPLEADO y la declararemos como abstracta. También podemos dotarla de un método equals() similar al que hemos hecho con PERSONA.

Código: [Seleccionar]

public abstract class Empleado {

private String cedula;
private String nombre;
private String apellido;
private double salario;

public Empleado(String cedula, String nombre, String apellido, double salario) {
this.cedula = cedula;
this.nombre = nombre;
this.apellido = apellido;
this.salario = salario;
}

public String getCedula() {
return cedula;
}

public void setCedula(String cedula) {
this.cedula = cedula;
}

public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {
this.nombre = nombre;
}

public String getApellido() {
return apellido;
}

public void setApellido(String apellido) {
this.apellido = apellido;
}

public double getSalario() {
return salario;
}

public void setSalario(double salario) {
this.salario = salario;
}

@Override
public boolean equals(Object objeto) {
if (objeto instanceof Empleado) {
Empleado otroEmple = (Empleado)objeto;
return cedula.equals(otroEmple.getCedula());
}
else
return false;
}

@Override
public String toString() {
StringBuilder sb= new StringBuilder();
sb.append("\nCédula : " + cedula);
sb.append("\nNombre: " + nombre);
sb.append("\nApellido: " + apellido);
sb.append("\nSalario: " + salario);
return sb.toString();
}

}
Ahora seguimos con CHEF y MESERO, que son clases que simplemente tienen que heredar de EMPLEADO y obligatoriamente tener un constructor que pida los atributos exigidos por su superclase EMPLEADO

Código: [Seleccionar]

public class Chef extends Empleado{

public Chef(String cedula, String nombre, String apellido, double salario) {
super(cedula, nombre, apellido, salario);
}

}

Código: [Seleccionar]

public class Mesero extends Empleado{

public Mesero(String cedula, String nombre, String apellido, double salario) {
super(cedula, nombre, apellido, salario);
}

}

Pasamos a la clase PRODUCTO a quien incluiremos un CHEF entre sus atributos que identifica al creador de dicho PRODUCTO.
En el constructor no consideraremos obligatorio indicar un CHEF, aunque se lo podemos asignar después mediante su método setChef().
También tendrá sobrescrito el método equals()

Código: [Seleccionar]

public class Producto {

private String codigo;
private String nombreProducto;
private String receta;
private String ingredienteSecreto;
private String nacionalidad;
private Chef chefCreador;

public Producto(String codigo, String nombreProducto, String receta, String ingredienteSecreto,
String nacionalidad) {
this.codigo = codigo;
this.nombreProducto = nombreProducto;
this.receta = receta;
this.ingredienteSecreto = ingredienteSecreto;
this.nacionalidad = nacionalidad;
}

public String getCodigo() {
return codigo;
}

public void setCodigo(String codigo) {
this.codigo = codigo;
}

public String getNombreProducto() {
return nombreProducto;
}

public void setNombreProducto(String nombreProducto) {
this.nombreProducto = nombreProducto;
}

public String getReceta() {
return receta;
}

public void setReceta(String receta) {
this.receta = receta;
}

public String getIngredienteSecreto() {
return ingredienteSecreto;
}

public void setIngredienteSecreto(String ingredienteSecreto) {
this.ingredienteSecreto = ingredienteSecreto;
}

public String getNacionalidad() {
return nacionalidad;
}

public void setNacionalidad(String nacionalidad) {
this.nacionalidad = nacionalidad;
}

public Chef getChefCreador() {
return chefCreador;
}

public void setChefCreador(Chef chefCreador) {
this.chefCreador = chefCreador;
}

@Override
public boolean equals(Object objeto) {
if (objeto instanceof Producto) {
Producto otroProducto = (Producto)objeto;
return codigo.equals(otroProducto.getCodigo());
}
else
return false;
}

@Override
public String toString() {
StringBuilder sb= new StringBuilder();
sb.append("\nCódigo : " + codigo);
sb.append("\nNombre: " + nombreProducto);
sb.append("\nReceta: " + receta);
sb.append("\nIngrediente Secreto: " + ingredienteSecreto);
sb.append("\nNacionalidad: " + nacionalidad);
sb.append("\nCreado por el Chef: " + chefCreador.getNombre() + " " + chefCreador.getApellido());
return sb.toString();
}

}
La clase DETALLE es muy sencilla, tan solo necesitamos como atributos un PRODUCTO y un int para indicar las unidades de ese PRODUCTO que se van a facturar.

Código: [Seleccionar]

public class Detalle {

private int cantidad;
private Producto producto;

public Detalle(int cantidad, Producto producto) {
this.cantidad = cantidad;
this.producto = producto;
}

public int getCantidad() {
return cantidad;
}

public void setCantidad(int cantidad) {
this.cantidad = cantidad;
}

public Producto getProducto() {
return producto;
}

public void setProducto(Producto producto) {
this.producto = producto;
}

@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("\nCantidad servida: " + cantidad);
sb.append("\nProducto: " + producto.getNombreProducto());
return sb.toString();
}

}
Por último, llegamos a FACTURA, donde entre sus atributos tendremos una PERSONA que es el cliente que paga, un MESERO que ha atendido al CLIENTE, y el DETALLE de la factura con el PRODUCTO y unidades facturadas.
El atributo propina, no lo consideraré obligatorio incluirlo en el constructor.

Código: [Seleccionar]

public class Factura {

private String codigo;
private String fecha;
private double propina;
private String formaPago;
private Persona cliente;
private Mesero meseroEntrega;
private Detalle detalle;

public Factura(String codigo, String fecha, String formaPago, Persona cliente, Mesero meseroEntrega,
Detalle detalle) {
this.codigo = codigo;
this.fecha = fecha;
this.formaPago = formaPago;
this.cliente = cliente;
this.meseroEntrega = meseroEntrega;
this.detalle = detalle;
}

public String getCodigo() {
return codigo;
}

public void setCodigo(String codigo) {
this.codigo = codigo;
}

public String getFecha() {
return fecha;
}

public void setFecha(String fecha) {
this.fecha = fecha;
}

public double getPropina() {
return propina;
}

public void setPropina(double propina) {
this.propina = propina;
}

public String getFormaPago() {
return formaPago;
}

public void setFormaPago(String formaPago) {
this.formaPago = formaPago;
}

public Persona getCliente() {
return cliente;
}

public void setCliente(Persona cliente) {
this.cliente = cliente;
}

public Mesero getMeseroEntrega() {
return meseroEntrega;
}

public void setMeseroEntrega(Mesero meseroEntrega) {
this.meseroEntrega = meseroEntrega;
}

public Detalle getDetalle() {
return detalle;
}

public void setDetalle(Detalle detalle) {
this.detalle = detalle;
}

@Override
public boolean equals(Object objeto) {
if (objeto instanceof Factura) {
Factura otraFactura = (Factura)objeto;
return codigo.equals(otraFactura.getCodigo());
}
else
return false;
}

@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("\nCódigo Factura: " + codigo);
sb.append("\nFecha: " + fecha);
sb.append("\nForma de Pago: " + formaPago);
sb.append("\nMesero: " + meseroEntrega.getNombre() + " " + meseroEntrega.getApellido());
sb.append("\nDetalle Factura:");
sb.append(detalle);
return sb.toString();
}

}
Con esto ya tenemos todas las clases modeladas. Ahora habría que preparar el programa principal y darle funcionalidad.
Esto lo vemos en el siguiente mensaje.

[Kabuto]

Continuamos.

Ya tenemos las clases, ahora hay que crear el programa principal.
El programa tendrá dos tareas.
La primera, crear automáticamente objetos PERSONA, EMPLEADO, FACTURA, PRODUCTO...

Dichos objetos los guardaremos en alguna colección de datos dinámica, por ejemplo en ArrayList.
Para crear esos objetos, haremos varias funciones donde crearemos objetos de cada clase y las añadiremos a los ArrayList.
Lo primero que hará nuestro main() será llamar a estas funciones para que vayan llenando los ArrayList con datos.

Terminado esto, pasamos a la segunda tarea, que es simplemente mostrar un menú al usuario dentro de un bucle para que elija las opciones que quiera hasta que decida terminar el programa.
El menú tiene que ofrecer consultar EMPLEADOS, PERSONAS(Clientes), y PRODUCTOS
Yo simplemente lo que hago es recorrer el ArrayList correspondiente y mostrar los datos de los objetos que contiene. Gracias a que a cada clase le hemos creado un método toString(), ahora nos va a bastar con un par de líneas de código para cada opción.

Hay otra opción más que ofrecer, que es la de mostrar FACTURAS según la PERSONA/Cliente.
Yo lo que hago es pedir al usuario un número de cédula. Compruebo en el ArrayList si existe una PERSONA con esa cédula.
Si existe, uso esa PERSONA para consultar el ArrayList de FACTURAS. A cada una de ellas le pido que me devuelva la PERSONA asociada y la comparo con la PERSONA que me ha indicado el usuario. Si coinciden (método equals() facilita esta comparación) mando imprimir en pantalla los datos de esa FACTURA y paso a la siguiente.

Y ya está, creo que no es difícil de entender. Aquí dejo mi código y cualquier duda, tan solo tienes que preguntarla.
Un saludo.

Código: [Seleccionar]

public class GestionRestaurante {

static ArrayList<Empleado> empleados = new ArrayList<Empleado>();
static ArrayList<Persona> clientes = new ArrayList<Persona>();
static ArrayList<Producto> productos = new ArrayList<Producto>();
static ArrayList<Factura> facturas = new ArrayList<Factura>();

public static void main(String[] args) {
//Inicializamos datos
crearEmpleados();
crearClientes();
crearProductos();
crearFacturas();
//Comienza el menú principal
Scanner teclado = new Scanner(System.in);
int opcion = 0;
while (opcion != 5) {
System.out.println("\n\t\tOPCIONES");
System.out.println("(1) Consultar Empleados");
System.out.println("(2) Consultar Productos");
System.out.println("(3) Consultar Clientes");
System.out.println("(4) Consultar Facturas por Cliente");
System.out.println("(5) TERMINAR PROGRAMA");
System.out.print("Seleccione opción (1-5): ");
opcion = Integer.parseInt(teclado.nextLine());
switch(opcion) {
case 1:
System.out.println("\n\t\tCONSULTAR EMPLEADOS");
for (Empleado emp: empleados) {
if (emp instanceof Chef)
System.out.println("\nTipo empleado: Chef");
else
System.out.println("\nTipo empleado: Mesero");
System.out.println(emp);
}
break;
case 2:
System.out.println("\n\t\tCONSULTAR PRODUCTOS");
for (Producto prod: productos)
System.out.println("\n" + prod);
break;
case 3:
System.out.println("\n\t\tCONSULTAR CLIENTES");
for (Persona cli: clientes)
System.out.println("\n" + cli);
break;
case 4:
System.out.println("\n\t\tCONSULTAR FACTURAS POR CLIENTE");
System.out.print("\nIndique cédula de cliente: ");
String cedula = teclado.nextLine();
//Buscamos cliente a ver si existe
Persona cliente = null;
for (Persona cli: clientes)
if (cli.getCedula().equals(cedula))
cliente = cli; //Encontrado, lo referenciamos en la variable cliente
//Comprobamos si lo hemos encontrado
if (cliente == null)
System.out.println("No se encontro cliente con cédula: " + cedula);
else {
//Mostramos facturas de esta Persona cliente
System.out.println("\n\tFacturas asociadas al Cliente:");
for (Factura fac: facturas) {
if (fac.getCliente().equals(cliente))
System.out.println(fac);
}
}
break;
case 5:
System.out.println("\n\n\t\tFIN DE PROGRAMA");
break;
default:
System.out.println("\nOpción equivocada, elija entre 1-5");
}
}

teclado.close();

}

static void crearEmpleados() {
empleados.add(new Mesero("CED00", "Ramón", "Espinosa", 850));
empleados.add(new Mesero("CED01", "Susana", "López", 850));
empleados.add(new Chef("CED02", "Carlos", "Santana", 975));
empleados.add(new Chef("CED03", "María", "Reina", 975));
}

static void crearClientes() {
clientes.add(new Persona("CED04", "Federico", "fede@gmail.com"));
clientes.add(new Persona("CED05", "Cristina", "cristi@gmail.com"));
clientes.add(new Persona("CED06", "Raul", "raul@gmail.com"));
}

static void crearProductos() {
productos.add(new Producto("COD000", "Raviolis", "Ravioli, Ternera, Tomate, Salsa Queso",
"Nata", "Italia"));
productos.add(new Producto("COD010", "Pelmeni", "Carne Pollo, Sal, Harina, Aceite Oliva, Huevo",
"Cebolla picada", "Rusia"));
productos.add(new Producto("COD020", "Udon", "Fideos, Aceite, Ajo, Jengibre, Brócoli, Soja",
"Setas Shiitake", "Japón"));
productos.add(new Producto("COD030", "Paella", "Arroz, Gambas, Mejillones, Calamares, Ajo",
"Azafrán", "España"));
//Seteamos el Chef creador para cada producto
productos.get(0).setChefCreador((Chef)empleados.get(2));
productos.get(1).setChefCreador((Chef)empleados.get(3));
productos.get(2).setChefCreador((Chef)empleados.get(2));
productos.get(3).setChefCreador((Chef)empleados.get(3));
}

static void crearFacturas() {
facturas.add(new Factura("FAC000", "07/08/2019", "Efectivo", clientes.get(0), (Mesero)empleados.get(1),
new Detalle(2, productos.get(2))));
facturas.add(new Factura("FAC001", "06/08/2019", "Tarjeta VISA", clientes.get(1), (Mesero)empleados.get(1),
new Detalle(3, productos.get(1))));
facturas.add(new Factura("FAC002", "05/08/2019", "Efectivo", clientes.get(0), (Mesero)empleados.get(0),
new Detalle(4, productos.get(0))));
facturas.add(new Factura("FAC003", "07/08/2019", "PayPal", clientes.get(2), (Mesero)empleados.get(0),
new Detalle(1, productos.get(0))));
facturas.add(new Factura("FAC004", "05/08/2019", "Efectivo", clientes.get(1), (Mesero)empleados.get(1),
new Detalle(3, productos.get(1))));
facturas.add(new Factura("FAC005", "04/08/2019", "PayPal", clientes.get(0), (Mesero)empleados.get(0),
new Detalle(2, productos.get(2))));
facturas.add(new Factura("FAC006", "05/08/2019", "Tarjeta VISA", clientes.get(1), (Mesero)empleados.get(0),
new Detalle(4, productos.get(1))));
facturas.add(new Factura("FAC007", "03/08/2019", "Efectivo", clientes.get(2), (Mesero)empleados.get(1),
new Detalle(2, productos.get(2))));
facturas.add(new Factura("FAC008", "04/08/2019", "Tarjeta VISA", clientes.get(0), (Mesero)empleados.get(0),
new Detalle(3, productos.get(1))));
}

}

[merymoom@hotmail.com]

Hola, Muchisimas gracias por la gran ayuda.
me ha salvado y no sabe cuanto, muchas bendiciones y espero aprender todo acerca de programación.