Héritage

Point de départ

// ── 1. Le test « est-un » ─────────────────────────────────────────────────
const PAIRES = [
  { fille: "Livre",    mere: "Document",      indice: "un livre est un document" },
  { fille: "Voiture",  mere: "Moteur",        indice: "une voiture démarre, et a une puissance" },
  { fille: "Etudiant", mere: "Personne",      indice: "un étudiant a un nom et un âge" },
  { fille: "Compte",   mere: "Banque",        indice: "un compte appartient à une banque" },
  { fille: "Carre",    mere: "Rectangle",     indice: "en mathématiques, c'en est un" },
  { fille: "Pile",     mere: "ArrayList",     indice: "une pile stocke des éléments en liste" },
];

// ← à écrire : pour chaque paire, répondre estUn (true/false) et dire
//   pourquoi. Deux questions : la phrase « une F est une M » est-elle vraie
//   de NATURE ? et un code écrit pour M fonctionnerait-il sur une F ?
const VERDICTS = {};

// ── 2. La substituabilité, mesurée ────────────────────────────────────────
class Rectangle {
  constructor(l, h) { this._largeur = l; this._hauteur = h; }
  setLargeur(l) { this._largeur = l; }
  setHauteur(h) { this._hauteur = h; }
  aire() { return this._largeur * this._hauteur; }
}

class Carre extends Rectangle {
  constructor(cote) { super(cote, cote); }
  setLargeur(l) { this._largeur = l; this._hauteur = l; }   // maintient l'invariant
  setHauteur(h) { this._largeur = h; this._hauteur = h; }
}

// Un test écrit POUR Rectangle, par quelqu'un qui ignore que Carre existe.
function testEcritPourRectangle(forme) {
  forme.setLargeur(5);
  forme.setHauteur(4);
  return { aire: forme.aire(), attendu: 20 };
}

// ── 3. Voiture : héritage fautif, puis composition ────────────────────────
class Moteur {
  constructor(puissance) { this.puissance = puissance; this.tourne = false; }
  demarrer() { this.tourne = true; return "moteur " + this.puissance + " ch démarré"; }
  arreter() { this.tourne = false; }
}

class VoitureHeritee extends Moteur {          // ← la faute
  constructor(marque, puissance) { super(puissance); this.marque = marque; }
}

class Voiture {
  #moteur;
  constructor(marque, moteur) { this.marque = marque; this.#moteur = moteur; }
  // ← à écrire : déléguer demarrer() au moteur, sans hériter de lui
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Remplissez VERDICTS pour les six paires.
// 2. Lancez testEcritPourRectangle sur un Rectangle puis sur un Carre.
// 3. Écrivez la délégation dans Voiture, et vérifiez qu'une Voiture ne peut
//    plus être rangée dans une liste de moteurs.

console.log("   " + testEcritPourRectangle(new Rectangle(1, 1)).aire);

Solution

const VERDICTS = {
  Livre:    { estUn: true,  pourquoi: "un livre EST un document : tout ce qu'on fait d'un document (décrire, ranger, référencer) a un sens sur un livre" },
  Voiture:  { estUn: false, pourquoi: "elle POSSÈDE un moteur — attributs communs n'est pas nature commune. Composition" },
  Etudiant: { estUn: true,  pourquoi: "un étudiant EST une personne, et tout code écrit pour Personne reste correct" },
  Compte:   { estUn: false, pourquoi: "il APPARTIENT à une banque : c'est une association, pas une nature" },
  Carre:    { estUn: false, pourquoi: "vrai en mathématiques, faux en programmation : Rectangle promet deux dimensions INDÉPENDANTES, promesse qu'un carré ne peut pas tenir" },
  Pile:     { estUn: false, pourquoi: "une pile UTILISE une liste pour stocker, mais hériter exposerait get(i) et remove(i), qui violent le LIFO. Composition" },
};

console.log("— 1. le test « est-un » —");
for (const [nom, v] of Object.entries(VERDICTS)) {
  console.log("   " + nom.padEnd(10) + (v.estUn ? "HÉRITAGE   " : "composition") + "  " + v.pourquoi);
}

class Rectangle {
  constructor(l, h) { this._largeur = l; this._hauteur = h; }
  setLargeur(l) { this._largeur = l; }
  setHauteur(h) { this._hauteur = h; }
  aire() { return this._largeur * this._hauteur; }
  get nom() { return this.constructor.name; }
}
class Carre extends Rectangle {
  constructor(cote) { super(cote, cote); }
  setLargeur(l) { this._largeur = l; this._hauteur = l; }
  setHauteur(h) { this._largeur = h; this._hauteur = h; }
}

function testEcritPourRectangle(forme) {
  forme.setLargeur(5);
  forme.setHauteur(4);
  return { nom: forme.nom, aire: forme.aire(), attendu: 20 };
}

console.log("");
console.log("— 2. le MÊME test, deux objets —");
for (const forme of [new Rectangle(1, 1), new Carre(1)]) {
  const r = testEcritPourRectangle(forme);
  console.log("   " + r.nom.padEnd(10) + " aire = " + String(r.aire).padStart(3) +
              "  attendu " + r.attendu + (r.aire === r.attendu ? "   ok" : "   ÉCHEC"));
}
console.log("   Le test n'a pas été modifié d'un caractère. L'appelant ne fait rien");
console.log("   d'illégitime : Rectangle promet deux dimensions indépendantes, il en");
console.log("   use. C'est Carre qui rompt la promesse — donc l'héritage est fautif,");
console.log("   malgré la phrase « un carré est un rectangle ».");

console.log("");
console.log("— 3. héritage fautif contre composition —");
class Moteur {
  constructor(puissance) { this.puissance = puissance; this.tourne = false; }
  demarrer() { this.tourne = true; return "moteur " + this.puissance + " ch démarré"; }
  arreter() { this.tourne = false; }
}
class VoitureHeritee extends Moteur {
  constructor(marque, puissance) { super(puissance); this.marque = marque; }
}
class Voiture {
  #moteur;
  constructor(marque, moteur) { this.marque = marque; this.#moteur = moteur; }
  // DÉLÉGATION : on appelle le moteur au lieu d'hériter de lui. Le code de
  // Moteur n'est pas dupliqué, et on n'expose que ce qu'on a choisi.
  demarrer() { return this.marque + " : " + this.#moteur.demarrer(); }
  get puissance() { return this.#moteur.puissance; }
  changerMoteur(m) { this.#moteur = m; }    // impossible avec l'héritage
}

// Un atelier qui ne travaille que sur des moteurs.
function atelier(moteurs) {
  return moteurs.map((m) => (m instanceof Moteur ? "révisé" : "REFUSÉ : ce n'est pas un moteur"));
}

const stock = [new Moteur(90), new VoitureHeritee("Renault", 110)];
console.log("   avec l'héritage fautif : " + atelier(stock).join("  |  "));
console.log("   Une voiture entière est passée pour un moteur, et l'atelier l'a prise.");

const stock2 = [new Moteur(90), new Voiture("Renault", new Moteur(110))];
console.log("   avec la composition    : " + atelier(stock2).join("  |  "));
console.log("   " + new Voiture("Peugeot", new Moteur(75)).demarrer());
console.log("   La relation absurde a disparu, et l'on peut même changer de moteur");
console.log("   à l'exécution — ce qu'un lien d'héritage, fixé à la compilation,");
console.log("   n'aurait jamais permis.");

Avant de commencer

• Les TP 1 à 4

Énoncé

1. Une hiérarchie légitime — Faites dériver Livre, Dvd et Revue de Document. Mettez dans la classe mère ce qui est commun, et rien d'autre. Comptez les lignes économisées.
2. super — Écrivez les constructeurs des filles en appelant celui de la mère. Retirez l'appel et lisez l'erreur. Expliquez pourquoi il doit être en première instruction.
3. La hiérarchie qui semble juste — Écrivez une classe Rectangle avec largeur, hauteur et surface. Faites-en dériver Carre, en redéfinissant les modificateurs pour garder les côtés égaux.
4. La casser — Écrivez une méthode qui prend un Rectangle, lui met une largeur de 5 et une hauteur de 4, et vérifie que la surface vaut 20. Passez-lui un Carre. Indice : La méthode ne fait rien d'illégitime : elle utilise le contrat de Rectangle.
5. Le principe — Énoncez en une phrase la règle que le carré viole, et vérifiez si votre hiérarchie de documents la respecte.
6. Le deuxième contre-exemple — Faites dériver une Pile d'une classe de liste. Ajoutez un élément par la méthode d'insertion de la liste et constatez ce que devient l'invariant de la pile.
7. Composer — Réécrivez la pile en CONTENANT une liste plutôt qu'en héritant d'elle. Comparez la surface publique des deux versions.
8. Le critère — Écrivez la question à se poser avant tout héritage, et appliquez-la aux cinq relations suivantes : Livre/Document, Carre/Rectangle, Pile/Liste, Cercle/Forme, Employe/Personne.

C'est réussi quand

• ✓ Votre test échoue avec un Carre, sans que le test soit fautif
• ✓ Vous énoncez le principe de substitution sans le relire
• ✓ Votre pile par composition n'expose aucune méthode qui casse son invariant

Correction

public abstract class Document {
  protected final String titre;
  protected boolean disponible = true;

  protected Document(String titre) { this.titre = titre; }

  public boolean emprunter() { … }
  public abstract int dureeEmpruntEnJours();   /* diffère par type */
}

public class Livre extends Document {
  private final int pages;
  public Livre(String titre, int pages) {
      super(titre);                 /* PREMIÈRE instruction */
      this.pages = pages;
  }
  @Override public int dureeEmpruntEnJours() { return 21; }
}

class Carre extends Rectangle {
  @Override public void setLargeur(int l) { super.setLargeur(l);
                                            super.setHauteur(l); }
  @Override public void setHauteur(int h) { super.setLargeur(h);
                                            super.setHauteur(h); }
}

void tester(Rectangle r) {
  r.setLargeur(5);
  r.setHauteur(4);
  assert r.surface() == 20;    /* légitime pour un Rectangle */
}

tester(new Rectangle()) → 20, réussit
tester(new Carre())     → 16, ÉCHOUE

Partout où l'on attend une classe mère, on doit pouvoir mettre
n'importe quelle fille SANS que le programme cesse d'être correct.

en pratique, une sous-classe ne doit jamais :
- renforcer ce qu'elle exige en entrée
- affaiblir ce qu'elle garantit en sortie
- casser un invariant de la mère
- lever une exception que la mère ne déclarait pas

class Pile<T> extends ArrayList<T> {
  public void empiler(T t) { add(t); }
  public T depiler() { return remove(size() - 1); }
}

Pile<String> p = new Pile<>();
p.empiler("a"); p.empiler("b");
p.add(0, "triché");        /* HÉRITÉ d'ArrayList : insertion au milieu */
p.remove(0);               /* HÉRITÉ : retrait par le bas */
/* la pile n'est plus une pile : l'invariant DERNIER ENTRÉ,
 PREMIER SORTI est cassé, et on ne pouvait pas l'empêcher */

class Pile<T> {
  private final List<T> elements = new ArrayList<>();   /* CONTIENT */

  public void empiler(T t) { elements.add(t); }
  public T depiler() {
      if (elements.isEmpty()) throw new NoSuchElementException();
      return elements.remove(elements.size() - 1);
  }
  public boolean estVide() { return elements.isEmpty(); }
}

surface publique : héritage 40+ méthodes | composition 3 méthodes

La question n'est PAS « est-ce un » mais :
« puis-je le substituer partout, sans casser le contrat ? »

Livre / Document     OUI  — un livre fait tout ce qu'un document fait
Carre / Rectangle    NON  — sur un rectangle MUTABLE
Pile / Liste         NON  — la liste offre trop
Cercle / Forme       OUI  — si Forme n'expose que des opérations communes
Employe / Personne   ATTENTION — souvent un RÔLE, pas une nature :
                   une personne peut devenir employée, cesser de l'être,
                   ou l'être deux fois. La composition est préférable.

par défaut : COMPOSER. Hériter seulement quand la substitution
est vérifiée par des tests.