Polymorphisme

10.1 Fondamentaux du polymorphisme

Le polymorphisme est l'un des concepts clés de la programmation orientée objet (POO). Globalement, le polymorphisme permet à des objets de classes différentes de manipuler des données en utilisant la même interface. Dans le contexte de JavaScript, cela signifie que différents objets peuvent avoir des méthodes avec les mêmes noms, et ces méthodes peuvent être appelées sur les objets sans connaître leur type précis.

Types de polymorphisme

En JavaScript, les principaux types de polymorphisme sont :

1. Polymorphisme ad-hoc :

• Polymorphisme des méthodes, appel de méthodes portant le même nom pour des objets de types différents
• Les exemples incluent la surcharge de fonctions et d'opérateurs (ce qui n'est pas directement pris en charge dans JavaScript, mais peut être simulé)

2. Polymorphisme de sous-type :

• Polymorphisme de sous-type ou d'inclusion, lorsque des objets de différentes classes héritant de la même classe de base peuvent être traités comme des objets de la classe de base
• C'est le principal type de polymorphisme, mis en œuvre par l'héritage et les interfaces

Avantages du polymorphisme :

1. Simplification du code : le polymorphisme permet d'écrire un code plus flexible et généralisé, capable de fonctionner avec différents types d'objets sans connaître leurs types spécifiques.
2. Extensibilité : le polymorphisme facilite l'ajout de nouveaux types et comportements au système sans nécessiter de modifications du code existant.
3. Soutien : le polymorphisme favorise une meilleure séparation des responsabilités et améliore la lisibilité et la maintenance du code.

10.2 Exemples de polymorphisme en JavaScript

Polymorphisme de sous-type via l'héritage

Exemple 1 : Manipuler différents types d'objets avec une seule interface

Dans cet exemple, la fonction playWithAnimal accepte un objet de type Animal et appelle la méthode makeSound. Les objets Dog et Cat, qui héritent de Animal, redéfinissent la méthode makeSound, et l'appel de la méthode sur chaque objet produit un résultat différent.

    
      class Animal {
        makeSound() {
          console.log('Some generic sound');
        }
      }

      class Dog extends Animal {
        makeSound() {
          console.log('Woof!');
        }
      }

      class Cat extends Animal {
        makeSound() {
          console.log('Meow!');
        }
      }

      function playWithAnimal(animal) {
        animal.makeSound();
      }

      const dog = new Dog();
      const cat = new Cat();

      playWithAnimal(dog); // Affichera : Woof!
      playWithAnimal(cat); // Affichera : Meow!
    
  

10.3 Polymorphisme via les interfaces (Duck Typing)

JavaScript n'a pas de prise en charge intégrée des interfaces, comme dans d'autres langages tels que TypeScript ou Java. À la place, il utilise une approche appelée "Duck Typing". Cela signifie qu'un objet est considéré comme conforme à une interface s'il possède les méthodes et propriétés nécessaires, indépendamment de son type ou de son héritage spécifique.

Exemple 2 : Utilisation de Duck Typing

Dans cet exemple, la fonction takeOff accepte tout objet qui possède une méthode fly. Les objets Bird et Airplane implémentent la méthode fly, et peuvent donc être passés à takeOff.

    
      class Bird {
        fly() {
          console.log('Flying...');
        }
      }

      class Airplane {
        fly() {
          console.log('Jet engine roaring...');
        }
      }

      function takeOff(flyingObject) {
        flyingObject.fly();
      }

      const bird = new Bird();
      const airplane = new Airplane();

      takeOff(bird);      // Affichera : Flying...
      takeOff(airplane);  // Affichera : Jet engine roaring...
    
  

10.4 Polymorphisme par les fonctions

En JavaScript, les fonctions sont des objets de première classe, et elles peuvent être passées et utilisées pour mettre en œuvre un comportement polymorphique.

Exemple 3 : Polymorphisme par les fonctions

Dans cet exemple, la fonction greet prend une autre fonction en tant qu'argument et l'appelle. Cela permet d'utiliser différentes fonctions pour effectuer différentes actions.

    
      function greetMorning() {
        console.log('Good morning!');
      }

      function greetEvening() {
        console.log('Good evening!');
      }

      function greet(greetingFunction) {
        greetingFunction();
      }

      greet(greetMorning); // Affichera : Good morning!
      greet(greetEvening); // Affichera : Good evening!
    
  

10.5 Polymorphisme par la surcharge de méthode (Simulation)

JavaScript ne prend pas en charge la surcharge de méthodes directement, comme certains autres langages de programmation. Cependant, on peut simuler la surcharge de méthodes en utilisant des arguments de fonction et en vérifiant leurs types.

Exemple 4 : Simulation de la surcharge de méthode

Dans cet exemple, la méthode add prend deux arguments et effectue différentes actions en fonction de leurs types. Si les arguments sont des nombres, la méthode les additionne. Si les arguments sont des tableaux, la méthode les fusionne.

    
      class Calculator {
        add(a, b) {
          if (typeof a === 'number' && typeof b === 'number') {
            return a + b;
          } else if (Array.isArray(a) && Array.isArray(b)) {
            return a.concat(b);
          } else {
            throw new Error('Invalid arguments');
          }
        }
      }

      const calc = new Calculator();
      console.log(calc.add(1, 2));           // Affichera : 3
      console.log(calc.add([1, 2], [3, 4])); // Affichera : [1, 2, 3, 4]