Comprendre le polymorphisme en Java : Concepts et Utilisation pratique

Le polymorphisme est la capacité d'un objet à prendre plusieurs formes. En POO, l'usage le plus courant est quand une référence de classe parente pointe vers un objet de classe fille.

Tout objet Java passant plus d'un test IS-A est polymorphe. En Java, tous les objets sont polymorphes car tout objet passe le test IS-A pour son propre type et pour Object.

Points clés :

• On accède à un objet uniquement via une variable de référence
• Une variable de référence a un seul type, immuable après déclaration
• Elle peut être réaffectée à d'autres objets (si non final)
• Son type détermine les méthodes invocables
• Elle peut référencer tout objet de son type ou de sous-types
• Peut être déclarée comme type classe ou interface

Exemple : Polymorphisme avec interfaces

public interface Vegetarien {}
public class Animal {}
public class Cerf extends Animal implements Vegetarien {}

Cerf est polymorphe (héritage multiple via interface) :

• Cerf EST-UN Animal
• Cerf EST-UN Vegetarien
• Cerf EST-UN Cerf
• Cerf EST-UN Object

Déclarations légales :

Cerf d = new Cerf();
Animal a = d;
Vegetarien v = d;
Object o = d;

Toutes les références d, a, v, o pointent vers le même objet dans le tas (heap).

Méthodes virtuelles

Le comportement des méthodes redéfinies permet le polymorphisme lors de la conception.

Une méthode redéfinie est masquée dans la classe parente et n'est invoquée que si la classe fille utilise super.

Exemple : Employee et Salary

/* Employee.java */
public class Employee {
    private String name;
    private String address;
    private int number;
    
    public Employee(String name, String address, int number) {
        System.out.println("Construction Employee");
        this.name = name;
        this.address = address;
        this.number = number;
    }
    
    public void mailCheck() {
        System.out.println("Envoi chèque à " + name + " " + address);
    }
    // getters/setters...
}

/* Salary.java */
public class Salary extends Employee {
    private double salary;
    
    public Salary(String name, String address, int number, double salary) {
        super(name, address, number);
        setSalary(salary);
    }
    
    @Override
    public void mailCheck() {
        System.out.println("Dans mailCheck de Salary");
        System.out.println("Envoi chèque à " + getName() + " avec salaire " + salary);
    }
    
    public double computePay() {
        System.out.println("Calcul paie pour " + getName());
        return salary / 52;
    }
    // getters/setters...
}

Démonstration du polymorphisme

/* VirtualDemo.java */
public class VirtualDemo {
    public static void main(String[] args) {
        Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
        Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
        
        System.out.println("Appel mailCheck via référence Salary --");
        s.mailCheck();
        
        System.out.println("\nAppel mailCheck via référence Employee --");
        e.mailCheck();
    }
}

Résultat :

Construction Employee
Construction Employee
Appel mailCheck via référence Salary --
Dans mailCheck de Salary
Envoi chèque à Mohd Mohtashim avec salaire 3600.0

Appel mailCheck via référence Employee --
Dans mailCheck de Salary
Envoi chèque à John Adams avec salaire 2400.0

Analyse

• s.mailCheck() : compilateur voit Salary.mailCheck(), JVM appelle Salary.mailCheck()
• e.mailCheck() : compilateur voit Employee.mailCheck() (validation), mais JVM appelle Salary.mailCheck() à l'exécution

Ce comportement est l'invocation de méthode virtuelle. Une méthode redéfinie est invoquée à l'exécution selon le type réel de l'objet, pas le type de la référence utilisée à la compilation.

C'est la liaison dynamique (late binding) qui rend le polymorphisme possible en Java.