Будут ли эквивалентны объекты разных классов с одинаковыми значениями полей

Эквивалентность объектов разных классов

Короткий ответ: Нет, не будут эквивалентны — даже если объекты разных классов имеют одинаковые значения полей, они не будут равны при стандартной реализации метода equals(). Это одна из фундаментальных концепций объектно-ориентированного программирования в Java.

Почему объекты разных классов не эквивалентны

Идентичность типа — это ключевой принцип в Java:

• Два объекта разных классов — это объекты разных типов
• Даже если их поля совпадают, они остаются разными сущностями
• equals() по умолчанию проверяет именно тип объекта перед сравнением значений

Пример проблемы

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class Employee {
    String name;
    int age;

    Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

// Использование
Person person = new Person("John", 30);
Employee employee = new Employee("John", 30);

// Результат
boolean equal = person.equals(employee); // false
// Они имеют одинаковые значения, но это разные типы

Стандартная реализация equals()

По умолчанию метод equals() из класса Object выглядит так:

public boolean equals(Object obj) {
    return this == obj; // Сравнение только по ссылке (identity)
}

Это означает, что объекты равны только если это один и тот же объект в памяти.

Однако, когда мы переопределяем equals(), первая проверка обычно такая:

public class Person {
    String name;
    int age;

    @Override
    public boolean equals(Object obj) {
        // Проверка типа — ПЕРВАЯ проверка!
        if (!(obj instanceof Person)) {
            return false; // Разный класс = не равны
        }
        
        Person other = (Person) obj;
        return this.name.equals(other.name) && this.age == other.age;
    }
}

Видишь? Первая строка в реализации — это проверка instanceof Person. Если объект не является Person, сразу возвращается false.

Правильный подход

Всегда проверяй тип в начале:

public class Person {
    String name;
    int age;

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;              // Одна ссылка
        if (obj == null) return false;             // Null-проверка
        if (!(obj instanceof Person)) return false;  // Проверка типа
        
        Person other = (Person) obj;
        return this.name.equals(other.name) && this.age == other.age;
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

Что происходит в Collections

Это особенно важно при работе с коллекциями:

Set<Person> people = new HashSet<>();
Person p1 = new Person("John", 30);
Employee e1 = new Employee("John", 30);

people.add(p1);
people.add(e1);

people.size(); // 2 (потому что разные типы)

Контракт equals() в Java

В документации Java явно сказано, что реализация equals() должна соответствовать этим правилам:

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-безопасность: x.equals(null) всегда false

Любая попытка сравнивать объекты разных типов нарушает эти принципы.

Выводы

• Объекты разных классов НЕ эквивалентны, даже с одинаковыми полями
• Это гарантируется при правильной реализации equals(), которая проверяет тип через instanceof
• Контракт equals() требует проверки типа для сохранения симметричности
• Всегда сравнивай тип при переопределении equals()