Membres de classe et surcharge

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