Dominando la Herencia en Java: Subclases, Superclases y Principios Fundamentales

La herencia es el proceso mediante el cual una clase adquiere las propiedades (métodos y campos) de otra. Permite organizar la información en una jerarquía lógica y reutilizar código.

• Subclase (clase hija / derivada): La que hereda.
• Superclase (clase base / padre): La que es heredada.

Palabra Clave extends

Se usa para heredar de una clase.

class Super { ... }
class Sub extends Super { ... }

Ejemplo Básico

class Calculation {
    int z;
    public void addition(int x, int y) {
        z = x + y;
        System.out.println("Suma: " + z);
    }
    public void Subtraction(int x, int y) {
        z = x - y;
        System.out.println("Resta: " + z);
    }
}

public class My_Calculation extends Calculation {
    public void multiplication(int x, int y) {
        z = x * y;
        System.out.println("Producto: " + z);
    }

    public static void main(String args[]) {
        int a = 20, b = 10;
        My_Calculation demo = new My_Calculation();
        demo.addition(a, b);       // heredado
        demo.Subtraction(a, b);    // heredado
        demo.multiplication(a, b); // propio
    }
}

Salida:

Suma: 30
Resta: 10
Producto: 200

Al crear un objeto de la subclase, se incluye una copia de los miembros de la superclase (excepto constructores).

Referencia de Superclase a Objeto de Subclase

Una variable de tipo superclase puede referenciar un objeto de subclase, pero solo permite acceder a miembros de la superclase.

Calculation cal = new My_Calculation();
cal.addition(a, b);      // OK
cal.Subtraction(a, b);   // OK
// cal.multiplication(a, b); // ERROR: no visible desde tipo Calculation

Para acceder a miembros de ambas, usa referencia de subclase.

Palabra Clave super

Similar a this, pero para la superclase. Dos usos principales:

1. Diferenciar Miembros con Mismo Nombre

super.variable
super.metodo()

Ejemplo

class Super_class {
    int num = 20;
    public void display() {
        System.out.println("display de Superclase");
    }
}

public class Sub_class extends Super_class {
    int num = 10;
    public void display() {
        System.out.println("display de Subclase");
    }

    public void my_method() {
        Sub_class sub = new Sub_class();
        sub.display();       // método de subclase
        super.display();     // método de superclase
        System.out.println("num subclase: " + sub.num);
        System.out.println("num superclase: " + super.num);
    }

    public static void main(String args[]) {
        Sub_class obj = new Sub_class();
        obj.my_method();
    }
}

Salida:

display de Subclase
display de Superclase
num subclase: 10
num superclase: 20

2. Invocar Constructor de la Superclase

La subclase hereda el constructor por defecto. Para llamar a uno parametrizado:

super(valores);

Ejemplo

class Superclass {
    int age;
    Superclass(int age) { this.age = age; }
    public void getAge() { System.out.println("Edad en superclase: " + age); }
}

public class Subclass extends Superclass {
    Subclass(int age) { super(age); } // invoca constructor parametrizado
    public static void main(String args[]) {
        Subclass s = new Subclass(24);
        s.getAge();
    }
}

Salida: Edad en superclase: 24

Relación IS-A

extends establece una relación ES-UN (IS-A).

class Animal {}
class Mammal extends Animal {}
class Reptile extends Animal {}
class Dog extends Mammal {}

• Mammal ES-UN Animal
• Dog ES-UN Mammal → Dog ES-UN Animal

Verificación con instanceof:

Animal a = new Animal();
Mammal m = new Mammal();
Dog d = new Dog();
System.out.println(m instanceof Animal); // true
System.out.println(d instanceof Mammal); // true
System.out.println(d instanceof Animal); // true

Palabra Clave implements

Se usa para implementar interfaces (una clase no puede extends una interfaz).

interface Animal {}
class Mammal implements Animal {}
class Dog extends Mammal {}

Relación HAS-A (Composición)

Basada en uso: una clase TIENE-UN objeto de otra. Reduce duplicación y permite reutilización.

class Vehicle {}
class Speed {}
class Van extends Vehicle {
    private Speed sp; // Van TIENE-UN Speed
}

La clase Van oculta los detalles de Speed (encapsulamiento).

Tipos de Herencia

• Simple (una subclase → una superclase)
• Multinivel (A → B → C)
• Jerárquica (A → B, A → C)

Java NO soporta herencia múltiple de clases (una clase no puede extender más de una).

// ILEGAL
class C extends A, B {}

Pero una clase sí puede implementar múltiples interfaces, lo que resuelve la limitación.