Modélisation UML

Point de départ

// ── Un diagramme, décrit sous forme de données ────────────────────────────
const DIAGRAMME = {
  classes: [
    { nom: "Document", abstraite: true,
      attributs: [{ v: "-", nom: "titre", type: "String" }],
      methodes:  [{ v: "+", nom: "decrire", type: "String", abstraite: true }] },
    { nom: "Livre", herite: "Document", implemente: ["Empruntable"],
      attributs: [{ v: "-", nom: "isbn", type: "long" },
                  { v: "+", nom: "NB_MAX", type: "int", statique: true }],
      methodes:  [{ v: "+", nom: "decrire", type: "String" }] },
    { nom: "Bibliotheque",
      attributs: [{ v: "-", nom: "nom", type: "String" }],
      methodes:  [] },
    { nom: "Lecteur", attributs: [{ v: "-", nom: "nom", type: "String" }], methodes: [] },
  ],
  relations: [
    { de: "Bibliotheque", vers: "Livre", type: "composition", multiplicite: "*" },
    { de: "Lecteur", vers: "Livre", type: "agregation", multiplicite: "*" },
    { de: "Livre", vers: "Lecteur", type: "association", multiplicite: "0..1" },
  ],
};

// ── 1. Du diagramme au code ───────────────────────────────────────────────
function versJava(d) {
  const lignes = [];
  for (const c of d.classes) {
    let entete = (c.abstraite ? "abstract " : "") + "class " + c.nom;
    if (c.herite) entete += " extends " + c.herite;
    if (c.implemente) entete += " implements " + c.implemente.join(", ");
    lignes.push("public " + entete + " {");

    const VISIBILITE = { "-": "private", "+": "public", "#": "protected", "~": "" };
    for (const a of c.attributs) {
      lignes.push("    " + [VISIBILITE[a.v], a.statique ? "static final" : "", a.type, a.nom]
        .filter(Boolean).join(" ") + ";");
    }
    // ← à écrire : traduire les relations dont cette classe est l'origine.
    //   « 1 » et « 0..1 » donnent un attribut simple, « * » donne une List.
    lignes.push("}");
    lignes.push("");
  }
  return lignes.join("\n");
}

// ── 2. Du code au diagramme ───────────────────────────────────────────────
const SOURCES = {
  Panier: [
    "class Panier {",
    "  private List<Article> articles;",
    "  Panier(List<Article> articles) { this.articles = articles; }",   // reçus
    "}",
  ],
  Maison: [
    "class Maison {",
    "  private List<Piece> pieces = new ArrayList<>();",
    "  Maison(int n) { for (int i=0;i<n;i++) pieces.add(new Piece()); }", // créées
    "}",
  ],
};

function versDiagramme(nom, source) {
  const texte = source.join("\n");
  const champ = /private List<(\w+)>/.exec(texte);
  if (!champ) return { de: nom, type: "aucune relation détectée" };
  // ← à écrire : agrégation ou composition ? Regardez QUI CRÉE les objets.
  return { de: nom, vers: champ[1], type: "à déterminer", multiplicite: "*" };
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Complétez versJava pour les trois multiplicités.
// 2. Complétez versDiagramme : le critère est « qui crée les objets ».
// 3. Écrivez un contrôle de multiplicité : un livre emprunté par deux
//    lecteurs simultanément viole le 0..1 du diagramme.

console.log(versJava(DIAGRAMME));

Solution

const DIAGRAMME = {
  classes: [
    { nom: "Document", abstraite: true,
      attributs: [{ v: "-", nom: "titre", type: "String" }], methodes: [] },
    { nom: "Livre", herite: "Document", implemente: ["Empruntable"],
      attributs: [{ v: "-", nom: "isbn", type: "long" },
                  { v: "+", nom: "NB_MAX", type: "int", statique: true }], methodes: [] },
    { nom: "Bibliotheque", attributs: [{ v: "-", nom: "nom", type: "String" }], methodes: [] },
    { nom: "Lecteur", attributs: [{ v: "-", nom: "nom", type: "String" }], methodes: [] },
  ],
  relations: [
    { de: "Bibliotheque", vers: "Livre", type: "composition", multiplicite: "*" },
    { de: "Lecteur", vers: "Livre", type: "agregation", multiplicite: "*" },
    { de: "Livre", vers: "Lecteur", type: "association", multiplicite: "0..1" },
  ],
};

const VISIBILITE = { "-": "private", "+": "public", "#": "protected", "~": "" };

function versJava(d) {
  const lignes = [];
  for (const c of d.classes) {
    let entete = (c.abstraite ? "abstract " : "") + "class " + c.nom;
    if (c.herite) entete += " extends " + c.herite;
    if (c.implemente) entete += " implements " + c.implemente.join(", ");
    lignes.push("public " + entete + " {");

    for (const a of c.attributs) {
      lignes.push("    " + [VISIBILITE[a.v], a.statique ? "static final" : "", a.type, a.nom]
        .filter(Boolean).join(" ") + ";");
    }

    const sortantes = d.relations.filter((r) => r.de === c.nom);
    for (const r of sortantes) {
      const pluriel = r.vers.toLowerCase() + "s";
      if (r.multiplicite === "*" || r.multiplicite === "1..*") {
        // Une multiplicité multiple devient une collection. En COMPOSITION,
        // le tout crée ses parties : la liste est initialisée sur place et
        // final. En AGRÉGATION, elle est reçue par le constructeur.
        const init = r.type === "composition" ? " = new ArrayList<>()" : "";
        const finalite = r.type === "composition" ? "final " : "";
        lignes.push("    private " + finalite + "List<" + r.vers + "> " + pluriel + init + ";");
      } else if (r.multiplicite === "0..1") {
        lignes.push("    private " + r.vers + " " + r.vers.toLowerCase() +
                    ";   // peut être null");
      } else {
        lignes.push("    private final " + r.vers + " " + r.vers.toLowerCase() + ";");
      }
    }
    lignes.push("}");
    lignes.push("");
  }
  return lignes.join("\n");
}

console.log("— 1. du diagramme au code —");
console.log(versJava(DIAGRAMME));

console.log("— 2. du code au diagramme —");
const SOURCES = {
  Panier: ["class Panier {", "  private List<Article> articles;",
           "  Panier(List<Article> articles) { this.articles = articles; }", "}"],
  Maison: ["class Maison {", "  private List<Piece> pieces = new ArrayList<>();",
           "  Maison(int n) { for (int i=0;i<n;i++) pieces.add(new Piece()); }", "}"],
};

function versDiagramme(nom, source) {
  const texte = source.join("\n");
  const champ = /private (?:final )?List<(\w+)>/.exec(texte);
  if (!champ) return { de: nom, type: "aucune relation détectée" };
  const partie = champ[1];
  // LE critère : qui crée les objets ? Un « new Partie() » à l'intérieur
  // signale une composition ; une réception en paramètre, une agrégation.
  const cree = new RegExp("new " + partie + "\\s*\\(").test(texte);
  const recu = new RegExp("\\(\\s*List<" + partie + ">").test(texte);
  const type = cree ? "composition" : recu ? "agrégation" : "indéterminé";
  return { de: nom, vers: partie, type, multiplicite: "*",
           indice: cree ? "crée ses parties" : "les reçoit en paramètre" };
}

for (const [nom, src] of Object.entries(SOURCES)) {
  const r = versDiagramme(nom, src);
  console.log("   " + r.de.padEnd(10) + (r.type === "composition" ? "◆" : "◇") +
              "──── " + r.vers.padEnd(9) + r.multiplicite.padEnd(4) +
              r.type.padEnd(13) + "(" + r.indice + ")");
}
console.log("   Le même attribut List<X> donne deux relations différentes : la");
console.log("   nuance n'est pas dans le type, elle est dans QUI CRÉE.");

console.log("");
console.log("— 3. contrôle des multiplicités —");
// Le diagramme dit : Livre 0..1 Lecteur. Deux emprunteurs sont donc interdits.
const emprunts = [
  { livre: "Dune", lecteur: "Ana" },
  { livre: "Ubik", lecteur: "Bo" },
  { livre: "Dune", lecteur: "Cy" },     // viole le 0..1
];
const parLivre = new Map();
for (const e of emprunts) {
  parLivre.set(e.livre, [...(parLivre.get(e.livre) ?? []), e.lecteur]);
}
for (const [livre, lecteurs] of parLivre) {
  const ok = lecteurs.length <= 1;
  console.log("   " + livre.padEnd(6) + lecteurs.length + " lecteur(s) : " +
    lecteurs.join(", ") + (ok ? "   conforme au 0..1" : "   VIOLE le 0..1 du diagramme"));
}
console.log("   Sans la multiplicité, ce cas serait passé inaperçu jusqu'à ce");
console.log("   qu'un utilisateur s'en plaigne.");

Avant de commencer

• Les TP 1 à 7 : la médiathèque en état de marche
• Un outil de diagramme, ou du papier

Énoncé

1. Rétro-modéliser — Dessinez le diagramme de classes de votre médiathèque telle qu'elle est aujourd'hui. Classes, attributs, méthodes publiques, et les relations entre elles.
2. Nommer les relations — Pour chaque trait de votre diagramme, dites s'il s'agit d'un héritage, d'une composition, d'une agrégation ou d'une simple association, et justifiez. Indice : La question qui tranche entre composition et agrégation : si le tout disparaît, la partie disparaît-elle aussi ?
3. Les cardinalités — Annotez chaque association de ses cardinalités. Vérifiez ensuite dans le code que chacune est réellement appliquée.
4. Ce que le diagramme révèle — Repérez sur votre dessin : une classe qui connaît trop de monde, une relation dans les deux sens, un cycle de dépendances. Corrigez-en un dans le code.
5. Concevoir en amont — Nouvelle exigence : gérer les adhérents et les emprunts avec dates. Dessinez le modèle AVANT d'écrire une ligne. Discutez-en à deux, dessin contre dessin.
6. Le diagramme de séquence — Dessinez le déroulement d'un emprunt : qui appelle qui, dans quel ordre, et où la règle métier est vérifiée. Trouvez si la vérification est au bon endroit.
7. Coder puis comparer — Implémentez ce que vous avez dessiné, puis rétro-modélisez à nouveau. Listez les écarts et dites, pour chacun, qui avait raison — le dessin ou le code.

C'est réussi quand

• ✓ Vous distinguez composition et agrégation sur un exemple de votre propre code
• ✓ Vos cardinalités sont réellement appliquées, ou bien vous savez dire où elles ne le sont pas
• ✓ Vous listez au moins deux écarts entre le dessin initial et le code final

Correction

┌──────────────────┐          ┌──────────────────┐
│   Mediatheque    │◆────────▶│    Document      │
├──────────────────┤ 1    0..*├──────────────────┤
│ -documents: List │          │ #titre: String   │
├──────────────────┤          │ #disponible: bool│
│ +ajouter()       │          ├──────────────────┤
│ +chercher()      │          │ +emprunter()     │
│ +penalite()      │          │ +penaliteParJour()│ {abstract}
└──────────────────┘          └────────△─────────┘
                                     │
                      ┌──────────────┼──────────────┐
                   ┌──┴───┐      ┌───┴──┐      ┌────┴───┐
                   │Livre │      │ Dvd  │      │ Revue  │
                   └──────┘      └──────┘      └────────┘

◆── composition   △── héritage   - privé  # protégé  + public

COMPOSITION (losange PLEIN) : le tout POSSÈDE la partie
si le tout disparaît, la partie disparaît
Mediatheque ◆── Document ? discutable : un document peut être
transféré ailleurs → plutôt une AGRÉGATION

AGRÉGATION (losange VIDE) : le tout RÉFÉRENCE la partie
Emprunt ◇── Adherent : l'adhérent survit à l'emprunt

la vraie composition, ici :
Emprunt ◆── DateEmprunt : la date n'existe que par l'emprunt

Adherent 1 ──── 0..* Emprunt 0..* ──── 1 Document

class Emprunt {
  private final Adherent adherent;      /* agrégation */
  private final Document document;      /* agrégation */
  private final LocalDate debut;
  private LocalDate retour;             /* null tant que non rendu */
}

/* l'erreur fréquente : mettre l'emprunteur DANS Document
 → un document ne peut alors avoir qu'un emprunt, jamais d'historique */

Interface   Mediatheque   Document   Adherent
  │            │             │          │
  │─emprunter─▶│             │          │
  │            │──peutEmprunter()───────▶│   quota atteint ?
  │            │◀────true────────────────│
  │            │──emprunter()▶│              disponible ?
  │            │◀───true──────│
  │            │─── new Emprunt() ───▶
  │◀───ok──────│

la règle « un adhérent ne dépasse pas 5 emprunts » est chez
l'ADHÉRENT, pas dans Mediatheque : c'est lui qui la connaît

écarts typiques après implémentation :
- une classe utilitaire non prévue (validation, formatage)
- une interface extraite pour pouvoir tester
- une relation bidirectionnelle prévue, rendue unidirectionnelle
  (la bidirectionnelle est pénible à maintenir cohérente)
- une méthode prévue, jamais appelée → supprimée

le CODE a souvent raison sur le détail,
le DESSIN a souvent raison sur la structure