Contexto

En cualquier sistema de software real, rara vez manejamos una única instancia de una entidad. Un club de fútbol, por ejemplo, administra decenas de jugadores que conforman un plantel deportivo. Cada jugador es un objeto con su propio estado y comportamiento, pero el club necesita agruparlos, listarlos, buscar refuerzos, premiar a los goleadores y dar de baja a quienes cambian de equipo.

En esta actividad vas a construir la gestión de un plantel utilizando arrays de objetos. Vas a experimentar de primera mano los dos niveles de memoria, la diferencia entre capacidad reservada y cantidad real, el redimensionamiento dinámico con Arrays.copyOf, la búsqueda lineal, el ordenamiento manual por intercambio de referencias y la prevención de fugas de memoria al eliminar elementos.


Consigna

Desarrollá tres clases Java: Jugador.java, Plantel.java y MainPlantel.java.

1. Clase Jugador.java

Representa a cada deportista individual.

  • Atributos:
    • private final String nombre;
    • private final int dorsal;
    • private int goles;
  • Constructor canónico:
    • public Jugador(String nombre, int dorsal, int goles)
    • Si nombre es nulo o está en blanco, asignar "Sin nombre" e informar la corrección por consola.
    • Si dorsal <= 0, asignar 99 e informar la corrección.
    • Si goles < 0, asignar 0 e informar la corrección.
  • Métodos:
    • Getters: getNombre(), getDorsal(), getGoles().
    • public void anotarGoles(int cantidad): si cantidad > 0, suma al atributo goles.
    • @Override public String toString(): devuelve un texto con formato #<dorsal> <nombre> (<goles> goles).

2. Clase Plantel.java

Encapsula la colección de jugadores y administra el array interno.

  • Atributos:
    • private Jugador[] jugadores; (capacidad física)
    • private int cantidad; (elementos reales almacenados)
  • Constructor:
    • public Plantel(int capacidadInicial): si capacidadInicial <= 0, usar 5. Instancia jugadores = new Jugador[capacidadInicial] y fija cantidad = 0.
  • Métodos obligatorios:
    • public int getCantidad(): retorna la cantidad actual de jugadores.
    • public int getCapacidad(): retorna jugadores.length.
    • public boolean agregar(Jugador j):
      • Valida que j != null (si es null, informa y retorna false).
      • Si cantidad == jugadores.length, duplica la capacidad del array usando jugadores = Arrays.copyOf(jugadores, jugadores.length * 2); e imprime el aviso de redimensionamiento.
      • Asigna jugadores[cantidad] = j;, incrementa cantidad++, imprime confirmación y retorna true.
    • public Jugador buscarPorDorsal(int dorsal):
      • Recorre con un for desde 0 hasta cantidad.
      • Si coincide el dorsal, retorna la referencia al Jugador.
      • Si finaliza el bucle sin coincidencias, retorna null.
    • public Jugador buscarPorNombre(String nombre):
      • Si nombre == null, retorna null.
      • Recorre hasta cantidad, verificando jugadores[i] != null y comparando con equalsIgnoreCase. Retorna la referencia o null.
    • public boolean eliminar(int dorsal):
      • Localiza el índice idx del jugador con ese dorsal.
      • Si no existe, retorna false.
      • Si existe, desplaza hacia la izquierda los elementos desde idx hasta cantidad - 2:
        for (int i = idx; i < cantidad - 1; i++) {
            jugadores[i] = jugadores[i + 1];
        }
      • Limpieza de referencia: asigna jugadores[cantidad - 1] = null; para evitar que la última casilla retenga una referencia huérfana (memory loitering), permitiendo la acción del recolector de basura.
      • Decrementa cantidad-- y retorna true.
    • public void ordenarPorGolesDescendente():
      • Implementa el ordenamiento por selección a mano.
      • En cada pasada i (desde 0 hasta cantidad - 2), encuentra el índice del jugador con más goles en el resto del array.
      • Si el mayor no está en la posición i, intercambia referencias usando una variable temporal Jugador temp.
    • public void listar():
      • Recorre estrictamente desde 0 hasta cantidad e imprime cada jugador (System.out.println(jugadores[i])).
    • public Jugador[] getJugadores():
      • Retorna una copia defensiva: return Arrays.copyOf(jugadores, cantidad);.

3. Clase MainPlantel.java

Contiene el método main y comprueba cada concepto de la lección:

  1. Inicialización en dos pasos: declara Jugador[] prueba = new Jugador[3]; e imprime prueba[0]. Explica en un comentario por qué invocar un método allí arrojaría NullPointerException.
  2. Llenado y expansión: crea un Plantel con capacidad inicial 3 y agrega 4 jugadores para demostrar cómo Arrays.copyOf redimensiona el array sin perder datos.
  3. Búsqueda lineal: busca un jugador existente y uno inexistente. Demuestra la verificación if (encontrado != null) antes de interactuar con el resultado.
  4. Ordenamiento manual: ordena por goles descendente y lista los jugadores para verificar el nuevo orden.
  5. Eliminación y limpieza: elimina a un jugador del medio, confirma que cantidad baja en uno y que el jugador ya no figura en la lista.
  6. Aliasing y copia defensiva: obtiene una referencia a un jugador existente, modifica sus goles con anotarGoles(2) y comprueba que el plantel refleja el cambio (ambas variables apuntan al mismo objeto en el Heap). Luego obtiene el array con getJugadores() y comprueba que es una copia independiente del array interno.