Ejercicio Java NetBeans código permita registrar eliminar actualizar calcular %

[alejo9908]

Hola, necesitaría ayuda, estoy tratando de resolver este ejercicio en Java.


Ejercicio

La liga departamental de BMX requiere un programa que le permita almacenar la información de sus N deportistas. Se sabe que de cada deportista se tiene el código, nombre, edad, nivel y sexo.

El programa debe permitir realizar lo siguiente:

1.   Registrar un competidor con los datos anteriores.
2.   Eliminar la información de un competidor.
3.   Actualizar la información de un competidor.
4.   Registrar resultados competencia. Cada competidor realiza tres vueltas, se debe registrar el tiempo de cada una.
5.   Determinar el promedio de tiempo empleado por cada competidor en dar las tres vueltas.
6.   Asignarle puesto a cada competidor por nivel. Para cada uno de los niveles de los deportistas, se le debe asignar un puesto de acuerdo al promedio de tiempo empleado en completar las tres vueltas, de menor a mayor tiempo. 
7.   Determinar el porcentaje de deportistas que emplearon un tiempo mayor al promedio de su nivel. 
8.   Mostrar los resultados para un deportista dado.
9.   Listar los competidores que se inscribieron en la competencia, pero no participaron en ella (los tiempos de las tres vueltas son 0)
10.   Hallar por rango de edad, la cantidad de niños y niñas que participaron. Los rangos de edad son: (i) menores de 5, (ii) entre 5 y 10 y (iii) mayores o iguales de 10

Se debe realizar la implementación en el lenguaje de programación Java de los puntos anteriores.

[Kabuto]

¿En JavaScript o en Java?
Aunque se parezcan en el nombre, son lenguajes totalmente distintos, para entornos completamente diferentes.

En cualquier caso, comienza tú el código, ves haciendo poco a poco y cuando te atasques te ayudamos.

Comienza por escribir la clase Deportista, el enunciado ya te indica cuáles son los atributos básicos:

cada deportista se tiene el código, nombre, edad, nivel y sexo.

[alejo9908]

en java, ya inicie con el menú pero no sé como hacer los sub programas para cada parametro (edad, nombre etc)

[Kabuto]

Insisto, primero hay que escribir una clase Deportista, con sus atributos y métodos.
Al menos sus getter y setter, pero ya que nos dicen que uno de sus atributos es un código, se supone que es un código identificador único, es decir, no pueden haber dos Deportistas con el mismo código.

Para poder tener cierto control sobre este aspecto, podemos sobreescribir el método equals() de manera que dos Deportistas se consideren iguales si tienen el mismo código.

Código: [Seleccionar]

public class Deportista {

private String codigo;
private String nombre;
private int edad;
private String nivel;
private String sexo;

public Deportista(String codigo, String nombre, int edad, String nivel, String sexo) {
this.codigo = codigo;
this.nombre = nombre;
this.edad = edad;
this.nivel = nivel;
this.sexo = sexo;
}

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 int getEdad() {
return edad;
}

public void setEdad(int edad) {
this.edad = edad;
}

public String getNivel() {
return nivel;
}

public void setNivel(String nivel) {
this.nivel = nivel;
}

public String getSexo() {
return sexo;
}

public void setSexo(String sexo) {
this.sexo = sexo;
}

@Override
public boolean equals(Object obj) {
if (obj instanceof Deportista) {
//Dos deportistas son equivalentes si tienen el mismo codigo
Deportista otroDepor = (Deportista) obj;
return otroDepor.codigo.equals(codigo);
}
else
return false;
}
}
De momento esta será la clase Deportista, luego según se vaya desarrollando el programa puede que la modifiquemos.

Pero por ahora, ya podríamos realizar las tres primeras opciones del menú: registrar deportista, eliminarlos y modificarlos.

Para eso, en otra clase, que será la clase principal con el main(), podemos declarar un ArrayList donde registrar los Deportistas.
Mostraremos un menú de opciones, y para cada opción, escribiremos una función que se encargue de llevarla a cabo.

Código: [Seleccionar]

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

public class MenuCompeticion {

private static ArrayList<Deportista> deportistas;
private static Scanner teclado;

public static void main(String[] args) {

deportistas = new ArrayList<Deportista>();
teclado = new Scanner(System.in);
int opcion = 0;

do {
mostrarMenu();
opcion = Integer.parseInt(teclado.nextLine());

switch(opcion) {
case 0:
System.out.println("\nFIN DE PROGRAMA");
break;
case 1:
registrarDeportista();
break;
case 2:
eliminarDeportista();
break;
case 3:
modificarDeportista();
break;
default:
System.out.println("\nOpcion equivocada");
}

}while (opcion != 0);

}

private static void mostrarMenu() {
System.out.println("\n\t\tMENU COMPETICION");
System.out.println("\t\t---- -----------\n");
System.out.println("[1] -- Registrar Deportista");
System.out.println("[2] -- Eliminar Deportista");
System.out.println("[3] -- Modificar Deportista");
System.out.println("\n[0] -- TERMINAR PROGRAMA");
}

private static void registrarDeportista() {
System.out.println("\n\t--NUEVO DEPORTISTA--");
System.out.print("Codigo: ");
String codigo = teclado.nextLine();
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Edad: ");
int edad = Integer.parseInt(teclado.nextLine());
System.out.print("Nivel(A/B/C): ");
String nivel = teclado.nextLine().toUpperCase();
System.out.print("Sexo: ");
String sexo = teclado.nextLine();

Deportista nuevo = new Deportista(codigo, nombre, edad, nivel, sexo);
if (deportistas.contains(nuevo))
System.out.println("\nYa existe deportista con codigo: " + codigo);
else {
deportistas.add(nuevo);
System.out.println("\nDeportista registrado");
}
}

private static void eliminarDeportista() {
System.out.println("\n\t--ELIMINAR DEPORTISTA--");
System.out.print("Codigo: ");
String codigo = teclado.nextLine();

Deportista buscado = null;
for (int i = 0; i < deportistas.size(); i++)
if (deportistas.get(i).getCodigo().equals(codigo))
buscado = deportistas.get(i);

if (buscado == null)
System.out.println("\nNo existe deportista con el codigo: " + codigo);
else {
deportistas.remove(buscado);
System.out.println("\nDeportista eliminado");
}
}

private static void modificarDeportista() {
System.out.println("\n\t--MODIFICAR DEPORTISTA--");
System.out.print("Codigo: ");
String codigo = teclado.nextLine();

Deportista buscado = null;
for (int i = 0; i < deportistas.size(); i++)
if (deportistas.get(i).getCodigo().equals(codigo))
buscado = deportistas.get(i);

if (buscado == null)
System.out.println("\nNo existe deportista con el codigo: " + codigo);
else {
//Codigo no se puede modificar
System.out.println("\nNombre actual: " + buscado.getNombre());
System.out.print("Nuevo nombre: ");
buscado.setNombre(teclado.nextLine());
System.out.println("\nEdad actual: " + buscado.getEdad());
System.out.print("Nueva edad: ");
buscado.setEdad(Integer.parseInt(teclado.nextLine()));
System.out.println("\nNivel actual: " + buscado.getNivel());
System.out.print("Nuevo nivel: ");
buscado.setNivel(teclado.nextLine());
System.out.println("\nSexo actual: " + buscado.getSexo());
System.out.print("Nuevo sexo: ");
buscado.setSexo(teclado.nextLine());

System.out.println("\nDeportista modificado");
}
}

}
Bien, ya tenemos lo básico. Antes de seguir, revisa este código, asegúrate de que lo entiendes y ya tu mismo decides si quieres escribir el tuyo propio siguiendo esta lógica o utilizar este.
Sobre todo lo importante es que quede clara la necesidad de modelar una clase y de cómo su gestión se llevará a cabo desde otra clase distinta.

Luego continúo en otro mensaje.

[Kabuto]

La siguiente opción del menú habla de registrar las tres vueltas de la competencia en la que participan cada uno de los deportistas.
No se nos indica de que manera debemos registrar y relacionar las vueltas con los deportistas, así que lo decidimos nosotros.

Hay múltiples formas: una matriz paralela al ArrayList de deportistas, agregar nuevos atributos a los deportistas,...

Tampoco nos dicen cómo hemos de recoger los tiempos de las vueltas: ¿en minutos, en segundos, en minutos y segundos....?

Creo que por equilibrio entre sencillez y lógica, podemos pedir al usuario minutos y segundos por separado.
De hecho, podemos crear una clase llamada Vuelta con esos dos atributos, minutos y segundos.
Luego se nos va a pedir comparar los tiempos de unas vueltas con otras, en este caso si puede resultarnos más cómodo tratar el tiempo total en solo segundos para que sea más fácil comparar. Así que podemos darle a esta clase Vuelta un método que haga este cálculo.

También podemos sobreescribirle el método toString() para que así una Vuelta sepa darnos un String que representa sus tiempos con un formato adecuado

Código: [Seleccionar]

public class Vuelta {

private int minutos;
private int segundos;

public Vuelta() {
minutos = 0;
segundos = 0;
}

public Vuelta(int minutos, int segundos) {
this.minutos = minutos;
this.segundos = segundos;
}

public int getMinutos() {
return minutos;
}

public void setMinutos(int minutos) {
this.minutos = minutos;
}

public int getSegundos() {
return segundos;
}

public void setSegundos(int segundos) {
this.segundos = segundos;
}

/*
* Para comparar tiempos de distintas vueltas,
* puede ser más cómodo convertir el tiempo
* en segundos totales.
*/
public int totalSegundos() {
return (minutos * 60) + segundos;
}

@Override
public String toString() {
return String.format("[%02d:%02d]", minutos, segundos);
}

}
Vale, ahora ya tenemos una clase donde recoger tiempos de vueltas. ¿Cómo las relacionamos con los deportistas?

Cada deportista realizará tres vueltas, y solo tres, así que por ahora (quizás luego cambie de opinión) creo que lo más cómodo es modificar la clase Deportista para que tenga un nuevo atributo, que será un array de tres objetos Vuelta.

En su constructor inicializaremos el array con tres Vueltas con tiempo 0, aunque solo será por no dejar el array con valores null en ningún momento.
Luego los valores de las vueltas, se los haremos llegar (por comodidad) por un setter que machacará el array anterior. Así que en realidad no sería necesario inicializarlo al crear un Deportista, pero no me gusta dejar atributos con valores null si no hay un motivo lógico.

La clase Deportista queda así cambiada:

public class Deportista {
   
   private String codigo;
   private String nombre;
   private int edad;
   private String nivel;
   private String sexo;
   //Las vueltas que realiza el deportista
   private Vuelta[] vueltas;
   
   public Deportista(String codigo, String nombre, int edad, String nivel, String sexo) {
      this.codigo = codigo;
      this.nombre = nombre;
      this.edad = edad;
      this.nivel = nivel;
      this.sexo = sexo;
      //Un competidor realiza 3 vueltas
      vueltas = new Vuelta[3];
      for (int i = 0; i < 3; i++)
         vueltas = new Vuelta();//Inicialmente las vueltas tienen los tiempos en 0
   }

   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 int getEdad() {
      return edad;
   }

   public void setEdad(int edad) {
      this.edad = edad;
   }

   public String getNivel() {
      return nivel;
   }

   public void setNivel(String nivel) {
      this.nivel = nivel;
   }

   public String getSexo() {
      return sexo;
   }

   public void setSexo(String sexo) {
      this.sexo = sexo;
   }
   
   /*
    * Los tiempos de vueltas llegarán ya coleccionadas
    *  en un array que machará el actual.
    */
   public void setVueltas(Vuelta[] vueltas) {
      this.vueltas = vueltas;
   }
   
   @Override
   public boolean equals(Object obj) {
      if (obj instanceof Deportista) {
         //Dos deportistas son equivalentes si tienen el mismo codigo
         Deportista otroDepor = (Deportista) obj;
         return otroDepor.codigo.equals(codigo);
      }
      else
         return false;
   }
}

Con esto, ya podemos hacer el punto 4 del menú.
Para ello a la clase principal le añadimos una nueva función que, tras comprobar si hay deportistas registrados, pida los tiempos de tres vueltas y luego pida el código del deportista al que quiere asignarle esos tiempos.

Código: [Seleccionar]

private static void registrarVueltas() {

if (deportistas.isEmpty())
System.out.println("No hay deportistas registrados."
+ "\nNo se pueden registar tiempos de vueltas.");
else {
Vuelta[] vueltas = new Vuelta[3];
System.out.println("\n\tREGISTRAR COMPETENCIA");
System.out.println("Introduzca los tiempos de tres vueltas");
for (int i = 0; i < 3; i++) {
System.out.println("Vuelta #" + (i+1));
System.out.print("Minutos: ");
int minutos = Integer.parseInt(teclado.nextLine());
System.out.print("Segundos: ");
int segundos = Integer.parseInt(teclado.nextLine());
vueltas[i] = new Vuelta(minutos, segundos);
}

//Ahora preguntamos a que Deportista se las asignamos
System.out.print("\nIndique el codigo del Deportista: ");
String codigo = teclado.nextLine();

Deportista buscado = null;
for (int i = 0; i < deportistas.size(); i++)
if (deportistas.get(i).getCodigo().equals(codigo))
buscado = deportistas.get(i);

if (buscado == null)
System.out.println("\nNo existe deportista con el codigo: " + codigo);
else {
buscado.setVueltas(vueltas);
System.out.println("\nTiempos de vueltas se han asignado al deportista.");
}
}
}
Añadimos nueva opción al menú y por supuesto al switch del main() para poder llevarla a cabo:

      do {
         mostrarMenu();
         opcion = Integer.parseInt(teclado.nextLine());
         
         switch(opcion) {
         case 0:
            System.out.println("\nFIN DE PROGRAMA");
            break;
         case 1:
            registrarDeportista();
            break;
         case 2:
            eliminarDeportista();
            break;
         case 3:
            modificarDeportista();
            break;
         case 4:
            registrarVueltas();
            break;
         default:
            System.out.println("\nOpcion equivocada");
         }
         
      }while (opcion != 0);

Si continuamos con la siguiente opción del menú, la 5, nos pide obtener el tiempo promedio de cada deportista en realizar las tres vueltas.
Para esto, primero le vamos a enseñar a la clase Deportista a retornar el tiempo promedio.
Para esto nos será útil el poder convertir los tiempos a segundos, calcular el promedio, y dicho promedio reconvertirlo a minutos y segundos para poder presentarlo en pantalla debidamente formateado.

Así que a la clase Deportista le añadimos los siguientes métodos:
Uno se encargará de calcular el promedio, en segundos. Hay más opciones del menú que dependen de este cálculo, así que va bien tener un método específico para esta tarea y que otros métodos puedan recurrir a él.

Código: [Seleccionar]

/*
* El tiempo promedio se retorna calculado
* en segundos
*/
public int tiempoPromedio() {
int segundosTotales = 0;
for (Vuelta v: vueltas)
segundosTotales += v.totalSegundos();

return segundosTotales / 3;
}

Otro método será el que se encargue de retornar un String para mostrar en pantalla el tiempo promedio.
Para esto, se ha de transformar el promedio en minutos y segundos. Con estos dos elemenos, podemos construir un objeto Vuelta e invocar a su método toString(), al que anteriormente ya le enseñamos a como ha de formatear un tiempo de vuelta para mostrarlo en pantalla.

Pero, ¡¡atención!!...
Pueden haber deportistas que aún no hayan competido, es decir, que no tengan tiempos de vueltas registrados.
En ese caso, convendría mostrar un mensaje en pantalla y no un tiempo.
Hay que distinguir entre los que han competido y los que no, para tratarlos de distinta manera.

Una forma de saberlo, es aprovechar el método calcularPromedio(). Si retorna un valor de 0, que es el tiempo de las vueltas al inicializarse, es que no se le han registrado nuevas Vueltas todavía y por tanto no ha competido el deportista en cuestión.

Podemos hacer otro método boolean que basándose en el promedio, retorne verdadero o falso para indicar si ha competido o no este deportista.

Código: [Seleccionar]

/*
* Para saber si un Deportista ha competido podemos comprobar
* si su tiempo promedio es distinto de 0
*/
public boolean haCompetido() {
return tiempoPromedio() != 0;
}
Y ahora sí, podemos hacer el método que mostrará el tiempo promedio en pantalla si el deportista ha competido, y si no, mostrará un mensaje

Código: [Seleccionar]

/*
* Para mostrar en pantalla el tiempo promedio
* bien formateado, hay que convertir a minutos y segundos
* para poder construir un objeto Vuelta
*/
public String mostrarPromedio() {
if (haCompetido()) {
int promedio = tiempoPromedio();
int minutos = promedio / 60;
int segundos = promedio % 60;
//El objeto Vuelta ya sabe como mostrarse en pantalla formateado
return new Vuelta(minutos, segundos).toString();
}
else
return "No ha competido.";
}
Con esto, ya podemos volver a la clase principal y añadir nueva función que se encargue de recorrer los deportistas registrados y mostrar sus tiempos promedios:

Código: [Seleccionar]

private static void mostrarPromedios() {
System.out.println("\n\tTIEMPOS PROMEDIOS");
System.out.println("\t------- ---------");
if (deportistas.isEmpty())
System.out.println("No hay deportistas registrados todavía");
else {
for (Deportista dpt: deportistas) {
System.out.println("\n\t---------------------------");
System.out.println("Codigo: " + dpt.getCodigo());
System.out.println("Nombre: " + dpt.getNombre());
System.out.println("Tiempo promedio: " + dpt.mostrarPromedio());
System.out.println("\t---------------------------");
}
}
}
Tras esto, actualizamos el menú y el switch para disponer de esta nueva opción.
Y si la ejecutamos, veremos en pantalla que se muestran los tiempos promedios de aquellos que han competido y los que no, se muestra un mensaje.

   TIEMPOS PROMEDIOS
   ------- ---------

   ---------------------------
Codigo: DEP001
Nombre: Lucas
Tiempo promedio: [01:03]
   ---------------------------

   ---------------------------
Codigo: DEP002
Nombre: Sara
Tiempo promedio: [00:59]
   ---------------------------

   ---------------------------
Codigo: DEP003
Nombre: Ramon
Tiempo promedio: No ha competido.
   ---------------------------

   ---------------------------
Codigo: DEP004
Nombre: Laura
Tiempo promedio: [01:05]
   ---------------------------

Continuaremos en un próximo mensaje.

[Kabuto]

Veamos el siguiente punto:

6.   Asignarle puesto a cada competidor por nivel. Para cada uno de los niveles de los deportistas, se le debe asignar un puesto de acuerdo al promedio de tiempo empleado en completar las tres vueltas, de menor a mayor tiempo.

Parece complejo, pero no lo es tanto.
Los competidores tienen un "nivel", así que se nos pide agrupar deportistas por sus niveles y ordenarlos de menor a mayor tiempo promedio.
No se nos ha dicho exactamente que es ese "nivel", si una categoría o que...

No importa, yo en mi código puse que hay tres niveles: A , B y C.
Así que para hacer lo que nos piden, agruparemos en distintas colecciones a los deportistas que sean A, en otra los B y en otras los C.
Y los ordenaremos según su tiempo promedio.

El proceso de ordenación, podríamos hacerlo más simple y eficiente si le enseñamos a la clase Deportista cómo ha de compararse con ella misma, es decir, que un objeto Deportista pueda recibir otro objeto y determinar quien es "menor o mayor", en función de sus tiempos promedios.

Para esto, podemos modificar la clase Deportista y al principio de todo, en su declaración, pedirle que implemente la interface Comparable

public class Deportista implements Comparable<Deportista>{

Esto nos "obliga" a incluirle ahora un método llamado compareTo() donde tenemos que escribir el código necesario para decidir cómo se han de comparar dos objetos Deportista.
Puesto que lo queremos comparar son sus tiempos promedios, que ya tenemos un método que nos lo calcula y nos lo retorna como segundos guardados en un int/Integer, pues simplemente tenemos que retornar el resultado de comparar esos Integer.

Código: [Seleccionar]

@Override
public int compareTo(Deportista otroDpt) {
//Esta comparación ordena deportistas de menor a mayor promedio
return Integer.compare(tiempoPromedio(), otroDpt.tiempoPromedio());
}
Y ahora volvemos a la clase principal para añadir una nueva función.
Lo que haremos será crear tres ArrayList, uno para cada nivel. Agruparemos en ellos los Deportistas correspondientes (solo los que hayan competido) y le pediremos al ArrayList que se ordene.
El ArrayList lo que hará será ordenar según lo que hemos establecido en el método compareTo(), así que automáticamente tendremos los deportistas separados por niveles y ordenados de menor a mayor promedio.
Solo faltará mostrarlos en pantalla:

Código: [Seleccionar]

private static void rankingPorNivel() {
System.out.println("\n\t\tRANKING POR NIVEL");
System.out.println("\t\t------- --- -----");
if (deportistas.isEmpty())
System.out.println("No hay deportistas registrados todavía");
else {
var nivelA = new ArrayList<Deportista>();
var nivelB = new ArrayList<Deportista>();
var nivelC = new ArrayList<Deportista>();
//Separamos por niveles
for (Deportista dpt: deportistas) {
if (dpt.haCompetido()) {
switch(dpt.getNivel()) {
case "A":
nivelA.add(dpt);
break;
case "B":
nivelB.add(dpt);
break;
case "C":
nivelC.add(dpt);
}
}
}
//Pedimos a los ArrayList que se ordenen.
nivelA.sort(null); //Al indicar null, se ordenan según el compareTo() de los Deportistas
nivelB.sort(null);
nivelC.sort(null);
//Mostramos rankings en pantalla
System.out.println("\n\t---Nivel A---");
for (int i = 0; i < nivelA.size(); i++) {
System.out.println("\n#" + (i+1));
System.out.println("Nombre: " + nivelA.get(i).getNombre());
System.out.println("Promedio: " + nivelA.get(i).mostrarPromedio());
}
System.out.println("\n\t---Nivel B---");
for (int i = 0; i < nivelB.size(); i++) {
System.out.println("\n#" + (i+1));
System.out.println("Nombre: " + nivelB.get(i).getNombre());
System.out.println("Promedio: " + nivelB.get(i).mostrarPromedio());
}
System.out.println("\n\t---Nivel C---");
for (int i = 0; i < nivelC.size(); i++) {
System.out.println("\n#" + (i+1));
System.out.println("Nombre: " + nivelC.get(i).getNombre());
System.out.println("Promedio: " + nivelC.get(i).mostrarPromedio());
}
}
}
Actualizamos el menú y el switch, y al probarlo, veremos que se clasifican y ordenan correctamente. Y no ha sido tan difícil la verdad.
Usando bien la interfaz Comparable, nos ahorramos tener que ordenar con "métodos burbujas" y algoritmos de ese estilo.

      RANKING POR NIVEL
      ------- --- -----

   ---Nivel A---

#1
Nombre: Cristina
Promedio: [01:03]

#2
Nombre: Laura
Promedio: [01:05]

   ---Nivel B---

#1
Nombre: Sara
Promedio: [00:59]

#2
Nombre: Soledad
Promedio: [01:02]

   ---Nivel C---

#1
Nombre: Roberto
Promedio: [01:02]

#2
Nombre: Lucas
Promedio: [01:03]

[Kabuto]

Punto 7

7.   Determinar el porcentaje de deportistas que emplearon un tiempo mayor al promedio de su nivel.

Parecido al anterior, habrá que distinguir entre deportistas según su nivel.
Calcular el promedio de cada nivel y ver cuántos están por encima y expresarlo en un porcentaje.

La función para realizar esto es un poco larga, no por su dificultad, si no porque hay que hacer varios recuentos y habrá que recorrer el ArrayList de deportistas dos veces

Código: [Seleccionar]

private static void porcentajeDeportistasSobreNivel() {
System.out.println("\n\tPORCENTAJE DEPORTISTAS SUPERAN TIEMPOS PROMEDIOS");
System.out.println("\t---------- ----------- ------- ------- ---------\n");
if (deportistas.isEmpty())
System.out.println("No hay deportistas registrados todavía");
else {
//Suma de promedios y recuento de jugadores, según nivel
int sumaA = 0, contadorA = 0;
int sumaB = 0, contadorB = 0;
int sumaC = 0, contadorC = 0;
for (Deportista dpt: deportistas) {
switch(dpt.getNivel()) {
case "A":
sumaA += dpt.tiempoPromedio();
contadorA++;
break;
case "B":
sumaB += dpt.tiempoPromedio();
contadorB++;
break;
case "C":
sumaC += dpt.tiempoPromedio();
contadorC++;
}
}
//Calculamos promedio de cada nivel
int promedioA = sumaA / contadorA;
int promedioB = sumaB / contadorB;
int promedioC = sumaC / contadorC;
//Tenemos el promedio de cada nivel
//volvemos a recorrer deportistas para contar quien está por encima de su promedio
int superanA = 0, superanB = 0, superanC = 0;
for (Deportista dpt: deportistas) {
switch(dpt.getNivel()) {
case "A":
if (dpt.tiempoPromedio() > promedioA)
superanA++;
break;
case "B":
if (dpt.tiempoPromedio() > promedioB)
superanB++;
break;
case "C":
if (dpt.tiempoPromedio() > promedioC)
superanC++;
}
}
//Tenemos todos los datos
System.out.println("--Nivel A--");
System.out.println("Deportistas por encima del promedio: "
+ (superanA * 100 / contadorA) + "%");
System.out.println("\n--Nivel B--");
System.out.println("Deportistas por encima del promedio: "
+ (superanB * 100 / contadorB) + "%");
System.out.println("\n--Nivel C--");
System.out.println("Deportistas por encima del promedio: "
+ (superanC * 100 / contadorC) + "%");
int totalSuperan = superanA + superanB + superanC;
System.out.println("\nTotal deportistas por encima del promedio: "
+ (totalSuperan * 100 / deportistas.size()) + "%");
}
}Aunque no lo pide, he hecho que se desglosen los porcentajes por cada nivel, además de mostrar el total, que es lo que se pedía.
Como de todos modos era necesario obtener todos eso datos, ya que los tenemos los usaremos para mostrar más info en pantalla.

   PORCENTAJE DEPORTISTAS SUPERAN TIEMPOS PROMEDIOS
   ---------- ----------- ------- ------- ---------

--Nivel A--
Deportistas por encima del promedio: 66%

--Nivel B--
Deportistas por encima del promedio: 50%

--Nivel C--
Deportistas por encima del promedio: 66%

Total deportistas por encima del promedio: 62%

Bien restan por hacer los puntos 8 , 9 y 10.
Intenta realizarlos tú (el 9 prácticamente está hecho porque ya tenemos un método para saber quien ha competido y quien no) siguiendo la misma dinámica.

Si te atascas, equivocas o lo que sea. Comparte por aquí lo que hayas conseguido y lo corregimos.

[alejo9908]

amigo hola. la verdad quedé un poco confundido y no creo ser capaz de hacer los puntos restantes porque pues soy novato en programacion, esto es la primer materia que veo en la Universidad de programacion y esta tarea es el proyecto final, entonces ando medio perdido. De igual modo te agradezco mucho tu ayuda. Tratare de estudiar bien los codigos

[alejo9908]

Te agradeceria mucho si me pasaras el codigo completo por favor, me comprometo a estudiarlo bien

[Kabuto]

El compromiso es contigo mismo, no conmigo.

Pongo ahora el código completo. Revísalo y no dudes en preguntar el por qué de esto, el significado de aquello,... lo que sea.

Puede que haya usado cosas que aún no te han explicado, como la interfaz Comparable que he usado para resolver lo de ordenar deportistas según sus tiempos promedios.
Eso puede resolverse sin usar esa interfaz, aunque sería un poco más engorroso.

Pero si crees que hay algo que no se espera que puedas/sepas usarlo, dilo y buscamos otra alternativa.

Clase Vuelta

Código: [Seleccionar]

public class Vuelta {

private int minutos;
private int segundos;

public Vuelta() {
minutos = 0;
segundos = 0;
}

public Vuelta(int minutos, int segundos) {
this.minutos = minutos;
this.segundos = segundos;
}

public int getMinutos() {
return minutos;
}

public void setMinutos(int minutos) {
this.minutos = minutos;
}

public int getSegundos() {
return segundos;
}

public void setSegundos(int segundos) {
this.segundos = segundos;
}

/*
* Para comparar tiempos de distintas vueltas,
* puede ser más cómodo convertir el tiempo
* en segundos totales.
*/
public int totalSegundos() {
return (minutos * 60) + segundos;
}

@Override
public String toString() {
return String.format("[%02d:%02d]", minutos, segundos);
}

}
Clase Deportista, que está relacionada con Vuelta. Porque un Deportista compite dando tres Vueltas.

Código: [Seleccionar]

public class Deportista implements Comparable<Deportista>{

private String codigo;
private String nombre;
private int edad;
private String nivel;
private String sexo;
//Las vueltas que realiza el deportista
private Vuelta[] vueltas;

public Deportista(String codigo, String nombre, int edad, String nivel, String sexo) {
this.codigo = codigo;
this.nombre = nombre;
this.edad = edad;
this.nivel = nivel;
this.sexo = sexo;
//Un competidor realiza 3 vueltas
vueltas = new Vuelta[3];
for (int i = 0; i < 3; i++)
vueltas[i] = new Vuelta();//Inicialmente las vueltas tienen los tiempos en 0
}

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 int getEdad() {
return edad;
}

public void setEdad(int edad) {
this.edad = edad;
}

public String getNivel() {
return nivel;
}

public void setNivel(String nivel) {
this.nivel = nivel;
}

public String getSexo() {
return sexo;
}

public void setSexo(String sexo) {
this.sexo = sexo;
}

/*
* Los tiempos de vueltas llegarán ya coleccionadas
*  en un array que machará el actual.
*/
public void setVueltas(Vuelta[] vueltas) {
this.vueltas = vueltas;
}

/*
* El tiempo promedio se retorna calculado
* en segundos
*/
public int tiempoPromedio() {
int segundosTotales = 0;
for (Vuelta v: vueltas)
segundosTotales += v.totalSegundos();

return segundosTotales / 3;
}

/*
* Para saber si un Deportista ha competido podemos comprobar
* si su tiempo promedio es distinto de 0
*/
public boolean haCompetido() {
return tiempoPromedio() != 0;
}

/*
* Para mostrar en pantalla el tiempo promedio
* bien formateado, hay que convertir a minutos y segundos
* para poder construir un objeto Vuelta
*/
public String mostrarPromedio() {
if (haCompetido()) {
int promedio = tiempoPromedio();
int minutos = promedio / 60;
int segundos = promedio % 60;
//El objeto Vuelta ya sabe como mostrarse en pantalla formateado
return new Vuelta(minutos, segundos).toString();
}
else
return "No ha competido.";
}

public void mostrarResultados() {
if (haCompetido()) {
System.out.println("--Tiempos de vueltas--");
System.out.println("1era Vuelta: " + vueltas[0]);
System.out.println("2da Vuelta: " + vueltas[1]);
System.out.println("3era Vuelta: " + vueltas[2]);
}
else
System.out.println("No ha competido.");
}

@Override
public boolean equals(Object obj) {
if (obj instanceof Deportista) {
//Dos deportistas son equivalentes si tienen el mismo codigo
Deportista otroDepor = (Deportista) obj;
return otroDepor.codigo.equals(codigo);
}
else
return false;
}

@Override
public int compareTo(Deportista otroDpt) {
//Esta comparacion ordena deportistas de menor a mayor promedio
return Integer.compare(tiempoPromedio(), otroDpt.tiempoPromedio());
}
}
Y la clase principal, con un menú y un procedimiento para cada uno de los puntos del menú.
Además hay un procedimiento que se ejecuta al arrancar el programa y lo que hace es registrar automáticamente algunos deportistas. Así el programa ya comienza con algunos registros para poder probar todas las opciones directamente, sin tener que hacer nuevos registros cada vez que iniciamos la aplicación.

Código: [Seleccionar]

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

public class MenuCompeticion {

private static ArrayList<Deportista> deportistas;
private static Scanner teclado;

public static void main(String[] args) {

deportistas = new ArrayList<Deportista>();
teclado = new Scanner(System.in);
int opcion = 0;
deportistasPruebas(); //Automáticamente añade algunos deportistas para probar el código

do {
mostrarMenu();
opcion = Integer.parseInt(teclado.nextLine());

switch(opcion) {
case 0:
System.out.println("\nFIN DE PROGRAMA");
break;
case 1:
registrarDeportista();
break;
case 2:
eliminarDeportista();
break;
case 3:
modificarDeportista();
break;
case 4:
registrarVueltas();
break;
case 5:
mostrarPromedios();
break;
case 6:
rankingPorNivel();
break;
case 7:
porcentajeDeportistasSobreNivel();
break;
case 8:
mostrarResultadosDeportista();
break;
case 9:
listaNoHanCompetido();
break;
case 10:
participantesPorEdad();
break;
default:
System.out.println("\nOpcion equivocada");
}

}while (opcion != 0);

}

private static void mostrarMenu() {
System.out.println("\n\t\tMENU COMPETICION");
System.out.println("\t\t---- -----------\n");
System.out.println("[1] -- Registrar Deportista");
System.out.println("[2] -- Eliminar Deportista");
System.out.println("[3] -- Modificar Deportista");
System.out.println("[4] -- Registrar resultados de la competencia");
System.out.println("[5] -- Mostrar tiempos promedios de vueltas");
System.out.println("[6] -- Mostrar posiciones ranking por nivel");
System.out.println("[7] -- Mostrar porcentajes jugadores con promedios superior a su nivel");
System.out.println("[8] -- Mostrar resultados de un deportista");
System.out.println("[9] -- Listar deportistas sin competir");
System.out.println("[10] -- Participantes por rango de edad");
System.out.println("\n[0] -- TERMINAR PROGRAMA");
}
//Opcion 1 del menú
private static void registrarDeportista() {
System.out.println("\n\t--NUEVO DEPORTISTA--");
System.out.print("Codigo: ");
String codigo = teclado.nextLine();
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Edad: ");
int edad = Integer.parseInt(teclado.nextLine());
System.out.print("Nivel(A/B/C): ");
String nivel = teclado.nextLine().toUpperCase();
System.out.print("Sexo: ");
String sexo = teclado.nextLine();

Deportista nuevo = new Deportista(codigo, nombre, edad, nivel, sexo);
if (deportistas.contains(nuevo))
System.out.println("\nYa existe deportista con codigo: " + codigo);
else {
deportistas.add(nuevo);
System.out.println("\nDeportista registrado");
}
}
//Opcion 2 del menú
private static void eliminarDeportista() {
System.out.println("\n\t--ELIMINAR DEPORTISTA--");
System.out.print("Codigo: ");
String codigo = teclado.nextLine();

Deportista buscado = null;
for (int i = 0; i < deportistas.size(); i++)
if (deportistas.get(i).getCodigo().equals(codigo))
buscado = deportistas.get(i);

if (buscado == null)
System.out.println("\nNo existe deportista con el codigo: " + codigo);
else {
deportistas.remove(buscado);
System.out.println("\nDeportista eliminado");
}
}
//Opcion 3 del menú
private static void modificarDeportista() {
System.out.println("\n\t--MODIFICAR DEPORTISTA--");
System.out.print("Codigo: ");
String codigo = teclado.nextLine();

Deportista buscado = null;
for (int i = 0; i < deportistas.size(); i++)
if (deportistas.get(i).getCodigo().equals(codigo))
buscado = deportistas.get(i);

if (buscado == null)
System.out.println("\nNo existe deportista con el codigo: " + codigo);
else {
//Atributo código no se debe modificar
System.out.println("\nNombre actual: " + buscado.getNombre());
System.out.print("Nuevo nombre: ");
buscado.setNombre(teclado.nextLine());
System.out.println("\nEdad actual: " + buscado.getEdad());
System.out.print("Nueva edad: ");
buscado.setEdad(Integer.parseInt(teclado.nextLine()));
System.out.println("\nNivel actual: " + buscado.getNivel());
System.out.print("Nuevo nivel: ");
buscado.setNivel(teclado.nextLine());
System.out.println("\nSexo actual: " + buscado.getSexo());
System.out.print("Nuevo sexo: ");
buscado.setSexo(teclado.nextLine());

System.out.println("\nDeportista modificado");
}
}
//Opcion 4 del menú
private static void registrarVueltas() {

if (deportistas.isEmpty())
System.out.println("No hay deportistas registrados."
+ "\nNo se pueden registar tiempos de vueltas.");
else {
Vuelta[] vueltas = new Vuelta[3];
System.out.println("\n\tREGISTRAR COMPETENCIA");
System.out.println("Introduzca los tiempos de tres vueltas");
for (int i = 0; i < 3; i++) {
System.out.println("Vuelta #" + (i+1));
System.out.print("Minutos: ");
int minutos = Integer.parseInt(teclado.nextLine());
System.out.print("Segundos: ");
int segundos = Integer.parseInt(teclado.nextLine());
vueltas[i] = new Vuelta(minutos, segundos);
}

//Ahora preguntamos a que Deportista se las asignamos
System.out.print("\nIndique el codigo del Deportista: ");
String codigo = teclado.nextLine();

Deportista buscado = null;
for (int i = 0; i < deportistas.size(); i++)
if (deportistas.get(i).getCodigo().equals(codigo))
buscado = deportistas.get(i);

if (buscado == null)
System.out.println("\nNo existe deportista con el codigo: " + codigo);
else {
buscado.setVueltas(vueltas);
System.out.println("\nTiempos de vueltas se han asignado al deportista.");
}
}
}
//Opcion 5 del menú
private static void mostrarPromedios() {
System.out.println("\n\tTIEMPOS PROMEDIOS");
System.out.println("\t------- ---------\n");
if (deportistas.isEmpty())
System.out.println("No hay deportistas registrados todavía");
else {
for (Deportista dpt: deportistas) {
System.out.println("\n\t---------------------------");
System.out.println("Codigo: " + dpt.getCodigo());
System.out.println("Nombre: " + dpt.getNombre());
System.out.println("Tiempo promedio: " + dpt.mostrarPromedio());
System.out.println("\t---------------------------");
}
}
}
//Opcion 6 del menú
private static void rankingPorNivel() {
System.out.println("\n\t\tRANKING POR NIVEL");
System.out.println("\t\t------- --- -----\n");
if (deportistas.isEmpty())
System.out.println("No hay deportistas registrados todavía");
else {
var nivelA = new ArrayList<Deportista>();
var nivelB = new ArrayList<Deportista>();
var nivelC = new ArrayList<Deportista>();
//Separamos por niveles
for (Deportista dpt: deportistas) {
if (dpt.haCompetido()) {
switch(dpt.getNivel()) {
case "A":
nivelA.add(dpt);
break;
case "B":
nivelB.add(dpt);
break;
case "C":
nivelC.add(dpt);
}
}
}
//Pedimos a los ArrayList que se ordenen.
nivelA.sort(null); //Al indicar null, se ordenan según el compareTo() de los Deportistas
nivelB.sort(null);
nivelC.sort(null);
//Mostramos rankings en pantalla
System.out.println("\n\t---Nivel A---");
for (int i = 0; i < nivelA.size(); i++) {
System.out.println("\n#" + (i+1));
System.out.println("Nombre: " + nivelA.get(i).getNombre());
System.out.println("Promedio: " + nivelA.get(i).mostrarPromedio());
}
System.out.println("\n\t---Nivel B---");
for (int i = 0; i < nivelB.size(); i++) {
System.out.println("\n#" + (i+1));
System.out.println("Nombre: " + nivelB.get(i).getNombre());
System.out.println("Promedio: " + nivelB.get(i).mostrarPromedio());
}
System.out.println("\n\t---Nivel C---");
for (int i = 0; i < nivelC.size(); i++) {
System.out.println("\n#" + (i+1));
System.out.println("Nombre: " + nivelC.get(i).getNombre());
System.out.println("Promedio: " + nivelC.get(i).mostrarPromedio());
}
}
}
//Opcion 7 del menú
private static void porcentajeDeportistasSobreNivel() {
System.out.println("\n\tPORCENTAJE DEPORTISTAS SUPERAN TIEMPOS PROMEDIOS");
System.out.println("\t---------- ----------- ------- ------- ---------\n");
if (deportistas.isEmpty())
System.out.println("No hay deportistas registrados todavía");
else {
//Suma de promedios y recuento de jugadores, según nivel
int sumaA = 0, contadorA = 0;
int sumaB = 0, contadorB = 0;
int sumaC = 0, contadorC = 0;
for (Deportista dpt: deportistas) {
switch(dpt.getNivel()) {
case "A":
sumaA += dpt.tiempoPromedio();
contadorA++;
break;
case "B":
sumaB += dpt.tiempoPromedio();
contadorB++;
break;
case "C":
sumaC += dpt.tiempoPromedio();
contadorC++;
}
}
//Calculamos promedio de cada nivel
int promedioA = sumaA / contadorA;
int promedioB = sumaB / contadorB;
int promedioC = sumaC / contadorC;
//Tenemos el promedio de cada nivel
//volvemos a recorrer deportistas para contar quien está por encima de su promedio
int superanA = 0, superanB = 0, superanC = 0;
for (Deportista dpt: deportistas) {
switch(dpt.getNivel()) {
case "A":
if (dpt.tiempoPromedio() > promedioA)
superanA++;
break;
case "B":
if (dpt.tiempoPromedio() > promedioB)
superanB++;
break;
case "C":
if (dpt.tiempoPromedio() > promedioC)
superanC++;
}
}
//Tenemos todos los datos
System.out.println("--Nivel A--");
System.out.println("Deportistas por encima del promedio: "
+ (superanA * 100 / contadorA) + "%");
System.out.println("\n--Nivel B--");
System.out.println("Deportistas por encima del promedio: "
+ (superanB * 100 / contadorB) + "%");
System.out.println("\n--Nivel C--");
System.out.println("Deportistas por encima del promedio: "
+ (superanC * 100 / contadorC) + "%");
int totalSuperan = superanA + superanB + superanC;
System.out.println("\nTotal deportistas por encima del promedio: "
+ (totalSuperan * 100 / deportistas.size()) + "%");
}
}
//Opcion 8 del menú
private static void mostrarResultadosDeportista() {
System.out.println("\n\t\tRESULTADOS DEPORTISTAS");
System.out.println("\t\t---------- -----------\n");
if (deportistas.isEmpty())
System.out.println("No hay deportistas registrados todavía");
else {
System.out.print("Codigo: ");
String codigo = teclado.nextLine();

Deportista buscado = null;
for (int i = 0; i < deportistas.size(); i++)
if (deportistas.get(i).getCodigo().equals(codigo))
buscado = deportistas.get(i);

if (buscado == null)
System.out.println("\nNo existe deportista con el codigo: " + codigo);
else {
System.out.println("\nNombre: " + buscado.getNombre());
buscado.mostrarResultados();
}
}
}
//Opcion 9 del menú
private static void listaNoHanCompetido() {
System.out.println("\n\t\tLISTA DEPORTISTAS SIN COMPETIR");
System.out.println("\t\t----- ----------- --- --------\n");
if (deportistas.isEmpty())
System.out.println("No hay deportistas registrados todavía");
else {
for (Deportista dpt: deportistas)
if (!dpt.haCompetido()) {
System.out.println("Codigo: " + dpt.getCodigo());
System.out.println("Nombre: " + dpt.getNombre());
System.out.println();
}
}
}
//Opcion 10 del menú
private static void participantesPorEdad() {
System.out.println("\n\t\tPARTICIPANTES POR EDADES");
System.out.println("\t\t------------- --- ------\n");
if (deportistas.isEmpty())
System.out.println("No hay deportistas registrados todavía");
else {
int menor5 = 0, menor10 = 0, mayor10 =0;
for (Deportista dpt: deportistas)
if (dpt.haCompetido()) {
int edad = dpt.getEdad();
if (edad < 5)
menor5++;
else if (edad < 10)
menor10++;
else
mayor10++;
}
//Resultados
System.out.println("Menores de 5 años: " + menor5);
System.out.println("Entre 5 y 9 años: " + menor10);
System.out.println("DE 10 años o mayor: " + mayor10);
}
}
//Deportistas para probar el código y no tener que hacer registros en cada prueba
private static void deportistasPruebas() {
deportistas.add(new Deportista("DEP001", "Lucas", 4, "C", "Hombre"));
deportistas.add(new Deportista("DEP002", "Sara", 5, "B", "Mujer"));
deportistas.add(new Deportista("DEP003", "Ramon", 6, "C", "Hombre"));
deportistas.add(new Deportista("DEP004", "Laura", 4, "A", "Mujer"));
deportistas.add(new Deportista("DEP005", "Pedro", 10, "A", "Hombre"));
deportistas.add(new Deportista("DEP006", "Soledad", 12, "B", "Mujer"));
deportistas.add(new Deportista("DEP007", "Roberto", 4, "C", "Hombre"));
deportistas.add(new Deportista("DEP008", "Cristina", 11, "A", "Mujer"));
deportistas.get(0).setVueltas(new Vuelta[] {new Vuelta(1,10), new Vuelta(0,55), new Vuelta(1,5)});
deportistas.get(1).setVueltas(new Vuelta[] {new Vuelta(1,5), new Vuelta(0,50), new Vuelta(1,3)});
deportistas.get(3).setVueltas(new Vuelta[] {new Vuelta(1,9), new Vuelta(0,53), new Vuelta(1,13)});
deportistas.get(5).setVueltas(new Vuelta[] {new Vuelta(1,8), new Vuelta(0,57), new Vuelta(1,1)});
deportistas.get(6).setVueltas(new Vuelta[] {new Vuelta(1,7), new Vuelta(0,56), new Vuelta(1,5)});
deportistas.get(7).setVueltas(new Vuelta[] {new Vuelta(1,8), new Vuelta(0,51), new Vuelta(1,11)});
}
}
Cuando creas que más o menos lo has entendido, intenta volver a hacerlo por tu cuenta.
No pienses en resolver los 10 puntos de golpe, ya has visto que yo he ido uno a uno, modificando la clase Deportista para adaptarla a lo que iba pidiendo cada uno de los puntos del enunciado.
Piensa en resolver únicamente el primero. Y luego el segundo, luego el tercero,.. etc.

Un saludo.

[alejo9908]

Mil gracias hermano. A la hora de ir copiando el codigo en netbeans me salen errores, no se a que se deba

[alejo9908]

Podrias pasarmelo como archivo zip, para que abra en netbeans, por favor amigo. Y acabas de salvarme esta materia. Estudiaré bien el codigo

[alejo9908]

Estimado, y cuando hablas de override, de sort. A que te refieres, o sea, como puedo entender eso? y la utima parte donde haces la prueba, como entiendo mejor eso? porque la parte donde dices deportista.add Qué es. 

Lamento tantas preguntas, es que no he visto casi nada de programacion.

Gracias por la paciencia amigo, eres un crack en este tema

[alejo9908]

psd: Aun no he visto programacion orientada a objetos

[Kabuto]

Adjunto zip en este mensaje. Abajo de todo, verás enlace para descargarlo

psd: Aun no hemos visto programacion orientada a objetos

¿Seguro?
Porque entonces prácticamente nada de lo que hemos hecho serviría, ya que está enfocado a POO.

Pero vamos, cuando un enunciado comienza así:

Se sabe que de cada deportista se tiene el código, nombre, edad, nivel y sexo.

Tiene toda la pinta de ser POO y que estén pidiendo crear una clase Deportistas con todos esos atributos.

De lo contrario, la forma "no POO" de poder gestionar todos esos datos es usando 5 arrays, uno para los códigos, otro para los nombres, otro para las edades...
Sin poder usar una clase que gestione esos datos y podamos otorgarle métodos para que haga sus propias tareas..., el código entonces resultaría enorme y muy engorroso.

cuando hablas de override, de sort. A que te refieres, o sea, como puedo entender eso? y la utima parte donde haces la prueba, como entiendo mejor eso? porque la parte donde dices deportista.add Qué es.

Si realmente nos has visto nada de POO, ni clases, ni métodos, ni herencias... pues puede que no sirva para nada explicar estas cosas.

Override, significa "sobreescribir". En Java se usa la etiqueta @Override para indicar que el método que se va codificar a continuación, en realidad está sobreescribiendo a otro método que ya existe y que se recibe por herencia.

Una clase puede ser heredera de otra. Por ejemplo, imagina la clase Animal y que tiene un método llamado caminar()

Ahora imagina las clases Perro, Gallina y Serpiente.
Todos son animales, así que podemos hacer que sean herederas de la clase Animal, y entonces automáticamente esas tres clases van a disponer del método caminar().

Sin embargo, cada uno camina de forma diferente: el perro usa 4 patas, la gallina solo 2 y la serpiente en realidad usa su cuerpo para desplazarse.

Sí, todos caminan, pero cada uno a su manera, así que para cada uno querremos "sobreescribir"(Override) el método caminar() que han heredado, para adaptarlo a cada uno.

Eso es lo que hicimos al implementar la interfaz Comparable. Una interface es muy similar a una clase (ya te lo explicarán). Entonces, al implementarsela a la clase Deportista, automáticamente heredó el método compareTo()
Pero ese método heredado no le va a servir a un Deportista, hay que sobreescribirlo para que se adapte a los atributos de un Deportista.



sort() es un método que dispone la clase ArrayList. Esta clase puede almacenar una lista de elementos que se los vamos añadiendo con el método add() o quitando con remove().
Los elementos se colocan en la lista según se van añadiendo, pero podemos hacer que se ordenen invocando al método sort().

Este método espera recibir un objeto de la clase Comparable que será quien le diga como ha de ordenar los elementos de su lista: si por nombre, por edad, por estatura, por fecha nacimiento, etc..

Si en lugar de eso le pasamos un valor null, entonces el método sort() comprobará si los elementos de su lista, ya disponen de un método que le indique cómo hay que ordenarlos.
En nuestro ejercicio, el ArrayList contiene objetos de la clase Deportista, la cuál ya tiene implementada la interfaz Comparable y el método compareTo() sobreescrito para indicar como se han de ordenar (por el tiempo de vuelta promedio).
Así que al llamar a sort(), podemos pasarle valor null, porque los Deportistas ya le dirán al ArrayList como se han de ordenar.




En la última parte, lo que hago es añadir por código unos cuantos deportistas para que al iniciar la aplicación, ya tengamos algunos registrados.
Al cerrar aplicación, esos registros se pierden. Si no añadimos algunos por código, entonces cada vez que iniciemos la aplicación, vamos a tener que añadir a mano con la 1ª opción del menú nuevos deportistas.

Es un engorro, y se pierde mucho tiempo, si cada vez que queremos probar las distintas opciones del menú, primero tenemos que registrar unos cuantos deportistas, y además unas cuentas vueltas para cada deportista.
Por eso mejor añadir algunos por código.

Eso es lo que hace este método, construir Deportistas, añadirlos al ArrayList, y luego a algunos les añado Vueltas.
A otros no, para que consten como deportistas que no han competido

Código: [Seleccionar]

private static void deportistasPruebas() {
deportistas.add(new Deportista("DEP001", "Lucas", 4, "C", "Hombre"));
deportistas.add(new Deportista("DEP002", "Sara", 5, "B", "Mujer"));
deportistas.add(new Deportista("DEP003", "Ramon", 6, "C", "Hombre"));
deportistas.add(new Deportista("DEP004", "Laura", 4, "A", "Mujer"));
deportistas.add(new Deportista("DEP005", "Pedro", 10, "A", "Hombre"));
deportistas.add(new Deportista("DEP006", "Soledad", 12, "B", "Mujer"));
deportistas.add(new Deportista("DEP007", "Roberto", 4, "C", "Hombre"));
deportistas.add(new Deportista("DEP008", "Cristina", 11, "A", "Mujer"));
deportistas.get(0).setVueltas(new Vuelta[] {new Vuelta(1,10), new Vuelta(0,55), new Vuelta(1,5)});
deportistas.get(1).setVueltas(new Vuelta[] {new Vuelta(1,5), new Vuelta(0,50), new Vuelta(1,3)});
deportistas.get(3).setVueltas(new Vuelta[] {new Vuelta(1,9), new Vuelta(0,53), new Vuelta(1,13)});
deportistas.get(5).setVueltas(new Vuelta[] {new Vuelta(1,8), new Vuelta(0,57), new Vuelta(1,1)});
deportistas.get(6).setVueltas(new Vuelta[] {new Vuelta(1,7), new Vuelta(0,56), new Vuelta(1,5)});
deportistas.get(7).setVueltas(new Vuelta[] {new Vuelta(1,8), new Vuelta(0,51), new Vuelta(1,11)});
}


Si aún no has visto nada de POO, por mucho que explique estas cosas concretas puede que no se entiendan bien.

En la web hay un curso de Java, puedes empezar desde este capítulo e ir viendo lo que son objetos, clases y demás.

[alejo9908]

de verdad muchas gracias amigo, ya me explicaran poo en el segundo semestre.

psd: seria posible que lo hicieras con los arrays ya que no he visto nada de POO?
gracias amigo, igual tambien lo estudiaria bien

[alejo9908]

Estimado, en la parte que dice var nivel a, var nivel b y var nivel c, me marca un error, no sé a qué se deba eso

[Kabuto]

Estimado, en la parte que dice var nivel a, var nivel b y var nivel c, me marca un error, no se a que se deba eso

Código: [Seleccionar]

var nivelA = new ArrayList<Deportista>();
var nivelB = new ArrayList<Deportista>();
var nivelC = new ArrayList<Deportista>();
Sustitúyelo por:

Código: [Seleccionar]

ArrayList<Deportista> nivelA = new ArrayList<Deportista>();
ArrayList<Deportista> nivelB = new ArrayList<Deportista>();
ArrayList<Deportista> nivelC = new ArrayList<Deportista>();

Sobre hacerlo con arrays, lo siento, tenía un par de días libres pero ya se acabaron.
No dispongo de tanto tiempo.

De todos modos, consulta con compañeros o algún profesor si realmente hay que resolverlo sin usar clases.
Porque incluso usando un ArrayList para cada tipo de dato, ya supondría un kilombo de código importante.
Y si tuviera que ser con arrays "primitivos", aún peor...