对方法的引用不明确，具有泛型，行为奇怪

Question

考虑以下场景：

class C {
  void m(Class<?> c1, Class<?> c2) {}
  <S, U extends S> void m(S s, U u) {}
}

class x {{
  final Class<Integer> cInteger = Integer.class;
  final Class<?> cSomething = null;
  final C c = new C();
  c.m(cInteger,  cInteger);
  c.m(cSomething,  cSomething); // *
}}

使用 Oracle 的 javac 版本 1.7.0_01（以及 1.7.0，以及 OpenJDK 的 Java 7 和 Java 6 编译器），我在标有 // *：

错误：对 m 的引用不明确，C 中的方法 m(Class,Class) 和 C 中的方法 m(S,U) 均匹配

我无法理解为什么会发生这种情况：编译器能够判断静态时调用哪个方法参数的类型为Class，但与Class有问题。

IntelliJ 的代码分析表明这是可以的，JRockit 的（或者是 Sun 的 Java 6）编译器也是如此。

所以，这里显然存在一个错误，无论是在那些说它是正确的软件中，还是在那些说它是错误的软件中。

请注意，如果我删除 U 的边界（也就是说，如果我将 m 声明为 void M(S s, U u) {}，它将编译而不会出现错误。此外，使用原始类型（即 Class x = null; m(x, x)）的调用也可以正常编译

。根据Java规范，这段代码有效还是无效

？

Answer 1

你确定吗？我的测试是第一个 m(cInteger, cInteger) 失败，第二个 m(cSomething, cSomething) 正常。此外，原始 m(x,x) 无法编译。

(1) m(cInteger,cInteger) 失败

m() 都与参数匹配；对于m2，推理产生S=U=Class。

现在的问题是，m1 比 m2 更具体吗？按照 15.12.2.5 中的过程，确实如此。如果是这样，那就没有歧义了； m1 应该被选为最具体的方法，并且调用应该编译。

但是，这违反了规范给出的非正式要求：如果m1比m2更具体，则由m1<处理的任何调用/em> 可以传递给 m2 而不会出现编译时类型错误。例如，m1 可以接受参数 (Class,Class)，而 m2 则不能（由于较少） - 不完美的类型推断
程序）。

Javac 显然坚持非正式的概念；这可能是因为正式规范有一个错误 - 它应该在更具体关系的定义中包含捕获转换（稍后解释）；那么m1并不比m2更具体，因此调用m(cInteger,cInteger)是不明确的。

如果另一个编译器严格遵守正式规范，那么继承规范的错误并不是它的错。

(2) m(x, x) 失败

的原因与 (1) 相同；两种方法都匹配，但都不比另一种更具体。

m1 通过方法调用转换进行匹配，这允许从原始Class到Class未经检查的转换 ;。 m2 推断 S=U=Class 后匹配

(3) m(cSomething, cSomething) 编译

这是因为 m1 > 是唯一适用的，因此没有歧义。

m2 不适用，让我们看看为什么。

首先，参数的类型并不完全是 (Class,Class) - 首先对它们应用捕获转换。 （同样，规范非常不清楚（参见第 15 章），但我非常确定这是很好理解的；任何表达式的类型都适用于捕获转换）

因此参数类型是 ( Class,Class)，具有两个新类型变量。这里还有另一个错误，更精确的转换应该是 (Class,Class)，不幸的是，捕获转换独立地应用了两次，产生了两种不同的类型。

m1 轻松匹配参数类型。但由于类型推断过程不太完美，m2 不匹配。该过程首先产生 S=Class、U=Class，之后，检查类型变量的边界，其中 U 扩展 S失败。

(4) 移除U 的绑定

现在(1),(2),(3) 全部编译。因为没有U extends S，推理就会通过。

对于 (1) 和 (2)，m1 现在比 m2 更具体，不再含糊不清。

对于 (3)，m2 现在匹配；但随后被更具体的 m1 所掩盖

Answer 2

也许是因为如果你在方法调用中说让 为 Class 类型，那么 也是 < code>Class 并且无法确定应使用哪种方法。

<S, U extends S> void m(S s, U u) {} //S=U=Class<?> => void m(Class<?> s, Class<?> u) {} //same signature

如果您说让 和 为 Class 的类型，那么它必须是带有泛型的第二种方法 和 。

<S, U extend S> void m(S s, U u) {} //S=U=Class<Integer> => void m(Class<Integer> s, Class<Integer> u) {} //Ok

问题

声明指定您的意图是使用两种不同的不相关类型。