Programación orientada a objetos Tema 6
Polimorfismo
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.
Con la herencia, un gerente es un empleado. Eso tiene una consecuencia muy útil: donde el programa espera un Empleado, se puede poner un Gerente, o cualquier otra clase hija. Una misma variable puede guardar objetos de distintas formas, y cada uno se comporta según lo que es de verdad. Eso es el polimorfismo («muchas formas»).
Los ejemplos de este tema usan estas tres clases: el Empleado, el Gerente del tema anterior y un Becario, que cobra la mitad.
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 + ": " + calcularSueldo() + " €";
}
}public class Gerente extends Empleado {
private double plus;
public Gerente(String nombre, double sueldoBase, double plus) {
super(nombre, sueldoBase);
this.plus = plus;
}
@Override
public double calcularSueldo() {
return sueldoBase + plus;
}
public void convocarReunion() {
System.out.println(nombre + " convoca una reunión");
}
}public class Becario extends Empleado {
public Becario(String nombre, double sueldoBase) {
super(nombre, sueldoBase);
}
@Override
public double calcularSueldo() {
return sueldoBase / 2;
}
}Un array con objetos de distintas clases#
Un array de tipo Empleado admite empleados, gerentes y becarios, porque todos son empleados. Al recorrerlo, cada uno calcula su sueldo a su manera:
Empleado[] plantilla = {
new Empleado("Eva", 1500),
new Gerente("Raúl", 2000, 800),
new Becario("Iván", 1200)
};
double total = 0;
for (Empleado e : plantilla) {
System.out.println(e);
total += e.calcularSueldo();
}
System.out.println("Total de nóminas: " + total);Eva: 1500.0 €
Raúl: 2800.0 €
Iván: 600.0 €
Total de nóminas: 4900.0El bucle no sabe ni le importa qué hay en cada posición: llama a calcularSueldo() y Java ejecuta la versión de la clase del objeto, no la del tipo de la variable. Si mañana se añade un Comercial con su propio sueldo, este bucle funciona sin tocar una línea.
Lo mismo sirve para los parámetros: un método que recibe un Empleado acepta cualquiera de sus hijas.
public class App {
public static void imprimirNomina(Empleado e) {
System.out.println("Nómina de " + e.getNombre() + ": " + e.calcularSueldo() + " €");
}
public static void main(String[] args) {
imprimirNomina(new Gerente("Raúl", 2000, 800)); // Nómina de Raúl: 2800.0 €
imprimirNomina(new Becario("Iván", 1200)); // Nómina de Iván: 600.0 €
}
}Qué se puede pedir a cada variable#
El tipo de la variable decide qué métodos se pueden llamar; el tipo del objeto decide qué versión se ejecuta.
Empleado e = new Gerente("Raúl", 2000, 800);
System.out.println(e.calcularSueldo()); // 2800.0: la versión de Gerente
// e.convocarReunion(); // error: un Empleado no tiene ese métodoe apunta a un gerente, pero es una variable de tipo Empleado, y a un empleado solo se le puede pedir lo que tiene cualquier empleado. convocarReunion() es solo de los gerentes, así que Java no deja llamarlo desde ahí.
| Lo decide | En el ejemplo | |
|---|---|---|
| Qué métodos se pueden llamar | El tipo de la variable (al compilar) | Empleado: getNombre(), calcularSueldo(), toString() |
| Qué versión se ejecuta | El tipo del objeto (al ejecutar) | Gerente: el sueldo con el plus |
Por eso el temario habla de dos polimorfismos: el estático, que es la sobrecarga (Java elige el método al compilar, por los parámetros), y el dinámico, que es la sobrescritura (elige al ejecutar, por el objeto). Cuando se dice «polimorfismo» a secas, se habla del dinámico.
instanceof y casting#
Si en un array de empleados hace falta algo que solo tienen los gerentes, primero se pregunta qué es cada objeto con instanceof, y después se convierte la variable al tipo hija con un casting, (Gerente):
Empleado[] plantilla = {
new Empleado("Eva", 1500),
new Gerente("Raúl", 2000, 800),
new Becario("Iván", 1200)
};
for (Empleado e : plantilla) {
if (e instanceof Gerente) {
Gerente g = (Gerente) e; // ahora sí se ve como gerente
g.convocarReunion();
}
}Raúl convoca una reunión| Expresión | Da | Cuándo |
|---|---|---|
e instanceof Gerente | true o false | true si el objeto es un Gerente (o una hija suya) |
(Gerente) e | La misma referencia, vista como Gerente | Solo si de verdad es un gerente: si no, el programa se para |
Atención
El casting no convierte el objeto en otra cosa: solo cambia cómo lo ve la variable. Si haces (Gerente) sobre un becario, Java para el programa con ClassCastException. Pregunta siempre antes con instanceof.
Consejo
Desde Java 16, las dos cosas van en una: if (e instanceof Gerente g) pregunta y, si lo es, deja el objeto en g, ya como gerente, para usarlo dentro del if. Es lo mismo que las dos líneas de arriba, más corto.
Consejo
El casting al revés, de hija a padre, no hace falta escribirlo: Empleado e = new Gerente(...) ya funciona solo, porque un gerente siempre es un empleado.
Errores frecuentes#
| Mensaje o síntoma | Qué significa | Cómo se arregla |
|---|---|---|
cannot find symbol: method convocarReunion() | Llamas a un método de la hija desde una variable del tipo padre | Pregunta con instanceof y haz el casting: ((Gerente) e).convocarReunion() |
ClassCastException: class Becario cannot be cast to class Gerente | Has hecho un casting a una clase que el objeto no es | Antes del casting, comprueba if (e instanceof Gerente) |
incompatible types: Empleado cannot be converted to Gerente | Guardas una variable del tipo padre en una del tipo hija sin casting | Si estás seguro de que lo es, haz el casting: Gerente g = (Gerente) e; |
| Todos calculan el sueldo igual | La hija no sobrescribe el método, o el nombre o los parámetros no coinciden con los del padre | Revisa la firma y pon @Override, que avisa si no coincide |