Walter White y Jesse Pinkman han cocinado 1000 pastillas de «mentaanfetamienta» en su caravana.

Cada pastilla tiene una calidad aleatoria entre 0 y 100.

El “señor del pollo” (Gus Fring) solo acepta aquellas con calidad mayor o igual que 90.

Base común: generar calidad 0–100

Usaremos:

Random r = new Random(); int calidad = r.nextInt(101); // 0..100 (incluye 100)

RETO 1: “El recuento del lote”

Calcular cuántas pastillas tienen una calidad superior a 90.

Pistas:

• Usa Random para generar números del 0 al 100.
• Usa un for para simular las 1000 pastillas.
• Usa un contador para las “buenas”.

Ejemplo de salida:

Pastillas totales: 1000
De calidad superior: 128

Objetivo: de 1000 pastillas, contar cuántas tienen calidad > 90 (ojo: tu historia dice “≥90”, pero el reto 1 pide “superior a 90” → >90).

Idea

• Bucle for de 1 a 1000
• Generar calidad
• Si calidad > 90, incrementamos contador

Código

import java.util.Random;

public class Reto1RecuentoLote {
    public static void main(String[] args) {
        Random r = new Random();

        int total = 1000;
        int buenas = 0;

        for (int i = 1; i <= total; i++) {
            int calidad = r.nextInt(101); // 0..100

            if (calidad > 90) {           // superior a 90
                buenas++;
            }
        }

        System.out.println("Pastillas totales: " + total);
        System.out.println("De calidad superior: " + buenas);
    }
}

RETO 2: “Hasta lograr la receta perfecta”

Walter repite la cocción hasta que consiga una pastilla con calidad 100.

Pistas:

• Genera números aleatorios entre 0 y 100.
• Detén el bucle cuando salga 100.
• Muestra cuántos intentos necesitó.

Ejemplo:

¡Perfecta! Calidad 100 obtenida tras 57 intentos.

Objetivo: repetir intentos hasta que salga calidad 100, mostrar cuántos intentos.

Idea

• Bucle while o do-while
• Contador de intentos
• Se para cuando calidad == 100

Código

import java.util.Random;

public class Reto2RecetaPerfecta {
    public static void main(String[] args) {
        Random r = new Random();

        int intentos = 0;
        int calidad;

        do {
            calidad = r.nextInt(101);
            intentos++;
        } while (calidad != 100);

        System.out.println("¡Perfecta! Calidad 100 obtenida tras " + intentos + " intentos.");
    }
}

Por qué do-while: garantiza al menos un intento (tiene sentido aquí).

RETO 3: “La producción nocturna”

Walter y Jesse producen pastillas hasta llegar a 1000 unidades buenas (≥90).

Muestra cuántas totales han hecho (incluyendo las malas).

Ejemplo:

Para conseguir 1000 pastillas buenas, produjeron un total de 8732.

Objetivo: producir hasta conseguir 1000 buenas (≥90), y mostrar cuántas totales se produjeron.

Idea

• buenas llega a 1000
• totales cuenta todas, buenas y malas
• Condición buena: calidad >= 90

Código

import java.util.Random;

public class Reto3ProduccionNocturna {
    public static void main(String[] args) {
        Random r = new Random();

        int buenas = 0;
        int totales = 0;

        while (buenas < 1000) {
            int calidad = r.nextInt(101);
            totales++;

            if (calidad >= 90) {
                buenas++;
            }
        }

        System.out.println("Para conseguir 1000 pastillas buenas, produjeron un total de " + totales + ".");
    }
}

RETO 4: “El análisis por lotes”

Dividir la producción en 10 lotes de 100 pastillas y mostrar cuántas buenas hay en cada lote.

Salida esperada:

Lote 1 → 13 pastillas buenas
Lote 2 → 8 pastillas buenas
...
Lote 10 → 11 pastillas buenas

Objetivo: 10 lotes de 100, contar buenas (≥90) por lote.

Idea

• Bucle externo: lotes 1..10
• Bucle interno: 100 pastillas
• Contador buenasLote reiniciado en cada lote

Código

import java.util.Random;

public class Reto4AnalisisPorLotes {
    public static void main(String[] args) {
        Random r = new Random();

        int lotes = 10;
        int tamLote = 100;

        for (int lote = 1; lote <= lotes; lote++) {
            int buenasLote = 0;

            for (int i = 1; i <= tamLote; i++) {
                int calidad = r.nextInt(101);
                if (calidad >= 90) {
                    buenasLote++;
                }
            }

            System.out.println("Lote " + lote + " \u2192 " + buenasLote + " pastillas buenas");
        }
    }
}

RETO 5: “Promedio de calidad”

Calcular el promedio total de calidad de las 1000 pastillas.

Salida:

Promedio de calidad general: 72.38

Objetivo: promedio de calidad de 1000 pastillas.

Idea

• Acumulador sumaCalidades
• Tras el bucle: promedio = suma / total
• Para mostrar con 2 decimales: System.out.printf

Código

import java.util.Random;

public class Reto5PromedioCalidad {
    public static void main(String[] args) {
        Random r = new Random();

        int total = 1000;
        int sumaCalidades = 0;

        for (int i = 1; i <= total; i++) {
            int calidad = r.nextInt(101);
            sumaCalidades += calidad;
        }

        double promedio = (double) sumaCalidades / total;

        System.out.printf("Promedio de calidad general: %.2f%n", promedio);
    }
}

Detalle clave: el casteo a double evita división entera.

RETO 6 (extra): “La inspección de Gus Fring”

Genera pastillas hasta tener 500 buenas, pero cada vez que salgan 50 malas seguidas, muestra:

🔥 Gus Fring sospecha del laboratorio...

Objetivo: generar pastillas hasta tener 500 buenas (≥90), pero cada vez que haya 50 malas seguidas, imprimir:

Gus Fring sospecha del laboratorio...

Idea

• Contador buenas hasta 500
• Contador malasSeguidas que:
  • aumenta si sale mala (<90)
  • se reinicia a 0 si sale buena
• Cuando malasSeguidas == 50, avisamos y reiniciamos (o seguimos contando, tú eliges; aquí reiniciamos para no spamear).

Código

import java.util.Random;

public class Reto6InspeccionGusFring {
    public static void main(String[] args) {
        Random r = new Random();

        int buenas = 0;
        int totales = 0;
        int malasSeguidas = 0;

        while (buenas < 500) {
            int calidad = r.nextInt(101);
            totales++;

            if (calidad >= 90) {
                buenas++;
                malasSeguidas = 0; // racha de malas se rompe
            } else {
                malasSeguidas++;
            }

            if (malasSeguidas == 50) {
                System.out.println("🔥 Gus Fring sospecha del laboratorio...");
                malasSeguidas = 0; // reiniciamos para volver a detectar otra racha de 50
            }
        }

        System.out.println("Buenas conseguidas: " + buenas);
        System.out.println("Pastillas producidas en total: " + totales);
    }
}

Evil Corp —el gigante que controla todo lo que consumes, lo que piensas y hasta lo que olvidas— cree tenerlo todo bajo control.

Pero no contaba contigo.

En un sótano lleno de cables, pantallas parpadeantes y tazas de café frías, un grupo de hackers conocidos como Atriumsociety prepara su próximo golpe digital. Su misión: devolver el poder a la gente, línea de código a línea de código.

Tu papel comienza aquí.

Eres parte del equipo. Hoy no vienes a “hacer ejercicios”, vienes a infiltrarte en el sistema, Cada array que declares es una base de datos secreta, cada bucle un intento de intrusión, cada condicional una decisión que puede cambiarlo todo.

Prepárate: el prompt está parpadeando.

Atriumsociety te necesita.

1. “Elliot vs Evil Corp”

Enunciado:

Elliot ha interceptado una lista con los balances de Evil Corp.

Con el siguiente array:

int[] balances = {12000, -50, 5000, 15000, 0, -300, 800, 22000, 9999, 100};

Muestra:

• Cuántas cuentas tienen saldo negativo.
• Cuántas tienen saldo superior a 10 000 $.
• El saldo medio.

Qué se hace

• Recorremos balances
• Contamos negativos (<0)
• Contamos los que superan 10.000 (>10000)
• Sumamos todo para el promedio

Código

public class ElliotVsEvilCorp {
    public static void main(String[] args) {

        int[] balances = {12000, -50, 5000, 15000, 0, -300, 800, 22000, 9999, 100};

        int negativos = 0;
        int masDe10000 = 0;
        int suma = 0;

        for (int i = 0; i < balances.length; i++) {
            int b = balances[i];

            if (b < 0) negativos++;
            if (b > 10000) masDe10000++;

            suma += b;
        }

        double media = (double) suma / balances.length;

        System.out.println("Cuentas con saldo negativo: " + negativos);
        System.out.println("Cuentas con saldo superior a 10000$: " + masDe10000);
        System.out.printf("Saldo medio: %.2f%n", media);
    }
}

2. “Backdoor Scanner”

Enunciado:

Darlene analiza si los servidores de Evil Corp están vulnerables.

Usa el siguiente array:

boolean[] vulnerables = {false, true, false, false, true, false, true, false};

Muestra:

• Cuántos servidores son vulnerables (true).
• En qué posiciones están.

Qué se hace

• Recorremos el array de boolean
• Si es true, contamos y mostramos la posición

Código

public class BackdoorScanner {
    public static void main(String[] args) {

        boolean[] vulnerables = {false, true, false, false, true, false, true, false};

        int contador = 0;

        System.out.print("Servidores vulnerables en posiciones: ");
        for (int i = 0; i < vulnerables.length; i++) {
            if (vulnerables[i]) {
                contador++;
                System.out.print(i + " ");
            }
        }

        System.out.println();
        System.out.println("Total vulnerables: " + contador);
    }
}

3. “Password Audit”

Enunciado:

Elliot encuentra las siguientes contraseñas antiguas de Evil Corp:

String[] passwords = {"admin123", "e@mpl3", "supersecure99", "pass", "root@2020"};

Indica:

• Cuántas contienen el carácter @.
• Cuántas tienen más de 8 caracteres.
• Cuántas terminan en un número.
• Cuál es la más larga.

Qué se hace

Para cada contraseña:

• contains("@") → cuenta las que tienen @
• length() > 8 → largas
• “termina en número” → miramos el último carácter con charAt y comprobamos si es dígito
• “la más larga” → guardamos la que tenga mayor longitud

Código

public class PasswordAudit {
    public static void main(String[] args) {

        String[] passwords = {"admin123", "e@mpl3", "supersecure99", "pass", "root@2020"};

        int conArroba = 0;
        int masDe8 = 0;
        int terminanEnNumero = 0;

        String masLarga = passwords[0];

        for (int i = 0; i < passwords.length; i++) {
            String p = passwords[i];

            if (p.contains("@")) conArroba++;
            if (p.length() > 8) masDe8++;

            char ultimo = p.charAt(p.length() - 1);
            if (Character.isDigit(ultimo)) terminanEnNumero++;

            if (p.length() > masLarga.length()) {
                masLarga = p;
            }
        }

        System.out.println("Contraseñas con @: " + conArroba);
        System.out.println("Contraseñas con más de 8 caracteres: " + masDe8);
        System.out.println("Contraseñas que terminan en número: " + terminanEnNumero);
        System.out.println("La más larga es: " + masLarga + " (" + masLarga.length() + " caracteres)");
    }
}

4. “Hack the Gibson”

Enunciado:

Simula los niveles de éxito de los ataques de Elliot con el siguiente array:

int[] intentos = {82, 13, 45, 79, 90, 5, 33, 72, 18, 65, 40, 100, 29, 10, 67, 55, 88, 60, 14, 3};

Muestra:

• El valor máximo y el mínimo.
• Cuántos intentos fueron “exitosos” (más de 70).
• Si todos son menores de 30, muestra “Mr Robot sospecha que estás desconectado”.

Qué se hace

• Máximo y mínimo: inicializamos con el primer elemento y comparamos
• Exitosos: >70
• “si todos son menores de 30”: bandera todosMenor30 (true al inicio, se rompe si encontramos uno >= 30)

Código

public class HackTheGibson {
    public static void main(String[] args) {

        int[] intentos = {82, 13, 45, 79, 90, 5, 33, 72, 18, 65, 40, 100, 29, 10, 67, 55, 88, 60, 14, 3};

        int max = intentos[0];
        int min = intentos[0];
        int exitosos = 0;

        boolean todosMenor30 = true;

        for (int i = 0; i < intentos.length; i++) {
            int v = intentos[i];

            if (v > max) max = v;
            if (v < min) min = v;

            if (v > 70) exitosos++;

            if (v >= 30) {
                todosMenor30 = false;
            }
        }

        System.out.println("Máximo: " + max);
        System.out.println("Mínimo: " + min);
        System.out.println("Intentos exitosos (>70): " + exitosos);

        if (todosMenor30) {
            System.out.println("Mr Robot sospecha que estás desconectado");
        }
    }
}

5. “Logs del Servidor”

Enunciado:

Angela revisa los registros de acceso de un servidor:

String[] logs = {"OK", "ERROR", "OK", "OK", "ERROR", "OK", "ERROR", "ERROR", "OK", "OK"};

Cuenta:

• Cuántos accesos fueron "OK".
• Cuántos "ERROR".
• Si hay más errores que accesos correctos, muestra “Servidor en peligro”.

Qué se hace

• Contar "OK" y "ERROR" usando equals
• Comparar: si errores > ok → aviso

Código

public class LogsDelServidor {
    public static void main(String[] args) {

        String[] logs = {"OK", "ERROR", "OK", "OK", "ERROR", "OK", "ERROR", "ERROR", "OK", "OK"};

        int ok = 0;
        int error = 0;

        for (int i = 0; i < logs.length; i++) {
            if (logs[i].equals("OK")) ok++;
            else if (logs[i].equals("ERROR")) error++;
        }

        System.out.println("OK: " + ok);
        System.out.println("ERROR: " + error);

        if (error > ok) {
            System.out.println("Servidor en peligro");
        }
    }
}

6. “Temperaturas del Servidor”

Enunciado:

Durante un ataque, Elliot monitoriza las temperaturas del servidor:

int[] temperaturas = {45, 49, 52, 57, 60, 59, 55, 48, 46, 50};

Calcula:

• La temperatura media.
• Cuántas mediciones superan los 55 °C.
• Si todas las temperaturas están por debajo de 60 °C, muestra “Sistema estable”; si alguna es 60 o más, muestra “¡Sobrecalentamiento detectado!”.

Qué se hace

• Media: suma / total
• Contar >55
• Comprobar si alguna es >=60 (bandera sobrecalentamiento)

Código

public class TemperaturasServidor {
    public static void main(String[] args) {

        int[] temperaturas = {45, 49, 52, 57, 60, 59, 55, 48, 46, 50};

        int suma = 0;
        int superan55 = 0;

        boolean sobrecalentamiento = false;

        for (int i = 0; i < temperaturas.length; i++) {
            int t = temperaturas[i];

            suma += t;

            if (t > 55) superan55++;
            if (t >= 60) sobrecalentamiento = true;
        }

        double media = (double) suma / temperaturas.length;

        System.out.printf("Temperatura media: %.2f%n", media);
        System.out.println("Mediciones que superan 55°C: " + superan55);

        if (!sobrecalentamiento) {
            System.out.println("Sistema estable");
        } else {
            System.out.println("¡Sobrecalentamiento detectado!");
        }
    }
}

7. “DDoS Simulator”

Enunciado:

Durante un ataque DDoS, se registran los siguientes tiempos de respuesta (en ms):

int[] tiempos = {200, 540, 720, 150, 950, 330, 480, 510, 870, 610};

Muestra:

• La media, el máximo y el mínimo.
• Si más del 60 % supera los 500 ms, muestra “Servidor saturado”.
• Si menos del 10 % supera los 200 ms, muestra “Ataque fallido”.

Qué se hace

• Media, máximo, mínimo (igual que antes)
• Contar cuántos superan 500 → para porcentaje
• Si (superan500 / total) > 0.60 → “Servidor saturado”
• Si (superan200 / total) < 0.10 → “Ataque fallido”
  • Nota: “supera 200” significa >200, no >=200.

Código

public class DDoSSimulator {
    public static void main(String[] args) {

        int[] tiempos = {200, 540, 720, 150, 950, 330, 480, 510, 870, 610};

        int suma = 0;
        int max = tiempos[0];
        int min = tiempos[0];

        int superan500 = 0;
        int superan200 = 0;

        for (int i = 0; i < tiempos.length; i++) {
            int t = tiempos[i];

            suma += t;
            if (t > max) max = t;
            if (t < min) min = t;

            if (t > 500) superan500++;
            if (t > 200) superan200++;
        }

        double media = (double) suma / tiempos.length;

        double porcentaje500 = (double) superan500 / tiempos.length;
        double porcentaje200 = (double) superan200 / tiempos.length;

        System.out.printf("Media: %.2f ms%n", media);
        System.out.println("Máximo: " + max + " ms");
        System.out.println("Mínimo: " + min + " ms");

        if (porcentaje500 > 0.60) {
            System.out.println("Servidor saturado");
        }

        if (porcentaje200 < 0.10) {
            System.out.println("Ataque fallido");
        }
    }
}

El Ministerio de Magia ha implantado un nuevo sistema de clasificación de magos para evaluar su progreso, capacidades y responsabilidades dentro del mundo mágico.

1) Casa.java (enum)

La enum sirve para tener un conjunto cerrado de valores (solo esas casas), evitando Strings sueltos.

package modelo;

public enum Casa {
    GRYFFINDOR,
    SLYTHERIN,
    RAVENCLAW,
    HUFFLEPUFF
}

2) Mago.java (clase base)

Qué aporta esta clase

• Define lo común a todos: nombre, nivel, vida, mana, casa.
• Aplica un bonus inicial según la casa.
• Tiene métodos base (entrenar, descansar, ficha, lanzarHechizo).
• lanzarHechizo NO es abstracto: por defecto hace algo simple.

package modelo;

public class Mago {

    protected String nombre;
    protected int nivel; // 1..100
    protected int vida;  // 0..100
    protected int mana;  // 0..100
    protected Casa casa;

    public Mago(String nombre, Casa casa) {
        this.nombre = nombre;
        this.casa = casa;

        // Valores base
        this.nivel = 1;
        this.vida = 100;
        this.mana = 100;

        aplicarBonusCasa();
    }

    private void aplicarBonusCasa() {
        // Bonus simples y fáciles de ver en consola
        switch (casa) {
            case GRYFFINDOR:
                vida += 10; // más resistencia
                break;
            case SLYTHERIN:
                mana += 10; // más “energía mágica”
                break;
            case RAVENCLAW:
                nivel += 1; // aprende más rápido (nivel inicial superior)
                break;
            case HUFFLEPUFF:
                vida += 5;
                mana += 5; // equilibrio
                break;
        }
        // Normalizamos límites
        vida = clamp(vida, 0, 100);
        mana = clamp(mana, 0, 100);
        nivel = clamp(nivel, 1, 100);
    }

    public void entrenar() {
        // Entrenar sube nivel, pero cansa
        nivel += 1;
        mana -= 5;
        vida -= 2;

        nivel = clamp(nivel, 1, 100);
        mana = clamp(mana, 0, 100);
        vida = clamp(vida, 0, 100);
    }

    public void descansar() {
        // Descansar recupera recursos
        mana += 10;
        vida += 10;

        mana = clamp(mana, 0, 100);
        vida = clamp(vida, 0, 100);
    }

    public String ficha() {
        return nombre + " | Casa: " + casa +
               " | Nivel: " + nivel +
               " | Vida: " + vida +
               " | Mana: " + mana;
    }

    /**
     * Lanza un hechizo genérico. Las clases hijas lo mejoran.
     * Devuelve el "daño" (o 0 si no se puede).
     */
    public int lanzarHechizo(String hechizo) {
        int coste = 5;
        if (!gastarMana(coste)) return 0;
        return 3; // daño base genérico
    }

    protected boolean gastarMana(int cantidad) {
        if (mana < cantidad) {
            return false;
        }
        mana -= cantidad;
        mana = clamp(mana, 0, 100);
        return true;
    }

    public void recibirDaño(int daño) {
        vida -= daño;
        vida = clamp(vida, 0, 100);
    }

    protected int clamp(int valor, int min, int max) {
        if (valor < min) return min;
        if (valor > max) return max;
        return valor;
    }
}

3) Aprendiz.java

Idea clave

• Un Aprendiz tiene torpeza, así que puede fallar.
• Aprende con practicarBasico().
• Sobrescribe lanzarHechizo para permitir solo hechizos básicos.

package modelo;

import java.util.Random;

public class Aprendiz extends Mago {

    protected int torpeza; // 0..100 (más torpeza = más fallos)
    protected Random rnd = new Random();

    public Aprendiz(String nombre, Casa casa) {
        super(nombre, casa);

        torpeza = 40;

        // Ajuste según casa (sencillo y visible)
        if (casa == Casa.RAVENCLAW) torpeza -= 10;   // más “cabeza”
        if (casa == Casa.HUFFLEPUFF) torpeza -= 5;   // constancia
        if (casa == Casa.SLYTHERIN) torpeza += 5;    // “se la juega más”
        torpeza = clamp(torpeza, 0, 100);
    }

    public void practicarBasico() {
        // Practicar reduce torpeza (mejora)
        if (!gastarMana(3)) return;

        torpeza -= 2;
        torpeza = clamp(torpeza, 0, 100);

        // Practicar también puede subir un poquito el nivel
        if (nivel < 100) nivel += 1;
    }

    @Override
    public int lanzarHechizo(String hechizo) {
        // Coste base
        if (!gastarMana(5)) return 0;

        // Probabilidad de fallo basada en torpeza
        int tirada = rnd.nextInt(100); // 0..99
        if (tirada < torpeza) {
            // falló
            return 0;
        }

        // Hechizos permitidos
        if (hechizo.equalsIgnoreCase("Lumos")) return 5;
        if (hechizo.equalsIgnoreCase("Alohomora")) return 7;

        // Si escribe otro, no lo conoce
        return 0;
    }

    public int getTorpeza() {
        return torpeza;
    }

    public void setTorpeza(int torpeza) {
        this.torpeza = clamp(torpeza, 0, 100);
    }
}

4) Hechicero.java

Idea clave

• Hereda de Aprendiz, pero ahora tiene controlVarita.
• Puede hacer hechizos más potentes.
• Los fallos deberían ser menos frecuentes: usamos torpeza pero “rebajada”.

package modelo;

import java.util.Random;

public class Hechicero extends Aprendiz {

    protected int controlVarita; // 0..100
    protected Random rnd2 = new Random();

    public Hechicero(String nombre, Casa casa) {
        super(nombre, casa);

        controlVarita = 50;

        // Ravenclaw suele destacar en control
        if (casa == Casa.RAVENCLAW) controlVarita += 10;
        if (casa == Casa.GRYFFINDOR) controlVarita += 5;

        controlVarita = clamp(controlVarita, 0, 100);
    }

    public void estudiarEnBiblioteca() {
        if (!gastarMana(6)) return;

        controlVarita += 3;
        controlVarita = clamp(controlVarita, 0, 100);

        nivel += 1;
        nivel = clamp(nivel, 1, 100);
    }

    @Override
    public int lanzarHechizo(String hechizo) {
        if (!gastarMana(7)) return 0;

        // Los Hechiceros fallan menos: torpeza influye menos
        int torpezaEfectiva = clamp(torpeza - (controlVarita / 5), 0, 100);
        int tirada = rnd2.nextInt(100);
        if (tirada < torpezaEfectiva) return 0;

        // Hechizos
        if (hechizo.equalsIgnoreCase("Lumos")) return 6;
        if (hechizo.equalsIgnoreCase("Alohomora")) return 8;
        if (hechizo.equalsIgnoreCase("Expelliarmus")) return 12;
        if (hechizo.equalsIgnoreCase("Stupefy")) return 18;

        return 0;
    }

    public int getControlVarita() {
        return controlVarita;
    }
}

5) Auror.java

Idea clave

• Un Auror es “modo combate”: tiene experiencia y puede arrestar.
• Añadimos métodos propios: patrullar() y arrestar(...).

package modelo;

public class Auror extends Hechicero {

    private int experienciaCombate; // 0..100
    private int arrestos;

    public Auror(String nombre, Casa casa) {
        super(nombre, casa);

        experienciaCombate = 40;
        arrestos = 0;

        if (casa == Casa.GRYFFINDOR) experienciaCombate += 10; // valentía
        if (casa == Casa.SLYTHERIN) experienciaCombate += 5;   // ambición táctica
        experienciaCombate = clamp(experienciaCombate, 0, 100);
    }

    public void patrullar() {
        if (!gastarMana(8)) return;

        experienciaCombate += 4;
        experienciaCombate = clamp(experienciaCombate, 0, 100);

        nivel += 1;
        nivel = clamp(nivel, 1, 100);
    }

    public boolean arrestar(Aprendiz objetivo) {
        // Regla: solo si está débil
        if (objetivo == null) return false;

        // Como vida es protected en Mago, podemos leerla aquí directamente:
        if (objetivo.vida <= 20) {
            arrestos++;
            return true;
        }
        return false;
    }

    @Override
    public int lanzarHechizo(String hechizo) {
        if (!gastarMana(9)) return 0;

        // Auror: daño mejorado por experienciaCombate
        if (hechizo.equalsIgnoreCase("Stupefy")) {
            return 20 + (experienciaCombate / 10);
        }

        // Protego: “defensa” simple -> recupera vida (no daño)
        if (hechizo.equalsIgnoreCase("Protego")) {
            vida += 10;
            vida = clamp(vida, 0, 100);
            return 0;
        }

        // Otros hechizos como en Hechicero (reutilizamos lógica)
        return super.lanzarHechizo(hechizo);
    }

    public int getArrestos() {
        return arrestos;
    }
}

6) Profesor.java

Idea clave

• Un Profesor enseña: puede reducir torpeza y subir nivel del alumno.
• Sus hechizos son “eficientes”: consumen menos mana o fallan menos.

package modelo;

public class Profesor extends Hechicero {

    private String asignatura;
    private int prestigio; // 0..100

    public Profesor(String nombre, Casa casa, String asignatura) {
        super(nombre, casa);
        this.asignatura = asignatura;

        prestigio = 60;
        if (casa == Casa.SLYTHERIN) prestigio += 5;
        if (casa == Casa.RAVENCLAW) prestigio += 10;
        prestigio = clamp(prestigio, 0, 100);
    }

    public void enseñar(Aprendiz alumno) {
        if (alumno == null) return;
        if (!gastarMana(6)) return;

        // Enseñar reduce torpeza y sube nivel
        alumno.setTorpeza(alumno.getTorpeza() - 8);
        alumno.nivel = clamp(alumno.nivel + 1, 1, 100);
    }

    public void evaluar() {
        if (!gastarMana(4)) return;
        prestigio += 2;
        prestigio = clamp(prestigio, 0, 100);
    }

    @Override
    public int lanzarHechizo(String hechizo) {
        // Profesor: coste menor y resultados más estables
        int coste = 6;
        if (!gastarMana(coste)) return 0;

        // “Daño controlado”
        if (hechizo.equalsIgnoreCase("Expelliarmus")) return 14;
        if (hechizo.equalsIgnoreCase("Stupefy")) return 17;
        if (hechizo.equalsIgnoreCase("Lumos")) return 5;
        if (hechizo.equalsIgnoreCase("Alohomora")) return 7;

        return 0;
    }

    public String getAsignatura() {
        return asignatura;
    }
}

7) Main.java (sin listas de Mago, tipos concretos)

package app;

import modelo.*;

public class Main {

    public static void main(String[] args) {

        Aprendiz harry = new Aprendiz("Harry", Casa.GRYFFINDOR);
        Aprendiz hermione = new Aprendiz("Hermione", Casa.RAVENCLAW);

        Hechicero draco = new Hechicero("Draco", Casa.SLYTHERIN);
        Hechicero luna = new Hechicero("Luna", Casa.HUFFLEPUFF);

        Auror kingsley = new Auror("Kingsley", Casa.HUFFLEPUFF);
        Profesor snape = new Profesor("Snape", Casa.SLYTHERIN, "Pociones");

        System.out.println("=== FICHAS INICIALES ===");
        System.out.println(harry.ficha());
        System.out.println(hermione.ficha());
        System.out.println(draco.ficha());
        System.out.println(luna.ficha());
        System.out.println(kingsley.ficha());
        System.out.println(snape.ficha());

        System.out.println("\n=== RONDA 1: PRACTICAR Y ESTUDIAR ===");
        harry.practicarBasico();
        hermione.practicarBasico();
        draco.estudiarEnBiblioteca();
        luna.estudiarEnBiblioteca();
        kingsley.patrullar();
        snape.evaluar();

        System.out.println(harry.ficha());
        System.out.println(hermione.ficha());
        System.out.println(draco.ficha());
        System.out.println(luna.ficha());
        System.out.println(kingsley.ficha());
        System.out.println(snape.ficha());

        System.out.println("\n=== RONDA 2: DUELO SIMPLE (daño a vida) ===");
        int d1 = draco.lanzarHechizo("Stupefy");
        harry.recibirDaño(d1);
        System.out.println("Draco lanza Stupefy a Harry. Daño: " + d1);
        System.out.println("Harry -> " + harry.ficha());

        int d2 = harry.lanzarHechizo("Lumos");
        draco.recibirDaño(d2);
        System.out.println("Harry lanza Lumos a Draco (sí, es cutre). Daño: " + d2);
        System.out.println("Draco -> " + draco.ficha());

        System.out.println("\n=== RONDA 3: PROFESOR EN ACCIÓN ===");
        snape.enseñar(harry);
        System.out.println("Snape enseña a Harry (baja torpeza y sube nivel).");
        System.out.println("Harry -> " + harry.ficha());

        System.out.println("\n=== RONDA 4: AUROR Y PROTEGO ===");
        int d3 = kingsley.lanzarHechizo("Stupefy");
        luna.recibirDaño(d3);
        System.out.println("Kingsley lanza Stupefy a Luna. Daño: " + d3);
        System.out.println("Luna -> " + luna.ficha());

        kingsley.lanzarHechizo("Protego");
        System.out.println("Kingsley usa Protego (se cura un poco).");
        System.out.println("Kingsley -> " + kingsley.ficha());

        System.out.println("\n=== RONDA 5: INTENTO DE ARRESTO ===");
        // Bajamos a propósito la vida de Hermione para probar arresto
        hermione.recibirDaño(85);
        System.out.println("Hermione queda débil: " + hermione.ficha());

        boolean arresto = kingsley.arrestar(hermione);
        System.out.println("¿Kingsley arresta a Hermione? " + arresto);
        System.out.println("Arrestos de Kingsley: " + kingsley.getArrestos());
    }
}

Aquí el alumnado ve claramente la herencia: cada clase tiene lo suyo.

El conocimiento es poder… pero en Hogwarts, también lo es la herencia bien diseñada.