Guide pour débutants : Maîtriser l'abstraction en programmation orientée objet (POO)

Imaginez que vous dégustez un burrito : vos papilles gustatives s'illuminent à chaque bouchée. Chaque ingrédient – salé, sucré, épicé ou umami – se mélange pour créer une explosion de saveurs unique.

Vous connaissez peut-être les ingrédients listés au menu, mais les secrets de la salsa ou de l'assaisonnement des légumes vous échappent. Pourtant, cela n'a pas d'importance : vous savez juste que c'est délicieux.

Les éléments concrets comme le riz nature sont évidents ; les autres, comme la salsa, restent abstraits. Vous en reconnaissez l'essence sans en connaître tous les détails.

L'abstraction dans l'abstrait

L'abstraction est un pilier de la programmation orientée objet (POO), aux côtés de l'héritage. Elle vise à simplifier les interactions : chaque objet délivre des résultats prévisibles et partage uniquement l'essentiel.

L'abstraction cache code et données quand nécessaire

Considérez un burrito comme un objet contenant d'autres objets : haricots, riz, fromage et salsa. Ces composants ont leurs propres secrets – assaisonnements spéciaux ou mélanges uniques. Vous n'avez pas besoin de tout savoir pour en profiter, tant qu'il reste savoureux et cohérent.

L'abstraction va de pair avec l'encapsulation

En POO, instancier un objet ressemble à commander un burrito : vous accédez à certaines données publiques, sans plonger dans les entrailles internes. L'objet fonctionne si ses méthodes renvoient les bonnes valeurs. Voici un exemple en TypeScript :

class CheeseBlend {
  private _ingredients = ["Colby Jack", "Cheddar", "Manchego"];
  get ingredients() {
    return "fromage fondu";
  }
}

class SecretSalsa {
  private _ingredients = ["oignons", "tomates", "coriandre", "Guatemalan Insanity Peppers"];
  get ingredients() {
    return "c'est un secret";
  }
}

class Burrito {
  private _beans = "haricots";
  private _rice = "riz";
  private _cheese: CheeseBlend = new CheeseBlend();
  private _salsa: SecretSalsa = new SecretSalsa();

  get cheese() {
    return this._cheese.ingredients;
  }

  get salsa() {
    return this._salsa.ingredients;
  }
}

const burro = new Burrito();
console.log(burro.cheese);  // "fromage fondu"
console.log(burro.salsa);   // "c'est un secret"

Testez ce code dans un bac à sable TypeScript. Les ingrédients sont encapsulés (privés) et exposés via des getters qui fournissent une vue abstraite.

L'abstraction dans le concret

L'abstraction dépasse la théorie : les classes abstraites définissent un contrat pour d'autres classes, sans pouvoir être instanciées elles-mêmes.

Pourquoi utiliser des classes abstraites ?

Imaginez un menu avec un seul plat : "Nourriture". Trop vague pour commander ! Il faut préciser : pâtes, puis fettuccine Alfredo pour du concret.

Abstrait vs concret

En POO, une classe abstraite comme Aliment impose une structure. Ses enfants concrets, comme MacadamiaNuts, l'implémentent :

abstract class Nourriture {
  public nom: string;
  constructor(nom: string) {
    this.nom = nom;
  }
  abstract totalCalories(): number;
  abstract description(): string;
  abstract saveur(): string;
}

class MacadamiaNuts extends Nourriture {
  constructor() {
    super("Une tasse de noix de macadamia");
  }
  totalCalories(): number {
    return 962;
  }
  description(): string {
    return "Une noix d'Hawaï.";
  }
  saveur(): string {
    return "riche, beurré et noisette";
  }
}

const noix = new MacadamiaNuts();
console.log(noix.nom);
console.log(noix.description());

Voici le code fonctionnel. La classe abstraite Nourriture dicte le comportement : nom, calories, description, saveur. MacadamiaNuts étend et implémente via super.

Si vous débutez, explorez ces concepts interactivement.

Pratique de l'abstraction

• Créez une classe abstraite Soupe dans un bac à sable.
• Ajoutez un enfant concret : Cereale.
• Testez avec console.log. Que se passe-t-il si une méthode manque ?

À quoi servent les classes abstraites ?

Elles paraissent inutiles au début : non instanciables et méthodes à réimplémenter. Pourtant, elles garantissent cohérence et standardisation en équipe. Consultez la documentation TypeScript pour approfondir.