Vericode
Entrar

Programación orientada a objetos Tema 5

Herencia

Funciona en el IDE online. Todo lo de esta sección funciona en el IDE online: pulsa Pruébalo en cualquier ejemplo, o abre el IDE y escribe el tuyo. Sin instalar nada.

En una empresa hay empleados, y algunos son gerentes. Un gerente es un empleado más —tiene nombre y sueldo— pero con algo propio: un plus. Si escribes las dos clases por separado, repites todo lo común y, si mañana cambia, tienes que cambiarlo en dos sitios.

La herencia permite crear una clase a partir de otra que ya existe: la nueva hereda todos sus atributos y métodos, y solo añade lo que la hace distinta.

ConceptoQué esEn el ejemplo
Clase padre (superclase)La general, con lo comúnEmpleado
Clase hija (subclase)La específica, que hereda de la padre y añade lo suyoGerente
RelaciónLa hija es un tipo de padreUn gerente es un empleado

extends: heredar de otra clase#

La clase padre se escribe como siempre. Sus atributos van protected en vez de private, para que las hijas puedan usarlos (se explica más abajo):

Java
public class Empleado {
    protected String nombre;
    protected double sueldoBase;

    public Empleado(String nombre, double sueldoBase) {
        this.nombre = nombre;
        this.sueldoBase = sueldoBase;
    }

    public String getNombre() {
        return nombre;
    }

    public double calcularSueldo() {
        return sueldoBase;
    }

    @Override
    public String toString() {
        return nombre + " cobra " + calcularSueldo() + " €";
    }
}

La hija dice de quién hereda con extends, y solo escribe lo que añade:

Java
public class Gerente extends Empleado {
    private double plus;   // lo propio del gerente

    public Gerente(String nombre, double sueldoBase, double plus) {
        super(nombre, sueldoBase);   // el constructor de Empleado guarda lo común
        this.plus = plus;
    }

    @Override
    public double calcularSueldo() {
        return sueldoBase + plus;
    }
}
Java
Empleado eva = new Empleado("Eva", 1500);
Gerente raul = new Gerente("Raúl", 2000, 800);

System.out.println(eva);    // Eva cobra 1500.0 €
System.out.println(raul);   // Raúl cobra 2800.0 €
System.out.println(raul.getNombre());   // Raúl

Gerente no tiene escrito ni getNombre() ni toString(), y los dos funcionan: los ha heredado de Empleado. Y el toString heredado, al llamar a calcularSueldo(), usa la versión del gerente, con el plus.

Nota

Java solo tiene herencia simple: una clase hereda de una sola clase padre (extends admite un nombre). Lo que no se puede heredar de dos sitios a la vez se resuelve con interfaces.

super: hablar con la clase padre#

super sirve para llegar a la clase padre desde la hija. Tiene dos usos:

UsoSe escribePara qué
En el constructorsuper(nombre, sueldoBase);Llamar al constructor del padre, para que guarde lo común. Tiene que ser la primera línea
En un métodosuper.toString()Usar la versión del padre de un método que la hija ha cambiado

El segundo uso es útil para ampliar un método en vez de reescribirlo entero. Por ejemplo, un dispositivo y un móvil que lo muestra todo y añade lo suyo:

Java
public class Dispositivo {
    protected String marca;

    public Dispositivo(String marca) {
        this.marca = marca;
    }

    @Override
    public String toString() {
        return "Dispositivo de " + marca;
    }
}
Java
public class Movil extends Dispositivo {
    private String modelo;

    public Movil(String marca, String modelo) {
        super(marca);           // atributo heredado
        this.modelo = modelo;   // atributo propio
    }

    @Override
    public String toString() {
        return super.toString() + ", modelo " + modelo;
    }
}
Java
Movil m = new Movil("Nokia", "3310");
System.out.println(m);   // Dispositivo de Nokia, modelo 3310

Atención

Si el constructor del padre tiene parámetros, el de la hija está obligado a llamarlo con super(...). Si no lo hace, Java busca un constructor del padre sin parámetros y, si no lo hay, da error.

Sobrescritura: @Override#

Sobrescribir es que la hija cambie un método que ha heredado, con la misma firma (mismo nombre, mismos parámetros) y otro cuerpo. Es lo que hace Gerente con calcularSueldo().

La línea @Override encima del método no es obligatoria, pero conviene ponerla siempre: le dice a Java «esto sustituye a un método del padre», y si te equivocas al escribir el nombre (calcularSueldO), da error en vez de crear en silencio un método nuevo.

Sobrescritura y sobrecarga se parecen en el nombre, pero son cosas distintas:

Sobrescritura (override)Sobrecarga (overload)
DóndeEn la clase hijaEn la misma clase
La firmaIdéntica a la del padreDistinta en cada versión (otros parámetros)
Qué cambiaEl cuerpo del método heredadoQué datos recibe
Tiene que ver con la herenciaSíNo
EjemplocalcularSueldo() en Empleado y en Gerentesumar(int a, int b) y sumar(int a, int b, int c)

Consejo

Ya lo habías usado sin saberlo: todas las clases de Java heredan de Object, aunque no lo escribas. De ahí sale el toString que imprime Alumno@6d06d69c, y por eso al escribir el tuyo pones @Override: estás sobrescribiendo el de Object.

Quién ve qué: private, protected y public#

ModificadorDesde la propia claseDesde una clase hijaDesde cualquier otra clase
privateSíNoNo
protectedSíSíSolo si está en el mismo paquete
publicSíSíSí

Si los atributos de Empleado fueran private, el calcularSueldo() de Gerente no podría leer sueldoBase y tendría que usar un getSueldoBase(). Las dos formas son correctas:

  • protected: cómodo, las hijas usan los atributos directamente. Es lo que se hace en estos apuntes.
  • private con getters: más protegido, las hijas pasan por los métodos como cualquier otra clase.

final: impedir la herencia#

A veces no se quiere que una clase tenga hijas, o que un método se pueda cambiar. Para eso está final, el «candado» de la herencia:

DóndeSe escribeQué impide
En una clasepublic final class Dni { … }Que alguien herede de ella (extends Dni da error)
En un métodopublic final String saludar() { … }Que una hija lo sobrescriba
En un atributoprivate final String codigo;Que cambie su valor después de darle el primero

String es una clase final: nadie puede heredar de ella y cambiar cómo funciona.

Errores frecuentes#

Mensaje o síntomaQué significaCómo se arregla
constructor Empleado in class Empleado cannot be applied to given typesEl constructor de la hija no llama a super(...), y el padre no tiene constructor sin parámetrosAñade super(…) con los datos del padre como primera línea del constructor
call to super must be first statement in constructorEl super(...) no está arriba del todoMuévelo a la primera línea
sueldoBase has private access in EmpleadoLa hija intenta usar un atributo private del padreHazlo protected, o usa su getter
method does not override or implement a method from a supertypeTiene @Override pero el padre no tiene ningún método con ese nombre y esos parámetrosRevisa el nombre, las mayúsculas y los parámetros: tienen que ser idénticos a los del padre
cannot inherit from final DniIntentas heredar de una clase finalNo se puede: usa la clase como atributo (composición) en vez de heredar
class Gerente cannot extend multiple classes (o '{' expected tras la coma)Has puesto dos clases en extendsJava solo hereda de una: para lo demás, usa interfaces