Vericode
Entrar

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.

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 + ": " + calcularSueldo() + " €";
    }
}
Java
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");
    }
}
Java
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:

Java
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);
Salida
Eva: 1500.0 €
Raúl: 2800.0 €
Iván: 600.0 €
Total de nóminas: 4900.0

El 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.

Java
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.

Java
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étodo

e 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 decideEn el ejemplo
Qué métodos se pueden llamarEl tipo de la variable (al compilar)Empleado: getNombre(), calcularSueldo(), toString()
Qué versión se ejecutaEl 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):

Java
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();
    }
}
Salida
Raúl convoca una reunión
ExpresiónDaCuándo
e instanceof Gerentetrue o falsetrue si el objeto es un Gerente (o una hija suya)
(Gerente) eLa misma referencia, vista como GerenteSolo 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íntomaQué significaCómo se arregla
cannot find symbol: method convocarReunion()Llamas a un método de la hija desde una variable del tipo padrePregunta con instanceof y haz el casting: ((Gerente) e).convocarReunion()
ClassCastException: class Becario cannot be cast to class GerenteHas hecho un casting a una clase que el objeto no esAntes del casting, comprueba if (e instanceof Gerente)
incompatible types: Empleado cannot be converted to GerenteGuardas una variable del tipo padre en una del tipo hija sin castingSi estás seguro de que lo es, haz el casting: Gerente g = (Gerente) e;
Todos calculan el sueldo igualLa hija no sobrescribe el método, o el nombre o los parámetros no coinciden con los del padreRevisa la firma y pon @Override, que avisa si no coincide