Classes et objets

Point de départ

// JavaScript possède class, constructor et this : la transposition depuis
// Java est directe, à la déclaration des types près.

class Compte {
  constructor(titulaire, depotInitial) {
    // ← à écrire : refuser un dépôt initial négatif, puis initialiser
    this.titulaire = titulaire;
    this.solde = depotInitial;
  }
  deposer(montant) { this.solde += montant; }
  getSolde() { return this.solde; }
  toString() { return this.titulaire + " : " + this.solde.toFixed(2); }
}

// Affiche l'état de plusieurs objets CÔTE À CÔTE, comme au tableau.
function etat(etiquette, ...comptes) {
  console.log("   " + etiquette.padEnd(28) +
    comptes.map((c) => c.toString()).join("   |   "));
}

// ── 1. Deux objets, deux jeux d'attributs ─────────────────────────────────
const a = new Compte("Ana", 100);
const b = new Compte("Bo", 50);
etat("après les deux new", a, b);
a.deposer(30);
etat("après a.deposer(30)", a, b);

// ── 2. L'alias ────────────────────────────────────────────────────────────
const c = a;               // COPIE LA RÉFÉRENCE, pas l'objet
c.deposer(20);
etat("après c.deposer(20)", a, b);
console.log("   a et c sont le même objet :", a === c);

// ── 3. L'attribut masqué ──────────────────────────────────────────────────
class CompteFautif {
  constructor(titulaire, solde) {
    titulaire = titulaire;   // ← sans this : on affecte le paramètre à lui-même
    solde = solde;
  }
  toString() { return this.titulaire + " : " + this.solde; }
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Faites refuser un dépôt initial négatif par le constructeur.
// 2. Créez un CompteFautif et affichez-le : que valent ses attributs, et
//    pourquoi le code compile-t-il sans rien dire ?
// 3. Détachez la méthode : const f = a.deposer; f(10). Que se passe-t-il,
//    et qu'est-ce que cela apprend sur this ?

Solution

class Compte {
  constructor(titulaire, depotInitial) {
    // Le constructeur ÉTABLIT L'INVARIANT : à sa sortie, l'objet doit être
    // dans un état valide. Un compte au solde négatif ne doit pas exister.
    if (depotInitial < 0) throw new Error("dépôt initial négatif : " + depotInitial);
    if (!titulaire) throw new Error("un compte doit avoir un titulaire");
    this.titulaire = titulaire;
    this.solde = depotInitial;
  }
  deposer(montant) { this.solde += montant; }
  getSolde() { return this.solde; }
  toString() { return this.titulaire + " : " + this.solde.toFixed(2); }
}

function etat(etiquette, ...comptes) {
  console.log("   " + etiquette.padEnd(28) + comptes.map((c) => c.toString()).join("   |   "));
}

console.log("— 1. deux objets, deux jeux d'attributs —");
const a = new Compte("Ana", 100);
const b = new Compte("Bo", 50);
etat("après les deux new", a, b);
a.deposer(30);
etat("après a.deposer(30)", a, b);
console.log("   Le code de deposer est écrit UNE fois ; il a modifié une case et");
console.log("   pas l'autre, parce que this désignait a et non b.");

console.log("");
console.log("— l'invariant tient dès la construction —");
try { new Compte("Cy", -10); } catch (e) { console.log("   refusé : " + e.message); }

console.log("");
console.log("— 2. l'alias —");
const c = a;
c.deposer(20);
etat("après c.deposer(20)", a, b);
console.log("   a === c :", a === c, "  — un seul objet, deux noms");
const d = new Compte(a.titulaire, a.getSolde());   // là, une vraie copie
d.deposer(1000);
etat("après d.deposer(1000)", a, d);
console.log("   d est un AUTRE objet : il a fallu un second new.");

console.log("");
console.log("— 3. l'attribut masqué —");
class CompteFautif {
  constructor(titulaire, solde) {
    // « solde = solde » affecte le paramètre à lui-même : l'attribut n'est
    // jamais créé. Aucune erreur — c'est du code parfaitement légal, et
    // c'est ce qui le rend dangereux.
    titulaire = titulaire;
    solde = solde;
  }
  toString() { return this.titulaire + " : " + this.solde; }
}
console.log("   " + new CompteFautif("Dee", 500).toString());
console.log("   Les deux attributs valent undefined : le constructeur n'a rien");
console.log("   initialisé. En Java, le code compile aussi — les attributs y");
console.log("   prennent simplement leur valeur par défaut, 0 et null.");

console.log("");
console.log("— 4. la méthode détachée —");
const f = a.deposer;
try { f(10); } catch (e) { console.log("   f(10) échoue : " + e.message.split("\n")[0]); }
const g = a.deposer.bind(a);
g(10);
etat("après g(10), lié à a", a);
console.log("   this n'est pas fixé une fois pour toutes à la définition : il est");
console.log("   déterminé par l'APPEL. En Java le problème ne se pose pas ainsi —");
console.log("   on ne détache pas une méthode de son objet — mais le principe est");
console.log("   le même : une méthode reçoit l'objet sur lequel elle travaille.");

Avant de commencer

• Le TP 1

Énoncé

1. Deux objets — Créez deux Document et modifiez le titre du premier. Affichez les deux. Puis affichez ce que vaut une variable statique modifiée sur l'un des deux.
2. Le constructeur qui ne fait rien — Écrivez un constructeur dont les paramètres portent le même nom que les champs, SANS écrire this. Créez un objet et affichez ses champs. Expliquez. Indice : Le paramètre masque le champ : l'affectation se fait du paramètre vers lui-même.
3. Le réparer, deux fois — Corrigez d'abord en renommant les paramètres, puis avec this. Dites laquelle des deux formes vous garderez et pourquoi.
4. this dans une méthode — Écrivez une méthode qui renvoie l'objet lui-même, et enchaînez trois appels sur une seule ligne. Expliquez ce que vaut this à chaque appel.
5. Plusieurs constructeurs — Écrivez trois constructeurs de Document, dont deux qui délèguent au troisième. Vérifiez que la validation n'est écrite qu'une fois.
6. L'objet non initialisé — Déclarez une référence sans l'affecter et appelez une méthode dessus. Lisez le message, et distinguez « la référence est nulle » de « l'objet est vide ».
7. Comparer deux objets — Créez deux Document de contenu identique et comparez-les avec l'opérateur d'égalité. Expliquez le résultat, et faites de même avec deux chaînes construites de deux façons.
8. Au fil rouge — Écrivez la classe Mediatheque contenant un tableau de Document, avec ajouter, chercher et lister. Vérifiez qu'aucune méthode n'a besoin de connaître l'intérieur de Document.

C'est réussi quand

• ✓ Vous expliquez pourquoi le constructeur sans this laisse les champs à null
• ✓ Vos trois constructeurs ne dupliquent aucune validation
• ✓ Vous savez dire ce que compare l'opérateur d'égalité sur deux objets

Correction

public Document(String titre, String auteur) {
  titre  = titre;      /* le PARAMÈTRE est affecté au PARAMÈTRE */
  auteur = auteur;     /* le champ n'est jamais touché */
}

new Document("1984", "Orwell").getTitre()   →  null

/* javac avec -Xlint signale : self-assignment */

public Document(String titre, String auteur) {
  this.titre  = titre;    /* this.titre : le CHAMP de l'objet courant */
  this.auteur = auteur;   /* titre      : le PARAMÈTRE */
}

/* this = « l'objet sur lequel la méthode a été appelée » */
Document a = new Document("1984", "Orwell");
Document b = new Document("Dune", "Herbert");
a.getTitre();   /* dans getTitre, this vaut a */
b.getTitre();   /* dans getTitre, this vaut b */

public Document avecAnnee(int annee) {
  this.annee = annee;
  return this;                    /* on rend l'objet lui-même */
}

Document d = new Document("Dune", "Herbert")
               .avecAnnee(1965)
               .avecGenre("science-fiction")
               .avecCote("SF-HER-01");

/* à chaque appel, this est le MÊME objet : un seul Document existe */

public Document(String titre, String auteur, int annee) {
  if (titre == null || titre.isBlank())
      throw new IllegalArgumentException("titre obligatoire");
  if (annee < 1400 || annee > 2100)
      throw new IllegalArgumentException("année invalide : " + annee);
  this.titre = titre; this.auteur = auteur; this.annee = annee;
}

public Document(String titre, String auteur) {
  this(titre, auteur, 0);          /* this(...) : DÉLÉGATION */
}
public Document(String titre) {
  this(titre, "inconnu", 0);
}

Document d;              /* champ non initialisé → null */
d.getTitre();            /* NullPointerException */

/* null = AUCUN objet. Différent d'un objet aux champs vides. */

Document a = new Document("1984", "Orwell");
Document b = new Document("1984", "Orwell");
a == b            → false   /* deux objets DISTINCTS, deux adresses */
a.equals(b)       → false   /* tant qu'on n'a pas redéfini equals (TP 6) */

String s1 = "abc", s2 = "abc";
s1 == s2          → true    /* littéraux INTERNÉS : même objet */
String s3 = new String("abc");
s1 == s3          → false   /* d'où : TOUJOURS equals sur les chaînes */