Maîtriser l'héritage en programmation orientée objet : organisez votre code efficacement

En programmation orientée objet (POO), la réutilisation de code est essentielle. Les classes permettent de créer des objets sans répéter indéfiniment les mêmes variables et méthodes.

Les classes elles-mêmes présentent souvent des similarités. Par exemple, un arbre possède des branches, des racines et un tronc, que ce soit un orme, un chêne ou un pin ponderosa. Dans un jeu vidéo, plutôt que de coder chaque arbre individuellement, créez une classe Arbre de base dont hériteront les autres.

Pourquoi l'héritage est-il essentiel ?

Le principe DRY ("Don't Repeat Yourself", ou "Ne vous répétez pas") est fondamental en POO. Copier-coller du code multiplie les risques d'erreurs et de bugs.

Imaginons un jeu style Tamagotchi. Vous commencez par un ours polaire avec la classe PolarBear en TypeScript :

class PolarBear {
  private _weight: number = 990;

  constructor(weight: number = 0) {
    this._weight = weight;
  }

  makeNoise() {
    console.log("fait un rugissement");
  }

  eat() {
    console.log("mange ce qu'il veut");
  }

  sleep() {
    console.log("j'ai bien dormi");
  }

  wander() {
    console.log("errait sans but");
  }
}

Votre patron exige ensuite tous les ours, puis des infos sur leurs origines, et enfin des rongeurs ou une girafe. Modifier des centaines de lignes introduit des bogues. L'héritage offre une solution élégante.

L'héritage à la rescousse

Structurez vos classes en hiérarchie parent-enfant. Ours noirs, grizzlis et paresseux sont des ours, eux-mêmes des animaux.

Exemple de code :

class Animal {
  private _weight: number;
  private _origin: string;

  constructor(weight: number = 0, origin: string = "") {
    this._weight = weight;
    this._origin = origin;
  }

  makeNoise(noise: string = "") {
    console.log("a fait un bruit qui ressemblait à : " + noise);
  }

  eat(food: string = "") {
    console.log("mange " + food);
  }

  sleep() {
    console.log("j'ai bien dormi");
  }

  wander() {
    console.log("errait sans but");
  }
}

class Bear extends Animal {
  constructor(weight: number, origin: string) {
    super(weight, origin);
  }

  makeNoise(noise: string = "rugir") {
    super.makeNoise(noise);
  }

  eat(food: string = "tout ce qu'il veut") {
    super.eat(food);
  }
}

class GrizzlyBear extends Bear {
  constructor(weight: number = 600, origin: string = "Amérique du Nord") {
    super(weight, origin);
  }
}

class Panda extends Bear {
  constructor(weight: number = 230, origin: string = "Chine") {
    super(weight, origin);
  }

  makeNoise() {
    super.makeNoise("squeek");
  }

  eat() {
    super.eat("pousses et feuilles");
  }
}

Testez ce code dans un bac à sable TypeScript. Toutes les classes descendent de Animal. Bear étend Animal, et GrizzlyBear ou Panda étendent Bear. Les classes enfants héritent des méthodes par défaut ou les surchargent.

Identifier les relations : technique "is-a" vs "has-a"

Demandez-vous : une relation "est-un" (is-a) ou "a-un" (has-a) ?

• Un lémurien est-un singe.
• Un kangourou est-un marsupial.
• Une patte n'est pas un lapin : un lapin a-une patte.

Cette approche simplifie la modélisation du monde réel.

Pratiquez l'héritage en direct

Appliquez vos connaissances :

• Dans le bac à sable, complétez les classes Monkey et ProboscisMonkey (qui étend Monkey).

L'héritage dépasse l'organisation : il facilite le polymorphisme et la communication objet. Consultez la documentation TypeScript pour approfondir.