Java方法重载-相同继承树中的通用参数

Question

假设我有以下代码：

// Method acception generic parameter
public static <T> T foo(T para) {
    return para;
}

// Method accepting Integer parameter
public static Integer foo(Integer para) {
    return para + 1;
}

// Method accepting Number parameter
public static Number foo(Number para) {
    return para.intValue() + 2;
}

public static void main(String[] args) {
    Float f = new Float(1.0f);
    Integer i = new Integer(1);
    Number n = new Integer(1);
    String s = "Test";

    Number fooedFloat = foo(f);     // Uses foo(Number para)
    Number fooedInteger = foo(i);   // Uses foo(Integer para)
    Number fooedNumber = foo(n);    // Uses foo(Number para)
    String fooedString = foo(s);    // Uses foo(T para)

    System.out.println("foo(f): " + fooedFloat);
    System.out.println("foo(i): " + fooedInteger);
    System.out.println("foo(n): " + fooedNumber);
    System.out.println("foo(s): " + fooedString);
}

输出看起来如下：

foo(f): 3
foo(i): 2
foo(n): 3
foo(s): Test

现在的问题是：

1. foo(n)调用foo(Number para)，很可能是因为它n被定义为Number，即使它已Integer分配了。那么，我的假设是正确的，即采用哪种重载方法的决定是在编译时发生的，而没有动态绑定呢？（有关 静态 和 动态 绑定的问题）
2. foo(f)使用foo(Number para)，而foo(i)使用foo(Integer para)。仅foo(s)使用通用版本。因此，编译器始终会查找给定类型是否存在非泛型实现，并且只有在不回到泛型版本的情况下，该编译器才会查找？（有关 泛型的 问题）
3. 再次foo(f)使用foo(Number para)，而foo(i)使用foo(Integer para)。但是，Integer i也将是Number。因此，是否总是采用继承树中“最外层”类型的方法？（关于 继承的 问题）

我知道这些问题很多，并且该示例并非取自生产代码，但我只想知道什么“背后发生了”以及为什么会发生。

也非常感谢与Java文档或Java规范的任何链接，我自己找不到它们。

Answer 1

语言规范中说明了确定在编译时调用哪个方法签名的规则。特别重要的是选择最具体方法的部分。以下是与您的问题有关的部分：

如果多个成员方法既可访问又可应用于方法调用，则必须选择一个成员方法来为运行时方法分派提供描述符。Java编程语言使用选择 最具体 方法的规则。

…

如果满足以下任一条件，则对于使用参数表达式… … 的调用，一种适用的方法比另一种适用的方法更具体：m1``m2``e1``ek

• m2是通用的，由§18.5.4 推断比参数表达式… 更具体。m1``m2``e1``ek

• m2不是通用的，并且是适用通过严格或松散调用，并且其中具有形参类型S1，…，Sn和具有形参类型Ť 1，…，T Ñ，S型我比更具体Ť
  我为参数对于所有 我 （1≤ 我 ≤ ñ ， ñ = ķ ）。m1``m2``m1``m2``ei __
  

…

如果S <：T（第4.10节），则对于任何表达式，类型S 都比类型T 更具体 。

在这种情况下，由于Integer比extends 更具体，所以每当编译器检测到对该调用采用了 声明 为type
的变量的调用时，都会为添加一个调用。Number``Integer``Number``foo __Integer``foo(Integer)

本节将详细介绍与第二种方法有关的第一种条件有关的更多信息。这有点冗长，但我认为重要的部分是：

当测试一种适用的方法比另一种适用的方法 更具体时
（第15.12.2.5节），如果第二种方法是通用的，则必须测试是否可以推断出第二种方法的类型参数的某些实例化，以使第一种方法比第二。

…

让是第一种方法，并是第二种方法。其中有一个类型参数p 1，…，P p，让α 1，…，α p是推断变量，并让θ是取代[P 1：=α 1，…，P
p：= α p ]。m1``m2``m2

…

确定是否比下面更具体的过程如下：m1``m2

…

如果T i是适当的类型，则对于e i（§15.12.2.5），如果S i比T i更具体，则结果为 true； 否则为 false 。（请注意，S
i始终是适当的类型。） __

基本上，这意味着foo(Number)和foo(Integer)两者都比foo(T)因为编译器可以推断出至少一种类型的泛型方法（例如，Number本身）foo(Number)而foo(Integer)更具体（这是因为Integer <: Number和Number <: Number）更具体（这是因为和）。

这也意味着在您的代码foo(T)中，仅适用于传递a的调用（由于它仅是一种适用的方法，因此本质上是最具体的方法）String。