Java重载规则

Question

我最近遇到了两个重载问题,我找不到答案,也没有java环境来运行一些测试代码.我希望有人可以通过汇编一份java编译器遵循的所有规则列表来帮助我进行重载,或者交替指向我已经存在的列表.

首先,当两个方法只有最终的varargs参数不同时,在什么情况下每个方法都被调用,你可以在没有任何args的情况下调用varargs方法吗？

private void f(int a) { /* ... */ }
private void f(int a, int... b) { /* ... */ }

f(12); // calls the former? I would expect it to
f(12, (int[])null); // calls latter, but passes null for b? 
  // Can I force the compiler to call the second method in the same fashion
  // as would happen if the first method didn't exist?

第二个问题,当两个方法因为彼此继承而被调用的类型不同时？我希望调用最多的派生版本,并允许调用另一个版本.

interface A {}
class B implements A {}
class C implements A {}

private void f(A a) {}
private void f(B b) {}

f(new C()); // calls the first method
f(new B()); // calls the second method?
f((A)(new B()); // calls the first method using a B object?

这是两个例子,但作为代码阅读器,我更喜欢用于解决此问题的精确有序规则的规范列表,因为我经常没有时间设置构建环境来检查编译器正在做什么.

Answer 1

重载与覆盖

正如您所指出的那样,选择正确的方法实现是在运行时完成的,现在要调用的方法的签名是在编译时决定的.

编译时的重载方法选择

第15.12节" 方法调用表达式 "中的Java语言规范(JLS)详细说明了编译器在选择正确的调用方法时遵循的过程.

在那里,您会注意到这是一个编译时任务.JLS在第15.12.2小节中说:

此步骤使用方法的名称和参数表达式的类型 来定位可访问和适用的方法可能有多个此类方法,在这种情况下,选择最具体的方法.

通常,如果varargs方法与其他候选方法竞争,则它们是最后选择的方法,因为它们被认为不如接收相同参数类型的方法具体.

要验证此编译时的性质,您可以执行以下测试.

声明一个这样的类并编译它.

public class ChooseMethod {
   public void doSomething(Number n){
    System.out.println("Number");
   }
}

声明第二个类,它调用第一个方法并编译它.

public class MethodChooser {
   public static void main(String[] args) {
    ChooseMethod m = new ChooseMethod();
    m.doSomething(10);
   }
}

如果你调用main,输出说Number.

现在,向类添加第二个更具体的重载方法ChooseMethod,并重新编译它(但不要重新编译其他类).

public void doSomething(Integer i) {
 System.out.println("Integer");
}

如果再次运行main,则输出仍然是Number.

基本上,因为它是在编译时决定的.如果您重新编译MethodChooser该类(具有main的类),并再次运行该程序,则输出将是Integer.

因此,如果要强制选择其中一个重载方法,则参数类型必须与编译时参数的类型相对应,而不仅仅是在运行时.

在运行时覆盖方法选择

同样,方法的签名在编译时决定,但实际的实现是在运行时决定的.

声明一个这样的类并编译它.

public class ChooseMethodA {
   public void doSomething(Number n){
    System.out.println("Number A");
   }
}

然后声明第二个扩展类并编译:

public class ChooseMethodB extends ChooseMethodA {  }

在MethodChooser类中,您可以:

public class MethodChooser {
    public static void main(String[] args) {
        ChooseMethodA m = new ChooseMethodB();
        m.doSomething(10);
    }
}

如果你运行它,你得到输出Number A,这是好的,因为该方法尚未被覆盖ChooseMethodB,因此被调用的实现是ChooseMethodA.

现在,添加一个覆盖方法MethodChooserB:

public void doSomething(Number n){
    System.out.println("Number B");
}

并重新编译这一个,并再次运行main方法.

现在,你得到了输出 Number B

因此,在运行时选择了实现,而不需要重新编译MethodChooser类.