Point de départ

// ── 1. Attributs publics : l'invariant ne tient à rien ────────────────────
class LivreOuvert {
  constructor(titre) {
    this.titre = titre;
    this.disponible = true;
    this.emprunteur = null;
  }
  // Invariant voulu : emprunteur non nul  <=>  disponible faux.
  emprunter(qui) {
    if (!this.disponible) return false;
    this.disponible = false;
    this.emprunteur = qui;
    return true;
  }
  invariantOk() {
    return (this.emprunteur === null) === this.disponible;
  }
  toString() {
    return this.titre + " [" + (this.disponible ? "libre" : "pris par " + this.emprunteur) + "]";
  }
}

// ── 2. Version encapsulée ─────────────────────────────────────────────────
class Livre {
  #titre; #disponible; #emprunteurs;      // # = champ réellement privé

  constructor(titre) {
    if (!titre) throw new Error("un livre doit avoir un titre");
    this.#titre = titre;
    this.#disponible = true;
    this.#emprunteurs = [];
  }
  get titre() { return this.#titre; }
  estDisponible() { return this.#disponible; }

  emprunter(qui) {
    // ← à écrire : refuser si déjà emprunté, sinon enregistrer l'emprunteur
    return false;
  }
  rendre() { this.#disponible = true; }

  // ← FUITE : ce getter rend la liste INTERNE, que l'appelant peut vider.
  getEmprunteurs() { return this.#emprunteurs; }
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Cassez l'invariant de LivreOuvert en DEUX lignes, sans appeler emprunter.
// 2. Écrivez emprunter() dans Livre, et vérifiez que la même attaque échoue.
// 3. Réparez la fuite de getEmprunteurs, de deux façons : copie défensive,
//    puis exposition d'une valeur immuable.
// 4. Écrivez la même opération « emprunter si disponible » chez l'appelant,
//    puis dans l'objet. Que se passe-t-il quand la règle change ?

const a = new LivreOuvert("Dune");
console.log("   " + a.toString() + "   invariant :", a.invariantOk());

Solution

class LivreOuvert {
  constructor(titre) { this.titre = titre; this.disponible = true; this.emprunteur = null; }
  emprunter(qui) {
    if (!this.disponible) return false;
    this.disponible = false; this.emprunteur = qui; return true;
  }
  invariantOk() { return (this.emprunteur === null) === this.disponible; }
  toString() {
    return this.titre + " [" + (this.disponible ? "libre" : "pris par " + this.emprunteur) + "]";
  }
}

console.log("— 1. attributs publics : deux lignes suffisent —");
const a = new LivreOuvert("Dune");
console.log("   départ    : " + a.toString() + "   invariant : " + a.invariantOk());
a.emprunteur = "Ana";        // on contourne entièrement emprunter()
a.disponible = true;         // et l'on ment sur la disponibilité
console.log("   après     : " + a.toString() + "   invariant : " + a.invariantOk());
console.log("   Le livre est « libre » et pris par Ana. Aucune erreur, aucune trace.");

class Livre {
  #titre; #disponible; #emprunteurs;

  constructor(titre) {
    if (!titre) throw new Error("un livre doit avoir un titre");
    this.#titre = titre;
    this.#disponible = true;
    this.#emprunteurs = [];
  }
  get titre() { return this.#titre; }
  estDisponible() { return this.#disponible; }

  emprunter(qui) {
    // La règle, en un seul endroit — et cette fois on ne peut plus l'éviter.
    if (!this.#disponible) return false;
    if (!qui) throw new Error("emprunteur non renseigné");
    this.#disponible = false;
    this.#emprunteurs.push(qui);
    return true;
  }
  rendre() { this.#disponible = true; }

  // Copie défensive : l'appelant reçoit SA liste, pas la nôtre.
  getEmprunteurs() { return [...this.#emprunteurs]; }
  // Mieux encore : n'exposer qu'une valeur immuable, ici un simple compte.
  get nombreEmprunts() { return this.#emprunteurs.length; }

  toString() {
    return this.#titre + " [" + (this.#disponible ? "libre" : "emprunté") +
           ", " + this.#emprunteurs.length + " emprunt(s)]";
  }
}

console.log("");
console.log("— 2. la même attaque, sur la version encapsulée —");
const b = new Livre("Dune");
b.emprunter("Ana");
b.disponible = true;         // crée un champ PUBLIC sans rapport, inoffensif
console.log("   " + b.toString());
console.log("   estDisponible() rend toujours " + b.estDisponible() +
            " : le champ privé est intact, l'invariant tient.");
try { console.log(b.#titre); } catch (e) { console.log("   accès direct à #titre : refusé"); }

console.log("");
console.log("— 3. la fuite de référence —");
const c = new Livre("Solaris");
c.emprunter("Bo"); c.rendre(); c.emprunter("Cy");
const liste = c.getEmprunteurs();
liste.length = 0;            // l'appelant vide SA copie
console.log("   après que l'appelant a vidé la liste reçue : " + c.toString());
console.log("   Sans la copie défensive, le compte serait tombé à 0 : l'appelant");
console.log("   aurait modifié l'état interne sans passer par aucune méthode.");
console.log("   nombreEmprunts (valeur immuable) : " + c.nombreEmprunts + " — rien à fuir.");

console.log("");
console.log("— 4. dire, ne pas demander —");
// Chez l'appelant : la règle est ici, donc dupliquée partout où l'on emprunte.
function emprunterChezAppelant(livre, qui) {
  if (livre.estDisponible()) { livre.emprunter(qui); return true; }
  return false;
}
// Dans l'objet : la règle est là où vit la donnée.
const d = new Livre("Ubik");
console.log("   premier emprunt : " + d.emprunter("Ana"));
console.log("   second emprunt  : " + d.emprunter("Bo") + "   (refusé par l'objet)");
console.log("   Le jour où la règle devient « deux emprunts simultanés autorisés »,");
console.log("   la version « chez l'appelant » demande de retrouver tous les appels ;");
console.log("   la version « dans l'objet » demande de modifier une méthode.");

Avant de commencer

• Le TP 2
• Les collections de base de Java

Énoncé

1. Casser l'invariant — Rendez publics les champs de Document. Écrivez du code extérieur qui met une année à moins mille et une disponibilité incohérente. Comptez les lignes qu'il vous a fallu.
2. Fermer — Repassez tout en privé, ajoutez des accesseurs, et vérifiez que le code précédent ne compile plus.
3. La fuite par l'accesseur — Ajoutez à Mediatheque une liste privée de documents et un accesseur qui la renvoie. Depuis l'extérieur, videz la liste. Constatez que le privé n'a rien protégé. Indice : Renvoyer une référence sur une collection mutable, c'est en donner les clés.
4. Colmater, trois façons — Corrigez en renvoyant une copie, puis une vue non modifiable, puis en ne renvoyant rien du tout et en exposant les opérations utiles. Comparez les trois.
5. La fuite par le constructeur — Passez une liste au constructeur de Mediatheque et gardez-en la référence. Modifiez ensuite la liste d'origine depuis l'extérieur. Corrigez.
6. Les accesseurs inutiles — Comptez, dans votre code, les accesseurs qui ne servent qu'à recopier un champ vers l'extérieur. Pour chacun, demandez-vous quelle question du domaine il répond.
7. Déplacer le comportement — Trouvez une portion de code extérieur qui lit trois accesseurs pour décider quelque chose. Déplacez cette décision DANS la classe et supprimez les accesseurs devenus inutiles.
8. Le champ final — Rendez immuables les champs qui ne changent jamais après construction. Vérifiez ce que le compilateur refuse désormais.

C'est réussi quand

• ✓ Vous videz une liste « privée » depuis l'extérieur, en une ligne
• ✓ Après correction, la même ligne ne compile plus ou n'a plus d'effet
• ✓ Vous avez supprimé au moins deux accesseurs en déplaçant une décision

Correction

public class Mediatheque {
  private List<Document> documents = new ArrayList<>();
  public List<Document> getDocuments() { return documents; }   /* FUITE */
}

/* depuis l'extérieur */
mediatheque.getDocuments().clear();       /* tout est effacé */
mediatheque.getDocuments().add(null);     /* un null dans la collection */

/* 1. copie défensive : l'appelant modifie SA copie */
public List<Document> getDocuments() { return new ArrayList<>(documents); }

/* 2. vue non modifiable : moins coûteux, échoue à l'exécution */
public List<Document> getDocuments() {
  return Collections.unmodifiableList(documents);
}

/* 3. ne rien exposer : exposer les OPÉRATIONS */
public int nombreDeDocuments()          { return documents.size(); }
public Optional<Document> chercher(String titre) { … }
public void ajouter(Document d)         { … validation … }

public Mediatheque(List<Document> initiaux) {
  this.documents = initiaux;          /* FUITE : référence partagée */
}

List<Document> liste = new ArrayList<>();
Mediatheque m = new Mediatheque(liste);
liste.clear();                          /* la médiathèque est vidée */

/* correction : copier À L'ENTRÉE aussi */
this.documents = new ArrayList<>(initiaux);

/* AVANT : la décision est dehors */
if (doc.getAnnee() < 1900
  && doc.getEtat().equals("fragile")
  && !doc.estDisponible()) { … }

/* APRÈS : la décision est dans l'objet */
if (doc.necessiteUneConsultationSurPlace()) { … }

/* et getEtat(), getAnnee() peuvent disparaître de l'interface publique */

private final String titre;      /* fixé à la construction, définitif */
private boolean disponible;      /* varie légitimement */

titre = "autre";                 /* ERREUR DE COMPILATION */

/* mais attention : */
private final List<Document> docs = new ArrayList<>();
docs.add(...);                   /* AUTORISÉ : la RÉFÉRENCE est finale,
                                  pas le contenu */

Point de départ

// ── 1. Une case pour la classe ────────────────────────────────────────────
class Compte {
  static nombreDeComptes = 0;      // UNE case, pour toute la classe
  #solde;                          // une case PAR objet

  constructor(titulaire, depot) {
    this.titulaire = titulaire;
    this.#solde = depot;
    // ← à écrire : incrémenter le compteur DE CLASSE
  }
  deposer(m) { this.#solde += m; }
  getSolde() { return this.#solde; }
  static getNombreDeComptes() { return Compte.nombreDeComptes; }
}

// ── 2. Résolution de surcharge ────────────────────────────────────────────
// JavaScript n'a pas de surcharge : on la SIMULE en inspectant les types,
// ce qui rend visible ce que le compilateur Java fait à notre place.
function afficher(...args) {
  const signature = args.map((a) =>
    typeof a === "number" ? (Number.isInteger(a) ? "int" : "double") : typeof a
  ).join(", ");

  const CANDIDATES = {
    "int":            (n) => "afficher(int) -> " + n,
    "double":         (x) => "afficher(double) -> " + x.toFixed(2),
    "string":         (s) => "afficher(String) -> " + s,
    "string, int":    (s, n) => "afficher(String, int) -> " + s.repeat(n),
  };

  // ← à écrire : choisir la candidate exacte ; si aucune, tenter une
  //   conversion élargissante int -> double, comme le fait Java.
  return "aucune surcharge applicable pour (" + signature + ")";
}

// ── 3. Passage de paramètres ──────────────────────────────────────────────
function modifier(c) { c.deposer(100); }        // agit sur l'objet désigné
function remplacer(c) { c = new Compte("X", 0); } // réaffecte une locale
function incrementer(n) { n = n + 1; }           // type primitif

function echanger(a, b) {
  const t = a; a = b; b = t;    // échange les COPIES de références
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Incrémentez le compteur de classe, créez trois comptes, et vérifiez
//    qu'un compteur d'instance à la place vaudrait toujours 1.
// 2. Complétez la résolution de surcharge, y compris la conversion.
// 3. Lancez les trois cas de passage, puis echanger. Pourquoi échoue-t-il,
//    et par quoi le remplacer ?

const a = new Compte("Ana", 100);
const b = new Compte("Bo", 50);
console.log("   comptes créés :", Compte.getNombreDeComptes());

Solution

class Compte {
  static nombreDeComptes = 0;
  #solde;
  compteurPropre = 0;              // pour la comparaison du point 1

  constructor(titulaire, depot) {
    this.titulaire = titulaire;
    this.#solde = depot;
    Compte.nombreDeComptes++;      // par la CLASSE : plus clair que « nombre++ »
    this.compteurPropre++;         // une case par objet : vaudra toujours 1
  }
  deposer(m) { this.#solde += m; }
  getSolde() { return this.#solde; }
  toString() { return this.titulaire + " : " + this.getSolde(); }
  static getNombreDeComptes() { return Compte.nombreDeComptes; }
}

console.log("— 1. variable de classe contre variable d'instance —");
const a = new Compte("Ana", 100);
const b = new Compte("Bo", 50);
const c = new Compte("Cy", 20);
console.log("   Compte.nombreDeComptes = " + Compte.getNombreDeComptes() + "   (une seule case)");
console.log("   a.compteurPropre = " + a.compteurPropre +
            ", b = " + b.compteurPropre + ", c = " + c.compteurPropre +
            "   (une case chacun : toujours 1)");

console.log("");
console.log("— 2. résolution de surcharge —");
function afficher(...args) {
  const signature = args.map((x) =>
    typeof x === "number" ? (Number.isInteger(x) ? "int" : "double") : typeof x
  ).join(", ");

  const CANDIDATES = {
    "int":         (n) => "afficher(int) -> " + n,
    "double":      (x) => "afficher(double) -> " + x.toFixed(2),
    "string":      (s) => "afficher(String) -> " + s,
    "string, int": (s, n) => "afficher(String, int) -> " + s.repeat(n),
  };

  // 1) Correspondance EXACTE : toujours préférée.
  if (CANDIDATES[signature]) return CANDIDATES[signature](...args);
  // 2) À défaut, conversion élargissante int -> double, comme en Java.
  const elargie = signature.replace(/\bint\b/g, "double");
  if (CANDIDATES[elargie]) return CANDIDATES[elargie](...args) + "   (int élargi en double)";
  return "aucune surcharge applicable pour (" + signature + ")";
}

for (const appel of [[5], [5.5], ["ab"], ["ab", 3], [true]]) {
  console.log("   afficher(" + appel.map((x) => JSON.stringify(x)).join(", ") + ")".padEnd(12) +
              " -> " + afficher(...appel));
}
console.log("   Le littéral 5 est un int : la correspondance exacte l'emporte.");
console.log("   Si afficher(int) n'existait pas, 5 serait élargi en double.");
console.log("   Tout cela se décide À LA COMPILATION, sur les types DÉCLARÉS.");

console.log("");
console.log("— 3. passage de paramètres —");
function modifier(x) { x.deposer(100); }
function remplacer(x) { x = new Compte("Remplacé", 0); }
function incrementer(n) { n = n + 1; }
function echanger(x, y) { const t = x; x = y; y = t; }

console.log("   avant           : " + a.toString() + "   |   " + b.toString());
modifier(a);
console.log("   après modifier  : " + a.toString() + "   (le dépôt est VISIBLE)");
remplacer(a);
console.log("   après remplacer : " + a.toString() + "   (rien n'a changé)");

let n = 10;
incrementer(n);
console.log("   après incrementer(n) : n = " + n + "   (primitif : copie directe)");

let x = a, y = b;
echanger(x, y);
console.log("   après echanger  : x = " + x.toString() + ", y = " + y.toString());
console.log("   Rien n'a bougé : la méthode a échangé ses deux COPIES de");
console.log("   références, et l'appelant garde les siennes. On ne peut pas");
console.log("   écrire echanger en Java — il faut un conteneur, un tableau,");
console.log("   ou rendre un résultat :");
[x, y] = [y, x];             // l'appelant fait l'échange lui-même
console.log("   échange chez l'appelant : x = " + x.toString() + ", y = " + y.toString());

Avant de commencer

• Les TP 2 et 3

Énoncé

1. Compter les instances — Ajoutez à Document un compteur du nombre d'objets créés. Créez-en cinq et affichez le compteur, depuis un objet puis depuis la classe.
2. L'erreur symétrique — Tentez d'accéder à un champ d'instance depuis une méthode statique. Lisez le message et expliquez-le en une phrase avec le mot this.
3. La constante — Ajoutez une durée d'emprunt maximale, partagée et non modifiable. Testez ce que le compilateur refuse.
4. La fabrique statique — Ajoutez une méthode statique qui construit un Document à partir d'une ligne de fichier, et qui refuse une ligne mal formée. Comparez avec un constructeur.
5. Surcharger — Écrivez trois méthodes chercher : par titre, par titre et auteur, par année. Appelez les trois et vérifiez laquelle est choisie.
6. L'ambiguïté — Écrivez deux surcharges, l'une prenant un entier long, l'autre un flottant double. Appelez avec un entier ordinaire, puis avec null sur deux surcharges d'objets. Notez ce qui compile et ce qui ne compile pas. Indice : La résolution se fait à la COMPILATION, sur les types déclarés.
7. Le piège du nombre variable d'arguments — Ajoutez une surcharge à nombre variable d'arguments à côté d'une surcharge à un argument. Appelez avec un seul argument et déterminez laquelle est retenue.
8. Au fil rouge — Ajoutez à Mediatheque un identifiant unique généré automatiquement pour chaque document. Vérifiez qu'il reste unique après création de mille documents.

C'est réussi quand

• ✓ Votre compteur donne 5 sans qu'aucun objet ne le stocke
• ✓ Vous expliquez l'erreur de la méthode statique en parlant de this
• ✓ Vous prédisez correctement quelle surcharge est appelée dans les trois cas

Correction

public class Document {
  private static int nombreCreés = 0;      /* UNE seule copie */
  private final String titre;              /* une copie par objet */

  public Document(String titre) {
      this.titre = titre;
      nombreCreés++;                        /* partagé */
  }
  public static int getNombreCreés() { return nombreCreés; }
}

Document.getNombreCreés()    → 5     /* la bonne façon */
unDocument.getNombreCreés()  → 5     /* compile, mais TROMPEUR */

public static void afficher() {
  System.out.println(titre);   /* ERREUR : non-static variable titre
                                  cannot be referenced from a static
                                  context */
}

public static Optional<Document> depuisLigne(String ligne) {
  String[] champs = ligne.split(";");
  if (champs.length != 3) return Optional.empty();   /* refus PROPRE */
  try {
      return Optional.of(new Document(champs[0], champs[1],
                                      Integer.parseInt(champs[2])));
  } catch (NumberFormatException e) {
      return Optional.empty();
  }
}

void afficher(long x)   { System.out.println("long"); }
void afficher(double x) { System.out.println("double"); }

afficher(5);        → « long »   /* int s'élargit d'abord en long */

void traiter(String s) { }
void traiter(Object o) { }
traiter(null);      → « String » /* le type le plus SPÉCIFIQUE gagne */

void f(Integer i) { }
void f(String s)  { }
f(null);            → ERREUR : reference to f is ambiguous

void chercher(String titre)       { System.out.println("un"); }
void chercher(String... criteres)  { System.out.println("plusieurs"); }

chercher("Dune");   → « un »

/* la forme à nombre variable est le DERNIER recours :
 le compilateur essaie d'abord sans conversion,
 puis avec élargissement, puis avec autoboxing,
 et seulement ensuite avec varargs */