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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Обратите внимание на динамическое связывание (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

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

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

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);
    }
}

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

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

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

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

Ковариация возвращаемого типа реализована в версии языка программирования Java J2SE 5.0. Типы параметров должны быть точно такими же (инвариантными) для переопределения метода, иначе вместо этого метод будет перегружен параллельным определением.

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

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

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

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; у нас есть ссылка на Object для o1 и t1 по методу equals(). Таким образом, во время компиляции метод equals() из файла Object.class будет ограничен.

Однако, хотя reference для t1 - Object, он имеет инициализацию Test class .
Object t1 = new Test();.
Поэтому во время выполнения он вызывает public boolean equals(Object other), который является