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.

Point de départ

// ── 1. Quelle méthode s'exécute ? ─────────────────────────────────────────
class Animal {
  crier() { return "..."; }
  presenter() { return "je suis un animal et je fais " + this.crier(); }
}
class Chien extends Animal {
  crier() { return "Ouaf"; }
  aboyer() { return "Grrr"; }
}
class Chat extends Animal {
  crier() { return "Miaou"; }
}

// Une SURCHARGE, pas une redéfinition : deux méthodes différentes, dans la
// même classe, choisies d'après le type DÉCLARÉ de l'argument.
class Journal {
  journaliser(x) {
    // JavaScript n'a pas de surcharge : on simule la résolution que le
    // compilateur Java ferait, à partir du type DÉCLARÉ qu'on lui passe.
    return "à écrire";
  }
}

// Chaque appel est décrit par son type déclaré et son objet réel.
const APPELS = [
  { code: "a.crier()",              declare: "Animal", objet: new Chien(), attendu: "?" },
  { code: "a.presenter()",          declare: "Animal", objet: new Chat(),  attendu: "?" },
  { code: "j.journaliser(a)",       declare: "Animal", objet: new Chien(), attendu: "?" },
  { code: "a.aboyer()",             declare: "Animal", objet: new Chien(), attendu: "?" },
];

// ── 2. Une boucle sans aucun test de type ─────────────────────────────────
class Forme {
  constructor(nom) { this.nom = nom; }
  aire() { throw new Error("Forme est abstraite"); }
  decrire() { return this.nom + " d'aire " + this.aire().toFixed(2); }
}
class Cercle extends Forme {
  constructor(r) { super("cercle"); this.r = r; }
  aire() { return Math.PI * this.r * this.r; }
}
class Rectangle extends Forme {
  constructor(l, h) { super("rectangle"); this.l = l; this.h = h; }
  aire() { return this.l * this.h; }
}

// ── 3. == contre equals ───────────────────────────────────────────────────
class Livre {
  constructor(isbn, titre) { this.isbn = isbn; this.titre = titre; }
  // ← à écrire : deux livres sont égaux s'ils ont le même ISBN
  equals(autre) { return this === autre; }
  hashCode() { return 0; }   // ← contrat violé volontairement
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. PRÉDISEZ le résultat des quatre appels AVANT de lancer, puis complétez
//    journaliser() pour simuler la résolution de surcharge de Java.
// 2. Ajoutez une classe Triangle : combien de lignes existantes changent ?
//    Écrivez ensuite la version à instanceof, pour comparer.
// 3. Écrivez equals sur l'ISBN, puis un hashCode cohérent. Constatez ce qui
//    se passe dans un Set quand le contrat est violé.

for (const ap of APPELS) console.log("   " + ap.code.padEnd(22) + " -> à prédire");

Solution

class Animal {
  crier() { return "..."; }
  presenter() { return "je suis un animal et je fais " + this.crier(); }
}
class Chien extends Animal {
  crier() { return "Ouaf"; }
  aboyer() { return "Grrr"; }
}
class Chat extends Animal {
  crier() { return "Miaou"; }
}

class Journal {
  // On simule ce que le COMPILATEUR Java fait : il choisit d'après le type
  // DÉCLARÉ, sans jamais regarder l'objet réel.
  journaliser(typeDeclare) {
    if (typeDeclare === "Chien") return "journaliser(Chien) : un chien précis";
    return "journaliser(Animal) : un animal quelconque";
  }
}

const j = new Journal();

console.log("— 1. quelle méthode s'exécute ? —");
const chien = new Chien(), chat = new Chat();
console.log("   a.crier()          déclaré Animal, réel Chien -> " + chien.crier() +
            "        (redéfinition : TYPE RÉEL)");
console.log("   a.presenter()      déclaré Animal, réel Chat  -> " + chat.presenter());
console.log("      presenter() n'est PAS redéfinie : c'est celle d'Animal qui part.");
console.log("      Mais le this.crier() qu'elle contient repart en liaison dynamique");
console.log("      et exécute Chat.crier(). Le parent appelle la version de la fille.");
console.log("   j.journaliser(a)   déclaré Animal, réel Chien -> " + j.journaliser("Animal"));
console.log("      LE PIÈGE : surcharge, pas redéfinition. Le compilateur a choisi");
console.log("      d'après le type DÉCLARÉ, et la machine n'avait plus rien à décider.");
console.log("   a.aboyer()         déclaré Animal, réel Chien -> REFUSÉ À LA COMPILATION");
console.log("      L'objet possède la méthode, mais Animal ne la déclare pas.");
console.log("      Il faut ((Chien) a).aboyer(), après un test instanceof.");

console.log("");
console.log("— 2. une boucle sans test de type —");
class Forme {
  constructor(nom) { this.nom = nom; }
  aire() { throw new Error("Forme est abstraite"); }
  decrire() { return this.nom + " d'aire " + this.aire().toFixed(2); }
}
class Cercle extends Forme {
  constructor(r) { super("cercle"); this.r = r; }
  aire() { return Math.PI * this.r * this.r; }
}
class Rectangle extends Forme {
  constructor(l, h) { super("rectangle"); this.l = l; this.h = h; }
  aire() { return this.l * this.h; }
}
// La classe ajoutée. Aucune ligne existante n'a été touchée.
class Triangle extends Forme {
  constructor(b, h) { super("triangle"); this.b = b; this.h = h; }
  aire() { return (this.b * this.h) / 2; }
}

const formes = [new Cercle(2), new Rectangle(3, 4), new Triangle(3, 4)];
let total = 0;
for (const f of formes) { console.log("   " + f.decrire()); total += f.aire(); }
console.log("   total : " + total.toFixed(2) + "   — la boucle ignore quelles formes existent");

// La version que le polymorphisme évite.
function aireParTests(f) {
  if (f instanceof Cercle) return Math.PI * f.r * f.r;
  if (f instanceof Rectangle) return f.l * f.h;
  // ← et il a fallu revenir ICI pour ajouter le triangle. Puis dans le
  //    calcul de périmètre, l'affichage, la sauvegarde…
  if (f instanceof Triangle) return (f.b * f.h) / 2;
  throw new Error("forme inconnue");
}
console.log("   version à instanceof : même résultat, mais chaque nouvelle forme");
console.log("   oblige à retrouver TOUS les tests du programme.");

console.log("");
console.log("— 3. identité, égalité, et le contrat hashCode —");
class Livre {
  constructor(isbn, titre) { this.isbn = isbn; this.titre = titre; }
  // Deux livres sont égaux s'ils désignent le même ouvrage, donc le même ISBN.
  equals(autre) {
    if (this === autre) return true;
    if (!(autre instanceof Livre)) return false;   // l'un des emplois légitimes
    return this.isbn === autre.isbn;
  }
  // Le contrat : deux objets égaux DOIVENT avoir le même code de hachage.
  hashCode() { return this.isbn; }
  toString() { return this.titre + " (" + this.isbn + ")"; }
}

const a = new Livre(1234, "Dune");
const b = new Livre(1234, "Dune");
console.log("   a === b      : " + (a === b) + "   (identité : deux objets distincts)");
console.log("   a.equals(b)  : " + a.equals(b) + "    (égalité de contenu)");

// Un ensemble qui range par code de hachage, comme un HashSet.
function ensemble(hachage) {
  const seaux = new Map();
  return {
    ajouter(x) {
      const h = hachage(x);
      if (!seaux.has(h)) seaux.set(h, []);
      const seau = seaux.get(h);
      if (!seau.some((y) => x.equals(y))) seau.push(x);
    },
    contient(x) {
      const seau = seaux.get(hachage(x)) ?? [];    // on ne cherche QUE dans ce seau
      return seau.some((y) => x.equals(y));
    },
  };
}

const bon = ensemble((x) => x.hashCode());
bon.ajouter(a);
console.log("   contrat respecté : l'ensemble contient b ? " + bon.contient(b));

const casse = ensemble((x) => Math.floor(Math.random() * 100));  // hashCode incohérent
casse.ajouter(a);
console.log("   contrat violé    : l'ensemble contient b ? " + casse.contient(b) +
            "   — l'objet est là, et introuvable");
console.log("   Aucune erreur n'est levée : la recherche va simplement dans le");
console.log("   mauvais seau. C'est pourquoi equals et hashCode se redéfinissent");
console.log("   TOUJOURS ensemble.");

Avant de commencer

• Le TP 5 : héritage et substitution

Énoncé

1. La question de base — Déclarez une variable de type Document contenant un Livre, et appelez une méthode redéfinie. Prédisez la sortie AVANT d'exécuter.
2. L'expérience décisive — Dans la même classe, écrivez une méthode redéfinie ET une méthode surchargée prenant un Document et un Livre. Appelez les deux sur une variable déclarée Document contenant un Livre. Comparez. Indice : L'une se résout à la compilation sur le type déclaré, l'autre à l'exécution sur le type réel.
3. La cascade de tests — Écrivez une méthode qui calcule une pénalité de retard avec une suite de tests sur le type de document. Ajoutez ensuite un quatrième type et comptez les endroits à modifier.
4. La faire disparaître — Remplacez la cascade par une méthode redéfinie dans chaque sous-classe. Ajoutez de nouveau un cinquième type et recomptez.
5. Abstraite ou interface — Écrivez la même chose une fois avec une classe abstraite, une fois avec une interface. Dressez la liste des différences, et dites laquelle vous choisiriez ici.
6. equals et hashCode — Redéfinissez equals sur Document. Mettez deux documents identiques dans un ensemble et constatez qu'ils y sont tous les deux. Corrigez.
7. Le contrat — Écrivez un test qui vérifie les quatre propriétés d'equals, puis cassez-en une volontairement et observez le comportement de l'ensemble.
8. Au fil rouge — Faites afficher par Mediatheque tout son catalogue en une seule boucle, sans un seul test de type, chaque document sachant se décrire.

C'est réussi quand

• ✓ Vous prédisez correctement les deux sorties de l'étape 2
• ✓ Ajouter un type de document ne modifie plus aucun code existant
• ✓ Deux documents égaux ne rentrent qu'une fois dans un ensemble

Correction

class Document { 
  String decrire() { return "document"; }              /* redéfinie */
}
class Livre extends Document {
  @Override String decrire() { return "livre"; }
}

static void traiter(Document d) { System.out.println("traiter Document"); }
static void traiter(Livre l)    { System.out.println("traiter Livre"); }

Document d = new Livre();

d.decrire()   →  « livre »              TYPE RÉEL     (exécution)
traiter(d)    →  « traiter Document »   TYPE DÉCLARÉ  (compilation)

/* AVANT : tout est dans Mediatheque */
double penalite(Document d, int joursDeRetard) {
  if (d instanceof Livre)      return joursDeRetard * 0.20;
  else if (d instanceof Dvd)   return joursDeRetard * 1.00;
  else if (d instanceof Revue) return joursDeRetard * 0.10;
  return 0;
}

/* ajouter Partition : modifier ici, ET dans dureeEmprunt(),
 ET dans afficher(), ET dans exporter()… → 4 endroits,
 et le compilateur n'en signale AUCUN si vous en oubliez un */

public abstract class Document {
  public abstract double penaliteParJour();
}
class Livre    extends Document { public double penaliteParJour(){return 0.20;} }
class Dvd      extends Document { public double penaliteParJour(){return 1.00;} }
class Revue    extends Document { public double penaliteParJour(){return 0.10;} }

/* dans Mediatheque, il ne reste que : */
double penalite(Document d, int jours) { return jours * d.penaliteParJour(); }

/* ajouter Partition : créer UN fichier. Rien d'autre à toucher.
 Et si on oublie la méthode, LE COMPILATEUR REFUSE. */

classe abstraite            interface
état (champs) : OUI         non (sauf constantes)
constructeur  : OUI         non
héritage      : UNE seule   PLUSIEURS implémentées
méthodes concrètes : OUI    oui (default), sans état

ici : classe abstraite Document (il y a un état commun :
    titre, disponibilité, et un constructeur à factoriser)
    + interface Empruntable si des objets non-Document
      doivent aussi être empruntables

@Override public boolean equals(Object o) {
  if (this == o) return true;
  if (!(o instanceof Document d)) return false;
  return titre.equals(d.titre) && annee == d.annee;
}
/* hashCode NON redéfini */

Set<Document> s = new HashSet<>();
s.add(new Document("Dune", 1965));
s.add(new Document("Dune", 1965));
s.size()   →  2      /* alors qu'ils sont « égaux » ! */

@Override public int hashCode() { return Objects.hash(titre, annee); }

/* les quatre propriétés d'equals */
réflexivité : x.equals(x)
symétrie    : x.equals(y) == y.equals(x)
transitivité: x=y et y=z ⟹ x=z
cohérence   : le résultat ne change pas si les objets ne changent pas
et          : x.equals(null) est toujours faux

/* le piège de la symétrie */
livre.equals(document)  → true   si equals utilise instanceof
document.equals(livre)  → false  si l'autre utilise getClass()
→ le comportement dépend de l'ORDRE : contrat rompu