Le polymorphisme en programmation : définition simple et avantages incontournables

Si vous savez conduire une berline 4 portes, vous pouvez aussi piloter une camionnette. Si vous avez conduit une voiture à moteur thermique, vous pouvez conduire une électrique.

La forme et la taille des véhicules varient, tout comme leur moteur. Mais cela n'importe pas pour le conducteur : montez, attachez votre ceinture, démarrez, passez une vitesse et roulez. C'est parce que voitures, camionnettes et utilitaires sont polymorphes.

Polymorphisme : décomposons le terme

Le mot "polymorphisme" se décompose en poly (beaucoup), morphe (variante d'une espèce) et isme (système). Il désigne un système de multiples variations, appliqué ici à la programmation orientée objet (POO).

Si ça marche comme un canard... Pourquoi les objets polymorphes sont puissants

Quand une classe hérite d'une autre, elle signe un contrat : elle hérite de toutes ses variables et méthodes.

Chaque véhicule a un volant, des pédales et des clignotants. Pas besoin d'ouvrir le capot pour conduire. Il suffit que ce soit un véhicule.

En POO, c'est pareil. Voici un exemple en TypeScript :

class Véhicule {
  private _moteur: string;
  private _pneus: number;

  constructor(moteur: string = "combustion", pneus: number = 4) {
    this._moteur = moteur;
    this._pneus = pneus;
  }

  accélérer(vitesse: number) {
    console.log("Accélération à " + vitesse + " km/h");
  }

  freiner(pression: number) {
    console.log("Freinage avec " + pression + " de pression");
  }

  tournerÀGauche() {
    console.log("Virage à gauche");
  }

  tournerÀDroite() {
    console.log("Virage à droite");
  }
}

class Voiture extends Véhicule {}

class Tesla extends Voiture {
  constructor() {
    super("électrique");
  }
}

Nous avons une classe Véhicule, dont hérite Voiture, elle-même parent de Tesla. Instancions des objets :

let maCoupe: Voiture = new Véhicule();
let maBerline: Véhicule = new Tesla();

console.log(maCoupe.constructor.name); // "Véhicule"
console.log(maBerline.constructor.name); // "Tesla"

maCoupe.tournerÀGauche();
maBerline.tournerÀGauche();

Dans le bac à sable TypeScript, ce code s'exécute sans erreur. maCoupe est typée Voiture mais instanciée Véhicule ; maBerline est typée Véhicule mais une Tesla. Le compilateur respecte le contrat d'héritage.

C'est le "duck typing" : si ça marche comme un canard et cancane comme un canard, c'est un canard. Le typage se base sur les méthodes disponibles.

Le polymorphisme rend votre code robuste

Le polymorphisme garantit la compatibilité : ajoutez ou modifiez des classes sans casser le programme. Chaque objet typé Véhicule respecte le contrat, indépendamment de son implémentation réelle.

Les bugs internes sont possibles, mais pas de ruptures de type. Découvrez 10 principes de programmation essentiels.

Pratiquez le polymorphisme

• Créez une classe Bateau héritant de Véhicule.
• Instanciez un objet typé Véhicule mais de type Bateau.
• Vérifiez qu'il se comporte comme un véhicule.

Exemple concret : changer de base de données

Le polymorphisme passe de la théorie à la pratique. Imaginez une app web connectée à MySQL. Le patron passe à PostgreSQL : faut-il tout réécrire ?

Non ! Utilisez une classe abstraite AccèsDonnées avec sous-classes MySQLAccès et PostgreSQLAccès. Votre app manipule des objets AccèsDonnées : échangez les implémentations sans toucher au code métier.