Polymorphisme

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