Les limites de l'héritage profond

Fait partie de la section Programmation Orientée Objet du Journey JavaScript de Coddy — leçon 48 sur 56.

Bien que l'héritage soit utile, la création de hiérarchies d'héritage très profondes (parent → enfant → petit-enfant → arrière-petit-enfant) peut mener à des problèmes. Plus la chaîne est profonde, plus il devient difficile de comprendre, de maintenir et de modifier le code.

Voyons ce qui se passe avec une chaîne d'héritage profonde :

// Base class
class Vehicle {
  constructor(type) {
    this.type = type;
    this.isRunning = false;
  }
  
  start() {
    this.isRunning = true;
    console.log(`${this.type} started`);
  }
}

// First level of inheritance
class Car extends Vehicle {
  constructor(make, model) {
    super("Car");
    this.make = make;
    this.model = model;
    this.wheels = 4;
  }
  
  honk() {
    console.log("Beep beep!");
  }
}

// Second level of inheritance
class SportsCar extends Car {
  constructor(make, model, topSpeed) {
    super(make, model);
    this.topSpeed = topSpeed;
  }
  
  race() {
    this.start();
    console.log(`Racing at ${this.topSpeed} mph!`);
  }
}

Dans cet exemple, SportsCar se trouve à deux niveaux de profondeur dans l'héritage. Cela peut entraîner plusieurs problèmes :

Des modifications apportées à Vehicle pourraient casser SportsCar de manière inattendue

À mesure que la chaîne d'héritage s'allonge, il devient plus difficile de retracer l'origine des méthodes et des propriétés

Vous êtes contraint à des relations de type « est un » qui pourraient ne pas être assez flexibles

Défi

Complétez le fichier Robot.js pour rendre le robot fonctionnel. Pour l'instant, le robot est construit mais ne peut rien faire.

Ce qu'il faut faire dans <strong>Robot.js</strong> :

Créez les composants speaker et mover à l'intérieur du constructeur Robot
Utilisez les composants dans les méthodes :
1. Dans greet() : Appelez this.speaker.speak("Hello!");
2. Dans walkForward() : Appelez this.mover.move("forward");

Pourquoi nous faisons cela : C'est de la composition - le robot est construit en combinant de plus petits composants. Le robot a-un speaker (pour parler) et a-un mover (pour se déplacer), plutôt que d'hériter de ces capacités.

Aide-mémoire

Les hiérarchies d'héritage profondes (parent → enfant → petit-enfant) peuvent entraîner des problèmes de maintenance et un manque de flexibilité. Plus la chaîne est profonde, plus il devient difficile de comprendre et de modifier le code.

Exemple d'une chaîne d'héritage profonde :

class Vehicle {
  constructor(type) {
    this.type = type;
    this.isRunning = false;
  }
  
  start() {
    this.isRunning = true;
    console.log(`${this.type} started`);
  }
}

class Car extends Vehicle {
  constructor(make, model) {
    super("Car");
    this.make = make;
    this.model = model;
  }
}

class SportsCar extends Car {
  constructor(make, model, topSpeed) {
    super(make, model);
    this.topSpeed = topSpeed;
  }
}

Problèmes liés à l'héritage profond :

Les modifications apportées aux classes de base peuvent casser les classes enfants de manière inattendue
Il est difficile de suivre l'origine des méthodes et des propriétés
Cela impose des relations rigides de type « est-un » (is-a) qui manquent de flexibilité

La composition comme alternative : Au lieu de l'héritage, utilisez la composition où les objets ont une relation de type « a-un » (have-a) avec des composants, combinant de plus petites parties pour construire des fonctionnalités.

Essayez vous-même

import { Robot } from './Robot.js';

const myRobot = new Robot('Robo');

myRobot.greet();     // Devrait afficher : Saying: "Hello!"
myRobot.walkForward(); // Devrait afficher : Moving forward