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.
| Concepto | Qué es | En el ejemplo |
|---|---|---|
| Clase padre (superclase) | La general, con lo común | Empleado |
| Clase hija (subclase) | La específica, que hereda de la padre y añade lo suyo | Gerente |
| Relación | La hija es un tipo de padre | Un 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):
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:
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;
}
}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úlGerente 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:
| Uso | Se escribe | Para qué |
|---|---|---|
| En el constructor | super(nombre, sueldoBase); | Llamar al constructor del padre, para que guarde lo común. Tiene que ser la primera línea |
| En un método | super.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:
public class Dispositivo {
protected String marca;
public Dispositivo(String marca) {
this.marca = marca;
}
@Override
public String toString() {
return "Dispositivo de " + marca;
}
}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;
}
}Movil m = new Movil("Nokia", "3310");
System.out.println(m); // Dispositivo de Nokia, modelo 3310Atenció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ónde | En la clase hija | En la misma clase |
| La firma | Idéntica a la del padre | Distinta en cada versión (otros parámetros) |
| Qué cambia | El cuerpo del método heredado | Qué datos recibe |
| Tiene que ver con la herencia | Sí | No |
| Ejemplo | calcularSueldo() en Empleado y en Gerente | sumar(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#
| Modificador | Desde la propia clase | Desde una clase hija | Desde cualquier otra clase |
|---|---|---|---|
private | Sí | No | No |
protected | Sí | Sí | Solo si está en el mismo paquete |
public | Sí | 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.privatecon 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ónde | Se escribe | Qué impide |
|---|---|---|
| En una clase | public final class Dni { … } | Que alguien herede de ella (extends Dni da error) |
| En un método | public final String saludar() { … } | Que una hija lo sobrescriba |
| En un atributo | private 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íntoma | Qué significa | Cómo se arregla |
|---|---|---|
constructor Empleado in class Empleado cannot be applied to given types | El constructor de la hija no llama a super(...), y el padre no tiene constructor sin parámetros | Añade super(…) con los datos del padre como primera línea del constructor |
call to super must be first statement in constructor | El super(...) no está arriba del todo | Muévelo a la primera línea |
sueldoBase has private access in Empleado | La hija intenta usar un atributo private del padre | Hazlo protected, o usa su getter |
method does not override or implement a method from a supertype | Tiene @Override pero el padre no tiene ningún método con ese nombre y esos parámetros | Revisa el nombre, las mayúsculas y los parámetros: tienen que ser idénticos a los del padre |
cannot inherit from final Dni | Intentas heredar de una clase final | No 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 extends | Java solo hereda de una: para lo demás, usa interfaces |