📄 Programación en Java – Prácticas DAM

1.1 Estructura general del proyecto

Las clases importantes del paquete videojuego son:

La idea es que Personaje define lo común de todos los personajes (vida, ataque base, pociones, métodos como atacar, defender, etc.), y las subclases (Guerrero, Mago, Arquero, Enemigo) añaden comportamiento específico.

1.2 Clase abstracta Personaje

La clase Personaje es abstracta, lo que significa que:

• No se puede instanciar directamente (new Personaje(...) está prohibido).
• Define métodos abstractos que las clases hijas deben implementar (getTipo(), habilidadEspecial(...), actuar(...)).

JAVA// Clase base de todos los personajes
public abstract class Personaje {
    // Atributos privados (encapsulación)
    private String nombre;
    private int vida;
    private int vidamax;
    private int ataquebase;
    private int pociones;
    private boolean defendiendo;
    private java.util.List<Pocion> inventarioPociones;

    // Constructor: se llama desde las clases hijas con super(...)
    public Personaje(String nombre, int vidamax, int ataquebase) {
        this.nombre = nombre;
        this.vida = vidamax;
        this.vidamax = vidamax;
        this.ataquebase = ataquebase;
        this.pociones = 3;  // por ejemplo
        this.inventarioPociones = new java.util.ArrayList<>();
    }

    // Método que comprueba si el personaje sigue vivo
    public boolean estaVivo() {
        return this.vida > 0;
    }

    // Método de ataque genérico con posible crítico
    public void atacar(Personaje objetivo) {
        java.util.Random azar = new java.util.Random();
        int danioFinal = ataquebase;

        // 20% de probabilidad de crítico
        if (azar.nextInt(100) < 20) {
            danioFinal *= 2;
            System.out.println(nombre + " hace un GOLPE CRÍTICO de " + danioFinal);
        }

        // Si el objetivo se defiende, reduce el daño
        if (objetivo.getDefendiendo()) {
            danioFinal /= 2;
        }

        objetivo.setVida(Math.max(objetivo.getVida() - danioFinal, 0));
    }

    // Métodos abstractos que las hijas deben implementar
    public abstract String getTipo();
    public abstract void habilidadEspecial(Personaje objetivo);
    public abstract void actuar(Personaje objetivo);
}

1.3 Herencia: Guerrero, Mago, Arquero, Enemigo

Cada clase hija extiende Personaje y añade sus propios atributos y comportamiento. Por ejemplo, Guerrero tiene estamina, Mago tiene mana, Arquero tiene flechas, etc.

JAVA// Ejemplo simplificado de Guerrero
public class Guerrero extends Personaje {
    private int estamina;

    public Guerrero(String nombre, int vidamax,
                     int ataquebase, int estamina) {
        super(nombre, vidamax, ataquebase);
        this.estamina = estamina;
    }

    @Override
    public String getTipo() {
        return "Guerrero";
    }

    @Override
    public void habilidadEspecial(Personaje objetivo) {
        // Ejemplo: gastar estamina para hacer más daño
        if (estamina >= 10) {
            estamina -= 10;
            System.out.println(getNombre() + " usa GOLPE BRUTAL sobre " + objetivo.getNombre());
            objetivo.setVida(Math.max(objetivo.getVida() - 30, 0));
        } else {
            System.out.println(getNombre() + " está cansado, usa ataque normal.");
            atacar(objetivo);
        }
    }

    @Override
    public void actuar(Personaje objetivo) {
        // Decide si usar habilidad especial o ataque normal
        if (estamina >= 10) habilidadEspecial(objetivo);
        else atacar(objetivo);
    }
}

1.4 Enemigo: IA simple basada en la vida

La clase Enemigo también extiende Personaje, pero su método actuar no se decide por un jugador humano, sino por una lógica interna sencilla:

JAVA// Parte del método actuar en Enemigo
public void actuar(Personaje objetivo) {
    double porcentajeVida =
        (double) this.getVida() / this.getVidamax();

    // Si la vida baja del 30%, se defiende
    if (porcentajeVida < 0.3) {
        this.defender();
        System.out.println(getNombre() + " está herido y se pone en modo defensivo.");
    } else {
        // Si no, ataca normalmente
        this.atacar(objetivo);
    }
}

Con esto se consigue que el enemigo tenga un comportamiento mínimamente inteligente sin necesidad de un sistema de IA complejo.

1.5 Pocion y el inventario del personaje

La clase Pocion es muy sencilla, pero muestra un concepto clave: composición. Un Personaje tiene una lista de Pocion, es decir, está formado también por esos objetos.

JAVA// Clase Pocion
public class Pocion {
    private int curacion = 20;

    public void usar(Personaje objetivo) {
        int vidaActual = objetivo.getVida();
        int vidaMax = objetivo.getVidamax();
        objetivo.setVida(Math.min(vidaActual + curacion, vidaMax));
    }
}

En Personaje hay algo como:

JAVA// Uso del inventario de pociones
public void usarPocion() {
    if (!inventarioPociones.isEmpty()) {
        Pocion p = inventarioPociones.remove(0);  // coge la primera poción
        p.usar(this);                            // se aplica sobre este personaje
    } else {
        System.out.println(nombre + " no tiene pociones.");
    }
}

1.6 Combate y el flujo de ejecución

La clase Combate orquesta el intercambio de golpes entre dos personajes: controla los turnos hasta que uno muere.

JAVA// Bucle principal de combate
public class Combate {
    private Personaje p1, p2;
    private int turnos = 1;

    public Combate(Personaje p1, Personaje p2) {
        this.p1 = p1;
        this.p2 = p2;
    }

    public void iniciar() {
        while (p1.estaVivo() && p2.estaVivo()) {
            System.out.println("\n--- TURNO " + turnos + " ---");
            p1.mostrarEstado();
            p2.mostrarEstado();

            p1.actuar(p2);
            if (!p2.estaVivo()) break;

            p2.actuar(p1);

            p1.finturno();
            p2.finturno();
            turnos++;
        }

        System.out.println("\nGANADOR: " +
            (p1.estaVivo() ? p1.getNombre() : p2.getNombre()));
    }
}

1.7 Main: punto de entrada

JAVA
public class Main {
    public static void main(String[] args) {
        Personaje p1 = new Guerrero("Máximo", 100, 15, 50);
        Personaje p2 = new Enemigo("Orco Carnicero", 120, 12);

        Combate duelo = new Combate(p1, p2);
        duelo.iniciar();
    }
}

Aquí se ve la “foto final”: se crean los objetos concretos, se construye el combate con ellos y se llama a iniciar() para ejecutar el bucle.

2.1 Entrada por teclado y validaciones básicas

Al inicio, el programa pide al usuario las rutas de origen y destino:

JAVA
public class CopiaFicherosBinarios {
    public static void main(String[] args) {
        java.util.Scanner sc = new java.util.Scanner(System.in);

        try {
            System.out.println("Indica la ruta del archivo ORIGEN: ");
            String rutaOrigen = sc.nextLine().trim();

            System.out.println("Indica la ruta del archivo DESTINO: ");
            String rutaDestino = sc.nextLine().trim();

            java.io.File origen = new java.io.File(rutaOrigen);
            java.io.File destino = new java.io.File(rutaDestino);

            // Comprobaciones básicas
            if (!origen.exists()) {
                System.out.println("El archivo origen no existe.");
                return;
            }

            if (!origen.isFile()) {
                System.out.println("El origen no es un fichero válido.");
                return;
            }

            // (Opcional) comprobar extensión .jpg, .bin, etc.
            // Aquí iría la llamada al método de copia...

        } catch (java.io.IOException e) {
            System.out.println("Error de E/S: " + e.getMessage());
        }
    }
}

2.2 Copia usando FileInputStream y FileOutputStream

La copia real se hace leyendo bloques de bytes de un stream de entrada y escribiéndolos en el de salida. Usar un buffer mejora el rendimiento frente a leer byte a byte.

JAVA
private static void copiarFichero(java.io.File origen, java.io.File destino)
        throws java.io.IOException {

    try (java.io.FileInputStream fis = new java.io.FileInputStream(origen);
         java.io.FileOutputStream fos = new java.io.FileOutputStream(destino)) {

        byte[] buffer = new byte[4096];  // 4 KB por lectura
        int bytesLeidos;

        while ((bytesLeidos = fis.read(buffer)) != -1) {
            fos.write(buffer, 0, bytesLeidos);
        }
    }
}

2.3 Comprobar si los ficheros son idénticos

Después de copiar, se suele comprobar si ambos ficheros son iguales comparando byte a byte:

JAVA
private static boolean sonFicherosIguales(java.io.File f1, java.io.File f2)
        throws java.io.IOException {

    if (f1.length() != f2.length()) {
        return false;  // tamaños distintos ⇒ ya no son iguales
    }

    try (java.io.FileInputStream in1 = new java.io.FileInputStream(f1);
         java.io.FileInputStream in2 = new java.io.FileInputStream(f2)) {

        int b1, b2;
        do {
            b1 = in1.read();
            b2 = in2.read();
            if (b1 != b2) return false;
        } while (b1 != -1);
    }

    return true;
}

De este modo se asegura que no solo se ha copiado “algo”, sino que el contenido es exactamente igual.

2.4 Informe de copia y uso de fecha/hora

La práctica también escribe un log en texto usando BufferedWriter y FileWriter, añadiendo fecha y estadísticas de la copia.

JAVA
private static void escribirInforme(
        java.io.File origen, java.io.File destino,
        boolean sonIguales, String textoAnalisis)
        throws java.io.IOException {

    String salto = System.lineSeparator();
    java.time.LocalDateTime ahora = java.time.LocalDateTime.now();
    java.time.format.DateTimeFormatter formato =
        java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    String marcaTiempo = ahora.format(formato);

    try (java.io.BufferedWriter bw =
             new java.io.BufferedWriter(
                 new java.io.FileWriter("informe_copia.txt", true))) {

        bw.write("========== COPIA DE FICHEROS ==========" + salto);
        bw.write("Fecha y hora: " + marcaTiempo + salto);
        bw.write("Origen: " + origen.getAbsolutePath() + salto);
        bw.write("Destino: " + destino.getAbsolutePath() + salto);
        bw.write("¿Ficheros idénticos?: " + sonIguales + salto);
        bw.write("Estadísticas:" + salto);
        bw.write(textoAnalisis + salto + salto);
    }
}

3.1 Tabla comparativa de conceptos

3.2 Checklist mental para examen / prácticas