Java动态绑定和方法重写

Question

昨天我参加了一个两个小时的技术电话面试（我通过了，哇哦！），但我完全掩盖了以下有关 Java 动态绑定的问题。 这是双重令人费解的，因为几年前我还是助教时，我曾经向本科生讲过这个概念，所以我给他们提供错误信息的前景有点令人不安……

这是我遇到的问题：

/* What is the output of the following program? */

public class Test {

  public boolean equals( Test other ) {
    System.out.println( "Inside of Test.equals" );
    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);
  }
}

我断言输出重写的 equals() 方法中应该有两个单独的打印语句：at t1.equals(t3) 和 t3.equals(t3) >。 后一种情况很明显，对于前一种情况，即使 t1 具有 Object 类型的引用，它也会实例化为 Test 类型，因此动态绑定应该调用该方法的重写形式。

显然不是。 我的面试官鼓励我自己运行该程序，你瞧，重写的方法只有一个输出：在 t3.equals(t3) 行。

那么我的问题是，为什么？ 正如我已经提到的，即使 t1 是 Object 类型的引用（因此静态绑定将调用 Object 的 equals() 方法），动态绑定应该 根据引用的实例化类型来调用该方法的最具体版本。 我缺少什么？

Answer 1

Java 对重载方法使用静态绑定，对重写方法使用动态绑定。 在您的示例中，equals 方法被重载（具有与 Object.equals() 不同的参数类型），因此调用的方法在编译时绑定到 reference 类型。

此处的一些讨论

事实上，它是 equals 方法并不真正相关，其他重载而不是覆盖它是一个常见的错误，根据您在面试中对问题的回答，您已经意识到了这一点。

编辑：
此处也有很好的描述。 此示例显示了与参数类型相关的类似问题，但由同一问题引起。

我相信如果绑定实际上是动态的，那么调用者和参数是 Test 实例的任何情况都会导致调用重写的方法。 因此 t3.equals(o1) 将是唯一不会打印的情况。

Answer 2

Test 的 equals 方法不会覆盖 java.lang.Object 的 equals 方法。 看参数类型！ Test 类使用接受 Test 的方法重载 equals。

如果要重写 equals 方法，则应使用 @Override 注释。 这会导致编译错误指出这个常见错误。

Answer 3

有趣的是，在 Groovy 代码（可以编译为类文件）中，除了一个调用之外的所有调用都将执行 print 语句。 （将测试与对象进行比较的方法显然不会调用 Test.equals(Test) 函数。）这是因为 groovy 确实执行完全动态类型。 这是特别令人感兴趣的，因为它没有任何显式动态类型的变量。 我在几个地方读到这被认为是有害的，因为程序员期望 groovy 做 java 的事情。

Answer 4

Java 不支持参数的协变，仅支持返回类型。

换句话说，虽然重写方法中的返回类型可能是被重写方法中的返回类型的子类型，但对于参数来说却并非如此。

如果 Object 中的 equals 参数是 Object，则将 equals 与子类中的其他任何内容一起放置将是重载方法，而不是重写方法。 因此，只有当参数的静态类型为 Test 时才会调用该方法，如 T3 的情况。

祝面试过程顺利！ 我很乐意接受一家提出此类问题的公司的面试，而不是我教给学生的常见算法/数据结构问题。

Answer 5

我认为关键在于 equals() 方法不符合标准：它接受另一个 Test 对象，而不是 Object 对象，因此不会覆盖 equals() 方法。 这意味着您实际上只在给定 Test 对象并给它 Object 对象调用 Object.equals(Object o) 时重载它来执行一些特殊操作。 通过任何 IDE 查看代码应该会显示两个用于测试的 equals() 方法。

Answer 6

该方法被重载而不是被覆盖。 等于始终将对象作为参数。

顺便说一句，您在 Bloch 的 effective java 中有一个关于此的项目（您应该拥有）。

Answer 7

搜索一段时间后，动态绑定(DD)和静态绑定̣̣̣(SB)中的一些注意事项：

1.定时执行：(Ref.1)

• DB：运行时
• SB：编译时

2.用于：

• DB：重写
• SB：重载（静态、私有、最终）（参考 2）

参考：

1. 执行平均值解析器更喜欢使用哪种方法
2. 因为不能使用修饰符 static、private 或 final 覆盖方法
3. http://javarevisited.blogspot.com/2012/03/what-is-static-and-dynamic-binding-in.html

Answer 8

如果添加另一个方法来重写而不是重载，它将解释运行时的动态绑定调用。

/* 以下程序的输出是什么？ */

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

Answer 9

我发现了一篇关于动态与静态绑定的有趣文章。 它附带了一段用于模拟动态绑定的代码。 它使我的代码更具可读性。

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

Answer 10

“为什么？”这个问题的答案 Java 语言就是这样定义的。

引用关于协方差和逆变的维基百科文章：

实现返回类型协方差
在Java编程语言中
J2SE 5.0 版本。 参数类型有
完全相同（不变）
方法重写，否则
方法被并行重载
而是定义。

其他语言则不同。

Answer 11

很明显，这里没有覆盖的概念。 这是方法重载。
Object 类的 Object() 方法采用 Object 类型的引用作为参数，而这个 equal() 方法采用 Test 类型的引用作为参数。

Answer 12

我将尝试通过两个示例来解释这一点，这两个示例是我在网上遇到的一些示例的扩展版本。

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的行； 我们在 equals() 方法上有 o1 和 t1 的 Object 的引用 。 因此，在编译时，Object.class 文件中的 equals() 方法将受到限制。

但是，即使t1的引用是对象，它也具有测试类的初始化 。

对象 t1 = new Test();。

因此，在运行时它调用 public boolean equals(Object other) 这是一个

重写方法

。

现在，对于计数值为 4 和 6 的情况，t3 也很简单，它具有 引用 和初始化 Test 正在调用 equals() 方法，参数作为对象引用，并且是一个

重载方法

OK！

同样，为了更好地理解编译器将调用什么方法，只需
点击该方法，Eclipse会突出显示类似的方法
它认为会在编译时调用的类型。 如果没有得到
在编译时调用那么这些方法是方法的示例
覆盖。