Efficace Java 3rd Edition Chapitre 3 Méthodes communes à tous les objets

[Effective Java 3rd Edition](https://www.amazon.co.jp/Effective-Java-%E7%AC%AC3%E7%89%88-%E3%], qui est un livre indispensable pour les utilisateurs Java intermédiaires et supérieurs. 82% B8% E3% 83% A7% E3% 82% B7% E3% 83% A5% E3% 82% A2% E3% 83% BB% E3% 83% 96% E3% 83% AD% E3% 83% 83% E3% 82% AF-ebook / dp / B07RHX1K53) a une version Kindle, donc je vais le résumer.

Précédent: Création et disparition d'objets en vigueur dans le chapitre 2 de Java 3rd Edition Suivant: Classes et interfaces efficaces du chapitre 4 de Java 3rd Edition

Point 10 Lorsque vous remplacez les égaux, suivez le contrat général

• Si vous remplacez est égal à la mauvaise manière, les conséquences peuvent être désastreuses.
• Le moyen le plus simple d'éviter les problèmes est de ne pas passer outre.

La bonne façon de procéder consiste à ne pas remplacer si l'une des conditions suivantes est remplie:

• Chaque instance de la classe est intrinsèquement unique. --La classe n'a pas à fournir une vérification «d'équivalence logique». --La superclasse a déjà remplacé égal à égal et le comportement de la superclasse est approprié pour cette classe, --Il est certain que la classe est private ou package private et que sa méthode equals n'est pas appelée.

La méthode equals implémente la relation d'équivalence et possède les propriétés suivantes:

--Reflective: pour null, x.equals (x) doit retourner true pour toute valeur de référence x. --Contraste: x.equals (y) doit retourner vrai seulement si y.equals (x) retourne vrai pour toutes les valeurs de référence non nulles x et y. .. --Transitional: pour toutes les valeurs de référence non nulles x, y, z, si x.equals (y) et y.equals (z) retournent true, alors x.equals ( z) doit retourner true. --Constant: Pour toute valeur de référence non nulle x, y, plusieurs appels à x.equals (y) seront systématiquement mis à vrai si les informations utilisées dans la comparaison d'égaux n'ont pas changé. Doit renvoyer ou renvoyer systématiquement false. --Pour toute valeur de référence x non nulle, x.equals (null) doit renvoyer false.

[Good]Exemple de remplacement égal

public final class PhoneNumber {
    private final short areaCode, prefix, lineNum;

    public PhoneNumber(int areaCode, int prefix, int lineNum) {
        this.areaCode = rangeCheck(areaCode, 999, "area code");
        this.prefix = rangeCheck(prefix, 999, "prefix");
        this.lineNum = rangeCheck(lineNum, 9999, "line num");
    }

    private static short rangeCheck(int val, int max, String arg) {
        if (val < 0 || val > max) {
            throw new IllegalArgumentException(arg + ": " + val);
        }
        return (short) val;
    }

    //[Bon exemple] Remplacer l'exemple d'égalité
    @Override
    public boolean equals(Object o) {
        if (o == this) {
            //Est-ce une référence à votre propre objet?
            return true;
        }
        if (!(o instanceof PhoneNumber)) {
            //Est-ce le bon type?
            return false;
        }
        //Cast avec le bon type
        PhoneNumber pn = (PhoneNumber) o;
        //Correspond-il à chacun des plis significatifs?
        return pn.lineNum == lineNum && pn.prefix == prefix && pn.areaCode == areaCode;
    }
}

Méthode Equals générée automatiquement par IntelliJ

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        PhoneNumber that = (PhoneNumber) o;
        return areaCode == that.areaCode &&
                prefix == that.prefix &&
                lineNum == that.lineNum;
    }

• En utilisant le framework AutoValue de Google, equals et hashCode sont automatiquement générés par des annotations.

Élément 11 Toujours remplacer hashCode lors de la substitution égal à

contrat de méthode de hachage

• Si la méthode hashCode est appelée à plusieurs reprises sur le même objet pendant que l'application est en cours d'exécution, la méthode hashCode doit toujours renvoyer la même valeur sauf s'il y a un changement dans les informations de l'objet utilisé dans la comparaison égale. Cette valeur ne doit pas nécessairement correspondre pour une exécution de la même application et une autre.
• Si les deux objets sont égaux par la méthode equals (Obeject), l'appel de la méthode hashCode sur chacun des deux objets doit produire le même résultat entier.
• Si les deux objets ne sont pas égaux à la méthode equals (Object), il n'est pas nécessaire que l'appel de la méthode hashCode pour chacun des deux objets produise des résultats entiers différents. Toutefois, le programmeur doit être conscient que la production de résultats entiers différents pour des objets inégaux peut améliorer les performances de la table de hachage.

Exemple de remplacement de hashCode

    //[Bon exemple] Exemple de remplacement de hashCode
    @Override
    public int hashCode() {
        int result = Short.hashCode(areaCode);
        result = 31 * result + Short.hashCode(prefix);
        result = 31 * result + Short.hashCode(lineNum);
        return result;
    }

• «31» est traditionnellement choisi car il s'agit d'un nombre premier impair et de bonnes performances.
• Le hachage de Guava a peu de collisions. ――Le hashCode ci-dessous fait du boxing / unboxing, donc les performances ne sont pas très bonnes.

Méthode HashCode générée automatiquement par IntelliJ

    @Override
    public int hashCode() {
        return Objects.hash(areaCode, prefix, lineNum);
    }

Élément 12 Toujours remplacer toString

• Pour toutes les classes instanciables que vous créez, remplacez l'implémentation toString de l'Object si la superclasse ne l'a pas déjà remplacée. —— Cela rend la classe plus facile à utiliser et utile pour le débogage.
• La méthode toString doit renvoyer une description concise et utile de l'objet dans un format esthétique et agréable.

Point 13 Remplacer soigneusement le clone

• L'interface clonable indique que la classe autorise la réplication.
• La méthode de clonage d'Object est protégée, mais les classes qui implémentent Cloneable sont censées fournir une méthode de clonage public qui fonctionne bien. --Clone ne doit pas être fourni car les classes immuables font des doublons inutiles.

Méthode de clonage d'une classe qui n'a pas de référence à un état mutable

//Mettre en œuvre clonable
public final class PhoneNumber implements Cloneable {
//réduction
    @Override
    public PhoneNumber clone() {
        try {
            return (PhoneNumber) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError(); //Ça ne peut pas arriver
        }
    }

Méthode de clonage d'une classe avec une référence à un état mutable

public class Stack implements Cloneable {
//réduction
    @Override
    public Stack clone() {
        try {
            Stack result = (Stack) super.clone();
            //Clonez le tableau et placez-le dans une variable membre.
            result.elements = elements.clone();
            return result;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }

Point 14 Envisager de mettre en œuvre Comparable

• L'interface Comparable, qui indique qu'elle a un ordre naturel, n'a qu'une seule méthode, compareTo.

Comparable avec la méthode de construction du comparateur

public final class PhoneNumber implements Comparable<PhoneNumber> {
//réduction
    private static final Comparator<PhoneNumber> COMPARATOR =
            Comparator.comparingInt((PhoneNumber pn) -> pn.areaCode)
            .thenComparingInt(pn -> pn.prefix)
            .thenComparingInt(pn -> pn.lineNum);

    @Override
    public int compareTo(PhoneNumber pn) {
        return COMPARATOR.compare(this, pn);
    }