Polymorphisme en Java : Guide Complet avec Exemples Pratiques

Qu'est-ce que le Polymorphisme en Java ?

Le polymorphisme est un concept central de la programmation orientée objet (POO) en Java. Il survient lorsque des classes sont liées par l'héritage, permettant à une seule interface de représenter différentes formes sous-jacentes. Le résultat est qu'un appel de méthode peut invoquer différentes implémentations selon le type réel de l'objet à l'exécution.

Pensez à un smartphone qui peut communiquer par appel vocal, texte, image ou email. L'objectif – communiquer – est le même, mais chaque mode se comporte différemment. C'est le polymorphisme dans la vie quotidienne.

Ce que Vous Allez Apprendre

• Définition du polymorphisme Java
• Exemples POO pratiques
• Surcharge de méthode (overriding)
• Surcharge vs redéfinition (overloading vs overriding)
• Polymorphisme dynamique (à l'exécution)
• Polymorphisme statique vs dynamique
• Le mot-clé super

Polymorphisme Java en POO : Un Exemple

Considérez une classe de base Compte qui offre depot() et retrait(). Deux sous-classes, CompteEpargne et CompteCourant, héritent de ces méthodes inchangées car les opérations sont identiques.

S'Adapter aux Exigences Changeantes

Lorsqu'une nouvelle fonctionnalité – comme une facilité de découvert – est requise, une sous-classe ComptePrivilégié peut redéfinir retrait() pour fournir la nouvelle logique sans toucher aux sous-classes existantes. Cela démontre l'avantage de maintenabilité du polymorphisme.

Redéfinition de Méthode en Java

La redéfinition (overriding) se produit lorsqu'une sous-classe fournit sa propre implémentation d'une méthode déjà définie dans sa super-classe. La signature de la méthode (nom, paramètres, type de retour) doit correspondre exactement.

Règles Clés

• La méthode redéfinie peut avoir une visibilité plus large (ex. : protected vers public) mais jamais plus restrictive.
• Les types de retour doivent être les mêmes ou covariants.

Exemple :

class Medecin {
    public void soignerPatient() {
        // logique de traitement commune
    }
}
class Chirurgien extends Medecin {
    @Override
    public void soignerPatient() {
        // traitement chirurgical spécialisé
    }
}
public class Execution {
    public static void main(String[] args) {
        Medecin medecin = new Medecin();
        medecin.soignerPatient(); // exécute Medecin.soignerPatient()
        Chirurgien chirurgien = new Chirurgien();
        chirurgien.soignerPatient(); // exécute Chirurgien.soignerPatient()
    }
}

Surcharge vs Redéfinition

void somme(int a, int b);
void somme(int a, int b, int c);
void somme(float a, double b);

class X { int somme() { ... } }
class Y extends X {
    @Override int somme() { ... }
}

Polymorphisme Dynamique (Exécution)

Lorsqu'une référence de super-classe pointe vers un objet de sous-classe, la JVM résout l'appel de méthode à l'exécution. C'est le vrai polymorphisme en action.

Medecin doc = new Chirurgien();
doc.soignerPatient(); // Exécute Chirurgien.soignerPatient()

La méthode réellement invoquée dépend du type de l'objet à l'exécution, pas du type de la référence.

Polymorphisme Statique vs Dynamique

Le polymorphisme statique (surcharge) est résolu à la compilation, tandis que le polymorphisme dynamique (redéfinition) est résolu à l'exécution.

void somme(int a, int b);
void somme(float a, double b);

Medecin m = new Chirurgien();
m.soignerPatient();

Utilisation du Mot-Clé super

Lorsqu'une sous-classe doit étendre une méthode de la super-classe, super appelle l'implémentation parente avant d'ajouter sa propre logique.

class Chirurgien extends Medecin {
    @Override
    public void soignerPatient() {
        super.soignerPatient(); // logique de base
        // logique spécifique au chirurgien
    }
}

De même, super peut accéder aux champs protected ou public de la super-classe.

Exemple Pratique : Héritage, Polymorphisme & Super

Copiez le code ci-dessous dans votre IDE et observez la sortie.

public class Test {
    public static void main(String[] args) {
        X x = new X();
        Y y = new Y();
        y.m2();
        // Décommentez pour voir les effets de l'héritage
        // x.m1();
        // y.m1();
        // x = y; // référence parente vers objet enfant
        // x.m1();
        // y.a = 10; // erreur : a est private
    }
}
class X {
    private int a;
    int b;
    public void m1() {
        System.out.println("C'est la méthode m1 de la classe X");
    }
}
class Y extends X {
    int c;
    @Override
    public void m1() {
        System.out.println("C'est la méthode m1 de la classe Y");
    }
    public void m2() {
        super.m1();
        System.out.println("C'est la méthode m2 de la classe Y");
    }
}

Points Clés à Retenir

• Le polymorphisme permet aux objets de prendre plusieurs formes via l'héritage.
• La redéfinition de méthode change le comportement dans les sous-classes tout en conservant la même signature.
• Le polymorphisme dynamique résout les appels de méthode à l'exécution, permettant un code flexible.
• Le polymorphisme statique (surcharge) est à la compilation, le polymorphisme dynamique à l'exécution.
• Le mot-clé super permet aux sous-classes d'invoquer les méthodes parentes ou d'accéder aux membres protégés.