Projet

Point de départ

const ENONCE = [
  "Réaliser une application de gestion de bibliothèque.",
  "Les adhérents empruntent des ouvrages pour une durée limitée.",
  "Un ouvrage peut exister en plusieurs exemplaires.",
  "Les retards donnent lieu à une pénalité.",
].join(" ");

// ── 1. Du texte aux candidats ─────────────────────────────────────────────
const NOMS = ["bibliothèque", "adhérent", "ouvrage", "durée", "exemplaire", "retard", "pénalité"];
const VERBES = ["emprunter", "rendre", "calculer", "rechercher"];

// Pour chaque nom : "classe", "attribut", ou "à decider" (question à poser).
const VERDICTS = {
  // ← à écrire, avec une justification en une ligne
};

// ── 2. Le modèle, décrit en données ───────────────────────────────────────
const MODELE = {
  classes: {
    Adherent:   { attributs: ["nom"], methodes: ["emprunter", "rendre"] },
    Ouvrage:    { attributs: ["titre", "auteur", "isbn"], methodes: [] },
    Exemplaire: { attributs: ["cote", "etat", "disponible"], methodes: ["estDisponible"] },
    Emprunt:    { attributs: ["debut", "prevu", "effectif"], methodes: ["retardEnJours", "penalite"] },
  },
  relations: [
    { de: "Adherent", vers: "Emprunt", mult: "0..*" },
    { de: "Emprunt", vers: "Exemplaire", mult: "1" },
    { de: "Exemplaire", vers: "Ouvrage", mult: "1" },
  ],
};

// Fait marcher un scénario sur le modèle et signale ce qui manque.
function verifierScenario(modele, etapes) {
  const manques = [];
  for (const e of etapes) {
    const c = modele.classes[e.classe];
    if (!c) { manques.push("classe absente : " + e.classe); continue; }
    // ← à écrire : vérifier que la méthode et les attributs requis existent
  }
  return manques;
}

const SCENARIO = [
  { classe: "Adherent",   methode: "emprunter",     attributs: [] },
  { classe: "Exemplaire", methode: "estDisponible", attributs: ["disponible"] },
  { classe: "Emprunt",    methode: "retardEnJours", attributs: ["prevu", "effectif"] },
  { classe: "Emprunt",    methode: "penalite",      attributs: [] },
  { classe: "Ouvrage",    methode: "exemplairesLibres", attributs: [] },   // manque ?
];

// ── 3. Mesurer une conception ─────────────────────────────────────────────
const PROJET_RATE = {
  Main:       { methodes: 34, attributsPublics: 12, profondeur: 0 },
  Livre:      { methodes: 0,  attributsPublics: 5,  profondeur: 0 },
  Adherent:   { methodes: 0,  attributsPublics: 4,  profondeur: 0 },
  LivrePoche: { methodes: 1,  attributsPublics: 0,  profondeur: 4 },
};
const PROJET_CORRECT = {
  Bibliotheque: { methodes: 6, attributsPublics: 0, profondeur: 0 },
  Ouvrage:      { methodes: 4, attributsPublics: 0, profondeur: 0 },
  Exemplaire:   { methodes: 5, attributsPublics: 0, profondeur: 0 },
  Emprunt:      { methodes: 5, attributsPublics: 0, profondeur: 0 },
  Adherent:     { methodes: 5, attributsPublics: 0, profondeur: 0 },
};

function auditer(nom, projet) {
  // ← à écrire : signaler la classe divine, les classes anémiques, les
  //   attributs publics et les hiérarchies de plus de trois niveaux.
  console.log("   " + nom + " : à auditer");
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Remplissez VERDICTS pour les sept noms.
// 2. Complétez verifierScenario : que manque-t-il pour mener le scénario ?
// 3. Écrivez auditer() et comparez les deux projets.

console.log(ENONCE);

Solution

const ENONCE = [
  "Réaliser une application de gestion de bibliothèque.",
  "Les adhérents empruntent des ouvrages pour une durée limitée.",
  "Un ouvrage peut exister en plusieurs exemplaires.",
  "Les retards donnent lieu à une pénalité.",
].join(" ");

console.log("— 1. du texte aux candidats —");
const VERDICTS = {
  bibliothèque: ["classe", "porte le catalogue et les règles de prêt : identité et comportement"],
  adhérent:     ["classe", "identité propre, emprunts en cours, comportement"],
  ouvrage:      ["classe", "titre, auteur, ISBN — l'oeuvre, indépendamment des copies"],
  exemplaire:   ["classe", "copie PHYSIQUE : cote, état, disponibilité. On emprunte celui-ci"],
  durée:        ["attribut", "aucun comportement, aucune identité : un champ d'Emprunt ou une constante"],
  retard:       ["attribut", "valeur CALCULÉE à partir de deux dates : une méthode d'Emprunt"],
  pénalité:     ["à décider", "montant calculé ? ou objet avec date, statut payé, historique ? QUESTION À POSER"],
};
for (const [nom, [verdict, pourquoi]] of Object.entries(VERDICTS)) {
  console.log("   " + nom.padEnd(14) + verdict.padEnd(11) + pourquoi);
}
console.log("   Et un candidat que l'énoncé ne NOMME PAS : Emprunt. Il apparaît");
console.log("   parce que « emprunter pour une durée » porte des dates — une");
console.log("   association qui porte des attributs est une classe.");

const MODELE = {
  classes: {
    Adherent:   { attributs: ["nom"], methodes: ["emprunter", "rendre"] },
    Ouvrage:    { attributs: ["titre", "auteur", "isbn"], methodes: [] },
    Exemplaire: { attributs: ["cote", "etat", "disponible"], methodes: ["estDisponible"] },
    Emprunt:    { attributs: ["debut", "prevu", "effectif"], methodes: ["retardEnJours", "penalite"] },
  },
  relations: [
    { de: "Adherent", vers: "Emprunt", mult: "0..*" },
    { de: "Emprunt", vers: "Exemplaire", mult: "1" },
    { de: "Exemplaire", vers: "Ouvrage", mult: "1" },
  ],
};

function verifierScenario(modele, etapes) {
  const manques = [];
  for (const e of etapes) {
    const c = modele.classes[e.classe];
    if (!c) { manques.push("classe absente : " + e.classe); continue; }
    if (!c.methodes.includes(e.methode)) {
      manques.push(e.classe + "." + e.methode + "() n'existe pas dans le modèle");
    }
    for (const a of e.attributs) {
      if (!c.attributs.includes(a)) manques.push(e.classe + "." + a + " manque");
    }
  }
  return manques;
}

const SCENARIO = [
  { classe: "Adherent",   methode: "emprunter",         attributs: [] },
  { classe: "Exemplaire", methode: "estDisponible",     attributs: ["disponible"] },
  { classe: "Emprunt",    methode: "retardEnJours",     attributs: ["prevu", "effectif"] },
  { classe: "Emprunt",    methode: "penalite",          attributs: [] },
  { classe: "Ouvrage",    methode: "exemplairesLibres", attributs: [] },
];

console.log("");
console.log("— 2. le scénario sur le modèle —");
const manques = verifierScenario(MODELE, SCENARIO);
for (const m of manques) console.log("   MANQUE : " + m);
console.log("   « Ana veut emprunter Dune » suppose de retrouver un exemplaire");
console.log("   LIBRE de cet ouvrage. Le modèle ne le permet pas : la relation va");
console.log("   d'Exemplaire vers Ouvrage, pas l'inverse. Il faut soit une");
console.log("   navigabilité dans les deux sens, soit une méthode de Bibliotheque.");
console.log("   Découvrir cela ICI coûte une minute ; le découvrir en codant, une refonte.");

console.log("");
console.log("— 3. mesurer une conception —");
const PROJET_RATE = {
  Main:       { methodes: 34, attributsPublics: 12, profondeur: 0 },
  Livre:      { methodes: 0,  attributsPublics: 5,  profondeur: 0 },
  Adherent:   { methodes: 0,  attributsPublics: 4,  profondeur: 0 },
  LivrePoche: { methodes: 1,  attributsPublics: 0,  profondeur: 4 },
};
const PROJET_CORRECT = {
  Bibliotheque: { methodes: 6, attributsPublics: 0, profondeur: 0 },
  Ouvrage:      { methodes: 4, attributsPublics: 0, profondeur: 0 },
  Exemplaire:   { methodes: 5, attributsPublics: 0, profondeur: 0 },
  Emprunt:      { methodes: 5, attributsPublics: 0, profondeur: 0 },
  Adherent:     { methodes: 5, attributsPublics: 0, profondeur: 0 },
};

function auditer(nom, projet) {
  const entrees = Object.entries(projet);
  const total = entrees.reduce((s, [, c]) => s + c.methodes, 0);
  const alertes = [];
  for (const [classe, c] of entrees) {
    // Classe divine : elle concentre l'essentiel des méthodes du projet.
    if (total > 0 && c.methodes / total > 0.5) {
      alertes.push(classe + " concentre " + Math.round((c.methodes / total) * 100) +
                   " % des méthodes : CLASSE DIVINE");
    }
    // Classe anémique : des données, aucun comportement.
    if (c.methodes === 0 && c.attributsPublics > 0) {
      alertes.push(classe + " n'a aucune méthode : CLASSE ANÉMIQUE");
    }
    if (c.attributsPublics > 0) {
      alertes.push(classe + " expose " + c.attributsPublics + " attributs publics");
    }
    if (c.profondeur > 3) {
      alertes.push(classe + " est à " + c.profondeur + " niveaux d'héritage : trop profond");
    }
  }
  console.log("   " + nom + " — " + entrees.length + " classes, " + total + " méthodes");
  if (alertes.length === 0) console.log("      aucune alerte");
  else for (const a of alertes) console.log("      " + a);
}

auditer("projet raté", PROJET_RATE);
auditer("projet correct", PROJET_CORRECT);
console.log("   Un modèle raté et un modèle correct se distinguent à des chiffres");
console.log("   simples : répartition des méthodes, attributs publics, profondeur.");
console.log("   Aucun ne mesure la qualité — mais tous signalent où regarder.");

Avant de commencer

• Les TP 1 à 9
• Un dépôt Git, et JUnit

Énoncé

1. L'inventaire — Listez ce que votre médiathèque fait aujourd'hui, et ce que l'énoncé demandait. Signalez explicitement les manques plutôt que de les laisser découvrir.
2. Séparer les couches — Réorganisez en trois paquetages : domaine, persistance, interface. Vérifiez qu'aucune classe du domaine n'importe rien de l'interface. Indice : Une dépendance dans le mauvais sens se voit à un import.
3. Tester le domaine — Écrivez des tests sur les règles métier : emprunt d'un document indisponible, quota d'adhérent, calcul de pénalité, retour. Un test par règle.
4. Tester les cas limites — Ajoutez les cas limites : catalogue vide, adhérent sans emprunt, retard de zéro jour, emprunt le jour même du retour, document rendu deux fois.
5. Persister — Sauvegardez et rechargez le catalogue dans un fichier. Vérifiez qu'un aller-retour complet redonne exactement l'état initial.
6. Le remplacement — Écrivez une seconde implémentation de la persistance, dans un autre format. Branchez-la SANS modifier une seule ligne du domaine.
7. Relire son propre code — Cherchez dans votre projet : un accesseur inutile, une cascade de tests de type, une classe qui fait deux choses, un catch vide. Corrigez ce que vous trouvez.
8. Préparer la soutenance — Pour trois décisions de conception, préparez la justification et l'alternative que vous avez écartée. C'est ce qui distingue un projet compris d'un projet recopié.

C'est réussi quand

• ✓ Aucune classe du domaine n'importe quoi que ce soit de l'affichage ou du stockage
• ✓ Vos tests échouent si vous cassez volontairement une règle métier
• ✓ La seconde persistance se branche sans toucher au domaine
• ✓ Vous savez défendre trois choix et nommer ce que vous avez écarté

Correction

mediatheque/
domaine/       Document, Livre, Dvd, Adherent, Emprunt, Mediatheque
persistance/   DepotDocuments (interface), DepotFichier, DepotMemoire
interface/     ConsoleUI

RÈGLE : les flèches vont vers le DOMAINE, jamais l'inverse
interface   ──▶ domaine
persistance ──▶ domaine
domaine     ──▶ RIEN

vérification mécanique :
grep -r "import.*interface\." src/domaine/   → doit être VIDE

/* dans le DOMAINE : l'interface, exprimée dans ses termes */
public interface DepotDocuments {
  void enregistrer(Document d);
  Optional<Document> parCote(String cote);
  List<Document> tous();
}

/* dans la PERSISTANCE : les implémentations */
public class DepotFichier  implements DepotDocuments { … }
public class DepotMemoire  implements DepotDocuments { … }   /* pour les tests */

/* le domaine reçoit son dépôt, il ne le CHOISIT pas */
public Mediatheque(DepotDocuments depot) { this.depot = depot; }

@Test void unDocumentIndisponibleNeSEmpruntePas() {
  Document d = new Livre("Dune", 1965);
  assertTrue(d.emprunter());
  assertFalse(d.emprunter());      /* le second échoue */
}

@Test void leQuotaEstApplique() {
  Adherent a = new Adherent("Ada");
  for (int i = 0; i < 5; i++) a.emprunter(unLivre());
  assertThrows(QuotaDepasseException.class, () -> a.emprunter(unLivre()));
}

@Test void unRetardDeZeroJourNeCoutePasRien() {
  assertEquals(0.0, new Emprunt(livre, ada, hier).penalite(aujourdHui));
}

@Test void sauvegarderPuisRechargerRedonneLeMemeEtat() {
  Mediatheque avant = uneMediathequeDeTest();
  Path f = Files.createTempFile("cat", ".txt");

  new DepotFichier(f).enregistrerTout(avant.tous());
  List<Document> apres = new DepotFichier(f).tous();

  assertEquals(avant.tous(), apres);    /* d'où l'equals du TP 6 */
}

à chercher, dans l'ordre de rentabilité :

catch (Exception e) { }          → une erreur effacée      (TP 7)
if (x instanceof …) else if …    → une méthode manquante   (TP 6)
getListe() qui renvoie le champ  → encapsulation qui fuit  (TP 3)
une classe de 400 lignes         → elle fait deux choses
un accesseur jamais appelé        → à supprimer
un commentaire qui explique COMMENT → renommer plutôt que commenter

« Pourquoi une classe abstraite Document plutôt qu'une interface ? »
→ parce qu'il y a un ÉTAT commun (titre, disponibilité) et un
constructeur à factoriser. J'aurais pris une interface si les
documents n'avaient partagé que des comportements.

« Pourquoi Emprunt est-il une classe et pas un champ de Document ? »
→ parce que la relation porte des DATES, et qu'un document a un
historique de plusieurs emprunts. Le champ interdisait l'historique.

« Pourquoi ArrayList et pas LinkedList ? »
→ je l'ai MESURÉ au TP 9 : accès par indice 12 000 fois plus rapide,
parcours 8 fois plus rapide, et je n'insère jamais en tête.