Maîtriser le polymorphisme Java : concepts, exemples et bonnes pratiques

Polymorphisme Java

Explorez le polymorphisme Java à travers des explications claires et des exemples de code pratiques, et comprenez comment il améliore la flexibilité et la réutilisabilité du code.

Le polymorphisme – un pilier essentiel de la programmation orientée objet – signifie qu'une seule entité peut prendre plusieurs formes.

C'est-à-dire que la même entité (méthode, opérateur ou objet) peut effectuer différentes opérations selon le contexte.

---

Exemple : Polymorphisme Java

class Polygon { // méthode pour rendre une forme public void render() { System.out.println("Rendering Polygon..."); } } class Square extends Polygon { // rend Square public void render() { System.out.println("Rendering Square..."); } } class Circle extends Polygon { // rend circle public void render() { System.out.println("Rendering Circle..."); } } class Main { public static void main(String[] args) { // créer un objet de Square Square s1 = new Square(); s1.render(); // créer un objet de Circle Circle c1 = new Circle(); c1.render(); } }

Sortie

Rendering Square... Rendering Circle...

Dans l'exemple ci-dessus, nous créons une superclasse : Polygon et deux sous-classes : Square et Circle. La méthode render() est héritée par les deux sous-classes, mais chacune la redéfinit pour fournir une logique de rendu spécifique à la forme.

L'idée clé est que render() se comporte différemment selon le type d'objet réel, ce qui est l'essence du polymorphisme.

---

Pourquoi le polymorphisme ?

Le polymorphisme permet aux développeurs d'écrire un code propre et cohérent. Au lieu de définir des méthodes séparées telles que renderSquare() ou renderCircle(), une seule méthode render() s'adapte à chaque forme, réduisant la redondance et améliorant la maintenabilité.

Bien que des méthodes séparées fonctionneraient, elles mènent rapidement à la duplication de code et une API fragmentée. Le polymorphisme unifie le comportement sous un contrat commun, assurant que toute nouvelle forme peut être intégrée en redéfinissant simplement render().

Note : La méthode print() démontre aussi le polymorphisme – elle peut afficher char, int, String, et plus sans nécessiter de surcharges multiples.

---

Nous pouvons atteindre le polymorphisme en Java en utilisant les techniques suivantes :

1. Redéfinition de méthode
2. Surcharge de méthode
3. Surcharge d'opérateur

---

Redéfinition de méthode Java

Quand une sous-classe définit une méthode avec la même signature qu'une méthode dans sa superclasse, la méthode de la sous-classe redéfinit la méthode de la superclasse. Cela permet au même nom de méthode d'effectuer différentes opérations basées sur le type d'exécution de l'objet.

Exemple 1 : Polymorphisme par redéfinition de méthode

class Language { public void displayInfo() { System.out.println("Common English Language"); } } class Java extends Language { @Override public void displayInfo() { System.out.println("Java Programming Language"); } } class Main { public static void main(String[] args) { // créer un objet de la classe Java Java j1 = new Java(); j1.displayInfo(); // créer un objet de la classe Language Language l1 = new Language(); l1.displayInfo(); } }

Sortie :

Java Programming Language Common English Language

Ici, Language sert de classe de base et Java comme sous-classe. La méthode displayInfo() est définie dans les deux classes, mais chaque implémentation livre une information appropriée au contexte.

La méthode qui s'exécute est déterminée à l'exécution, c'est pourquoi ce motif est appelé polymorphisme d'exécution.

Note : La méthode appelée est déterminée pendant l'exécution du programme. Donc, la redéfinition de méthode est un polymorphisme d'exécution.

---

2. Surcharge de méthode Java

La surcharge de méthode permet à une classe d'avoir plusieurs méthodes avec le même nom mais des listes de paramètres différentes. Le compilateur résout quelle méthode invoquer basé sur les arguments fournis.

void func() { ... } void func(int a) { ... } float func(double a) { ... } float func(int a, float b) { ... }

Cette technique permet à la même opération logique d'accepter des entrées variées.

Exemple 3 : Polymorphisme par surcharge de méthode

class Pattern { // méthode sans paramètre public void display() { for (int i = 0; i < 10; i++) { System.out.print("*"); } } // méthode avec un paramètre public void display(char symbol) { for (int i = 0; i < 10; i++) { System.out.print(symbol); } } } class Main { public static void main(String[] args) { Pattern d1 = new Pattern(); // appeler la méthode sans argument d1.display(); System.out.println("\n"); // appeler la méthode avec un argument unique d1.display('#'); } }

Sortie :

********** ##########

Dans cet exemple, la classe Pattern contient deux méthodes display() surchargées. La version sans paramètres affiche dix astérisques, tandis que celle acceptant un char affiche dix copies du symbole fourni.

Comme le compilateur sélectionne la méthode au moment de la compilation, cette forme de polymorphisme est souvent appelée polymorphisme de compilation.

Note : La méthode appelée est déterminée par le compilateur. Donc, on l'appelle aussi polymorphisme de compilation.

---

3. Surcharge d'opérateur Java

Les opérateurs de Java peuvent exhiber différents comportements basés sur les types d'opérandes. Par exemple, l'opérateur + effectue l'addition numérique avec des nombres et la concaténation de chaînes avec des chaînes.

• + peut additionner des nombres ou concaténer des chaînes.
• Les opérateurs logiques et bitwise tels que &, |, et ! se comportent aussi différemment selon les types d'opérandes.

Voici des extraits illustratifs montrant comment + s'adapte à ses opérandes.

1. Avec des nombres :

int a = 5; int b = 6; // + avec nombres int sum = a + b; // Sortie = 11

2. Avec des chaînes :

String first = "Java "; String second = "Programming"; // + avec chaînes String name = first + second; // Sortie = Java Programming

Ainsi, + est surchargé en Java pour effectuer à la fois l'addition et la concaténation.

Note : Bien que des langages comme C++ permettent la surcharge d'opérateur définie par l'utilisateur, Java la restreint aux opérateurs intégrés seulement.

---

Variables polymorphiques

Une variable est considérée polymorphique quand elle peut référencer des objets de différents types pendant l'exécution du programme. En Java, les références d'objets permettent ce comportement, permettant une référence de type de base de pointer vers des instances de sous-classes.

Exemple : Variables polymorphiques

class ProgrammingLanguage { public void display() { System.out.println("I am Programming Language."); } } class Java extends ProgrammingLanguage { @Override public void display() { System.out.println("I am Object-Oriented Programming Language."); } } class Main { public static void main(String[] args) { // déclarer une variable objet ProgrammingLanguage pl; // créer objet de ProgrammingLanguage pl = new ProgrammingLanguage(); pl.display(); // créer objet de la classe Java pl = new Java(); pl.display(); } }

Sortie :

I am Programming Language. I am Object-Oriented Programming Language.

Dans cette illustration, la référence pl est déclarée avec le type de base ProgrammingLanguage mais est assignée des objets de la classe de base et de sa sous-classe. Cela démontre l'upcasting et le polymorphisme d'exécution.