Polimorfismo en Java: sobrescritura de métodos con ejemplos

Problema

El pago con un if para cada tipo

La empresa tiene empleados normales, gerentes con bono y becarios a media jornada. Alguien hizo una sola clase Employee con un campo «rol», y el pago se calcula así:

static int monthlyPay(Employee e) {
    if (e.getRole().equals("gerente")) {
        return e.getSalary() + e.getBonus();
    } else if (e.getRole().equals("becario")) {
        return e.getSalary() / 2;
    }
    return e.getSalary();
}

Funciona. Pero entonces llega un nuevo tipo de empleado: un contratista. Necesitas un nuevo else if aquí, y en el método de los impuestos, y en el método de la nómina, y en todos los lugares donde alguien preguntó por el rol. Y cada empleado lleva un campo de bono, aunque solo los gerentes reciben bono.

El código del gerente está repartido por todo el programa en lugar de estar en el gerente.

La idea

Cada clase decide por sí misma

Con la herencia de la lección anterior, Manager e Intern son clases separadas. Deja que cada una diga cuál es su pago mensual. La clase padre tiene una versión general, y la hija escribe su propia versión del mismo método:

class Employee {
    // ... name, salary, el constructor y los getters

    public int monthlyPay() {
        return salary;
    }
}

class Manager extends Employee {
    // ... bonus y el constructor

    @Override
    public int monthlyPay() {
        return getSalary() + bonus;
    }
}

Employee ivan = new Employee("Juan", 2000);
Manager maria = new Manager("María", 3000, 500);
System.out.println(ivan.monthlyPay());
System.out.println(maria.monthlyPay());

2000
3500

Esto se llama sobrescribir un método. La hija escribe un método con el mismo nombre, los mismos parámetros y el mismo tipo de retorno. Para los objetos de la clase hija, su versión reemplaza a la de la clase padre.

@Override es una anotación: una nota para el compilador. Dice: «este método sobrescribe un método de la clase padre, compruébalo». No es obligatoria, pero escríbela siempre. Enseguida verás por qué.

Más precisamente, para curiosos

En Java se puede sobrescribir cualquier método, salvo los private, los static y los final. final delante de un método dice «las clases hijas no pueden cambiarlo».
La hija no puede hacer el método más oculto: si es public en la clase padre, sigue siendo public.

Pruébalo

¿Qué cambió?

El becario sobrescribe solo el método del pago mensual:

¿Qué imprimirá el programa?

class Intern extends Employee {
    public Intern(String name, int salary) {
        super(name, salary);
    }

    @Override
    public int monthlyPay() {
        return getSalary() / 2;
    }
}

Intern ana = new Intern("Ana", 1600);
System.out.println(ana.monthlyPay());
System.out.println(ana.getSalary());

Respuesta

800
1600

1600
1600

800
800

La idea

Un array para todos

Un gerente es un empleado. Así que una variable de tipo Employee puede apuntar a un objeto de tipo Manager, y un array Employee[] puede guardar cualquier tipo de empleado:

Employee[] staff = {
    new Employee("Juan", 2000),
    new Manager("María", 3000, 500),
    new Intern("Ana", 1600)
};
for (Employee e : staff) {
    System.out.println(e.getName() + ": " + e.monthlyPay() + " €");
}

Juan: 2000 €
María: 3500 €
Ana: 800 €

El bucle llama al mismo método, e.monthlyPay(), y el resultado es distinto. La versión que se ejecuta es la del objeto, no la del tipo de la variable. Esto se llama polimorfismo: en griego, «muchas formas». Una llamada, y cada objeto responde a su manera.

Ahora un nuevo tipo de empleado es una clase nueva con su propio monthlyPay(). El bucle y el resto del programa se quedan como están. No hay ningún if sobre el rol ni un campo de bono en los empleados que no reciben bono.

Pero el tipo de la variable decide qué puedes llamar. A través de e no llegas al bono, aunque el objeto sea un gerente: el compilador solo sabe que e es algún Employee. Cómo llegar a lo que solo tienen algunos objetos está en la lección «Comprobaciones de tipo».

Míralo

Qué método se ejecuta

Employee[] staff = {
    new Employee("Juan", 2000),
    new Manager("María", 3000, 500),
    new Intern("Ana", 1600)
};
for (Employee e : staff) {
    System.out.println(e.getName() + ": " + e.monthlyPay() + " €");
}

Paso a paso, en palabras

El array es de tipo Employee, pero los objetos son de tres clases. Cada casilla guarda una flecha.
e apunta a Juan, un Employee normal: se ejecuta el monthlyPay de Employee.
e apunta a María, un Manager: se ejecuta su propio método, salario más bono.
e apunta a Ana, un Intern: el becario recibe la mitad del salario.
La misma línea, tres métodos distintos. Decide el objeto, no el tipo de la variable.

El array guarda tres flechas de tipo Employee. Cada una apunta a un objeto de una clase distinta. En cada vuelta e apunta al objeto siguiente, y la llamada va al método de ese objeto: primero en Employee, después en Manager, después en Intern.

La elección se hace mientras el programa se ejecuta, no al compilar. El compilador no sabe qué habrá en el array. Solo comprueba que todo Employee tenga ese método.

Pruébalo

Encuentra el error

El programa es el mismo, pero el becario recibe el salario completo:

Juan: 2000 €
María: 3500 €
Ana: 1600 €

Aquí está la clase Intern. ¿Qué línea tiene el error?

Elige la línea con el error.

El método se llama monthlypay, con «p» minúscula. Es un método nuevo, no una sobrescritura de monthlyPay. Así que a través de Employee se llama a la versión de la clase padre. Con @Override encima, el programa no compilaría: «method does not override or implement a method from a supertype». Por eso siempre escribes @Override.

La idea

Añade a la clase padre, no la reescribas

A veces la hija no quiere reemplazar el método por completo, solo añadirle algo. Un gerente se describe como un empleado, más el bono. Llamas a la versión de la clase padre con super.toString():

@Override
public String toString() {
    return super.toString() + ", bono " + bonus + " €";
}

System.out.println(new Employee("Juan", 2000));
System.out.println(new Manager("María", 3000, 500));

Juan (2000 €)
María (3000 €), bono 500 €

Si Employee cambia cómo se describe, el gerente lo sigue por sí solo.

Este es también el toString() del módulo «Clases y objetos». Allí ya sobrescribías un método: la versión de Object. Por eso tenía @Override encima.

Más precisamente, para curiosos

Puedes llamar a super.method() desde cualquier método de la hija, no solo desde el que sobrescribe.

La sobrescritura no es la sobrecarga del módulo «Métodos». En la sobrecarga el nombre es el mismo y los parámetros son distintos, y el compilador elige según los argumentos. En la sobrescritura todo es igual, y elige el objeto mientras el programa se ejecuta.

Pruébalo

¿Qué falta?

El becario se describe como un empleado más la palabra «becario». ¿Qué va en el hueco?

class Intern extends Employee {
    public Intern(String name, int salary) {
        super(name, salary);
    }

    @Override
    public String toString() {
        return .toString() + ", becario";
    }
}

Ejercicio

Cada uno a su manera

Resuelve las tareas en tu editor. Cada tarea tiene un array del tipo padre y un solo bucle.

1. Refugio de animales. Una clase Animal con un nombre y un método makeSound() que imprime «algún sonido». Dog y Cat lo sobrescriben. Pon uno de cada uno de los tres en un array Animal[]:

Invitado: algún sonido
Rex: ¡Guau!
Misi: ¡Miau, miau!

2. El estudiante se presenta. Student de la lección anterior ya tiene una nota. Sobrescribe introduce() para que también diga la nota. Usa super.introduce(); no copies la línea de Person.

Soy Jorge, tengo 45 años.
Soy Elena, tengo 19 años.
Nota media: 5.5

3. Fiesta. Una clase Performance con un título y un método start(). DanceMove, BreakDanceMove (hereda de DanceMove, añade complejidad) y Song lo sobrescriben. Una clase Party guarda un array Performance[] y tiene un método startParty() que lo empieza todo en orden y al final dice que la fiesta ha empezado.

Bailamos moonwalk
Bailamos windmill
  complejidad 8 de 10
Cantamos 'Bohemian Rhapsody'
Empieza rifa
¡La fiesta ha empezado!

Más tareas

Contratista. Añade a los empleados un Contractor, con horas y una tarifa por hora. Su pago mensual es horas × tarifa. Calcula las nóminas de Juan, María, Ana y Pablo (60 horas a 25 €):

Total de nóminas: 7800 €

Nómina. Dale a Employee un método payslip() que devuelve el texto «nombre: pago €» con el pago mensual. Escríbelo solo en Employee. ¿Por qué funciona bien también para el gerente y para el becario?

Test

Ponte a prueba

1. Employee e = new Manager("María", 3000, 500); ¿Qué monthlyPay se ejecuta con e.monthlyPay()?El de Employee, porque la variable es de tipo EmployeeEl de Manager, porque el objeto es un ManagerLos dos, uno tras otro

2. Employee e = new Manager("María", 3000, 500); ¿Puedes obtener el bono de e?Sí, el objeto es un Manager y tiene bonoSolo si el bono es publicNo, el compilador mira el tipo de la variable, y Employee no tiene bono

3. ¿Por qué escribes @Override delante de un método que sobrescribe?Para que el compilador compruebe que de verdad sobrescribes un método de la clase padreSin él el método no se sobrescribePara hacer el método public

4. ¿Qué hace super.toString() dentro del toString() de la clase hija?Crea un objeto de la clase padreVuelve a llamar al mismo método, para siempreLlama a la versión de la clase padre

5. ¿Cuál es la diferencia entre sobrescritura y sobrecarga?La sobrescritura es el mismo método con una versión nueva en la hija; la sobrecarga es el mismo nombre con parámetros distintosLa sobrescritura es para constructores y la sobrecarga para métodosNo hay diferencia, son dos nombres para lo mismo

Polimorfismo

Cookies