Herencia en Java: extends, super y sobrescritura

La herencia es reutilización del tipo "es-un"

La herencia permite que una clase nueva se construya sobre otra ya existente. La clase nueva -la subclase- obtiene automáticamente los campos y métodos de la superclase, y luego añade o cambia lo que necesite. Recurres a ella cuando un tipo es una variante más específica de otro: un Dog es un Animal, una SavingsAccount es una BankAccount.

Se escribe con la palabra clave extends. Todo lo que sea public o protected en el padre está disponible en el hijo sin tener que reescribirlo.

class Animal {
    String name;

    Animal(String name) { this.name = name; }

    void eat() { System.out.println(name + " is eating"); }
}

class Dog extends Animal {
    Dog(String name) { super(name); }   // pasa name hacia arriba, a Animal

    void bark() { System.out.println(name + " says woof"); }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog("Rex");
        d.eat();    // heredado de Animal
        d.bark();   // definido en Dog
    }
}

Dog nunca declara name ni eat(), y sin embargo tiene ambos. De eso se trata justamente: el comportamiento compartido vive en un solo lugar.

super: llegar al padre

El constructor de una subclase debe asegurarse de que el padre se inicialice primero. Eso se hace con super(...), que llama al constructor del padre y debe ser la primera instrucción del constructor de la subclase. Si lo omites, Java inserta una llamada silenciosa al constructor sin argumentos del padre; y si el padre no tiene ese constructor, el código no compila.

class Account {
    double balance;

    Account(double opening) {
        balance = opening;
        System.out.println("Account opened with " + opening);
    }
}

class SavingsAccount extends Account {
    double rate;

    SavingsAccount(double opening, double rate) {
        super(opening);     // ejecuta primero el constructor de Account
        this.rate = rate;
        System.out.println("Savings rate set to " + rate);
    }
}

public class Main {
    public static void main(String[] args) {
        new SavingsAccount(100.0, 0.05);
    }
}

La salida muestra que el constructor del padre se ejecuta antes que el cuerpo del hijo: la construcción fluye de arriba abajo en la jerarquía.

Sobrescribir métodos

Una subclase puede reemplazar un método heredado redefiniéndolo con la misma firma. Esto se llama sobrescritura, y siempre deberías marcarla con @Override. La anotación no es obligatoria, pero hace que el compilador verifique que realmente coincides con un método del padre; detecta errores tipográficos como tostring() en lugar de toString(), que de otro modo crearían silenciosamente un método completamente nuevo.

class Animal {
    String speak() { return "..."; }
}

class Cat extends Animal {
    @Override
    String speak() { return "meow"; }
}

class Cow extends Animal {
    @Override
    String speak() { return "moo"; }
}

public class Main {
    public static void main(String[] args) {
        Animal[] animals = { new Cat(), new Cow(), new Animal() };
        for (Animal a : animals) {
            System.out.println(a.speak());   // cada uno ejecuta su propia versión
        }
    }
}

Aunque el arreglo sea de tipo Animal, cada elemento ejecuta su propio speak(). Java elige el método según el objeto real en tiempo de ejecución, no según el tipo declarado de la variable; esa es la base del polimorfismo.

Llamar a la versión del padre con super.method()

Sobrescribir no tiene por qué descartar el trabajo del padre. Usa super.method() para ejecutar la versión heredada y luego ampliarla:

class Logger {
    void log(String msg) { System.out.println("[log] " + msg); }
}

class TimestampLogger extends Logger {
    @Override
    void log(String msg) {
        super.log("at t=0 " + msg);   // reutiliza el padre y luego amplía
    }
}

public class Main {
    public static void main(String[] args) {
        new TimestampLogger().log("server started");
    }
}

Sin super., llamar a log dentro de TimestampLogger.log se llamaría a sí mismo y entraría en recursión infinita. super. significa explícitamente "la versión del padre".

Campos heredados y acceso

Una subclase ve los miembros public y protected del padre, pero no los private. Los campos private siguen existiendo en el objeto -los propios métodos del padre pueden tocarlos- pero la subclase no puede referenciarlos directamente. Usa protected cuando quieras que las subclases tengan acceso mientras mantienes un miembro oculto del código no relacionado.

class Base {
    private int secret;      // invisible para las subclases
    protected int shared;    // visible para las subclases
}

class Derived extends Base {
    void demo() {
        shared = 5;          // OK
        // secret = 5;       // error de compilación: private en Base
    }
}

Esta es también la razón por la que el constructor de una subclase a menudo debe llamar a super(...): es la única forma de inicializar el estado privado del padre.

Detener la herencia con final

A veces una clase no debería poder extenderse en absoluto: String es final precisamente por esto. Marcar una clase como final prohíbe crear subclases; marcar un método como final prohíbe sobrescribirlo, aunque todavía permite extender la clase.

final class Constants { }            // no se puede heredar de ella

class Config {
    final void load() { }            // las subclases pueden extender Config
                                     // pero no pueden sobrescribir load()
}

Recurre a final cuando el comportamiento de una clase deba estar garantizado y ser inmutable en todo el programa: es una señal deliberada de "no extender", no la opción por defecto.

Un error común: prefiere la composición cuando no es "es-un"

La herencia resulta tentadora porque reutiliza código, pero acopla estrechamente al hijo con el padre. Si la relación no es un genuino "es-un" -digamos un Car que simplemente necesita un Engine- no hagas Car extends Engine. Un coche tiene un motor, no es un motor. Modela eso con un campo (composición) en su lugar:

class Car {
    private Engine engine = new Engine();   // Car TIENE-UN Engine

    void start() { engine.ignite(); }
}

Usa la herencia solo cuando la subclase sea realmente una forma especializada de la superclase y quieras heredar y sustituir su comportamiento.

Siguiente: Interfaces

La herencia con extends te da un único padre y una implementación compartida. Pero una clase solo puede extender una clase, entonces, ¿cómo das una capacidad común a clases que no están relacionadas? Para eso sirven las interfaces: un contrato que muchas clases pueden implementar, y el tema de la próxima página.