Réponse.

Historique de la question :

Le polymorphisme est l'un des principes clés de la programmation orientée objet (POO), qui est pris en charge par Java depuis sa création. Il permet à un objet de se comporter différemment en fonction de son type réel lors de l'exécution du programme, même si une référence de type de base est utilisée.

Problème :

Sans polymorphisme, le code devient rigide, et des constructions redondantes comme switch-case ou if-else apparaissent souvent pour travailler avec des objets de types différents. Cela complique la maintenance et l'extension du code. Le polymorphisme résout le problème de la nécessité d'écrire du code répétitif pour différents types.

Solution :

Le polymorphisme en Java est réalisé par l'héritage et les interfaces. Il permet :

à une référence de type parent de pointer vers un objet de type enfant ;
d'appeler des méthodes redéfinies sans connaître le type concret de l'objet lors de la compilation.

Exemple de code :

class Animal {
    void speak() { System.out.println("Animal parle"); }
}
class Dog extends Animal {
    @Override void speak() { System.out.println("Chien aboie"); }
}
class Cat extends Animal {
    @Override void speak() { System.out.println("Chat miaule"); }
}
public class PolyDemo {
    public static void main(String[] args) {
        Animal a1 = new Dog();
        Animal a2 = new Cat();
        a1.speak(); // Chien aboie
        a2.speak(); // Chat miaule
    }
}

Caractéristiques clés :

Permet d'étendre et de modifier des systèmes sans changer le code existant.
Assure un faible couplage entre les composants.
À travers le polymorphisme, des modèles de conception (par exemple, Strategy, Command) sont réalisés.

Questions pièges.

Quelle est la différence entre la surcharge (overloading) et la redéfinition (overriding) de méthodes dans le polymorphisme ?

La surcharge est la définition de plusieurs méthodes avec le même nom, mais avec des signatures différentes dans une même classe. La redéfinition est la définition d'une méthode dans une sous-classe avec la même signature que dans la classe parente.

class Example {
    void foo(int x) {}
    void foo(String y) {} // c'est une surcharge
}
class Base { void foo() {} }
class Child extends Base {
    @Override void foo() {} // c'est une redéfinition
}

Le polymorphisme peut-il exister sans héritage ?

Dans le sens classique en Java - non : le polymorphisme nécessite une hiérarchie d'héritage ou une interface implémentée.

Peut-on appeler des méthodes de la sous-classe à partir d'une référence à la classe parente ?

On ne peut appeler que les méthodes définies dans la classe parente ou redéfinies dans la sous-classe. Les méthodes qui n'existent que dans la sous-classe ne peuvent pas être appelées sans conversion de type.

Animal a = new Dog();
a.speak(); // c'est possible
// a.fetch(); // erreur de compilation, même si Dog a une méthode fetch()

Erreurs courantes et anti-modèles

Redéfinition de méthodes sans annotation @Override - le compilateur ne détectera pas l'erreur de non-conformité de signature.
Conversion de types sans vérification via instanceof, ce qui entraîne ClassCastException.
Utilisation de polymorphisme là où une composition serait plus simple.

Exemple de la vie réelle

Cas négatif

Dans un projet, des classes Dog, Cat, Cow ont été implémentées, mais le code utilisé travaillait directement avec les types, appelant des méthodes via des conversions explicites et instanceof :

Avantages:

Mise en œuvre rapide de nouveaux types d'animaux.

Inconvénients :

Croissance de if-else.
Violation des principes de POO.
Difficulté à évoluer.

Cas positif

Héritage de Animal avec un speak() virtuel. Toutes les interactions se font via le type de base Animal.

Avantages :

Flexibilité lors de l'ajout de nouveaux types.
Simplicité des tests.