Java动态绑定和方法覆盖

昨天我接受了两个小时的技术电话面试（我通过了，woohoo！），但是我完全想出了以下有关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()方法），动态绑定也应根据引用的实例化类型来调用方法的最特定版本。我想念什么？

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

这里一些讨论

它是equals方法的事实并没有什么实际意义，除了重载而不是覆盖它是一个常见的错误之外，您已经根据面试中对问题的答案知道了这一点。

编辑：这里也是一个很好的描述。本示例显示了与参数类型有关的类似问题，但是是由同一问题引起的。

我相信，如果绑定实际上是动态的，则在任何情况下调用方和参数都是Test实例的情况都将导致调用重写的方法。因此，t3.equals（o1）将是唯一无法打印的情况。

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

如果equals要覆盖该方法，则应使用@Override批注。这将导致编译错误，以指出此常见错误。

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

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

换句话说，尽管您的覆盖方法中的返回类型可能是被覆盖中的返回类型的子类型，但对于参数而言并非如此。

如果Object中equals的参数是Object，则将equals与其他任何内容放在子类中将是重载，而不是覆盖的方法。因此，仅在参数的静态类型为Test时才调用该方法，就像T3一样。

面试过程祝您好运！我很想在一家问这些类型的问题而不是我教我的学生的常规算法/数据结构问题的公司接受采访。

我认为关键在于以下事实：equals（）方法不符合标准：它接受另一个Test对象，而不是Object对象，因此不会覆盖equals（）方法。这意味着实际上，在给它提供Test对象的同时，给它提供Object对象调用Object.equals（Object o）的功能时，实际上您只是对其进行了重载。通过任何IDE查看该代码都应向您显示两个用于测试的equals（）方法。

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

顺便说一句，您在Bloch的有效Java中有一个项目（您应该拥有）。

搜索一段时间后，在动态绑定（DD）和静态绑定Static（SB）中的一些注意事项：

1.计时执行：（参考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

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

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

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

然而，尽管参考的T1是对象，它具有intialization的测试类。
Object t1 = new Test();。
因此，在运行时它调用public boolean equals(Object other)这是一个

覆盖方法

。

现在，对于4和6的计数值，再次很简单的一点是，具有Test的引用和初始化的t3正在调用参数为Object引用的方法，并且equals()

重载方法

好！

同样，为了更好地理解编译器将调用哪种方法，只需单击该方法，Eclipse将突出显示它认为在编译时将调用的类似类型的方法。如果在编译时未调用它，则这些方法就是方法重写的一个示例。