Java 8 泛型的模棱两可的方法参考 class

Question

下面的代码在 Java 7 中编译和运行正常，但在 Java 1.8.0 u25:

中编译失败

public class GenericTest {

    public static class GenericClass<T> {
        T value;

        public GenericClass(T value) {
            this.value = value;
        }
    }

    public static class SecondGenericClass<T> {
        T value;

        public SecondGenericClass(T value) {
            this.value = value;
        }
    }


    public static<T >void verifyThat(SecondGenericClass<T> actual, GenericClass<T> matcher) {
    }

    public static<T >void verifyThat(T actual, GenericClass<T> matcher) {
    }

    @Test
    public void testName() throws Exception {
        verifyThat(new SecondGenericClass<>(""), new GenericClass<>(""));
    }

}

Java8 中的错误消息如下所示：

Error:(33, 9) java: reference to verifyThat is ambiguous
  both method <T>verifyThat(com.sabre.ssse.core.dsl.GenericTest.SecondGenericClass<T>,com.sabre.ssse.core.dsl.GenericTest.GenericClass<T>) in com.sabre.ssse.core.dsl.GenericTest and method <T>verifyThat(T,com.sabre.ssse.core.dsl.GenericTest.GenericClass<T>) in com.sabre.ssse.core.dsl.GenericTest match

我已经查看了以下时间段内的所有更改：
https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.12.2
https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12.2

但我没有注意到这种行为的确切原因。

编辑：

只是为了回答一些评论，很明显 Java 7 和 8 中的编译器将能够处理此类调用（签名类似于编译时类型擦除后留下的签名：

public static void verifyThat(SecondGenericClass actual, GenericClass matcher) {
}

public static void verifyThat(Object actual, GenericClass matcher) {
}

@Test
public void testName() throws Exception {
    verifyThat(new SecondGenericClass<>(""), new GenericClass<>(""));
}

为两个泛型方法生成和擦除的字节码是相同的，看起来像这样：

public static verifyThat(Lcom/sabre/ssse/core/dsl/GenericTest$SecondGenericClass;Lcom/sabre/ssse/core/dsl/GenericTest$GenericClass;)V
public static verifyThat(Ljava/lang/Object;Lcom/sabre/ssse/core/dsl/GenericTest$GenericClass;)V

Edit2:

在 javac 1.8.0_40 下编译失败，同样的错误

Answer 1

在解决在多种方法适用的情况下使用哪种方法时，“...调用参数的类型通常不能作为分析的输入。” Java 7 规范缺少此资格。

如果您将 verifyThat 的第二个定义中的 T 替换为 SecondGenericClass，则签名匹配。

换句话说，想象一下像这样调用 verifyThat 的第二个定义：

SecondGenericClass<String> t = new SecondGenericClass<String>("foo");
GenericTest.verifyThat(t, new GenericClass<String>("bar"));

在运行时，无法确定要调用哪个版本的 verifyThat，因为变量类型 t 是 SecondGenericClass<T> 和 [=11 的有效替代=].

请注意，如果 Java 已经具体化了泛型（总有一天会实现），在此示例中，一个方法签名并不比另一个更具体。弥补漏洞...

Answer 2

JLS, chapter §15.12.2.5 Choosing the Most Specific Method 很难读，但包含一个有趣的摘要：

The informal intuition is that one method is more specific than another if any invocation handled by the first method could be passed on to the other one without a compile-time type error.

我们可以通过以下示例轻松反驳您的情况：

GenericTest.<String>verifyThat( // invokes the first method
    new SecondGenericClass<>(""), new GenericClass<>(""));
GenericTest.<SecondGenericClass<String>>verifyThat( // invokes the second
    new SecondGenericClass<>(""), new GenericClass<>(null));

所以这里没有最具体的方法，但是，如示例所示，可以使用使另一个方法不适用.[=28 的参数调用任一方法=]

在 Java 7 中，由于（编译器）寻找类型参数以使更多方法适用（也称为有限类型推断）的尝试有限，因此更容易使方法不适用。表达式 new SecondGenericClass<>("") 的类型 SecondGenericClass<String> 从它的参数 "" 推断出来，仅此而已。因此，对于调用 verifyThat(new SecondGenericClass<>(""), new GenericClass<>(""))，参数具有类型 SecondGenericClass<String> 和 GenericClass<String>，这使得方法 <T> void verifyThat(T,GenericClass<T>) 不适用。

请注意，有一个模棱两可的调用示例显示了 Java 7（甚至 Java 6）下的歧义：verifyThat(null, null); 在使用 javac.

但是 Java 8 具有 Invocation Applicability Inference（我们与 JLS 7 有所不同，这是一个全新的章节……）它允许编译器选择使方法候选适用的类型参数（这通过嵌套调用工作）。你可以为你的特殊情况找到这样的类型参数，你甚至可以找到适合两者的类型参数，

GenericTest.<Object>verifyThat(new SecondGenericClass<>(""), new GenericClass<>(""));

是明确的歧义（在 Java 8 中），甚至 Eclipse 也同意这一点。相反，调用

verifyThat(new SecondGenericClass<>(""), new GenericClass<String>(""));

足够具体，使第二个方法不适用并调用第一个方法，这给了我们关于 Java 7 中发生的事情的提示，其中 new GenericClass<>("") 的类型固定为 GenericClass<String> 就像 new GenericClass<String>("").

最重要的是，从 Java 7 到 Java 8（显着）变化的不是最具体方法的选择，而是由于改进的类型推断而导致的适用性。一旦两种方法都适用，调用就会变得不明确，因为两种方法都不比另一种更具体。

Java 8 泛型的模棱两可的方法参考 class

Java 8 ambiguous method reference for generic class

java

generics

jls

java-8