Concepto de herencia, sintaxis de extends

1. ¿Qué es la herencia?

La herencia es un mecanismo que permite crear una clase nueva a partir de otra ya existente, «heredando» sus propiedades y métodos. La clase nueva se llama subclase (o clase hija), y la original es la clase padre (o clase base).

Es como si hicieras una tarta nueva a partir de una receta antigua: tomas todo lo bueno, añades un par de ingredientes nuevos y, ¡voilà!, ya tienes «Tarta de la abuela con ingrediente secreto».

• Clase padre — contiene propiedades y comportamientos comunes.
• Subclase — hereda todo esto y, además, puede añadir algo propio o cambiar el comportamiento.

Por ejemplo, «Un gato es un animal»: todos los gatos son animales, pero no todos los animales son gatos. Animal puede ser la clase base y Gato su subclase. Lo mismo con Perro, por ejemplo.
O «Un círculo es una figura»: cada círculo es una figura, pero no toda figura es un círculo. Figura puede ser la clase padre, y Círculo y Triángulo sus descendientes. En Java estas relaciones se implementan con la palabra clave extends.

¿Para qué sirve la herencia?

La pregunta del millón: ¿por qué no copiar simplemente código de una clase a otra? ¿Para qué se inventó la herencia?

• Reutilización de código: Todo lo común se extrae a la clase base. No hace falta duplicar campos y métodos: aparecen automáticamente en las subclases. Por ejemplo, en un programa para una universidad, la clase base puede ser persona, que como mínimo tiene nombre y fecha de nacimiento, y «estudiante» y «profesor» serían subclases con sus propias propiedades.
• Extensión y especialización: Puedes añadir nuevos campos y métodos o modificar los existentes solo donde sea necesario. Todos los animales emiten sonidos, pero el gato maúlla y el perro ladra. Además, al gato puedes añadirle la habilidad de trepar a los árboles (que la clase base no tiene).
• Estructuración de jerarquías: El código se vuelve más lógico y comprensible. Por ejemplo, si tienes las clases Animal, Dog, Cat, se ve de inmediato que Dog y Cat son casos particulares de Animal.

Ejemplo. Si en Java no existiera la herencia, tendrías que copiar métodos como eat(), sleep() y el campo name en cada clase de animal. ¡Y si mañana necesitas añadir el método breathe(), tendrías que cambiar decenas de clases! Con la herencia, basta con añadir la capacidad de respirar en la clase base.

2. Sintaxis de la herencia: extends

¿Cómo declarar herencia en Java? Muy sencillo: usa la palabra clave extends.

class ParentClass {
    // campos y métodos
}

class Subclass extends ParentClass {
    // campos y métodos adicionales
}

Ejemplo 1: Animales

// Clase base
class Animal {
    String name;

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

// Subclase
class Cat extends Animal {
    void meow() {
        System.out.println(name + " dice: ¡Miau!");
    }
}

¿Qué está pasando aquí?

• La clase Cat hereda todos los campos y métodos de la clase Animal.
• Por lo tanto, Cat ya tiene el campo name y el método eat(), aunque no los hayamos escrito explícitamente.
• Además, Cat añade su propio método meow().

Uso

public class Main {
    public static void main(String[] args) {
        Cat kitty = new Cat();
        kitty.name = "Kitty";
        kitty.eat();      // Kitty come.  (heredado)
        kitty.meow();     // Kitty dice: ¡Miau! (método propio)
    }
}

¡Voilà! Obtuvimos una clase nueva con el mínimo de código, evitando duplicaciones.

3. ¿Qué hereda exactamente una subclase?

En Java, una subclase hereda:

• Todos los campos y métodos públicos (public) y protegidos (protected) de la clase base.
• Todos los miembros package-private si la subclase está en el mismo paquete.

No hereda:

• Constructores (hay que declararlos explícitamente en la subclase).
• Campos y métodos privados (private) (solo son accesibles dentro de la propia clase base).
• Bloques estáticos de inicialización (no se heredan, pero cada clase puede tener los suyos).
• Miembros con acceso package-private, si la subclase está en otro paquete.

Ilustración

class Animal {
    public String name;
    private int age;

    public void eat() { 
        System.out.println("Como"); 
    }
    private void secret() { 
        System.out.println("¡Secreto!"); 
    }
}

class Dog extends Animal {
    public void bark() { 
        System.out.println("¡Guau!"); 
    }
}

• Dog heredará el campo name y el método eat().
• Dog no puede ver el campo age ni el método secret(): son privados.

4. Limitaciones de la herencia en Java

Java es bastante estricta y tiene sus propias reglas:

Solo herencia simple de clases: cada clase puede heredar solo de otra clase. En cambio, una clase puede tener tantos descendientes como se desee.

class Dog extends Animal { ... } // OK
class Dog extends Animal, Pet { ... } // Error: no se puede

Herencia múltiple de interfaces — se puede, pero es otra historia de la que hablaremos más adelante.

La clase Object — es la antecesora de todas las clases en Java. Incluso si no escribes explícitamente extends, tu clase igualmente hereda de forma implícita de Object.

5. Ejemplo práctico

Sigamos construyendo nuestra aplicación «zoológica».

Paso 1. Clase base Animal

class Animal {
    String name;

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

Paso 2. Subclase Cat

class Cat extends Animal {
    void meow() {
        System.out.println(name + " dice: ¡Miau!");
    }
}

Paso 3. Subclase Dog

class Dog extends Animal {
    void bark() {
        System.out.println(name + " dice: ¡Guau!");
    }
}

Paso 4. Usamos las clases

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name = "Kitty";
        cat.eat();   // Kitty come.
        cat.meow();  // Kitty dice: ¡Miau!

        Dog dog = new Dog();
        dog.name = "Rex";
        dog.eat();   // Rex come.
        dog.bark();  // Rex dice: ¡Guau!
    }
}

¿Qué hemos obtenido?

• Ambas clases, Cat y Dog, utilizan el campo común name y el método eat() de la clase base.
• Cada clase añade su comportamiento único: meow() para el gato, bark() para el perro.
• Si necesitas cambiar la forma en que los animales comen, basta con modificar el método eat() en la clase Animal: los cambios se aplicarán automáticamente a todos los descendientes.

6. Detalles útiles

Visualización: jerarquía de clases

Podemos representar la jerarquía así:

.        Animal
        /    \
     Cat     Dog

• Animal — clase base, contiene todo lo común a los animales.
• Cat y Dog — subclases, añaden rasgos únicos.

Un poco sobre constructores y herencia

Los constructores no se heredan. Si no defines un constructor en la subclase, Java añadirá automáticamente un constructor sin parámetros (si existe en el padre). Si la clase padre solo tiene constructor con parámetros, en la subclase hay que llamarlo explícitamente mediante super(...). Un ejemplo breve:

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

class Cat extends Animal {
    Cat(String name) {
        super(name); // llamamos al constructor del padre
    }
}

7. Errores típicos al usar la herencia

Error n.º 1: Intentar heredar de varias clases a la vez.
En Java no se puede escribir class Cat extends Animal, Pet. ¡Solo un padre!

Error n.º 2: Esperar que los campos y métodos privados estén disponibles en la subclase.
Los miembros privados no se heredan (más exactamente, existen, pero no son accesibles desde la subclase). Usa protected si quieres permitir el acceso a los descendientes.

Error n.º 3: Olvidar llamar al constructor del padre.
Si en la clase base no hay constructor sin parámetros y no llamas explícitamente a super(...), habrá un error de compilación.

Error n.º 4: Usar la herencia «para ahorrar código» y no por significado.
Si entre las clases no hay una relación «is-a», es mejor no usar herencia. Por ejemplo, «Persona» no debe heredar de «Automóvil», aunque ambas tengan el campo speed.