---

En esta práctica vamos a construir una mini-aplicación de consola en Java con un menú interactivo.
El objetivo es que el alumno practique:

• Entrada por teclado (Scanner)
• Bucles (while)
• switch
• Programación orientada a objetos
• Encapsulación (private + getters/setters public)
• Nombres en camelCase, como se exige en entornos profesionales

Este tipo de ejercicio es típico de 1º DAM, cae mucho en prácticas y exámenes orales.

---

1. ¿Qué vamos a hacer?

Vamos a crear un programa que permita:

1. Añadir alumnos a una lista (nombre y edad)
2. Listar los alumnos guardados
3. Salir

Es decir, un menú de consola como este:

-------------------------
   MENÚ ALUMNOS DAM
-------------------------
1. Añadir alumno
2. Listar alumnos
0. Salir
Elige opción:

Y el usuario elige.

Esto parece muy básico… y lo es. Pero lo vamos a hacer bien hecho: con clases, atributos privados, getters/setters y camelCase.

---

2. Diseño por capas simples

Vamos a tener 3 clases:

1. Alumno
   Representa a un alumno. Aquí aplicamos encapsulación.
2. GestorAlumnos
   Lleva la lista de alumnos en memoria y ofrece métodos para añadir y mostrar.
3. Main
   Contiene el menú, lee el teclado y llama al GestorAlumnos.

Esto es ya mentalidad de POO: cada clase tiene su responsabilidad.

---

3. Clase Alumno: encapsulación y getters/setters

Puntos importantes que quieres que tu alumno entienda:

• Los atributos son private → nadie desde fuera puede tocarlos directamente.
• Los métodos públicos get... y set... son la “puerta de acceso” controlada.
• El nombre de las variables y métodos sigue camelCase:
  • atributos: nombreCompleto, edadAlumno
  • métodos: getNombreCompleto(), setEdadAlumno(...)

Código:

public class Alumno {

    // Atributos privados (encapsulación)
    private String nombre;
    private int edad;

    // Constructor
    public Alumno(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
    }

    // Getter del nombre
    public String getNombre() {
        return nombre;
    }

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

    // Getter de la edad
    public int getEdad() {
        return edad;
    }

    // Setter de la edad
    public void setEdad(int edad) {
        this.edad = edad;
    }

    // Método de utilidad para mostrar el alumno
    public String toString() {
        return "Alumno{nombre='" + nombre + "', edad=" + edad + "}";
    }
}

¿Por qué private?

Porque así evitamos cosas tipo:

Alumno a = new Alumno("Pepe", 20);
a.edad = -500; // esto NO debería ser posible

Con private obligas a pasar por setEdad(), y ahí podrías validar.

---

4. Clase GestorAlumnos: lista en memoria

Aquí guardamos los alumnos en una ArrayList.
Ojo: la lista también es privada. No se expone directamente.

import java.util.ArrayList;
import java.util.List;

public class GestorAlumnos {

    // Lista privada de alumnos
    private List<Alumno> listaAlumnos;

    // Constructor
    public GestorAlumnos() {
        this.listaAlumnos = new ArrayList<>();
    }

    // Añadir alumno nuevo
    public void anadirAlumno(String nombre, int edad) {
        Alumno nuevo = new Alumno(nombre, edad);
        listaAlumnos.add(nuevo);
        System.out.println("Alumno añadido correctamente.\n");
    }

    // Mostrar todos los alumnos
    public void listarAlumnos() {
        if (listaAlumnos.isEmpty()) {
            System.out.println("No hay alumnos registrados.\n");
            return;
        }

        System.out.println("Listado de alumnos:");
        for (int i = 0; i < listaAlumnos.size(); i++) {
            Alumno a = listaAlumnos.get(i);
            System.out.println((i + 1) + ". " + a.getNombre() + " (" + a.getEdad() + " años)");
        }
        System.out.println(); // línea en blanco
    }
}

Detalles importantes para clase:

• Método anadirAlumno(...) sigue camelCase.
• No hacemos System.out.println(listaAlumnos); directamente, sino que mostramos formateado.
• listarAlumnos() no devuelve nada, solo imprime. Está bien para consola.

---

5. Clase Main: el menú interactivo

Esta clase muestra el texto del menú, pide una opción y llama a los métodos del GestorAlumnos.

Usamos:

• Scanner
• while para repetir hasta que el usuario diga 0
• switch para decidir qué hacer con cada opción

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner teclado = new Scanner(System.in);
        GestorAlumnos gestor = new GestorAlumnos();

        int opcion = -1; // inicializamos con algo distinto de 0

        while (opcion != 0) {
            mostrarMenu();
            System.out.print("Elige opción: ");
            // leemos la opción
            opcion = leerEnteroSeguro(teclado);

            switch (opcion) {
                case 1 -> {
                    // Añadir alumno
                    System.out.print("Nombre del alumno: ");
                    String nombre = teclado.nextLine();

                    System.out.print("Edad del alumno: ");
                    int edad = leerEnteroSeguro(teclado);

                    gestor.anadirAlumno(nombre, edad);
                }

                case 2 -> {
                    // Listar alumnos
                    gestor.listarAlumnos();
                }

                case 0 -> {
                    System.out.println("Saliendo del programa. ¡Hasta luego!");
                }

                default -> {
                    System.out.println("Opción no válida.\n");
                }
            }
        }

        teclado.close();
    }

    // Menú "bonito"
    private static void mostrarMenu() {
        System.out.println("-------------------------");
        System.out.println("   MENÚ ALUMNOS DAM");
        System.out.println("-------------------------");
        System.out.println("1. Añadir alumno");
        System.out.println("2. Listar alumnos");
        System.out.println("0. Salir");
    }

    // Método auxiliar para leer enteros sin romper el Scanner
    private static int leerEnteroSeguro(Scanner teclado) {
        while (true) {
            if (teclado.hasNextInt()) {
                int valor = teclado.nextInt();
                teclado.nextLine(); // limpiar el salto de línea pendiente
                return valor;
            } else {
                System.out.print("Introduce un número válido: ");
                teclado.nextLine(); // descartamos lo que haya escrito mal
            }
        }
    }
}

Cosas a remarcar en clase:

1. mostrarMenu() es private static porque solo se usa dentro de Main.
   → Buen detalle de encapsulación incluso en métodos de utilidad.
2. leerEnteroSeguro() evita que el programa se caiga si el usuario mete “hola” en vez de un número.
   Esto es oro para los profes porque el alumno ve entrada robusta desde ya.
3. Nombres camelCase:
   • mostrarMenu
   • leerEnteroSeguro
   • listaAlumnos
   • anadirAlumno
   • listarAlumnos
   NO usamos cosas tipo Mostrar_menu ni ListaAlumnos ni ALUMNO1. Eso sería estilo C de 1998 o constantes, no Java moderno.

---

6. ¿Cómo compilar y ejecutar este mini-proyecto?

Si tienes los tres ficheros .java en la misma carpeta:

• Alumno.java
• GestorAlumnos.java
• Main.java

Compilas (en terminal, estando en esa carpeta):

javac *.java

Y ejecutas:

java Main

Salida típica:

-------------------------
   MENÚ ALUMNOS DAM
-------------------------
1. Añadir alumno
2. Listar alumnos
0. Salir
Elige opción: 1
Nombre del alumno: Lucía
Edad del alumno: 19
Alumno añadido correctamente.

-------------------------
   MENÚ ALUMNOS DAM
-------------------------
1. Añadir alumno
2. Listar alumnos
0. Salir
Elige opción: 2
Listado de alumnos:
1. Lucía (19 años)

Perfecto para enseñar en clase y para pedirles “ahora añade opción 3: borrar alumno por número”, etc.

---

7. Resumen didáctico para DAM

• Encapsulación:
  Atributos private, acceso controlado por métodos public (get / set).
  Esto no es capricho: evita datos incoherentes.
• Responsabilidad única:
  Alumno guarda datos, GestorAlumnos gestiona la lista, Main habla con el usuario.
  Separar responsabilidades = código mantenible.
• Menú con bucle:
  Un while con switch es la base de casi cualquier aplicación de consola.
  Este patrón lo verás otra vez en ejercicios de gestión de productos, inventarios, etc.
• camelCase:
  En Java profesional, los nombres de variables y métodos empiezan en minúscula y luego cada palabra nueva en mayúscula:
  listaAlumnos, getEdad(), leerEnteroSeguro().
• Evitamos public en todo por defecto:
  Solo lo que tiene sentido que sea visible, lo hacemos público. Lo demás, privado.

---

8. Tareas extra para el alumno

Para practicar más, pídele que añada estas mejoras:

1. Evitar edades negativas en setEdad(int edad).
   Si es < 0, no la aceptes y muestra un mensaje.
2. Añadir una nueva opción al menú:
   3. Buscar alumno por nombre.
3. Guardar también el email del alumno (nuevo atributo private String email; con su getter/setter).

Esto les hace ver que la POO no es teoría: es organizar tu programa para que escale sin volverse una bola de barro.

---

¿Te ha servido? Este ejercicio es básico pero está hecho con las mismas normas que vas a usar en empresa. Si lo dominas sin mirar, ya estás un paso por delante del típico “copiar/pegar sin entender”.