Objets, références et égalité en Java

Une variable Java contient une valeur. La question importante est de savoir si cette valeur est une donnée ordinaire ou une référence qui mène à un objet. Dans les deux cas, l’affectation copie cette valeur.

Données primitives et références d’objets

Java possède huit types primitifs : byte, short, int, long, float, double, char et boolean. Une variable de type primitif contient directement sa donnée. Une variable de type référence contient une référence à un objet ou la valeur spéciale null. Les classes comme String, Scanner et ArrayList, tes propres classes et les tableaux sont des types référence.

Dans new Counter(), Java crée un objet, exécute son constructeur et produit une référence. L’affectation stocke cette référence dans c. Dessine la variable sous forme de boîte avec une flèche menant à un objet distinct. Chaque évaluation de new crée un objet distinct, même lorsque les arguments sont identiques.

Copie la valeur, puis suis le résultat

Avec les types primitifs, modifier la variable copiée laisse la première variable inchangée :

int a = 5;
int b = a;
b = b + 1;

La dernière ligne lit 5 dans b, ajoute 1 et stocke 6 dans b. La valeur de a reste 5.

Pour un exemple avec une référence, utilise cette petite classe :

class Counter {
    private int value;

    Counter() { this.value = 0; }
    Counter(int value) { this.value = value; }
    void increase() { value++; }
    int value() { return value; }
}

Suis maintenant ces instructions :

Counter first = new Counter();
Counter second = first;
second.increase();
System.out.println(first.value()); // 1

Seule la première ligne crée un compteur. La deuxième copie la référence : l’appel de méthode modifie donc l’unique compteur auquel les deux variables donnent accès. Pour créer un compteur indépendant avec les mêmes données, écris new Counter(first.value()). Copier une variable n’appelle pas de constructeur.

Classes enveloppes et chaînes immuables

Chaque type primitif possède une classe enveloppe, comme Integer, Double, Boolean ou Character. Les variables de type enveloppe contiennent des références ou null. Java peut convertir automatiquement une valeur primitive en objet enveloppe et inversement ; ces conversions sont appelées autoboxing et unboxing. Les listes contiennent des références : une liste d’entiers est donc une ArrayList<Integer>.

String est aussi un type référence, mais ses objets sont immuables : leurs caractères ne peuvent pas changer après leur création.

String s = "java";
String t = s;
t = t.toUpperCase();

Ici, s référence toujours « java » et t référence « JAVA ». La dernière ligne affecte le résultat à t ; elle ne modifie pas la chaîne originale partagée. Les méthodes de String peuvent réutiliser l’objet original lorsqu’aucune modification n’est nécessaire.

Afficher un objet utilise sa méthode toString(). Sans redéfinition, le résultat hérité prend une forme comme Counter@7e9e5f8a : nom de classe, @ et code de hachage hexadécimal. Définis toString() lorsque l’affichage doit montrer les données de l’objet.

Deux variables qui référencent le même objet sont des alias. Un alias donne un autre chemin vers des données existantes. Pour suivre un programme, distingue les variables des objets auxquels elles donnent accès.

Une mutation change les données ; une réaffectation change une variable

Une mutation modifie l’état d’un objet, par exemple son poids enregistré. Une réaffectation place une autre valeur dans une variable. Pour une variable de type référence, elle change donc sa flèche.

Utilise une boîte dont le poids est en kilogrammes :

class Box {
    private double weight;
    Box(double weight) { this.weight = weight; }
    double getWeight() { return weight; }
    void setWeight(double weight) { this.weight = weight; }
}

Suis cette séquence :

Box a = new Box(2);
Box b = a;
b.setWeight(5);
b = new Box(7);

1. Dessine la variable a pointant vers l’objet A, de poids 2.
2. Dessine b pointant vers ce même objet A. Il n’y a toujours qu’une boîte.
3. Remplace le poids dans l’objet A par 5. Les deux chemins donnent maintenant accès au poids 5.
4. Crée l’objet B de poids 7 et redirige uniquement b vers lui.

À la fin, a.getWeight() vaut 5 et b.getWeight() vaut 7. La quatrième instruction ne réinitialise pas l’objet A et ne redirige pas a vers l’objet B.

L’accessibilité par référence détermine la durée de vie d’un objet

Un objet est accessible par référence tant que le programme en cours d’exécution peut suivre une chaîne de références utilisable jusqu’à lui. Cette chaîne peut passer par une variable, un champ d’objet ou un élément de liste. La disparition d’une variable locale ne suffit donc pas à rendre un objet inaccessible si une liste le contient encore.

Poursuis le suivi avec a = null;. Dans cet exemple, aucun chemin accessible ne mène plus à l’objet A, qui pèse 5 kg. Sa mémoire peut être récupérée par le mécanisme de récupération de mémoire. Java récupère automatiquement la mémoire des objets inaccessibles, mais le ramasse-miettes choisit le moment ; l’affectation ne garantit pas une récupération immédiate. L’objet B reste accessible par b.

Tu ne libères pas les objets Java manuellement. Lorsqu’un programme perd sa dernière référence utilisable vers un objet, il perd aussi la possibilité de consulter ou de modifier les données de cet objet.

Trouve les alias cachés

Des alias apparaissent lorsqu’un objet est ajouté à une liste, transmis à une méthode, renvoyé par une méthode ou stocké dans le champ d’un autre objet. Chaque opération peut transmettre une référence. Avant de modifier un objet reçu d’ailleurs, identifie les autres parties du code qui peuvent encore y accéder.

Un bogue courant commence par cette idée : « J’ai copié la variable, j’ai donc ma propre boîte. » Utilise un nouvel objet lorsque les modifications doivent être indépendantes. Pour diagnostiquer le bogue, compte séparément les créations d’objets et les affectations, nomme chaque objet une seule fois et traite chaque instruction dans l’ordre. Ne redessine pas un objet simplement parce qu’une deuxième variable pointe maintenant vers lui.

La valeur null signifie qu’une référence ne mène à aucun objet. Elle est utile pour un résultat absent, mais un programme doit gérer cette absence avant d’essayer d’utiliser un objet.

Absent et vide sont deux choses différentes

String text = ""; référence une véritable chaîne de longueur 0. String text = null; ne référence aucune chaîne : il n’y a donc aucun objet sur lequel appeler length().

Une variable de type primitif ne peut pas contenir null : int x = null; ne se compile pas. Une variable de type enveloppe peut le contenir : Integer x = null; se compile. Convertir cet objet enveloppe en valeur primitive avec int y = x; lève une NullPointerException, car l’unboxing nécessite un objet enveloppe.

Les champs reçoivent des valeurs par défaut lors de la création d’un objet. Les champs de type référence valent initialement null, les champs numériques 0 et les champs booléens false, jusqu’à ce que l’initialisation leur affecte d’autres valeurs. Les variables locales n’ont pas de valeur par défaut. Lire une variable locale avant de lui affecter une valeur provoque une erreur de compilation, comme « variable might not have been initialized ».

Trouve la référence manquante

Appeler une méthode d’instance par l’intermédiaire de null, accéder ainsi à un champ d’instance ou lire ainsi la longueur d’un tableau lève une NullPointerException à l’exécution. Par exemple :

String name = null;
System.out.println(name.length());

Lis le numéro de ligne de l’exception, puis identifie quelle référence manquait sur cette ligne. Les messages explicites sont activés par défaut depuis Java 15. Un message peut indiquer Cannot invoke "SimpleDate.getYear()" because "this.birthday" is null. Les noms locaux peuvent apparaître sous forme de repères comme <local4>, selon les détails de la compilation. Remonte jusqu’au constructeur, à l’affectation ou à la recherche qui aurait dû fournir l’objet.

Afficher une variable String dont la valeur est null affiche « null » ; la concaténer produit un texte comme « Hi null ». Ces opérations n’ont pas besoin d’appeler une méthode d’instance par l’intermédiaire de cette variable. Elles peuvent révéler des données manquantes avant l’échec d’un appel de méthode ultérieur.

Vérifie avant d’utiliser

L’opérateur && utilise une évaluation en court-circuit : il n’évalue le côté droit que si le côté gauche est vrai.

if (name != null && name.length() > 0) {
    System.out.println(name);
}

Lorsque name vaut null, le premier test est faux et length() n’est pas exécuté. Inverser les deux tests supprime cette protection : l’appel de méthode serait exécuté en premier.

La chaîne fixe est un objet connu : son equals peut donc recevoir null et renvoyer faux. command.equals("quit") échoue lorsque command vaut null. De même, x.equals(null) ne permet pas de vérifier si x existe : cet appel nécessite déjà un objet.

Fais de l’absence un choix de conception explicite

Initialise un champ de liste avec new ArrayList<>() afin qu’une collection vide soit immédiatement disponible. Si une recherche renvoie null pour signifier « introuvable », documente ce résultat et vérifie-le à l’endroit de l’appel. Évite de remplir chaque champ avec des objets arbitraires simplement pour faire disparaître une exception : fournis l’objet dont le programme a besoin ou donne à l’absence un sens clair que le code appelant prend en charge.

Java transmet chaque argument par valeur. Un paramètre est une nouvelle variable qui reçoit une copie de la valeur de l’argument. Pour un argument objet, la valeur copiée est une référence.

Modifier le paramètre ou modifier l’objet ?

Un paramètre de type primitif possède sa propre donnée :

static void addTen(int n) {
    n = n + 10;
}

Si x vaut 5, l’appel à addTen(x) laisse x à 5. Seul le paramètre local n prend la valeur 15.

Un paramètre de type référence peut donner accès au même objet que la variable de l’appelant. Supposons que Person.growOlder() augmente l’âge enregistré :

static void celebrate(Person p) {
    p.growOlder();
}

static void replace(Person p) {
    p = new Person("Bo", 30);
}

Pendant celebrate(ana), le paramètre p et la variable ana sont des alias. L’âge modifié reste visible ensuite. Pendant replace(ana), l’affectation à p ne redirige que ce paramètre. La variable ana de l’appelant référence toujours la personne initiale. Une méthode qui échange deux paramètres de type référence connaît la même limite : elle échange ses propres copies, et non les variables de l’appelant.

Recevoir un objet d’une autre classe

Un dispositif d’accès peut lire la taille d’une personne et tenir son propre compte des contrôles. Cette classe attend une personne non nulle dont la méthode getHeight() renvoie des centimètres :

class HeightGate {
    private int minHeight;
    private int checks;

    HeightGate(int minHeight) {
        this.minHeight = minHeight;
    }

    boolean allowIn(Person p) {
        checks++;
        return p.getHeight() >= minHeight;
    }

    int checks() { return checks; }
}

Pour un dispositif réglé à 120 cm, contrôler des personnes de 132 cm et de 115 cm renvoie respectivement vrai et faux. Le dispositif indique ensuite 2 contrôles. Il lit la taille de la personne par une méthode publique et modifie son propre compteur.

Recevoir un autre objet de la même classe

Dans SimpleDate.before(SimpleDate other), this est la date qui reçoit l’appel et other est l’argument. Une classe peut lire les champs privés de tout objet de cette même classe.

Pour les champs day, month et year, compare dans l’ordre :

boolean before(SimpleDate other) {
    if (year != other.year) {
        return year < other.year;
    }
    if (month != other.month) {
        return month < other.month;
    }
    return day < other.day;
}

Pour le 14 mars 2001 et le 2 novembre 2001, les années sont égales et le mois 3 est inférieur au mois 11 : la première date est donc antérieure. La comparaison de dates égales renvoie faux, car aucune ne précède l’autre.

Person.olderThan(other) peut déléguer à birthday.before(other.birthday). La comparaison des dates appartient à la classe qui possède les données des dates. Les méthodes qui appellent des méthodes d’instance sur un paramètre ont besoin d’un argument non nul ; vérifie-le ou indique cette exigence dans la documentation de la méthode.

Une méthode qui renvoie un objet renvoie une référence. Son type indique quel genre d’objet peut être renvoyé, mais pas si cet objet est nouveau, partagé ou absent. Le rôle de la méthode doit rendre ce choix clair.

Créer un résultat

Une méthode de fabrique fournit un objet. Elle peut en créer un ou réutiliser un objet existant. Ici, chaque appel crée délibérément un ticket distinct :

class TicketMachine {
    private int nextNumber = 1;

    Ticket issue() {
        Ticket t = new Ticket(nextNumber);
        nextNumber++;
        return t;
    }
}

La machine attend un constructeur Ticket qui stocke son numéro. Trois appels créent trois tickets numérotés 1, 2 et 3. Renvoyer une variable locale est sans risque : sa référence est copiée vers l’appelant, qui peut maintenir l’objet accessible après la sortie de portée de la variable locale.

Une méthode de copie promet un objet indépendant. Dans la classe Counter :

Counter copy() {
    return new Counter(this.value);
}

Après Counter a = new Counter(4); Counter b = a.copy(); b.increase();, a.value() vaut 4 et b.value() vaut 5. Remplacer a.copy() par a partagerait le compteur.

Une méthode peut aussi construire un objet calculé. Pour un Point avec les champs double x et y :

Point midpoint(Point other) {
    return new Point((x + other.x) / 2.0,
                     (y + other.y) / 2.0);
}

Les points (2 ; 4) et (6 ; 10) donnent le point (4,0 ; 7,0). La méthode calcule chaque coordonnée et transmet les deux à un nouveau point ; aucun des points initiaux ne change.

Renvoyer un objet déjà stocké

La méthode findByName d’un registre devrait renvoyer la personne stockée correspondante si les appelants doivent travailler avec cette entrée. Créer new Person(name, 0) renverrait des données de remplacement inventées et empêcherait les modifications ultérieures d’atteindre le registre.

Une recherche peut renvoyer null lorsqu’il n’existe aucune correspondance :

Person p = register.findByName("Lin");
if (p != null) {
    System.out.println(p);
} else {
    System.out.println("Not found");
}

Si p est la personne stockée, les modifications effectuées par p modifient aussi la personne à laquelle le registre donne accès. Une instruction return ne copie pas l’objet.

Garde le contrôle de l’état interne mutable

Supposons que Person.getBirthday() renvoie son champ SimpleDate et que cette date possède des mutateurs. Un appelant peut alors modifier la date de naissance de la personne sans appeler de méthode de Person. C’est une exposition de l’état mutable.

Pour protéger le champ, renvoie une nouvelle date construite à partir de ses valeurs :

SimpleDate getBirthday() {
    return new SimpleDate(birthday.getDay(),
                          birthday.getMonth(),
                          birthday.getYear());
}

Cette version exige qu’un objet représentant la date de naissance ait été initialisé. D’autres conceptions utilisent une date immuable ou proposent des requêtes spécifiques sans accesseur de date. Choisis le comportement de chaque méthode : find partage normalement une entrée stockée, tandis que copy crée un objet indépendant. Le nom court d’un accesseur ne garantit pas à lui seul une protection.

La composition construit une classe à l’aide de champs dont les types sont d’autres classes. Elle exprime une relation de possession : une personne a une date de naissance ; un cours a un enseignant. L’objet englobant stocke une référence à l’objet contenu.

Crée et relie les objets

Un constructeur peut recevoir une date existante :

class Person {
    private String name;
    private SimpleDate birthday;

    Person(String name, SimpleDate birthday) {
        this.name = name;
        this.birthday = birthday;
    }

    boolean olderThan(Person other) {
        return birthday.before(other.birthday);
    }

    public String toString() {
        return name + ", born " + birthday;
    }
}

L’appel new Person("Ana", new SimpleDate(14, 3, 2001)) crée d’abord une date, puis donne sa référence à la personne. Autre possibilité : un constructeur de personne peut recevoir le jour, le mois et l’année et créer la date dans son corps. Avec cette approche, l’appelant ne conserve pas de référence à cette date nouvellement créée.

Délègue le travail à l’objet contenu

L’appel birthday.before(other.birthday) demande à l’objet date de comparer les dates. Person n’a pas besoin de répéter les comparaisons des années, des mois et des jours. La concaténation dans toString() délègue elle aussi : Java appelle le toString() de l’objet date de naissance pour obtenir son texte.

Un objet date peut aider à calculer l’âge. Commence par soustraire l’année de naissance de l’année en cours. Construis ensuite la date de l’anniversaire de cette année et soustrais un si la date actuelle la précède. Une personne née le 14 mars 2001 a 24 ans le 1er janvier 2026 : la différence entre les années est de 25, mais l’anniversaire n’est pas arrivé. Le 14 mars 2026, l’anniversaire est arrivé et l’âge est de 25 ans. Garder la comparaison des dates dans SimpleDate évite de reproduire ses règles dans chaque méthode de personne.

Décide si l’objet contenu est partagé

Le constructeur ci-dessus stocke directement son argument. Si deux personnes reçoivent une même SimpleDate mutable, les deux champs de date de naissance pointent vers la même date. Modifier cette date affecte les deux personnes.

Un constructeur défensif peut copier le jour, le mois et l’année de la date reçue. Une date immuable n’a pas de méthode qui modifie son état et garde ses valeurs fixes ; des champs primitifs simples peuvent être final. Copier à l’entrée est important même si un accesseur renvoie ensuite une copie, car l’appelant initial peut encore détenir l’objet reçu.

Gère les liens facultatifs

Un Course peut ne pas encore avoir d’enseignant. Si cet état a un sens, teacherName() peut vérifier le champ et renvoyer « pas encore d’enseignant ». Sinon, exige un enseignant à la construction.

Dans course.getTeacher().getName(), chaque appel d’instance nécessite un objet : si le cours est nul, l’appel à getTeacher() échoue ; si l’enseignant est nul, c’est l’appel à getName() qui échoue. Une méthode du cours peut garder ce test d’absence à un seul endroit et éviter que chaque appelant ait besoin de connaître la même chaîne.

Une ArrayList<Person> est un objet dont les éléments contiennent des références à des personnes. La liste contrôle la succession de ses entrées ; chaque personne contrôle ses propres champs. Ce sont deux types de modifications distincts.

Ajoute un objet et accède-y à nouveau

ArrayList<Person> people = new ArrayList<>();
people.add(ana);
people.get(0).growOlder();

Ce code nécessite import java.util.ArrayList; et une personne ana existante et non nulle. add copie la référence. L’appel à growOlder() accède à la même personne que ana : la modification de l’âge est donc visible par les deux chemins. Ici, la liste ne crée jamais de deuxième personne.

Tu peux créer un objet au moment de l’ajouter : people.add(new Person("Lin", 1998));, à l’aide d’un constructeur de personne qui accepte un nom et une année de naissance. La liste donne alors au programme un chemin vers cette nouvelle personne par get ou par une boucle. Les arguments de type d’une liste doivent être des types référence : utilise donc ArrayList<Integer> pour les entiers.

Calcule à partir d’objets et sélectionne un objet

Supposons qu’une liste contienne des colis de 2,5 kg, 4,0 kg et 1,5 kg. Une boucle additionne le poids de chaque colis :

double total = 0;
for (Parcel p : parcels) {
    total += p.getWeight();
}

Les sommes cumulées sont 2,5, 6,5 et 8,0 kg. Pour sélectionner le colis le plus lourd, il faut une référence et une comparaison :

Parcel heaviest = parcels.get(0);
for (Parcel p : parcels) {
    if (p.getWeight() > heaviest.getWeight()) {
        heaviest = p;
    }
}

Cette sélection suppose que la liste n’est pas vide. Le résultat est l’objet colis de 4,0 kg : l’appelant peut donc aussi utiliser ses autres méthodes. Pour une liste vide, décide du résultat à renvoyer en cas d’absence avant de lire l’élément 0.

Parcours toutes les entrées lors d’une recherche

Une recherche par nom dans une classe qui stocke people peut utiliser :

Person findByName(String name) {
    for (Person p : people) {
        if (p.getName().equals(name)) {
            return p;
        }
    }
    return null;
}

Cette version attend des personnes non nulles dont les noms sont non nuls. La première correspondance est renvoyée immédiatement. Le return null final vient après la boucle : une comparaison infructueuse sur la première personne n’exclut pas des correspondances ultérieures.

contains, indexOf et remove(Object) effectuent leurs recherches avec equals. Si Person hérite d’une égalité fondée sur l’identité, une personne nouvellement construite ne correspondra pas à une personne existante simplement parce que leurs champs correspondent.

Retire une entrée sans détruire l’objet

Un objet peut apparaître deux fois dans une liste ou dans plusieurs listes. Retirer une entrée ne détruit pas l’objet et ne supprime pas les autres références vers lui.

Ne retire pas directement des entrées de la même liste pendant un parcours for-each. Cela peut déclencher une ConcurrentModificationException. Recueille d’abord les candidats, puis retire-les :

ArrayList<Person> toRemove = new ArrayList<>();
for (Person p : people) {
    if (p.getName().equals("Lin")) {
        toRemove.add(p);
    }
}
people.removeAll(toRemove);

Le parcours se termine avant que le contenu de la liste change. removeAll utilise l’égalité : elle retire donc les entrées égales aux candidats recueillis.

Une classe peut conserver une liste dans un champ privé et proposer des opérations qui décrivent son rôle. Une liste de lecture stocke des morceaux, les compte et calcule leur durée. Les appelants ne devraient pas avoir à gérer directement sa liste.

Initialise et encapsule la collection

Cette liste de lecture attend des objets Song non nuls avec une méthode seconds() :

import java.util.ArrayList;

class Playlist {
    private String name;
    private ArrayList<Song> songs;

    Playlist(String name) {
        this.name = name;
        this.songs = new ArrayList<>();
    }

    void add(Song song) { songs.add(song); }
    int count() { return songs.size(); }

    int totalSeconds() {
        int total = 0;
        for (Song song : songs) {
            total += song.seconds();
        }
        return total;
    }
}

Sans new ArrayList<>(), le champ de type référence reste à null ; le premier appel à add échoue alors. Une liste vide est déjà un objet utilisable, de taille 0.

Pour des morceaux de 210 s, 185 s et 247 s, count() renvoie 3. La somme passe de 210 à 395, puis à 642 s. La division entière par 60 donne 10 minutes, avec un reste de 42 secondes. Une méthode longest() peut sélectionner et renvoyer le morceau de 247 s, selon le même schéma de sélection de référence que pour le colis le plus lourd. Définis un résultat en cas d’absence pour une liste de lecture vide.

Protège le contenu de la liste par des méthodes

Garder songs privé bloque l’accès direct au champ, mais return songs; expose cette liste elle-même. Un appelant pourrait appeler clear() et contourner toutes les règles de la liste de lecture.

Des opérations spécifiques comme add, count et totalSeconds laissent la responsabilité à la liste de lecture. Sa méthode add pourrait imposer une taille maximale ou refuser les doublons avec songs.contains(song). Pour détecter les doublons par leur contenu, il faut que equals de la classe des morceaux définisse les champs qui rendent deux morceaux égaux.

Lorsqu’un constructeur reçoit une liste initiale, copie sa structure avec this.songs = new ArrayList<>(initialSongs);. Stocker directement le paramètre permettrait à l’appelant de conserver un alias vers la liste interne de la liste de lecture.

Une nouvelle liste peut toujours partager les morceaux

Une requête peut renvoyer new ArrayList<>(songs). C’est une copie superficielle : un nouvel objet liste qui contient les références aux morceaux existants.

Une requête songsLongerThan(200) crée une nouvelle liste de résultats, parcourt les morceaux stockés et ajoute ceux dont la durée dépasse 200 s. Pour les trois morceaux ci-dessus, elle renvoie ceux de 210 s et de 247 s. Lorsque les valeurs des morceaux doivent aussi être indépendantes, copie les morceaux mutables ou rends Song immuable.

L’identité indique si deux références mènent au même objet. L’égalité de contenu indique si des objets ont les mêmes données pertinentes, selon les règles de leur classe. Deux objets livre distincts peuvent décrire le même titre et la même année de publication sans être identiques.

Choisis la bonne comparaison

Chaque classe hérite de equals(Object) de Object. Cette méthode par défaut vérifie l’identité. Java n’inspecte pas automatiquement tous les champs d’une nouvelle classe.

String a = "java";
String b = new String("java");
System.out.println(a == b);      // false
System.out.println(a.equals(b)); // true

new String crée un objet distinct, tandis que String.equals compare ses caractères. La comparaison de texte est sensible à la casse : "Java".equals("java") vaut faux. equalsIgnoreCase permet une comparaison sans tenir compte de la casse lorsque c’est la règle voulue.

Pourquoi l’identité semble parfois comparer le contenu

Des littéraux de chaîne égaux partagent un objet chaîne : "java" == "java" vaut donc vrai. Cela peut masquer un bogue dans un petit test. Un texte obtenu par saisie ou construit pendant l’exécution d’un programme ne partage pas nécessairement cet objet. Utilise equals pour le contenu, quelle que soit la façon dont le texte a été obtenu.

Les comparaisons d’objets enveloppes présentent un piège similaire :

Integer a = 127, b = 127;
Integer c = 1000, d = 1000;
System.out.println(a == b);      // true
System.out.println(c.equals(d)); // true

L’autoboxing réutilise des objets Integer pour les valeurs de −128 à 127. Le fait que des valeurs plus grandes partagent ou non un objet ne constitue pas une règle de comparaison numérique portable. Dans une configuration standard, les deux objets enveloppes de valeur 1 000 sont distincts, mais un cache plus grand est autorisé. Utilise equals sur les objets enveloppes pour comparer leurs valeurs, ou compare des valeurs primitives. Si un côté de == est un int, Java effectue l’unboxing de l’objet enveloppe et compare les valeurs numériques ; l’unboxing d’un objet enveloppe nul échoue.

Décide quels champs définissent l’égalité

Pour un catalogue de livres, le titre et l’année de publication pourraient définir l’égalité, tandis que l’emprunteur actuel serait ignoré. Ces champs sélectionnés doivent déterminer le fonctionnement de la méthode d’égalité. Un autre programme pourrait choisir un identifiant unique à la place ; la règle utile dépend de ce que représentent ses objets.

Une ArrayList utilise equals dans contains, indexOf et remove(Object). Supposons que Book se contente de stocker des champs et hérite de equals. Ajouter un new Book("Dune", 1965) ne rend pas contains(new Book("Dune", 1965)) vrai : la seconde expression crée un autre objet. Redéfinir l’égalité selon le titre et l’année permet à une recherche de trouver ce contenu égal.

HashSet et HashMap utilisent aussi hashCode pour réduire le nombre d’objets candidats avant de vérifier l’égalité. Définir une égalité de contenu nécessite donc aussi une règle de hachage cohérente.

Une méthode d’égalité doit remplacer la méthode equals(Object) héritée et comparer les champs qui définissent le sens de ton objet. La bonne signature compte autant que les comparaisons qu’elle contient.

Un schéma complet pour l’égalité

Cette classe utilise le titre et l’année, accepte un titre nul et garde ses champs d’égalité fixes :

import java.util.Objects;

final class Book {
    private final String title;
    private final int year;

    Book(String title, int year) {
        this.title = title;
        this.year = year;
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof Book)) {
            return false;
        }
        Book book = (Book) other;
        return year == book.year
            && Objects.equals(title, book.title);
    }

    @Override
    public int hashCode() {
        return Objects.hash(title, year);
    }
}

Lis equals en quatre étapes. Le test d’identité accepte immédiatement le même objet. Le test de type rejette tout ce qui n’est pas un livre, y compris null. Le transtypage fournit une variable Book par laquelle les champs peuvent être lus. L’expression finale vérifie les deux champs d’égalité.

Le type du paramètre est Object, et non Book. Écrire equals(Book other) surcharge le nom avec une autre méthode et laisse la méthode héritée equals(Object) inchangée. Un appel direct peut alors sembler fonctionner tandis que ArrayList.contains utilise toujours l’identité. Grâce à @Override, le compilateur détecte cette erreur de signature.

À partir de Java 16, le test de type et le transtypage peuvent être combinés : if (!(other instanceof Book book)) { return false; }. Après un test réussi, book est disponible pour comparer les champs.

Adapte les comparaisons aux types des champs

Utilise == pour les champs entiers, caractères et booléens. Utilise equals d’un objet pour comparer son contenu. Pour un champ objet qui peut être nul, Objects.equals(a, b) renvoie vrai si les deux valeurs sont nulles, faux si une seule est nulle, et utilise sinon l’égalité.

Pour les champs double, Double.compare(x, other.x) == 0 traite les valeurs spéciales de façon cohérente : deux NaN sont considérés comme égaux, et les zéros positif et négatif sont distingués. Associe ce choix à une règle de hachage compatible. L’opérateur == appliqué directement aux nombres à virgule flottante traite NaN différemment.

Vérifie le contrat d’égalité

Pour les références non nulles, l’égalité doit être :

• Réflexive : x.equals(x) vaut vrai.
• Symétrique : x.equals(y) et y.equals(x) donnent le même résultat.
• Transitive : si x est égal à y et y à z, alors x est égal à z.
• Cohérente : les appels répétés donnent le même résultat tant que les données comparées restent inchangées.
• Fausse pour null : x.equals(null) vaut faux.

Deux livres pour « Dune », 1965, sont considérés comme égaux ; remplacer l’une des années par 1984 les rend inégaux. Un livre ne doit pas être considéré comme égal à une chaîne contenant son titre : la chaîne rejetterait le livre, ce qui romprait la symétrie.

Certaines implémentations utilisent other == null || getClass() != other.getClass() pour le test de type. Ce test rejette les classes effectives différentes. instanceof peut accepter les sous-classes ; pour la classe finale ci-dessus, aucune sous-classe n’existe et les deux tests donnent le même résultat.

Un code de hachage est un entier utilisé pour réduire le champ d’une recherche. HashSet et HashMap l’utilisent pour trouver des objets candidats, puis utilisent equals pour confirmer une correspondance. Ce n’est pas un identifiant unique d’objet.

Le contrat fonctionne dans un seul sens

Des objets égaux doivent renvoyer le même code de hachage. Des objets inégaux peuvent aussi partager un code ; c’est une collision. Une collision ne les rend pas égaux, car l’égalité est toujours vérifiée.

Un code de hachage doit rester cohérent tant que les informations utilisées par equals restent inchangées. Avec une implémentation correcte, des codes de hachage différents excluent l’égalité, mais des codes égaux ne la prouvent pas.

Lorsqu’une classe redéfinit equals mais hérite de Object.hashCode, des objets égaux distincts reçoivent souvent des codes différents. Un ensemble peut alors conserver les deux, et une recherche dans une Map avec une nouvelle clé égale peut échouer. Cet échec précis n’est pas garanti, car les codes hérités d’objets différents peuvent entrer en collision. Corrige le contrat au lieu de compter sur l’échec d’une recherche particulière.

Calcule à partir des champs d’égalité

Pour la classe de livre qui compare le titre et l’année :

@Override
public int hashCode() {
    return Objects.hash(title, year);
}

Importe java.util.Objects. Les mêmes valeurs de champs produisent maintenant le même résultat. Un ensemble de livres conserve une entrée après l’ajout de deux livres égaux, et une Map peut retrouver une valeur à l’aide d’une nouvelle clé livre égale.

Objects.hash combine les codes de hachage des champs à l’aide de 31. Pour « Dune », le code de hachage de la chaîne est 2 141 736. La combinaison de ce titre et de l’année 1965 donne 31 multiplié par la somme de 31 et de 2 141 736, puis ajoute 1965 : le résultat est 66 396 742.

Le hachage des chaînes utilise aussi 31. Pour « ab », les codes de caractères 97 et 98 donnent 97 multiplié par 31 plus 98, soit 3 105. Des calculs plus longs peuvent dépasser la plage de int et produire un retour par dépassement de capacité : un code de hachage négatif est donc normal.

Ne modifie pas la clé pendant son stockage

Supposons que l’année d’un livre soit mutable et influe sur son code de hachage. Après son insertion dans un ensemble, modifier l’année peut faire échouer contains(book) même avec cette même référence : la recherche utilise désormais un autre code. L’ensemble peut toujours indiquer une taille de 1.

Garde les champs d’égalité stables tant qu’un objet est un élément d’ensemble ou une clé de Map. S’ils doivent changer, retire l’objet tant que ses anciennes valeurs s’appliquent encore, modifie-le et insère-le à nouveau. Tenter de le retirer seulement après la modification peut entraîner le même problème de recherche.

Une égalité générée exige tout de même un bon choix de données

Java 16 et les versions ultérieures prennent en charge les records, comme record Book(String title, int year) {}. Un record génère les accesseurs title() et year(), ainsi que l’égalité, le hachage et une représentation lisible sous forme de chaîne à partir de tous ses composants. Les champs des composants sont final. Cet exemple constitue une valeur immuable utile, car ses composants sont une chaîne et un entier ; un record contenant une liste mutable partagerait toujours l’état de cette liste.

Pour les classes ordinaires, un IDE peut générer ensemble equals et hashCode. Sélectionne les champs qui définissent l’égalité voulue et garde les deux méthodes cohérentes lorsque ce choix change.

L’interface utilisateur lit les entrées et affiche les sorties. La logique applicative stocke les données et applique les règles. Dans une conception séparée, des valeurs sont transmises à la logique, qui renvoie des résultats ; les classes de logique n’utilisent ni Scanner ni System.out.

Relie les objets dans main

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    TemperatureLog log = new TemperatureLog();
    UserInterface ui = new UserInterface(scanner, log);
    ui.start();
}

Avec import java.util.Scanner;, cet assemblage crée un lecteur d’entrée, un journal et une interface. Il appartient à la classe qui contient le point d’entrée du programme. UserInterface stocke les objets reçus dans des champs afin que chaque commande utilise le même journal.

Renvoie des valeurs que tout appelant peut utiliser

Un journal peut proposer add(double celsius), count(), average() et max(). Les relevés 18,5, 21,0 et 19,5 °C ont pour somme 59,0, pour effectif 3, pour maximum 21,0 et pour moyenne environ 19,6667 °C. L’interface peut arrondir la moyenne renvoyée avec Math.round(average * 10) / 10.0 et afficher 19,7 °C.

Renvoyer le nombre facilite les vérifications directes. Une méthode nommée printAverage() qui se contente d’afficher lie un calcul à la sortie sur la console, ce qui rend sa réutilisation moins pratique.

Pour une boucle de commande simple, supposons que add accepte les températures valides et que count renvoie leur nombre :

class UserInterface {
    private Scanner scanner;
    private TemperatureLog log;

    UserInterface(Scanner scanner, TemperatureLog log) {
        this.scanner = scanner;
        this.log = log;
    }

    void start() {
        while (true) {
            String command = scanner.nextLine();
            if ("quit".equals(command)) {
                break;
            }
            if ("count".equals(command)) {
                System.out.println(log.count());
            }
        }
    }
}

La boucle gère l’interaction. Elle demande un résultat au journal et l’affiche sans savoir comment les relevés sont stockés. Une commande de moyenne devrait gérer un journal vide selon le résultat documenté de la logique ou vérifier count() avant d’appeler une méthode qui exige des relevés.

Valide à la bonne limite

La logique peut faire renvoyer faux à add sans stocker un relevé inférieur à −273,15 °C. Chaque appelant bénéficie alors de la même règle de validation des données. L’interface décide comment signaler ce rejet et demander une nouvelle saisie. Transformer une entrée non numérique en message d’erreur utile relève aussi de l’interface.

Utilise un seul Scanner pour System.in et transmets-le aux lecteurs. Plusieurs scanners peuvent se disputer les données d’entrée mises en tampon, et en fermer un ferme le flux d’entrée sous-jacent. Confie la durée de vie du scanner partagé au code responsable des entrées du programme.

La logique peut ensuite prendre en charge une autre interface par les mêmes méthodes publiques. La réutilisation est possible lorsque les calculs et les règles de validité sont accessibles sous forme de résultats de méthodes, indépendamment d’une boucle de commande particulière.

Un programme séparé peut évoluer par petites modifications successives. Donne à la logique une méthode utile, vérifie-la directement, puis relie-la à une commande qui recueille ses entrées et affiche son résultat.

Ajoute une requête à la logique

Un TemperatureLog qui stocke une ArrayList<Double> readings initialisée peut compter les relevés supérieurs à un seuil :

int countAbove(double limit) {
    int count = 0;
    for (double reading : readings) {
        if (reading > limit) {
            count++;
        }
    }
    return count;
}

La comparaison stricte exclut les relevés exactement égaux au seuil. Pour 18,5, 21,0, 19,5 et 23,0 °C, countAbove(20.0) renvoie 2. Place la comparaison dans le journal afin que chaque appelant bénéficie de la même règle.

La commande de l’interface lit un seuil, appelle log.countAbove(limit) et affiche le nombre obtenu. Si chaque commande devient longue, décompose start() en méthodes auxiliaires privées comme addReading() et showStatistics(). Ces méthodes organisent l’interaction ; elles ne déplacent pas les règles de validation des données hors du journal.

Vérifie sans saisir de commandes

Crée l’objet de logique et appelle ses méthodes avec des valeurs dont tu connais les résultats :

TemperatureLog log = new TemperatureLog();
log.add(18.5);
log.add(21.0);
log.add(19.5);
log.add(23.0);
System.out.println(log.count() == 4);
System.out.println(log.average() == 20.5);
System.out.println(log.max() == 23.0);
System.out.println(log.countAbove(20.0) == 2);

La somme est de 82,0, donc la moyenne attendue est de 20,5. Ces valeurs particulières ont des représentations binaires exactes, ce qui rend ces tests directs d’égalité adaptés à l’exemple. Vérifie aussi un journal vide selon son comportement documenté, un seuil égal à un relevé et le rejet d’une entrée incorrecte sans modification du nombre de relevés. Les outils de test automatisés reposent sur la même idée : une entrée connue et un résultat attendu.

Ne modifie le stockage que s’il permet toujours de répondre aux requêtes

Une interface qui n’appelle que average, count et max n’a pas besoin de savoir si le journal contient une liste. Des champs pour la somme cumulée, le nombre de relevés et le maximum peuvent répondre à ces trois requêtes sans conserver chaque relevé.

Une requête countAbove(limit) avec un seuil quelconque exige davantage d’informations. Les échantillons 18, 22, 23 et 20, 20, 23 ont la même somme de 63, le même effectif de 3 et le même maximum de 23, mais leurs nombres de valeurs supérieures à 20 sont respectivement 2 et 1. Ne conserver que ces trois agrégats fait perdre la distinction. Les méthodes publiques décrivent ce qui doit continuer à fonctionner après une modification du stockage.

Combine les idées de conception

Un livre de recettes peut posséder une liste privée de recettes. Chaque recette peut contenir des ingrédients mesurés en grammes et un temps de cuisson en minutes. L’égalité peut servir à détecter les doublons, tandis qu’une interface ajoute, affiche et recherche des recettes par les méthodes du livre. Une copie de la liste de résultats peut protéger son contenu tout en partageant les objets recette ; décide si les appelants peuvent modifier ces recettes.

Travaille par petites étapes : implémente une méthode, vérifie-la, puis ajoute sa commande. Si une modification casse un résultat existant, reviens à un état fonctionnel et isole cette modification avant d’ajouter une autre fonctionnalité.