Clases Abstractas e Interfaces en Java: Conceptos y Ejemplos Prácticos

Clases Abstractas en Java

public abstract class NombreClase {
    // Atributos (pueden ser protected para que hereden)
    protected String atributo1;
    private int atributo2;  // solo accesible vía getter

    // Constructor (llamado por subclases con super())
    public NombreClase(String atributo1) {
        this.atributo1 = atributo1;
    }

    // Método abstracto (sin cuerpo, obligatorio implementar)
    public abstract void metodoAbstracto();

    // Método concreto (con cuerpo, se hereda)
    public void metodoConcreto() {
        System.out.println("Implementación base");
    }
}

// Subclase concreta
public class SubClase extends NombreClase {
    public SubClase(String atributo1) {
        super(atributo1);  // ← OBLIGATORIO llamar a constructor padre
    }

    @Override
    public void metodoAbstracto() {
        System.out.println("Implementación específica");
    }
}

Interfaces en Java

¿Cuándo usar una interfaz?

• Define un contrato de tipo "puede hacer".
• Una clase puede implementar múltiples interfaces.
• Todos los métodos son públicos y abstractos (implícitamente).

public interface NombreInterfaz {
    // Constantes (implícitamente public static final)
    int VALOR_MAXIMO = 100;

    // Método abstracto (sin cuerpo)
    void metodo1();

    // Otro método abstracto
    int metodo2(String parametro);

    // Desde Java 8: método default (opcional)
    default void metodoDefault() {
        System.out.println("Implementación por defecto");
    }
}

// Clase que implementa la interfaz
public class MiClase implements NombreInterfaz {
    // OBLIGATORIO: implementar TODOS los métodos abstractos
    @Override
    public void metodo1() {
        System.out.println("Implementación de metodo1");
    }

    @Override
    public int metodo2(String parametro) {
        return parametro.length();
    }
}

Combinando Clase Abstracta e Interfaz

// 1. Interfaz (habilidad)
public interface Volador {
    void volar();
}

// 2. Clase abstracta (identidad)
public abstract class Animal {
    protected String nombre;

    public Animal(String nombre) {
        this.nombre = nombre;
    }

    public abstract void hacerSonido();
}

// 3. Clase híbrida (hereda identidad + implementa habilidad)
public class Pajaro extends Animal implements Volador {
    public Pajaro(String nombre) {
        super(nombre);
    }

    @Override
    public void hacerSonido() {
        System.out.println(nombre + " dice: Pío pío");
    }

    @Override
    public void volar() {
        System.out.println(nombre + " está volando");
    }
}

Polimorfismo con Clase Abstracta e Interfaz

public class Main {
    public static void main(String[] args) {
        // Polimorfismo con clase abstracta
        Animal animal = new Pajaro("Loro");
        animal.hacerSonido();  // Ejecuta método de Pajaro (enlace dinámico)

        // Polimorfismo con interfaz
        Volador volador = new Pajaro("Águila");
        volador.volar();        // ✅ funciona

        // Crear arreglo polimórfico
        Animal[] animales = {
            new Pajaro("Loro"),
            new Pajaro("Canario")
        };

        for (Animal a : animales) {
            a.hacerSonido();  // Enlace dinámico
        }
    }
}

Preguntas Típicas de Examen

• ¿Por qué no puedo instanciar una clase abstracta? Porque está incompleta (tiene métodos sin implementar). Solo sirve como plantilla.
• ¿Una clase puede implementar múltiples interfaces? Sí. Java permite herencia múltiple solo con interfaces.
• ¿Qué pasa si una subclase no implementa todos los métodos abstractos? La subclase debe declararse también como abstract.
• ¿Puede una interfaz tener un método con cuerpo? Sí, desde Java 8 con default o static.
• Diferencia entre abstract e interface: abstract = identidad base (es un); interface = capacidad adicional (puede hacer).
• ¿Qué es @Override? Es una anotación que le dice al compilador: "Este método está sobrescribiendo un método de la superclase o implementando un método de una interfaz".