Ayuda con este ejercicio please

[edisoncaballeroquispe15]

Debe usar POO(Patrones) y Programación funcional para todos los casos.

Una empresa organiza eventos tecnológicos con cierto nivel de frecuencia. Cuando se realiza un evento siempre
tiene un título, la duración del mismo, el nombre del expositor, la hora de ingreso, la hora de salida y si esta en temporada alta o no. El costo de las entradas depende de la ubicación según la tabla adjunta.
No: 01,02,03
codigo: P, G, V
Ubicacion: Platinum, Gold, VIP
Costo: S/250.25 , S/150.50 y S/95
Los expositores tienen código, nombre, apellidos, sueldo y correo, los asistentes al evento tienen código, nombre, apellidos, correo, teléfono y dirección.
Observación:
Para este caso se debe tener en cuenta que un evento solo debe tener un expositor y muchos asistentes. Un asistente solo puede ingresar a un evento.
Cree una aplicación Java con su apellido paterno y nombre.
1. Preparando ambiente desarrollo (10 puntos)
a. (2 puntos) Cree un paquete útil y dentro generar en la clase MisConstantes tres constantes de clase con la nomenclatura correspondiente, de acceso público que tengan los valores de los costos por ubicación. Opcionalmente puede usar ENUMs.
b. (2 puntos) Genere el modelo de clases de dominio del negocio con los constructores y los métodos de acceso de todas . Estas clases deben estar en el paquete entidades. Se revisará su nivel de abstracción. Use patrón Builder.
c. (2 puntos) Genere un método en la clase Evento que use valores generados para establecer el costo de ingreso al evento dependiendo del código ingresado del evento.
d. (2 puntos) Genere un método que calcule Monto total a pagar incluyendo el IGV, para esto use una constante previamente definida en la clase constantes.
e. (2 puntos) Genere un método que calcule el monto de descuento que debe ser de 10% en temporada baja y 5% en temporada alta.
2. Preparando ambiente pruebas (10 puntos)
a. Genere una clase Prueba01 en un paquete pruebas en donde pueda crear objetos del tipo evento, agregue valores a sus atributos y muestre un listado de los eventos ordenados por titulo de manera descendente, el expositor y sus asistentes.
b. Genere una clase Prueba02 que muestre la lista de eventos y sus precios, agrupados por ubicación.
c. Genera una clase Prueba03 que muestre la lista de eventos y el total recaudado por cada evento.
d. Genera una clase Prueba04 que muestre la lista asistentes que hayan pagado en Platinum, Gold y VIP.
e. Genera una clase Prueba05 que muestre el sueldo a apagar a todos los expositores que dieron charlas en VIP.

[Kabuto]

A ver, lo primero es identificar las principales entidades que intervienen.

Aquí se organizan Eventos.
En un Evento interviene un Expositor y van a acudir una cantidad indefinida de Asistentes

Evento, Expositor y Asistente serían las principales entidades.

Esta podría ser la clase Asistente

Código: [Seleccionar]

package entidades;

public class Asistente {

private String codigo;
private String nombre;
private String apellidos;
private String correo;
private String telefono;
private String direccion;

public Asistente(String codigo, String nombre, String apellidos, String correo,
String telefono, String direccion) {
this.codigo = codigo;
this.nombre = nombre;
this.apellidos = apellidos;
this.correo = correo;
this.telefono = telefono;
this.direccion = direccion;
}

public String getCodigo() {
return codigo;
}

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

public String getNombre() {
return nombre;
}

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

public String getApellidos() {
return apellidos;
}

public void setApellidos(String apellidos) {
this.apellidos = apellidos;
}

public String getCorreo() {
return correo;
}

public void setCorreo(String correo) {
this.correo = correo;
}

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;
}

}

Esta la clase Expositor

Código: [Seleccionar]

package entidades;

public class Expositor {

private String codigo;
private String nombre;
private String apellidos;
private double sueldo;
private String correo;

public Expositor(String codigo, String nombre, String apellidos, double sueldo, String correo) {
this.codigo = codigo;
this.nombre = nombre;
this.apellidos = apellidos;
this.sueldo = sueldo;
this.correo = correo;
}

public String getCodigo() {
return codigo;
}

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

public String getNombre() {
return nombre;
}

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

public String getApellidos() {
return apellidos;
}

public void setApellidos(String apellidos) {
this.apellidos = apellidos;
}

public double getSueldo() {
return sueldo;
}

public void setSueldo(double sueldo) {
this.sueldo = sueldo;
}

public String getCorreo() {
return correo;
}

public void setCorreo(String correo) {
this.correo = correo;
}

}

Y esta la clase Evento.
Además de los atributos que indica el enunciado, yo le he añadido un ArrayList para contener a los asistentes que acudirán a este evento.

Además incluye los métodos que pide el enunciado. Aunque no me queda claro si el descuento según la temporada, debería ir aplicado en el resultado que calcula el "monto total".

Código: [Seleccionar]

package entidades;

import java.util.ArrayList;
import util.MisConstantes;

public class Evento {

private String titulo;
private int duracion;
private Expositor expositor;
private String horaIngreso;
private String horaSalida;
private boolean esTemporadaAlta;
private char codigoUbicacion;
private ArrayList<Asistente> asistentes;

public Evento(String titulo, int duracion, Expositor expositor, String horaIngreso, String horaSalida,
boolean esTemporadaAlta, char codigoUbicacion) {
this.titulo = titulo;
this.duracion = duracion;
this.expositor = expositor;
this.horaIngreso = horaIngreso;
this.horaSalida = horaSalida;
this.esTemporadaAlta = esTemporadaAlta;
this.codigoUbicacion = codigoUbicacion;
asistentes = new ArrayList<Asistente>();
}

public String getTitulo() {
return titulo;
}

public void setTitulo(String titulo) {
this.titulo = titulo;
}

public int getDuracion() {
return duracion;
}

public void setDuracion(int duracion) {
this.duracion = duracion;
}

public Expositor getExpositor() {
return expositor;
}

public void setExpositor(Expositor expositor) {
this.expositor = expositor;
}

public String getHoraIngreso() {
return horaIngreso;
}

public void setHoraIngreso(String horaIngreso) {
this.horaIngreso = horaIngreso;
}

public String getHoraSalida() {
return horaSalida;
}

public void setHoraSalida(String horaSalida) {
this.horaSalida = horaSalida;
}

public boolean isEsTemporadaAlta() {
return esTemporadaAlta;
}

public void setEsTemporadaAlta(boolean esTemporadaAlta) {
this.esTemporadaAlta = esTemporadaAlta;
}

public char getCodigoUbicacion() {
return codigoUbicacion;
}

public void setCodigoUbicacion(char codigoUbicacion) {
this.codigoUbicacion = codigoUbicacion;
}

public void addAsistente(Asistente asis) {
asistentes.add(asis);
}

public double getCostoIngreso() {
switch(codigoUbicacion) {
case 'P':
return MisConstantes.COSTO_P;
case 'G':
return MisConstantes.COSTO_G;
default:
return MisConstantes.COSTO_V;
}
}

public double getMontoTotal() {
double ingreso = getCostoIngreso();
return ingreso + (ingreso*MisConstantes.IGV/100);
}

public double getDescuento() {
return esTemporadaAlta?getMontoTotal()*10/100:getMontoTotal()*5/100;
}

}

Para dichos cálculos, se usan una constantes que el enunciado pide declarar en un package separado:

Código: [Seleccionar]

package util;

public class MisConstantes {
//Costos de ubicacion
public final static double COSTO_P = 250.25;
public final static double COSTO_G = 150.5;
public final static double COSTO_V = 95;
//Impuesto general de ventas
public final static int IGV = 18; //% sobre precio base
}

Bien, esas podrían ser las clases. Luego puede que queramos añadir algún método más o modificar algo.

Pero en principio, con esto ya se podría comenzar a hacer las distintas clases de "prueba" que pide el enunciado.

Intenta comenzar tú la primera.
Se necesitará un ArrayList para almacenar los distintos Eventos que se vayan creando.
Estos eventos se tendrán que crear dentro de un bucle, pidiendo datos al usuario.
Y por cada Evento, habrá que crear también un Expositor y varios Asistentes (en un segundo bucle anidado)

Inténtalo y comparte por aquí lo que consigas.
Un saludo.

[edisoncaballeroquispe15]

No me sale la primera prueba 01, por favor su apoyo.

[Kabuto]

La primera prueba tendría dos partes:

• Creación de Eventos
• Listar Eventos creados

Centrémonos en la primera parte.
Hay que pedir datos al usuario para crear eventos, los cuáles podemos añadirlos a un ArrayList para luego poder mostrar un listado.
Por cada evento, hay que crear además un expositor y uno o más asistentes.

Este proceso podemos separarlo en tres métodos:

• para crear y retornar un Expositor
• para crear y retornar un Asistente
• para crear y retornar un Evento, donde invocaremos a los métodos que crean Expositores y Asistentes

Combinando esos tres métodos, podemos hacer un bucle while donde vayamos creando y añadiendo Eventos al ArrayList, hasta que el usuario decida terminar.

Código: [Seleccionar]

package pruebas;

import java.util.ArrayList;
import java.util.Scanner;

import entidades.*;

public class Prueba01 {

private static ArrayList<Evento> eventos = new ArrayList<Evento>();
private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {

//Creacion de Eventos
char terminar = 'N';
while (terminar != 'S') {
eventos.add(crearEvento());
System.out.println("\nEvento añadido. ¿Desea TERMINAR?(S/N): ");
terminar = teclado.nextLine().toUpperCase().charAt(0);
}


}

private static Expositor crearExpositor() {
System.out.println("\n\tDATOS DEL EXPOSITOR");
System.out.print("Codigo: ");
String codigo = teclado.nextLine();
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Apellidos: ");
String apellidos = teclado.nextLine();
System.out.print("Sueldo: ");
double sueldo = Double.parseDouble(teclado.nextLine());
System.out.print("Correo: ");
String correo = teclado.nextLine();

return new Expositor(codigo, nombre, apellidos, sueldo, correo);
}

private static Asistente crearAsistente() {
System.out.println("\n\tDATOS DEL ASISTENTE");
System.out.print("Codigo: ");
String codigo = teclado.nextLine();
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Apellidos: ");
String apellidos = teclado.nextLine();
System.out.print("Correo: ");
String correo = teclado.nextLine();
System.out.print("Telefono: ");
String telef = teclado.nextLine();
System.out.print("Direccion: ");
String direcc = teclado.nextLine();

return new Asistente(codigo, nombre, apellidos, correo, telef, direcc);
}

private static Evento crearEvento() {
System.out.println("\n\tDATOS DEL EVENTO");
System.out.print("Titulo: ");
String titulo = teclado.nextLine();
System.out.print("Duracion(en minutos): ");
int duracion = Integer.parseInt(teclado.nextLine());
System.out.print("Hora ingreso: ");
String ingreso = teclado.nextLine();
System.out.print("Hora salida: ");
String salida = teclado.nextLine();
System.out.print("Temporada Alta?(S/N): ");
boolean temporadaAlta = teclado.nextLine().toUpperCase().charAt(0) == 'S';
System.out.println("Indique codigo ubicacion");
System.out.println("[P] -> Platinum / [G] -> Gold / [V] -> VIP");
System.out.print("Codigo: ");
char ubicacion = teclado.nextLine().toUpperCase().charAt(0);

//Necesitamos un Expositor
Expositor expo = crearExpositor();

//Podemos crear el Evento
Evento evento = new Evento(titulo, duracion, expo, ingreso, salida, temporadaAlta, ubicacion);

//Ahora hay que añadir Asistentes al Evento
char terminar = 'N';
while (terminar != 'S') {
Asistente nuevo = crearAsistente();
evento.addAsistente(nuevo);
System.out.println("\nAsistente añadido. ¿Desea TERMINAR?(S/N): ");
terminar = teclado.nextLine().toUpperCase().charAt(0);
}

return evento;
}

}

Con esto tendríamos la primera parte.
Ahora hay que ver cómo hacemos la segunda parte.
Nos piden un listado de los Eventos, incluyendo su Expositor(que es uno) y Asistentes(que pueden ser muchos)
Y además el listado ha de estar ordenado por título y de manera descendente, es decir, de Z a A.

Bien, para facilitar esto, primero deberíamos añadir un nuevo método a la clase Evento que se encargue de mostrar detalladamente todos sus datos, incluyendo expositor y asistentes.

Código: [Seleccionar]


public void mostrarEvento() {
System.out.println("\n\t\t" + titulo.toUpperCase());
System.out.print("\t\t");
for (int i = 0; i < titulo.length(); i++)
System.out.print("-");
System.out.printf("\nExpositor: %s %s", expositor.getNombre(), expositor.getApellidos());
System.out.printf("\nDuracion: %d Ingreso: %s Salida: %s\n", duracion, horaIngreso, horaSalida);
System.out.println("Temporada: " + (esTemporadaAlta?"Alta":"Baja"));
System.out.print("Ubicacion: ");
switch(codigoUbicacion) {
case 'P':
System.out.println("Platinum");
break;
case 'G':
System.out.println("Gold");
break;
default:
System.out.println("VIP");
}

System.out.println("\n\t---Lista de Asistentes---\n");
for (Asistente asis: asistentes)
System.out.printf("-> %s %s\n", asis.getNombre(), asis.getApellidos());
}
Con esto ya podemos volver a la clase Prueba01 y añadir código para mostrar un listado tras la creación de los eventos:

   public static void main(String[] args) {
      
      //Creacion de Eventos
      char terminar = 'N';
      while (terminar != 'S') {
         eventos.add(crearEvento());
         System.out.println("\nEvento añadido. ¿Desea TERMINAR?(S/N): ");
         terminar = teclado.nextLine().toUpperCase().charAt(0);
      }
      
      //Listar los Eventos
      System.out.println("\n\t\tLISTADO DE EVENTOS");
      System.out.println("\t\t------- -- -------\n");
      for (Evento even: eventos) {
         System.out.println("\n\n\t\t*************************\n");
         even.mostrarEvento();
      }

   }

Bien, con esto listamos los eventos, pero aún no están ordenados como nos han solicitado.
Para poder ordenar a nuestro gusto los eventos contenidos en el ArrayList, podríamos implementarle la interfaz Comparable a la clase Evento y sobre escribir el método compareTo() para indicarle cómo se han de ordenar.

Pero, viendo lo que están solicitando en las siguientes clases de "pruebas", parece que nos va a convenir poder ordenar los eventos al menos de dos formas distintas.
Así que en lugar de usar la interfaz Comparable, podemos crear una serie de objetos Comparator, donde cada uno establecerá distintas reglas de ordenamiento y así podremos llamarlos según lo que necesitemos.

Parecido a lo que habíamos hecho con la clase MisConstantes, podemos hacer una clase MisComparadores donde definir unos objetos Comparator como unas constantes que puedan ser utilizadas en cualquier momento para decirle al ArrayList de Eventos cómo ha de ordenarse.

De momento, escribimos un comparador que permita ordenar por "título descendente".

Código: [Seleccionar]

package util;

import java.util.Comparator;

import entidades.Evento;

public class MisComparadores {

public static final Comparator<Evento> TITULO_EVENTO_DESCENDENTE = new Comparator<Evento>() {
@Override
public int compare(Evento evento1, Evento evento2) {
/*
* Los titulos son cadenas String.
* La clase String ya sabe como ha de compararse ella misma,
* así que podemos retornar directamente el resultado de
* comparar los títulos de los eventos.
* Sin embargo, por defecto, la comparación de la clase String
* nos daría un orden ASCENDENTE (de A a Z) y nosotros queremos
* un orden DESCENDENTE (de Z a A).
* Podemos revertir ese orden simplemente multiplicando por -1
* el resultado que da la comparación de la clase String
*/
return (evento1.getTitulo().compareTo(evento2.getTitulo())) * -1;
}
};

}
Con esto, en la clase Prueba01 podemos ordenar el ArrayList antes de mostrar el listado en pantalla.
Para ello, llamamos al método sort() que posee el ArrayList y le pasamos entre paréntesis el comparador que acabamos de escribir:

   public static void main(String[] args) {
      
      //Creacion de Eventos
      char terminar = 'N';
      while (terminar != 'S') {
         eventos.add(crearEvento());
         System.out.println("\nEvento añadido. ¿Desea TERMINAR?(S/N): ");
         terminar = teclado.nextLine().toUpperCase().charAt(0);
      }
      
      //Listar los Eventos
      eventos.sort(MisComparadores.TITULO_EVENTO_DESCENDENTE);
      System.out.println("\n\t\tLISTADO DE EVENTOS");
      System.out.println("\t\t------- -- -------\n");
      for (Evento even: eventos) {
         System.out.println("\n\n\t\t*************************\n");
         even.mostrarEvento();
      }

   }

Y con esto ya habríamos cumplido con lo que pide Prueba01: creación de eventos y mostrar listado ordenado descendente por título.


Antes de terminar, vamos a añadir una cosa.
Es tedioso, más bien terrible...., tener que crear eventos por teclado para poder comprobar si el listado sale ordenado o no.
Con las siguientes clases "pruebas", va a ocurrir lo mismo. Nos piden una serie de operaciones que para poder comprobar si funcionan, primero necesitamos tener eventos.

En lugar de estar creando eventos por teclado cada vez que ejecutamos una prueba, lo ideal es crear mediante código una serie de datos ya predefinidos para poder iniciar las pruebas con datos ya disponibles, sin tener que depende de introducirlos por teclado.

Para esto, en la clase Evento, podemos crear un método estático que reciba un ArrayList y lo cargue con una serie de datos: Expositores, Asistentes y Eventos listos para ser utilizados en las pruebas.

Código: [Seleccionar]



/*
* El siguiente método estático es para facilitar el "entorno de pruebas".
* Añade al ArrayList recibido por argumentos unos cuántos Eventos, con sus
* Expositores y Asistentes, para que las clases de prueba puedan comenzar
* con una serie de datos cargados con los que poder trabajar sin tener
* que introducirlos a mano
*/
public static void cargarDatosPruebas(ArrayList<Evento> eventos) {
//Expositores
Expositor ex1 = new Expositor("EXPO001", "Pedro", "Baños Lopez", 15000, "pedro@balo.com");
Expositor ex2 = new Expositor("EXPO002", "Ines", "Felisa Sanchez", 17000, "ines@fesa.com");
Expositor ex3 = new Expositor("EXPO003", "Ramon", "Lobo Maturana", 12000, "ramon@loma.com");
Expositor ex4 = new Expositor("EXPO004", "Luis", "Salvat Cami", 11000, "luis@saca.com");
Expositor ex5 = new Expositor("EXPO005", "Carmen", "Robledo Velez", 20000, "carmen@rove.com");
Expositor ex6 = new Expositor("EXPO006", "Felipe", "Moreno Reina", 16000, "feli@more.com");
//Asistentes
Asistente as1 = new Asistente("ASI001", "Jorge", "Morales Garcia", "jor@moga.com", "646578090", "C/Peru");
Asistente as2 = new Asistente("ASI002", "Laura", "Juan Moragas", "lalaura@jumo.com", "634588190", "C/Lima");
Asistente as3 = new Asistente("ASI003", "Sara", "Pelaez Tuna", "sarita@petu.com", "646578090", "C/Madrid");
Asistente as4 = new Asistente("ASI004", "Guadalupe", "Flores Flores", "lupe@floflo.com", "646578090", "C/Avestruz");
Asistente as5 = new Asistente("ASI005", "Antonio", "Paz Garcia", "toni@paga.com", "646578090", "C/Pelicano");
Asistente as6 = new Asistente("ASI006", "Antonia", "Perez Castillo", "anto@peca.com", "646578090", "C/Nutria");
Asistente as7 = new Asistente("ASI007", "Alicia", "Aloy Sanchez", "ali@alsa.com", "646578090", "C/Ibice");
Asistente as8 = new Asistente("ASI008", "Javier", "Barbudo Lopez", "javi@balo.com", "646578090", "C/Muflon");
Asistente as9 = new Asistente("ASI009", "Carla", "Bella Zapata", "carla@beza.com", "646578090", "C/Alce");
Asistente as10 = new Asistente("ASI010", "Federico", "Martin Vela", "fredy@mave.com", "646578090", "C/Ecuador");
Asistente as11 = new Asistente("ASI011", "Eva", "Santamaria Lopez", "eva@salo.com", "646578090", "C/Quito");
Asistente as12 = new Asistente("ASI011", "Mario", "Moreno Cantinflas", "mario@moca.com", "646578090", "C/Mexico");
//Eventos
Evento ev1 = new Evento("Impacto Guerra Ucrania", 90, ex1, "10:00", "11:30", true, 'P');
ev1.addAsistente(as1); ev1.addAsistente(as2);
Evento ev2 = new Evento("Arte Textil Africano", 60, ex2, "12:00", "13:00", false, 'V');
ev2.addAsistente(as3); ev2.addAsistente(as4);
Evento ev3 = new Evento("Recuperacion Fauna Iberica", 90, ex3, "14:00", "15:30", true, 'G');
ev3.addAsistente(as5); ev3.addAsistente(as6);
Evento ev4 = new Evento("Nuevas Tecnicas Marketing", 45, ex4, "10:00", "10:45", false, 'V');
ev4.addAsistente(as7); ev4.addAsistente(as8);
Evento ev5 = new Evento("Presentacion Novela Historica", 60, ex5, "17:00", "18:", true, 'P');
ev5.addAsistente(as9); ev5.addAsistente(as10);
Evento ev6 = new Evento("Descifrando Codigo Ensamblador", 120, ex6, "18:00", "20:00", false, 'G');
ev6.addAsistente(as11); ev6.addAsistente(as12);
//Añadimos los eventos creados
eventos.add(ev1); eventos.add(ev2); eventos.add(ev3);
eventos.add(ev4); eventos.add(ev5); eventos.add(ev6);
}
Así, en el main de nuestras pruebas, lo primero que haremos será invocar este método y pasarle nuestro ArrayList de eventos para que lo cargue con datos sin tener que hacerlo nosotros por teclado:

   
   private static ArrayList<Evento> eventos = new ArrayList<Evento>();
   private static Scanner teclado = new Scanner(System.in);

   public static void main(String[] args) {
      
      //Agregamos eventos para pruebas
      Evento.cargarDatosPruebas(eventos);
      
      //Creacion de Eventos
      char terminar = 'N';
      while (terminar != 'S') {
         eventos.add(crearEvento());
         System.out.println("\nEvento añadido. ¿Desea TERMINAR?(S/N): ");
         terminar = teclado.nextLine().toUpperCase().charAt(0);
      }
      
      //Listar los Eventos
      eventos.sort(MisComparadores.TITULO_EVENTO_DESCENDENTE);
      System.out.println("\n\t\tLISTADO DE EVENTOS");
      System.out.println("\t\t------- -- -------\n");
      for (Evento even: eventos) {
         System.out.println("\n\n\t\t*************************\n");
         even.mostrarEvento();
      }

   }

Y con esto ya podemos seguir con el resto de pruebas
Intenta Prueba02.

Recuerda que ya no tienes que introducir eventos por teclado, podemos cargar un ArrayList con eventos automáticamente llamando al método correspondiente.

Una vez cargado, haz un listado del arraylist mostrando:
- titulo del evento
- ubicación
- precio

Cuanto tengas el listado, ahora hay que ver como agrupar esos eventos por ubicación.
Para ello, intenta crear un nuevo comparador que se encargue de ordenar los eventos según la ubicación.
Una vez ordenados, ya podemos hacer una salida por pantalla en tres grupos

Inténtalo, llega hasta donde puedas, no importa si no lo consigues.
Atascarse en el intento es la mejor forma de aprender.
Comparte aquí lo que logres hacer y lo completamos.

Saludos

[edisoncaballeroquispe15]

Estimado la Prueba 02 Lo e realizado de la siguiente manera:

Paso 1  cree el metodo mostrarEventoAgrupUbica en la clase Evento:

public void mostrarEventoAgrupUbica() {

        for (int i = 0; i < titulo.length(); i++)
            System.out.print("-");
        System.out.printf("\n");
        System.out.print("Ubicacion: " );
        switch(codigoUbicacion) {
            case 'P':
                System.out.println("Platinum");
                System.out.println("\n EVENTO : " + titulo.toUpperCase() + " PRECIO :" + MisConstantes.COSTO_P);
                break;
            case 'G':
                System.out.println("Gold");
                System.out.println("\n EVENTO : " + titulo.toUpperCase() + " PRECIO :" + MisConstantes.COSTO_G);
                break;
            default:
                System.out.println("VIP" );
                System.out.println("\n EVENTO : " + titulo.toUpperCase() + " PRECIO :" + MisConstantes.COSTO_V);
        }
    }

Paso seguido mostré lo siguiente en Prueba 02:


public class Prueba02 {

    /*
    muestre la lista de eventos y sus precios, agrupados por ubicación.
     */
    private static ArrayList<Evento> eventos = new ArrayList<Evento>();

    public static void main(String[] args) {

        //Agregamos eventos para pruebas
        Evento.cargarDatosPruebas(eventos);

        //Listar los Eventos
        eventos.sort(MisComparadores.TITULO_EVENTO_DESCENDENTE);
        System.out.println("\n\t\tLISTADO DE EVENTOS AGRUPADOS POR UBICACION");
        for (Evento even: eventos) {
            even.mostrarEventoAgrupUbica();
        }

    }
}

No se si sea lo correcto trabajarlo asi?

[Kabuto]

Si ejecutas tu código, verás que no salen agrupados por ubicación.

La idea sería que primero se mostrasen por ejemplo los eventos Gold y el precio de cada evento. El precio se podría mostrar completo, con el impuesto y el descuento, que puede variar según si es temporada alta o baja.

Luego, lo mismo con los Platinum y por último los VIP.

Esto lo podríamos hacer con tres bucles, o tres métodos, donde cada uno se ocupe de mostrar los eventos de una ubicación concreta.

Pero si previamente ordenamos los eventos por ubicación, podremos hacerlo con un único bucle.

Para ordenarlos así, a la clase MisComparadores podemos añadir un nuevo Comparator, el cuál simplemente tiene que retornar el resultado de comparar el carácter que representa el código de ubicación de los eventos.

public class MisComparadores {
   
   public static final Comparator<Evento> TITULO_EVENTO_DESCENDENTE = new Comparator<Evento>() {
      @Override
      public int compare(Evento evento1, Evento evento2) {
         /*
          * Los titulos son cadenas String.
          * La clase String ya sabe como ha de compararse ella misma,
          * así que podemos retornar directamente el resultado de
          * comparar los títulos de los eventos.
          * Sin embargo, por defecto, la comparación de la clase String
          * nos daría un orden ASCENDENTE (de A a Z) y nosotros queremos
          * un orden DESCENDENTE (de Z a A).
          * Podemos revertir ese orden simplemente multiplicando por -1
          * el resultado que da la comparación de la clase String
          */
         return (evento1.getTitulo().compareTo(evento2.getTitulo())) * -1;
      }
   };
   
   public static final Comparator<Evento> UBICACION_ASCENDENTE = new Comparator<Evento>() {
      @Override
      public int compare(Evento evento1, Evento evento2) {
         return Character.compare(evento1.getCodigoUbicacion(), evento2.getCodigoUbicacion());
      }
   };

}

Con este comparador, y sin necesidad de cambiar nada en la clase Evento ya podemos desarrollar la clase Prueba02 para que haga el listado.
Primero ordenaremos según ubicación.
Y luego al listar, haremos que el sistema detecte cuándo ha terminado con los eventos de una ubicación y va a comenzar con otros, para que lo muestre en pantalla.

Código: [Seleccionar]

package pruebas;

import java.util.ArrayList;

import entidades.Evento;
import util.MisComparadores;

public class Prueba02 {

private static ArrayList<Evento> eventos = new ArrayList<Evento>();

public static void main(String[] args) {
//Agregamos eventos para pruebas
        Evento.cargarDatosPruebas(eventos);

        //Listar los Eventos
        eventos.sort(MisComparadores.UBICACION_ASCENDENTE); //Ordenamos por ubicacion
        System.out.println("\n\t\tLISTADO DE EVENTOS AGRUPADOS POR UBICACION");
       
        char ubicacion = ' ';
        for (Evento even: eventos) {
        //Comprobamos si el evento actual es de distinta ubicacion, y por tanto comienza nuevo grupo
        if (even.getCodigoUbicacion() != ubicacion) { //Ubicacion distinta
        System.out.println(textoUbicacion(even.getCodigoUbicacion())); //Iniciamos nuevo grupo
        ubicacion = even.getCodigoUbicacion(); //Actualizamos la ubicacion actual
        }
        //Mostramos datos del evento
        System.out.printf("--> Titulo: %-35s --> Precio: %.2f\n",
        even.getTitulo(), even.getMontoTotal() - even.getDescuento());
     
        }

}

/*
* Devuelve un texto descriptivo para el codigo de ubicacion.
* Lo usaremos como cabecera para cada grupo de eventos.
*/
private static String textoUbicacion(char codigo) {
switch(codigo) {
case 'G':
return "\n\t---EVENTOS Gold---";
case 'P':
return "\n\t---EVENTOS Platinum---";
default:
return "\n\t---EVENTOS VIP---";
}
}

}

Al ejecutarlo, en pantalla vemos como los eventos quedan visiblemente agrupados.

      LISTADO DE EVENTOS AGRUPADOS POR UBICACION

   ---EVENTOS Gold---
--> Titulo: Recuperacion Fauna Iberica          --> Precio: 159,83
--> Titulo: Descifrando Codigo Ensamblador      --> Precio: 168,71

   ---EVENTOS Platinum---
--> Titulo: Impacto Guerra Ucrania              --> Precio: 265,77
--> Titulo: Presentacion Novela Historica       --> Precio: 265,77

   ---EVENTOS VIP---
--> Titulo: Arte Textil Africano                --> Precio: 106,49
--> Titulo: Nuevas Tecnicas Marketing           --> Precio: 106,49

En los precios vemos que solo hay variedad en los Gold, porque uno es "temporada alta" y el otro no.
En los otros no hay variación porque resulta que los hemos creado bajo la misma temporada.

Opcionalmente, podemos modificar el código de creación de estos eventos para que no coincidan sus temporadas, y así reflejar más variedad en los precios.

      LISTADO DE EVENTOS AGRUPADOS POR UBICACION

   ---EVENTOS Gold---
--> Titulo: Recuperacion Fauna Iberica          --> Precio: 159,83
--> Titulo: Descifrando Codigo Ensamblador      --> Precio: 168,71

   ---EVENTOS Platinum---
--> Titulo: Impacto Guerra Ucrania              --> Precio: 265,77
--> Titulo: Presentacion Novela Historica       --> Precio: 280,53

   ---EVENTOS VIP---
--> Titulo: Arte Textil Africano                --> Precio: 106,49
--> Titulo: Nuevas Tecnicas Marketing           --> Precio: 100,89

Venga, que ya queda menos.
Sigue adelante con la siguiente prueba:

clase Prueba03 que muestre la lista de eventos y el total recaudado por cada evento.

Para esta prueba, no será necesario ordenar los eventos de ninguna manera.
Solamente hacer una lista con los títulos de los eventos y el total recaudado.

El total recaudado sería el resultado de multiplicar el precio (monto - descuento) por la cantidad de asistentes a dicho evento. La cantidad de asistentes la sabemos por el tamaño que tenga el ArrayList, y esto nos lo dice su método size()

En este caso, si podrías hacer un nuevo método para la clase Evento que se ocupe de hacer el cálculo de la recaudación.

Un saludo.

[edisoncaballeroquispe15]

Un favor maestro apoyame con los ejercicios, el domingo tengo q presentarlos.  :'(

[Kabuto]

Apoyar ya lo estoy haciendo.

Pero deberías hacerlos tú, ¿de qué sirve presentar unos ejercicios que no has hecho tú?
¿Los estás entendiendo?

Ya te dije lo que has de hacer para Prueba03

Para esta prueba, no será necesario ordenar los eventos de ninguna manera.
Solamente hacer una lista con los títulos de los eventos y el total recaudado.

El total recaudado sería el resultado de multiplicar el precio (monto - descuento) por la cantidad de asistentes a dicho evento. La cantidad de asistentes la sabemos por el tamaño que tenga el ArrayList, y esto nos lo dice su método size()

En este caso, si podrías hacer un nuevo método para la clase Evento que se ocupe de hacer el cálculo de la recaudación.

Pues eso, a la clase Evento le damos un método que nos calcule el total recaudado según la cantidad de asistentes:

Código: [Seleccionar]


public double getTotalRecaudado() {
//Cada asistente paga el total - descuento
return (getMontoTotal() - getDescuento()) * asistentes.size();
}
Y ya luego en Prueba03, solo hay que recorrer el array y mostrar el título y el resultado que nos da ese método:

Código: [Seleccionar]

public class Prueba03 {

private static ArrayList<Evento> eventos = new ArrayList<Evento>();

public static void main(String[] args) {
//Agregamos eventos para pruebas
        Evento.cargarDatosPruebas(eventos);

        System.out.println("\t\tTOTAL RECAUDADO POR CADA EVENTO\n");
       
        for (Evento even: eventos)
        System.out.printf("--> Titulo: %-35s --> Recaudacion: %.2f\n",
        even.getTitulo(), even.getTotalRecaudado());
}

}
Resultado en pantalla:

      TOTAL RECAUDADO POR CADA EVENTO

--> Titulo: Impacto Guerra Ucrania              --> Recaudacion: 531,53
--> Titulo: Arte Textil Africano                --> Recaudacion: 212,99
--> Titulo: Recuperacion Fauna Iberica          --> Recaudacion: 319,66
--> Titulo: Nuevas Tecnicas Marketing           --> Recaudacion: 201,78
--> Titulo: Presentacion Novela Historica       --> Recaudacion: 561,06
--> Titulo: Descifrando Codigo Ensamblador      --> Recaudacion: 337,42

No había ninguna dificultad, creo yo.
Siguientes pruebas:

Prueba04

Genera una clase Prueba04 que muestre la lista asistentes que hayan pagado en Platinum, Gold y VIP.

Es casi lo mismo que Prueba02.
Ordenar el ArrayList por ubicación y mostrar los nombres de los asistentes que han ido a evento Platinum, luego los que han ido a Gold y luego los VIP

Prueba05

Genera una clase Prueba05 que muestre el sueldo a apagar a todos los expositores que dieron charlas en VIP.

Hay que recorrer el ArrayList y busca los eventos que sean VIP (codigoUbicacion == 'V')
De dichos eventos, podemos mostrar el nombre del Expositor y su sueldo.
Ese sueldo, se puede ir sumando en una variable para que luego al terminar de mostrar el listado, podamos indicar también la suma total de todos esos sueldos.

Tienes que intentar hacerlas tú.
No te sirve de nada que los vaya haciendo yo, eso no te está ayudando me temo.

[edisoncaballeroquispe15]

Muchas gracias por todo. Seguiré practicando mas, para poder subir de nivel.