Как реализуешь сравнение объектов через equals с учетом их типа?

Как реализуешь сравнение объектов через equals с учетом их типа

Правило equals(): контракт

Метод equals() в Java должен соответствовать следующему контракту:

1. Рефлексивность — x.equals(x) всегда true
2. Симметричность — если x.equals(y) то y.equals(x)
3. Транзитивность — если x.equals(y) и y.equals(z) то x.equals(z)
4. Консистентность — повторные вызовы дают одинаковый результат
5. Null-safety — x.equals(null) всегда false

Неправильная реализация (❌ нарушает контракт)

public class User {
    private String email;
    private String name;
    
    // ❌ ПЛОХО: не проверяет тип
    @Override
    public boolean equals(Object obj) {
        User user = (User) obj;  // ClassCastException если obj не User!
        return this.email.equals(user.email);
    }
}

// Нарушение:
User user = new User("john@ex.com", "John");
Object obj = "john@ex.com";
user.equals(obj);  // ClassCastException!

Правильная реализация (✓ соответствует контракту)

public class User {
    private String email;
    private String name;
    
    public User(String email, String name) {
        this.email = email;
        this.name = name;
    }
    
    @Override
    public boolean equals(Object obj) {
        // 1. Проверка на null
        if (obj == null) {
            return false;
        }
        
        // 2. Проверка типа объекта
        if (!(obj instanceof User)) {
            return false;
        }
        
        // 3. Безопасное приведение типа
        User other = (User) obj;
        
        // 4. Сравнение полей
        return this.email.equals(other.email) &&
               this.name.equals(other.name);
    }
    
    // Не забыть переопределить hashCode()!
    @Override
    public int hashCode() {
        return Objects.hash(email, name);
    }
}

Пошагово: как реализовать правильно

Шаг 1: Проверка на null

@Override
public boolean equals(Object obj) {
    if (obj == null) {  // Немедленно верните false
        return false;
    }
    // ...
}

Шаг 2: Проверка типа (instanceof)

@Override
public boolean equals(Object obj) {
    if (obj == null) {
        return false;
    }
    
    // instanceof вернет false если obj неправильного типа
    if (!(obj instanceof User)) {
        return false;
    }
    // ...
}

Шаг 3: Приведение типа

@Override
public boolean equals(Object obj) {
    if (obj == null) {
        return false;
    }
    
    if (!(obj instanceof User)) {
        return false;
    }
    
    // Теперь безопасно приводить тип
    User other = (User) obj;
    // ...
}

Шаг 4: Сравнение полей

@Override
public boolean equals(Object obj) {
    if (obj == null) {
        return false;
    }
    
    if (!(obj instanceof User)) {
        return false;
    }
    
    User other = (User) obj;
    
    // Сравниваем все значимые поля
    return Objects.equals(this.email, other.email) &&
           Objects.equals(this.name, other.name);
}

instanceof с приведением типа (Java 16+)

В Java 16+ можно использовать паттерн-матчинг:

// Вместо:
if (!(obj instanceof User)) {
    return false;
}
User other = (User) obj;

// Пишем:
if (!(obj instanceof User other)) {
    return false;
}
// other уже приведен к User!

Полная реализация:

@Override
public boolean equals(Object obj) {
    if (obj == null || !(obj instanceof User other)) {
        return false;
    }
    
    return Objects.equals(this.email, other.email) &&
           Objects.equals(this.name, other.name);
}

Objects.equals() для null-safe сравнения

// ❌ Может быть NullPointerException
return this.email.equals(other.email);

// ✓ Безопасно (сравнивает null значения)
return Objects.equals(this.email, other.email);

// Objects.equals() работает так:
public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}

hashCode() и equals() должны быть согласованы

public class User {
    private String email;
    private String name;
    
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof User other)) return false;
        return Objects.equals(this.email, other.email) &&
               Objects.equals(this.name, other.name);
    }
    
    // ОБЯЗАТЕЛЬНО! Если объекты равны, их hashCode должны быть одинаковы
    @Override
    public int hashCode() {
        return Objects.hash(email, name);
    }
}

// Почему это важно:
User user1 = new User("john@ex.com", "John");
User user2 = new User("john@ex.com", "John");

user1.equals(user2);           // true
user1.hashCode() == user2.hashCode();  // Должно быть true!

// Это критично для использования в HashMap, HashSet
Set<User> users = new HashSet<>();
users.add(user1);
users.add(user2);  // Без правильного hashCode это не сработает

Пример полной реализации

public class User {
    private final String email;
    private final String name;
    private final int age;
    
    public User(String email, String name, int age) {
        this.email = email;
        this.name = name;
        this.age = age;
    }
    
    @Override
    public boolean equals(Object obj) {
        // 1. Проверка на null
        if (obj == null) {
            return false;
        }
        
        // 2. Проверка типа с приведением (Java 16+)
        if (!(obj instanceof User other)) {
            return false;
        }
        
        // 3. Сравнение полей
        // email не может быть null (обычно), но лучше быть осторожным
        return Objects.equals(this.email, other.email) &&
               Objects.equals(this.name, other.name) &&
               this.age == other.age;  // primitive int
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(email, name, age);
    }
    
    @Override
    public String toString() {
        return "User{" +
                "email='" + email + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

// Тесты:
public class UserTest {
    @Test
    void testEqualsReflexivity() {
        User user = new User("john@ex.com", "John", 30);
        assertEquals(user, user);  // x.equals(x) == true
    }
    
    @Test
    void testEqualsSymmetry() {
        User user1 = new User("john@ex.com", "John", 30);
        User user2 = new User("john@ex.com", "John", 30);
        
        assertEquals(user1, user2);  // x.equals(y)
        assertEquals(user2, user1);  // y.equals(x)
    }
    
    @Test
    void testEqualsTransitivity() {
        User user1 = new User("john@ex.com", "John", 30);
        User user2 = new User("john@ex.com", "John", 30);
        User user3 = new User("john@ex.com", "John", 30);
        
        assertEquals(user1, user2);
        assertEquals(user2, user3);
        assertEquals(user1, user3);  // Транзитивность
    }
    
    @Test
    void testEqualsNull() {
        User user = new User("john@ex.com", "John", 30);
        assertNotEquals(user, null);  // x.equals(null) == false
    }
    
    @Test
    void testEqualsDifferentType() {
        User user = new User("john@ex.com", "John", 30);
        assertNotEquals(user, "john@ex.com");  // Разные типы
    }
    
    @Test
    void testHashCodeConsistency() {
        User user1 = new User("john@ex.com", "John", 30);
        User user2 = new User("john@ex.com", "John", 30);
        
        assertEquals(user1, user2);
        assertEquals(user1.hashCode(), user2.hashCode());  // Согласованность
    }
    
    @Test
    void testInHashSet() {
        User user1 = new User("john@ex.com", "John", 30);
        User user2 = new User("john@ex.com", "John", 30);
        
        Set<User> users = new HashSet<>();
        users.add(user1);
        users.add(user2);  // Не добавится, т.к. user1.equals(user2)
        
        assertEquals(1, users.size());  // Только 1 элемент
    }
}

Использование Lombok для автоматизации

import lombok.Data;
import lombok.EqualsAndHashCode;

@Data  // Генерирует equals, hashCode, toString
@EqualsAndHashCode(of = {"email", "name"})  // Какие поля использовать
public class User {
    private String email;
    private String name;
    private int age;
}

// Lombok генерирует все нужные методы:
// - equals()
// - hashCode()
// - toString()
// - getters/setters

Наследование и equals()

⚠️ Осторожно с наследованием!

public class Person {
    private String name;
    
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Person other)) return false;
        return Objects.equals(this.name, other.name);
    }
}

public class Employee extends Person {
    private String employeeId;
    
    @Override
    public boolean equals(Object obj) {
        // Проблема: Person.equals() не знает про employeeId
        // Две Employee с разными ID но одинаковыми name считаются равными
        // Это может нарушить Liskov Substitution Principle
    }
}

// Решение: используйте final классы или composition вместо наследования

Правило для equals()

                    ┌─────────────────┐
                    │ obj == null?    │
                    └────────┬────────┘
                          Да → return false
                             Нет↓
                    ┌─────────────────┐
                    │ Same type?      │
                    │ instanceof User?│
                    └────────┬────────┘
                          Нет → return false
                            Да↓
                    ┌─────────────────┐
                    │ Cast to type    │
                    │ User other = ..│
                    └────────┬────────┘
                             ↓
                    ┌─────────────────┐
                    │ Compare fields  │
                    │ Objects.equals()│
                    └────────┬────────┘
                             ↓
                    ┌─────────────────┐
                    │ return result   │
                    └─────────────────┘

Резюме

1. Всегда проверяйте null — первое условие
2. Проверьте тип через instanceof — защита от ClassCastException
3. Приведите тип — после instanceof это безопасно
4. Сравните поля через Objects.equals() — null-safe
5. Реализуйте hashCode() — согласованно с equals()
6. Напишите тесты — проверьте контракт equals()
7. Рассмотрите Lombok — автоматизация типовой работы
8. Избегайте наследования — используйте composition