Hogyan írjuk fel helyesen az equals metódust…

// Példa a minimálisan helyes equals felülírására
class MyClass {
    private int id;
    private String name;

    public MyClass(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override // Kötelező annotáció
    public boolean equals(Object o) {
        // 1. Azonosítás ellenőrzése
        if (this == o) return true;
        // 2. null és osztályegyezőség ellenőrzése
        // A getClass() használata szigorú ellenőrzéshez
        if (o == null || getClass() != o.getClass()) return false;
        // 3. típuskonverzió
        MyClass myClass = (MyClass) o;
        // 4. Jelentős mezők összehasonlítása
        return id == myClass.id &&
               // Az Objects.equals() használata az objektumok összehasonlításához (null figyelembe véve)
               Objects.equals(name, myClass.name);
    }
}

A equals helyes felülírásának szabályai (az Object.equals szerződés szerint):

Reflexivitás: Minden nem null értékű x esetén, x.equals(x)-nek true-t kell adnia.
Szimmetria: Minden nem null értékű x és y esetén, x.equals(y) akkor és csak akkor true, ha y.equals(x) is true.
Tranzitivitás: Minden nem null értékű x, y, és z esetén, ha x.equals(y) és y.equals(z) is true, akkor x.equals(z) is true.
Konzisztencia: Minden nem null értékű x és y esetén, a többszöri x.equals(y) hívás ugyanazt az eredményt adja, amíg az összehasonlítandó adatok nem változnak.
Minden nem null értékű x esetén, x.equals(null)-nak false-t kell adnia.

Ajánlott az Objects.equals(obj1, obj2) használata az objektumok biztonságos összehasonlításához, mivel helyesen kezeli a null értékeket.

Mindig írja felül a hashCode()-t, ha az equals()-t felülírja, az általános Object.hashCode szerződés szerint: ha két objektum egyenlő az equals(Object) módszer szerint, akkor a hashCode() által visszaadott értékük ugyanaz kell legyen. A fordított nem kötelező. Ennek a szabálynak a be nem tartása hibás kollekció működést eredményezhet, például HashMap, HashSet.

// Példa a megfelelő hashCode() implementációra a MyClass esetében
class MyClass {
    private int id;
    private String name;

    // ... konstruktor és equals mint fent ...

    @Override
    public int hashCode() {
        // Az Objects.hash() használata a hash kód egyszerű kiszámításához
        return Objects.hash(id, name);
    }
}

Az equals és hashCode metódusokat automatikusan generálhatja az IDE (IntelliJ IDEA, Eclipse), ami jó gyakorlat.

Az instanceof használata az getClass() helyett csak akkor ajánlott, ha a osztály hierarchiájának része, és azt szeretné, hogy a szuper- és alosztály példányai egyenlőnek számítsanak, ha az állapotuk megegyezik. Általában azonban a szigorúbb getClass() használata ajánlott.

Hogyan írjuk fel helyesen az equals metódust Java-ban?