Динамическое связывание Java и переопределение методов

Я думаю, что ключ кроется в том, что метод equals () не соответствует стандарту: он принимает другой объект Test, а не объект Object, и, таким образом, не переопределяет метод equals (). Это означает, что вы фактически перегрузили его только для того, чтобы сделать что-то особенное, когда ему дали объект Test, а объект объекта вызывает Object.equals (Object o). Просмотр этого кода в любой среде IDE должен показать вам два метода equals () для Test.

Метод перегружен, а не переопределен. Equals всегда принимает объект в качестве параметра.

Кстати, у вас есть пункт об этом в эффективной java Блоха (который вам должен принадлежать).

Метод equals для Test не отменяет метод equals для java.lang.Object. Посмотрите на тип параметра! Класс Test перегружает equals методом, который принимает Test.

Если метод equals предназначен для переопределения, он должен использовать аннотацию @Override. Это привело бы к ошибке компиляции, чтобы указать на эту распространенную ошибку.

Java не поддерживает ковариацию параметров, только возвращаемых типов.

Другими словами, хотя ваш тип возвращаемого значения в методе переопределения может быть подтипом того, что было в переопределенном методе, это неверно для параметров.

Если вашим параметром для equals в Object является Object, установка равенства с чем-либо еще в подклассе будет перегруженным, а не переопределенным методом. Следовательно, единственная ситуация, в которой будет вызван этот метод, - это когда статическим типом параметра является Test, как в случае T3.

Удачи в прохождении собеседования! Я бы хотел пройти собеседование в компании, которая задает подобные вопросы вместо обычных вопросов об алгоритмах / структурах данных, которым я обучаю своих студентов.

Интересно, что в коде Groovy (который может быть скомпилирован в файл класса) все вызовы, кроме одного, будут выполнять оператор печати. (Тот, который сравнивает Test с Object, явно не вызовет функцию Test.equals (Test).) Это потому, что groovy ДЕЙСТВИТЕЛЬНО выполняет полностью динамическую типизацию. Это особенно интересно, потому что в нем нет переменных, которые явно динамически типизируются. Я читал в нескольких местах, что это считается вредным, так как программисты ожидают, что groovy сможет делать Java-вещь.

Java использует статическую привязку для перегруженных методов и динамическую привязку для переопределенных. В вашем примере метод equals перегружен (имеет другой тип параметра, чем Object.equals ()), поэтому вызываемый метод привязан к типу Справка во время компиляции.

Некоторое обсуждение здесь

Тот факт, что это метод equals, на самом деле не актуален, за исключением того, что это распространенная ошибка - перегрузить, а не переопределить его, о чем вы уже знаете, основываясь на своем ответе на проблему на собеседовании.

Редактировать: Хорошее описание здесь. В этом примере показана аналогичная проблема, связанная с типом параметра, но вызванная той же проблемой.

Я считаю, что если бы привязка была действительно динамической, то в любом случае, когда вызывающий объект и параметр были экземпляром Test, был бы вызван переопределенный метод. Таким образом, t3.equals (o1) будет единственным случаем, который не будет печататься.

Ответ на вопрос "почему?" так определяется язык Java.

Процитируем Статья в Википедии о ковариации и контравариантности:

Return type covariance is implemented in the Java programming language version J2SE 5.0. Parameter types have to be exactly the same (invariant) for method overriding, otherwise the method is overloaded with a parallel definition instead.

Остальные языки разные.

Совершенно очевидно, что здесь нет концепции переопределения. Это перегрузка метода. метод Object() класса Object принимает параметр ссылки типа Object, а этот метод equal() принимает параметр ссылки типа Test.

Некоторые заметки в Динамическое связывание (DD) и Статическая привязка̣̣̣ (SB) после некоторого поиска:

1. время выполнения: (Ссылка 1)

• БД: во время выполнения
• SB: время компиляции

2. используется для:

• БД: переопределение
• SB: перегрузка (статическая, приватная, окончательная) (ссылка 2)

Справка:

1. Выполнить средство определения средних значений, какой метод предпочитаете использовать
2. Потому что нельзя переопределить метод с модификатором static, private или final
3. http://javarevisited.blogspot.com/2012/03/what-is-static-and-dynamic-binding-in.html

Я нашел интересную статью о динамическом и статическом связывании. Он поставляется с фрагментом кода для имитации динамического связывания. Это сделало мой код более читабельным.

https://sites.google.com/site/jeffhartkopf/covariance

Если добавлен другой метод, который переопределяет вместо перегрузки, он объяснит вызов динамической привязки во время выполнения.

/ * Что дает следующая программа? * /

public class DynamicBinding {
    public boolean equals(Test other) {
        System.out.println("Inside of Test.equals");
        return false;
    }

    @Override
    public boolean equals(Object other) {
        System.out.println("Inside @override: this is dynamic binding");
        return false;
    }

    public static void main(String[] args) {
        Object t1 = new Test();
        Object t2 = new Test();
        Test t3 = new Test();
        Object o1 = new Object();

        int count = 0;
        System.out.println(count++);// prints 0
        t1.equals(t2);
        System.out.println(count++);// prints 1
        t1.equals(t3);
        System.out.println(count++);// prints 2
        t3.equals(o1);
        System.out.println(count++);// prints 3
        t3.equals(t3);
        System.out.println(count++);// prints 4
        t3.equals(t2);
    }
}

Я попытаюсь объяснить это двумя примерами, которые являются расширенными версиями некоторых примеров, с которыми я столкнулся в Интернете.

public class Test {

    public boolean equals(Test other) {
        System.out.println("Inside of Test.equals");
        return false;
    }

    @Override
    public boolean equals(Object other) {
        System.out.println("Inside of Test.equals ot type Object");
        return false;
    }

    public static void main(String[] args) {
        Object t1 = new Test();
        Object t2 = new Test();
        Test t3 = new Test();
        Object o1 = new Object();

        int count = 0;
        System.out.println(count++); // prints 0
        o1.equals(t2);

        System.out.println("\n" + count++); // prints 1
        o1.equals(t3);

        System.out.println("\n" + count++);// prints 2
        t1.equals(t2);

        System.out.println("\n" + count++);// prints 3
        t1.equals(t3);

        System.out.println("\n" + count++);// prints 4
        t3.equals(o1);

        System.out.println("\n" + count++);// prints 5
        t3.equals(t3);

        System.out.println("\n" + count++);// prints 6
        t3.equals(t2);
    }
}

Здесь для строк со значениями счетчика 0, 1, 2 и 3; у нас есть Справка из Объект для o1 и t1 для метода equals(). Таким образом, во время компиляции метод equals() из файла Object.class будет ограничен.

Однако даже если Справка из t1 равен Объект, он имеет инициализация из Тестовый класс.
Object t1 = new Test();.
Поэтому во время выполнения он вызывает public boolean equals(Object other), который является

overridden method

.

Теперь, для значений счетчика 4 и 6, снова очевидно, что t3, который имеет Справка и инициализация теста, вызывает метод equals() с параметром как ссылки на объекты и является

overloaded method

В ПОРЯДКЕ!

Again, to better understand what method the compiler will call, just click on the method and Eclipse will highlight the methods of similar types which it thinks will call at the compile time. If it doesn't get called at compile time then those methods are an example of method overridding.