Le polymorphisme expliqué simplement !

Les quatre concepts de base de la POO (Programmation Orientée Objet) sont l’Héritage, l’Abstraction, le Polymorphisme et l’Encapsulation. Pour quelqu’un qui est nouveau dans la POO, il peut être un peu difficile au début de saisir les 3 derniers des concepts de base de la POO (puisque l’Héritage est un peu facile à comprendre).

Le polymorphisme est la capacité d’un objet à prendre plusieurs formes.

Tout objet Java qui peut passer plus d’un test IS-A est considéré comme polymorphe- tutoriel. Cela signifie que tout objet de classe enfant peut prendre n’importe quelle forme d’une classe dans sa hiérarchie parentale et bien sûr lui-même également. Ce que cela signifie en fait, c’est que l’objet de classe enfant peut être assigné à n’importe quelle référence de classe dans sa hiérarchie parentale et bien sûr lui-même aussi.

Eg : Disons que la classe Student est un enfant de la classe Person

Student student = new Student()
Person person = new Student()

L’utilisation la plus courante du polymorphisme dans la POO se produit lorsqu’une référence de classe parentale est utilisée pour faire référence à un objet de classe enfant. En fait ici on parle de polymorphisme dynamique (que je décrirai ensuite).

Il y a 2 types de polymorphisme qui sont couramment mentionnés.

1. Polymorphisme dynamique
2. Polymorphisme statique

Polymorphisme dynamique

Ceci est également mentionné comme polymorphisme d’exécution, liaison dynamique, liaison d’exécution, liaison tardive et surcharge de méthode. Ici, avoir de nombreuses formes se produit dans différentes classes.

C’est ce qui est communément connu sous le nom de « polymorphisme ». Laissez-moi l’expliquer TRÈS SIMPLEMENT –

Supposons qu’il y ait des méthodes avec la même signature de méthode dans les classes d’une hiérarchie de classes (relations parent-enfant), ces méthodes sont sous des formes différentes (c’est ce qu’on appelle le  » method overriding « ).

Alors, lorsqu’un objet est affecté à une référence de classe et qu’une méthode de l’objet est appelée, la méthode de la classe de l’objet est exécutée. Pas la méthode de la classe de référence (si la référence est une classe parente).

Ce qui se passe ici, c’est que puisque la création de l’objet se fait à l’exécution, la forme de la méthode qui doit être exécutée (la méthode dans l’objet) ne peut être décidée qu’à l’exécution.

Eg : Code Java

class Person { 
public void teach(){
System.out.println("Person can teach");
}
}
class Teacher extends Person {
public void teach() {
System.out.println("Teacher can teach in a school");
}
}
public class TestTeacher {
public static void main(String args) {
Person person = new Person(); //Person reference and object
Person another_person = new Teacher(); //Person reference, Teacher object
Teacher teacher = new Teacher(); //Teacher reference and obj. person.teach();//output: Person can teach // Here you can see Teacher object's method is executed even-
// -though the Person reference was used 
another_person.teach();//output: Teacher can teach in a school teacher.teach();//output: Teacher can teach in a school
}
}

Polymorphisme statique

Ceci est également mentionné comme le polymorphisme en temps de compilation.Time polymorphism, Static binding, Compile-Time binding, Early binding et Method overloading. Ici, avoir plusieurs formes se produit dans la même classe.

Si j’explique cela SIMPLEMENT..

C’est en fait une surcharge de méthode. La surcharge de méthode consiste à avoir plus d’une méthode avec le même nom de méthode mais avec des arguments différents (le type de retour peut être ou non le même). Ici, lors de l’appel des méthodes compilateur choisir quelle méthode à appeler en fonction des paramètres passés lors de l’appel. Cela se passe au moment de la compilation.

Eg : code Java

class Calculator {
void add(int a, int b) {
System.out.println(a+b);
}
void add(int a, int b, int c) {
System.out.println(a+b+c);
}
}public class Demo {
public static void main(String args) {
Calculator calculator = new Calculator(); // method with 2 parameters is called
calculator.add(10, 20); //output: 30 // method with 3 parameters is called
calculator.add(10, 20, 30); //output: 60
}
}

Certains disent que la surcharge de méthode n’est pas vraiment du polymorphisme. Mais je pense qu’il peut être catégorisé comme un type de polymorphisme puisque dans la surcharge de méthode il y a une méthode sous plusieurs formes.

J’espère que cela a aidé à comprendre le polymorphisme simplement.

Cheeers ! 😀

Voici quelques liens utiles liens

• Surcharge des méthodes
• Surcharge des méthodes
• Types de polymorphisme
• Différence entre le polymorphisme à l’exécution et le polymorphisme à la compilation

.