Visibilité et accesseurs

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 */