JavaScript - Polymorphisme

Bonjour là-bas, futurs magiciens JavaScript ! Aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde du polymorphisme en JavaScript. Ne vous inquiétez pas si ce mot semble effrayant - d'ici la fin de cette leçon, vous utiliserez le polymorphisme comme un pro !

Polymorphisme en JavaScript

Commençons par les bases. Le polymorphisme est un terme pompeux qui vient du grec, signifiant "beaucoup de formes". En programmation, il fait référence à la capacité des objets à adopter plusieurs formes ou comportements. Pensez-y comme un caméléon changeant de couleur pour s'adapter à différents environnements.

En JavaScript, le polymorphisme nous permet d'utiliser une interface unique pour représenter différents types d'objets. C'est comme avoir une télécommande universelle qui peut opérer divers appareils - votre télévision, votre lecteur DVD et votre système audio - tous avec les mêmes boutons.

Voici un exemple simple pour illustrer ce concept :

function makeSound(animal) {
console.log(animal.sound());
}

let dog = {
sound: function() {
return "Woof!";
}
};

let cat = {
sound: function() {
return "Meow!";
}
};

makeSound(dog); // Sortie : Woof!
makeSound(cat); // Sortie : Meow!

Dans cet exemple, nous avons une fonction makeSound qui peut fonctionner avec différents objets animaux. dog et cat ont une méthode sound, mais elles produisent des sorties différentes. C'est l'action du polymorphisme !

Surcharge de méthode

Un des aspects clés du polymorphisme est la surcharge de méthode. Cela se produit lorsque une sous-classe fournit une implémentation spécifique pour une méthode qui est déjà définie dans sa classe parente.

Regardons un exemple :

class Animal {
makeSound() {
return "The animal makes a sound";
}
}

class Dog extends Animal {
makeSound() {
return "The dog barks";
}
}

class Cat extends Animal {
makeSound() {
return "The cat meows";
}
}

let animal = new Animal();
let dog = new Dog();
let cat = new Cat();

console.log(animal.makeSound()); // Sortie : The animal makes a sound
console.log(dog.makeSound());    // Sortie : The dog barks
console.log(cat.makeSound());    // Sortie : The cat meows

Ici, nous avons une classe Animal avec une méthode makeSound. Les classes Dog et Cat étendent Animal et redéfinissent la méthode makeSound avec leurs propres implémentations. Cela permet à chaque animal d'avoir son propre son unique tout en faisant partie de la famille Animal.

Exemples

Plongons plus profondément avec plus d'exemples pour vraiment ancrer notre compréhension du polymorphisme en JavaScript.

Exemple 1 : Calculateur de forme

Imaginez que nous construisons un calculateur de forme. Nous voulons calculer l'aire de différentes formes en utilisant le même nom de méthode.

class Shape {
calculateArea() {
return 0;
}
}

class Circle extends Shape {
constructor(radius) {
super();
this.radius = radius;
}

calculateArea() {
return Math.PI * this.radius * this.radius;
}
}

class Rectangle extends Shape {
constructor(width, height) {
super();
this.width = width;
this.height = height;
}

calculateArea() {
return this.width * this.height;
}
}

function printArea(shape) {
console.log("The area is: " + shape.calculateArea());
}

let circle = new Circle(5);
let rectangle = new Rectangle(4, 6);

printArea(circle);    // Sortie : The area is: 78.53981633974483
printArea(rectangle); // Sortie : The area is: 24

Dans cet exemple, nous avons une classe de base Shape et deux classes dérivées, Circle et Rectangle. Chaque classe implémente sa propre méthode calculateArea. La fonction printArea peut fonctionner avec n'importe quel objet forme, illustrant le polymorphisme.

Exemple 2 : Système de paie des employés

Créons un système simple de paie des employés pour illustrer davantage le polymorphisme :

class Employee {
constructor(name, salary) {
this.name = name;
this.salary = salary;
}

calculateBonus() {
return this.salary * 0.1;
}
}

class Manager extends Employee {
calculateBonus() {
return this.salary * 0.2;
}
}

class Developer extends Employee {
calculateBonus() {
return this.salary * 0.15;
}
}

function printBonus(employee) {
console.log(`${employee.name}'s bonus is: $${employee.calculateBonus()}`);
}

let john = new Employee("John", 50000);
let jane = new Manager("Jane", 70000);
let bob = new Developer("Bob", 60000);

printBonus(john); // Sortie : John's bonus is: $5000
printBonus(jane); // Sortie : Jane's bonus is: $14000
printBonus(bob);  // Sortie : Bob's bonus is: $9000

Dans cet exemple, nous avons différents types d'employés avec différentes règles de calcul des primes. La fonction printBonus peut fonctionner avec n'importe quel objet employé, mettant en vedette le polymorphisme.

Avantages de l'utilisation du polymorphisme en JavaScript

Maintenant que nous avons vu le polymorphisme en action, parlons pourquoi c'est si génial :

1. Réutilisabilité du code : Le polymorphisme nous permet d'écrire un code plus générique et réutilisable. Nos fonctions printArea et printBonus peuvent travailler avec n'importe quelle forme ou objet employé, respectivement.

2. Flexibilité : Il est plus facile d'ajouter de nouveaux types d'objets sans modifier le code existant. Nous pourrions ajouter une classe Triangle à notre calculateur de forme sans modifier la fonction printArea.

3. Maintenabilité : Le polymorphisme peut conduire à un code plus propre, plus organisé et plus facile à maintenir et à étendre.

4. Abstraction : Il nous permet de travailler avec des objets à un niveau de抽象 plus élevé, en nous concentrant sur ce que les objets font plutôt que sur la façon dont ils le font.

Voici un tableau résumant les méthodes clés que nous avons utilisées dans nos exemples :

Méthode	Description
calculateArea()	Calcule l'aire d'une forme
calculateBonus()	Calcule la prime pour un employé
makeSound()	Retourne le son qu'un animal fait
sound()	Retourne le son qu'un animal fait (dans l'exemple d'objet littéral)

Souvenez-vous, jeunes padawans, le polymorphisme est comme avoir un couteau suisse dans votre boîte à outils de codage. Il est polyvalent, puissant et peut rendre votre code plus élégant et efficace. Continuez à pratiquer, et bientôt vous serez maîtres du polymorphisme en JavaScript !

Credits: Image by storyset