Статическая и динамическая привязка Java, восходящее преобразование, смешанная перегрузка

Это кажется немного странным. Я ожидал показать «In equals from TestEqual», потому что t3 является объектом TestEqual, поэтому следует вызывать equals из t1. Мое объяснение здесь будет заключаться в том, что t1 является статическим и рассматривается как объект, поэтому вызывается метод equals, унаследованный от класса объекта, а параметр TestEqual t3 преобразуется в объект. Но не означает ли это, что предыдущее объяснение от t1.equals(t2) неверно?

Чтобы вызвать метод в контексте перегрузки, происходит наиболее конкретный вызов метода, который определяется во время компиляции. Правило выбора наиболее конкретного метода определено в спецификация языка Java 15.12.2.5. Выбор наиболее конкретного метода: с другим обсуждением упомянутое утверждение:

Метод m1 строго более специфичен, чем другой метод m2, тогда и только тогда, когда m1 более специфичен, чем m2, а m2 не более специфичен, чем m1.

Однако, чтобы объяснить ваш контекст, давайте объявим два простых класса Super и sup class:

class SuperA
{
    public void test(SuperA a)
    {
        System.out.println("super class's test() is called");
    }
}

class SubB extends SuperA
{

    public void test(SubB subB)
    {
        System.out.println("subclass's test() is called");


    }    
}

Теперь, если мы создадим два экземпляра таким образом:

SuperA obj = new SubB();
SubB obj2 = new SubB();
obj.test(obj2);

Вы увидите, что вызывается test() суперкласса, потому что он определяется как более конкретный во время компиляции, и компилятор видит, что obj является экземпляром типа SuperA. Теперь приведите obj к SuubB и вызовите test(obj2):

((SubB)obj).test(obj2); // cast to SubB

И он печатает: "subclass's test() is called", подразумевая, что он вызывает метод test(obj) SubB, потому что на этот раз компилятор знает, что obj имеет тип SubB и наиболее конкретное разрешение для вызова test.

Однако теперь давайте объявим два экземпляра таким образом:

   SuperA obj = new SubB();
   SuperA obj2 = new SubB();
   obj.test(obj2); // invokes super class's test method
   ((SubB)obj).test(obj2);// invokes super class's test method
   ((SubB)obj).test((SubB)obj2); // invoke sub class's test method

В этой серии вызовов первые два оператора будут вызывать тестовый метод суперкласса SuperA, поскольку эти вызовы более специфичны. Однако, чтобы объяснить второй случай:

((SubB)obj).test(obj2);// invokes super class's test method

На этот раз компилятор знает, что obj имеет тип SubB, но все еще видит, что obj2 имеет тип SperA, который более специфичен для вызова метода test. Следовательно, для второго примера, в котором и obj, и obj2 были объявлены с типом SuperA: нам нужно, чтобы они оба были приведены к SubB для вызова метода SubB'S test.

Поскольку Object является суперклассом всех классов в java, вы уже должны понимать, однако система вызова метода equal вашего контекста. Чтобы избежать подобных ловушек при вызове, вы увидите, что все реализованные equal методы в классах java на самом деле переопределяют equal метода Object класса и используют instanceof проверку. Например, реализация метода equal класса Integer:

public boolean equals(Object obj) {
        if (obj instanceof Integer) { //<<<---- instance of checking
            return value == ((Integer)obj).intValue();
        }
        return false;
    } 

Метод Object .equals(Object obj) принимает в качестве параметра еще один экземпляр Object. Если вы определяете свой TestEqual как:

class TestEqual{
    @override
    public boolean equals(Object other ) {
        System.out.println( "In equals from TestEqual" ); return false;
    }
}

Он будет работать так, как вы ожидаете.