Exceptions

Point de départ

// ── 1. Version à code de retour ───────────────────────────────────────────
const OK = 0, DEJA_EMPRUNTE = -1, INCONNU = -2;

class BibliothequeCodes {
  constructor(livres) { this.livres = livres; }
  emprunter(titre, qui) {
    const l = this.livres.find((x) => x.titre === titre);
    if (!l) return INCONNU;
    if (!l.disponible) return DEJA_EMPRUNTE;
    l.disponible = false; l.par = qui;
    return OK;
  }
}

// ── 2. Version à exceptions ───────────────────────────────────────────────
class LivreIndisponibleException extends Error {
  constructor(titre, detenteur) {
    super("« " + titre + " » est déjà emprunté par " + detenteur);
    this.name = "LivreIndisponibleException";
    // ← à écrire : transporter la donnée utile (le détenteur actuel)
  }
}

class BibliothequeExceptions {
  constructor(livres) { this.livres = livres; }
  emprunter(titre, qui) {
    const l = this.livres.find((x) => x.titre === titre);
    if (!l) throw new Error("titre inconnu : " + titre);
    // ← à écrire : lever LivreIndisponibleException si déjà emprunté
    l.disponible = false; l.par = qui;
  }
}

// Trois niveaux d'appel : le niveau intermédiaire n'écrit RIEN.
function servirUnLecteur(biblio, titre, qui) { traiterDemande(biblio, titre, qui); }
function traiterDemande(biblio, titre, qui) { biblio.emprunter(titre, qui); }

// ── 3. Le catch vide, instrumenté ─────────────────────────────────────────
let avales = 0;
function catchVide(action) {
  try { action(); } catch (e) { avales++; }        // le pire code du cours
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Appelez emprunter() deux fois SANS tester le code de retour, et
//    constatez ce qui n'est pas dit.
// 2. Complétez l'exception personnalisée et son levée. Vérifiez que le
//    niveau intermédiaire n'a rien eu à écrire.
// 3. Faites vingt emprunts dont plusieurs impossibles, à travers catchVide :
//    combien d'échecs ont disparu, et qu'en sait le programme ?

const catalogue = () => [
  { titre: "Dune", disponible: true, par: null },
  { titre: "Ubik", disponible: true, par: null },
];
const b = new BibliothequeCodes(catalogue());
b.emprunter("Dune", "Ana");
b.emprunter("Dune", "Bo");
console.log("   état : " + JSON.stringify(b.livres[0]));

Solution

const OK = 0, DEJA_EMPRUNTE = -1, INCONNU = -2;

class BibliothequeCodes {
  constructor(livres) { this.livres = livres; }
  emprunter(titre, qui) {
    const l = this.livres.find((x) => x.titre === titre);
    if (!l) return INCONNU;
    if (!l.disponible) return DEJA_EMPRUNTE;
    l.disponible = false; l.par = qui;
    return OK;
  }
}

class LivreIndisponibleException extends Error {
  constructor(titre, detenteur) {
    super("« " + titre + " » est déjà emprunté par " + detenteur);
    this.name = "LivreIndisponibleException";
    // La donnée utile voyage avec l'exception : c'est le troisième défaut
    // du code de retour, réglé.
    this.detenteur = detenteur;
    this.titre = titre;
  }
}

class BibliothequeExceptions {
  constructor(livres) { this.livres = livres; }
  emprunter(titre, qui) {
    const l = this.livres.find((x) => x.titre === titre);
    if (!l) throw new Error("titre inconnu : " + titre);
    if (!l.disponible) throw new LivreIndisponibleException(titre, l.par);
    l.disponible = false; l.par = qui;
  }
}

// Le niveau intermédiaire : PAS UNE LIGNE consacrée aux erreurs.
function traiterDemande(biblio, titre, qui) { biblio.emprunter(titre, qui); }
function servirUnLecteur(biblio, titre, qui) { traiterDemande(biblio, titre, qui); }

const catalogue = () => [
  { titre: "Dune", disponible: true, par: null },
  { titre: "Ubik", disponible: true, par: null },
];

console.log("— 1. code de retour, non testé —");
const b = new BibliothequeCodes(catalogue());
b.emprunter("Dune", "Ana");
b.emprunter("Dune", "Bo");        // échoue, et personne ne le sait
b.emprunter("Solaris", "Cy");     // titre inconnu, idem
console.log("   " + JSON.stringify(b.livres[0]));
console.log("   Bo croit avoir emprunté Dune, qui est chez Ana. Le programme n'a");
console.log("   rien dit, et rien dans son état ne permet de s'en apercevoir.");

console.log("");
console.log("— 2. exceptions, à travers trois niveaux —");
const c = new BibliothequeExceptions(catalogue());
servirUnLecteur(c, "Dune", "Ana");
console.log("   premier emprunt : ok");
try {
  servirUnLecteur(c, "Dune", "Bo");
} catch (e) {
  if (e instanceof LivreIndisponibleException) {
    console.log("   refusé : " + e.message);
    console.log("   donnée exploitable : détenteur = " + e.detenteur +
                " — on peut proposer une réservation");
  } else {
    console.log("   autre échec : " + e.message);
  }
}
console.log("   traiterDemande n'a écrit AUCUNE ligne sur les erreurs : l'exception");
console.log("   l'a traversé sans lui demander son avis.");

console.log("");
console.log("— l'ordre des catch —");
try {
  try { throw new LivreIndisponibleException("Dune", "Ana"); }
  catch (e) {
    // En Java, un catch (Exception e) placé AVANT le type précis rendrait
    // celui-ci inatteignable, et le compilateur le refuserait. On attrape
    // donc toujours du plus précis au plus général.
    if (e instanceof LivreIndisponibleException) throw new Error("relancée après traitement précis");
  }
} catch (e) { console.log("   " + e.message); }

console.log("");
console.log("— finally s'exécute même après un return —");
function avecFinally() {
  try { return "valeur du try"; }
  finally { console.log("   finally s'exécute — avant que la valeur ne soit rendue"); }
}
console.log("   " + avecFinally());

console.log("");
console.log("— 3. le catch vide, instrumenté —");
let avales = 0;
function catchVide(action) { try { action(); } catch (e) { avales++; } }
const d = new BibliothequeExceptions(catalogue());
const demandes = [["Dune", "Ana"], ["Dune", "Bo"], ["Ubik", "Cy"], ["Ubik", "Dee"],
                  ["Solaris", "Eve"], ["Dune", "Fay"]];
for (const [t, q] of demandes) catchVide(() => d.emprunter(t, q));
console.log("   " + demandes.length + " demandes, " + avales + " échecs AVALÉS sans trace.");
console.log("   Le programme s'est terminé normalement, avec quatre lecteurs qui");
console.log("   croient avoir un livre. C'est exactement l'état du point 1 — le");
console.log("   catch vide a rétabli tous les défauts du code de retour.");
console.log("   Si l'on ne sait pas quoi faire : ne rien écrire, et laisser remonter.");

Avant de commencer

• Les TP 1 à 6

Énoncé

1. Sans exceptions — Écrivez le chargement d'un catalogue en signalant les erreurs par des codes de retour. Comptez les lignes de traitement d'erreur par rapport aux lignes utiles.
2. Avec exceptions — Réécrivez la même chose avec des exceptions. Recomptez, et repérez où le code utile est devenu lisible d'un seul tenant.
3. Vérifiée ou non — Écrivez une exception vérifiée et une non vérifiée. Appelez les deux sans les traiter et comparez ce que dit le compilateur.
4. Le catch vide — Attrapez une exception et ne faites rien. Provoquez l'erreur et observez ce que voit l'utilisateur. Puis affichez la trace et comparez. Indice : Le pire n'est pas le plantage : c'est le programme qui continue avec des données fausses.
5. Attraper trop large — Attrapez le type le plus général possible autour d'un bloc, et faites-y survenir une erreur de programmation. Constatez ce qui est masqué.
6. L'exception qui perd sa cause — Attrapez une exception basse et relancez-en une métier SANS transmettre la cause. Comparez la trace obtenue avec celle où la cause est transmise.
7. Fermer quoi qu'il arrive — Ouvrez un fichier, provoquez une erreur avant la fermeture, et vérifiez que la ressource fuit. Corrigez avec la fermeture automatique.
8. Choisir — Pour six situations que vous listerez, décidez : code de retour, exception vérifiée, ou non vérifiée. Justifiez chaque choix en une phrase.

C'est réussi quand

• ✓ Votre version à exceptions sépare visiblement le cas nominal du traitement d'erreur
• ✓ Vous montrez un catch qui masque une erreur de programmation
• ✓ Votre trace conserve la cause d'origine sur trois niveaux
• ✓ Votre fichier est fermé même quand une exception survient

Correction

/* codes de retour : le cas nominal est NOYÉ */
int r = ouvrir(f);
if (r != 0) return r;
r = lireEntete(f);
if (r != 0) { fermer(f); return r; }
r = lireCorps(f);
if (r != 0) { fermer(f); return r; }

/* exceptions : le cas nominal se lit d'un trait */
try (Fichier f = ouvrir(chemin)) {
  lireEntete(f);
  lireCorps(f);
} catch (FormatInvalideException e) {
  journal.erreur("catalogue illisible : " + chemin, e);
}

class CatalogueIntrouvableException extends Exception { }      /* VÉRIFIÉE */
class CoteInvalideException extends RuntimeException { }       /* non */

void charger() throws CatalogueIntrouvableException { … }
/* l'appelant DOIT attraper ou déclarer : le compilateur l'exige */

void valider() { throw new CoteInvalideException(); }
/* l'appelant peut ignorer : rien ne l'oblige */

/* 1. le catch vide */
try { catalogue = charger(chemin); }
catch (IOException e) { }        /* catalogue reste null,
                                  le programme continue et
                                  plante 200 lignes plus loin */

/* 2. attraper trop large */
try { traiterTout(); }
catch (Exception e) { journal.avertir("souci mineur"); }
/* attrape aussi NullPointerException, ArrayIndexOutOfBounds…
 c'est-à-dire vos BOGUES, requalifiés en « souci mineur » */

/* SANS la cause : la trace commence au niveau métier */
catch (SQLException e) {
  throw new CatalogueException("chargement impossible");
}
→ CatalogueException: chargement impossible
  at Catalogue.charger(Catalogue.java:42)
 /* et POURQUOI ? Personne ne le saura jamais. */

/* AVEC la cause */
catch (SQLException e) {
  throw new CatalogueException("chargement impossible", e);
}
→ CatalogueException: chargement impossible
  at Catalogue.charger(Catalogue.java:42)
Caused by: SQLException: connection refused: port 5432
  at …

/* la ressource FUIT si lireTout() lève */
BufferedReader r = new BufferedReader(new FileReader(f));
String contenu = lireTout(r);
r.close();                       /* jamais atteint */

/* try-with-resources : close() est appelé DANS TOUS LES CAS */
try (BufferedReader r = new BufferedReader(new FileReader(f))) {
  return lireTout(r);
}
/* et si close() lève à son tour, l'exception d'origine est conservée,
 la seconde étant attachée comme « supprimée » */

fichier de configuration absent   → exception vérifiée (récupérable)
argument null passé à une méthode → non vérifiée (bogue de l'appelant)
recherche sans résultat           → NI l'une NI l'autre : Optional
                                  (l'absence est un cas NORMAL)
saisie utilisateur invalide       → valeur de retour ou Optional
                                  (attendu, fréquent, pas exceptionnel)
invariant interne rompu           → non vérifiée, et ne pas rattraper
disque plein à l'écriture         → vérifiée