方法重载并选择最具体的类型

Question

示例代码是：

    public class OverloadingTest {

       public static void test(Object obj){
           System.out.println("Object called");
       }

       public static void test(String obj){
           System.out.println("String called");
       }

       public static void main(String[] args){
           test(null);
           System.out.println("10%2==0 is "+(10%2==0));
           test((10%2==0)?null:new Object());
           test((10%2==0)?null:null);
   }

输出是：

名为字符串
10%2==0 为真
对象称为
名为

的字符串

第一次调用test(null)会调用带有String参数的方法，根据Java语言规范这是可以理解的。

1）谁能解释一下在前面的调用中调用 test() 的依据是什么？

2) 同样，当我们输入 if 条件时：

    if(10%2==0){
        test(null);
    }
    else
    {
        test(new Object());
    }

它总是使用 String 参数调用该方法。

编译器在编译时会计算表达式(10%2)吗？我想知道表达式是在编译时还是运行时计算的。谢谢。

Answer 1

这是 Java 语言规范所说的内容关于这个问题。

如果多个方法声明既可访问又适用
对于方法调用，必须选择一个来提供
运行时方法调度的描述符。 Java编程
语言使用选择最具体方法的规则。

这是您的情况下的 test(String) 方法。

因此，如果您添加...

public static void test(Integer obj){
           System.out.println("Ingeter called");
       }

它将显示编译错误 - 方法 test(String) 对于类型 OverloadingTest 来说不明确。

正如JLS所说：

可能没有一种方法是最具体的，因为有
两个或多个最大特定方法。在这种情况下：

如果所有最大特定方法都具有相同的签名，则：
如果最具体的方法之一没有声明为抽象的，那么它
是最具体的方法。否则，所有最大具体
方法必须声明为抽象的。最具体的方法是
在最大具体方法中任意选择。然而，
最具体的方法被认为抛出一个已检查的异常，如果并且
仅当该异常在每个的 throws 子句中声明时
最具体的方法。否则，我们说该方法
调用不明确，并且发生编译时错误。

Answer 2

Java 使用早期绑定。最具体的方法是在编译时选择的。最具体的方法是根据参数的数量和参数的类型来选择的。在这种情况下，参数的数量不相关。这给我们留下了参数的类型。

参数有什么类型？两个参数都是表达式，使用三元条件运算符。问题归结为：条件三元运算符返回什么类型？类型是在编译时计算的。

给出了两个表达式：

(10%2==0)? null : new Object(); // A
(10%2==0)? null : null; // B

列出了类型评估的规则 在这里。在 B 中很简单，两个术语完全相同：将返回 null （无论是什么类型）（JLS：“如果第二个和第三个操作数具有相同的类型（可能是 null 类型），那么这就是条件表达式。”）。在 A 中，第二项来自特定类。由于这更具体，并且 null 可以替换 Object 类的对象，因此整个表达式的类型是 Object （JLS：“如果如果第二个和第三个操作数之一是空类型，另一个是引用类型，则条件表达式的类型就是该引用类型。”）。

在对表达式进行类型评估后，方法选择符合预期。

您给出的 if 示例有所不同：您使用两种不同类型的对象调用方法。三元条件运算符始终在编译时评估为符合这两个条件的一个类型。

Answer 3

JLS 15.25：

<块引用>

条件表达式的类型确定如下：

[...]

• 如果第二个和第三个操作数之一为 null 类型且另一个为 null 类型
  是引用类型，那么条件表达式的类型就是该引用
  类型。

[...]

所以类型

10 % 2 == 0 ? null : new Object();

是Object。

Answer 4

test((10%2==0)?null:new Object());

等同于：

Object o;

if(10%2==0)
    o=null;
else
    o=new Object();

test(o);

由于 o 的类型是 Object （就像 (10%2==0)?null:new Object()< 的类型一样） /code>) test(Object) 将始终被调用。 o 的值并不重要。

Answer 5

这是一个非常好的问题。

让我尝试澄清您上面编写的代码。

• 在你的第一个方法调用中

测试（空）；

在此，null 将转换为字符串类型，因此调用 test(String obj)，根据 JLS，您确信该调用。

• 在第二个方法调用中

测试((10%2==0)?null:new Object());

这将返回布尔“true”值。因此，第一个布尔“true”值将自动转换为布尔包装类对象。布尔包装对象正在寻找与三元运算符中的 new Object() 选项的最佳匹配。并且该方法以 Object 作为参数进行调用，因此调用了以下方法

公共静态无效测试（对象obj）

为了实验目的，您可以尝试以下组合，然后您会获得更好的清晰度。

test((10 % 2 == 0) ? new Object() : "stringObj" );

test((10 % 2 == 0) ? new Object() : null );

test((10 % 2 == 0) ? "stringObj" : null );

• 最后，当您使用以下代码进行调用时。

测试((10%2==0)?null:null);

这次它再次返回布尔“true”值，并且它将再次遵循与上面解释的相同的转换。但这次三元运算符中没有 new Object() 参数。因此它将自动类型转换为 null 对象。同样，它遵循与第一个方法调用相同的方法调用。

• 最后，当您询问代码时，如果您放入 if .. else 语句。然后编译器也会对代码做出公平的决定。

如果（10%2==0）{
测试（空）；
}

您的 if 条件始终为 true 并调用此代码 test(null)。因此，它始终以 String 作为参数调用第一个 test(String obj) 方法，如上所述。

Answer 6

你的答案是：运行时，因为在运行时指定参数是字符串的实例或不是，所以在编译时找不到它。

Answer 7

我认为你的问题是你做出了错误的假设，你的表达式：

test((10%2==0)?null:new Object());

和

test((10%2==0)?null:null;

总是会调用 test(null)，这就是为什么它们会经历 test (Object)。

Answer 8

正如 @Banthar 提到的， ?: 运算符首先为变量赋值，然后评估条件。
另一方面，您提到的 if 条件始终返回 true，因此编译器将仅用 if< 的主体替换整个 if-else 块。 /代码>。

Answer 9

1) test() 方法是由编译时参数的类型决定的：

test((Object) null);
test((Object)"String");

输出：

Object called
Object called

2) 编译器更聪明，编译后的代码就相当于：

test(null);

可以检查字节码使用 javap -c ：

   0: aconst_null   
   1: invokestatic  #6                  // Method test:(Ljava/lang/String;)V
   4: return