Thread.sleep 的方法引用不明确

Question

我遇到了一个奇怪的问题，即对 Thread::sleep 的方法引用不明确，但具有相同签名的方法却不明确。

package test;    

public class Test
{
    public static void main(String[] args)
    {
        foo(Test::sleep, 1000L); //fine
        foo((FooVoid<Long>)Thread::sleep, 1000L); //fine
        foo(Thread::sleep, 1000L); //error
    }

    public static void sleep(long millis) throws InterruptedException
    {
        Thread.sleep(millis);
    }

    public static <P, R> void foo(Foo<P, R> function, P param) {}

    public static <P> void foo(FooVoid<P> function, P param) {}

    @FunctionalInterface
    public interface Foo<P, R> {
        R call(P param1) throws Exception;
    }

    @FunctionalInterface
    public interface FooVoid<P> {
        void call(P param1) throws Exception;
    }
}

我得到了这 2 个错误：

Error:(9, 17) java: reference to foo is ambiguous
  both method <P,R>foo(test.Test.Foo<P,R>,P) in test.Test and method <P>foo(test.Test.FooVoid<P>,P) in test.Test match

Error:(9, 20) java: incompatible types: cannot infer type-variable(s) P,R
    (argument mismatch; bad return type in method reference
      void cannot be converted to R)

我看到的唯一区别是Thread::sleep 是native。它有什么改变吗？我不认为过载Thread::sleep(long, int) 在这里发挥作用。为什么会这样？

编辑：使用 javac 版本 1.8.0_111

Answer 1

问题在于Thread.sleep 和foo 都超载了。所以存在循环依赖。

• 为了找出使用哪个sleep方法，我们需要知道目标类型，即调用哪个foo方法
• 为了找出调用哪个foo方法，我们需要知道参数的功能签名，即我们选择了哪个sleep方法

虽然人类读者很清楚，对于这种情况，只有 2×2 组合中的一种是有效的，但编译器必须遵循适用于任意组合的正式规则，因此，语言设计者必须做出调整。

为了方法引用的有用性，对明确的引用进行了特殊处理，例如您的Test::sleep：

JLS §15.13.1

对于某些方法引用表达式，无论目标函数类型如何，都只有一种可能的编译时声明和一种可能的调用类型（第 15.12.2.6 节）。这样的方法引用表达式被称为exact。不精确的方法引用表达式被称为不精确。

请注意，这种区别类似于 隐式类型 lambda 表达式 (arg -> expression) 和 显式 lambda 表达式 ((Type arg) -> expression) 之间的区别。

当您查看JLS, §15.12.2.5., Choosing the Most Specific Method 时，您会发现方法引用的签名仅用于确切 方法引用，就像选择正确的foo 时，决定为对sleep的方法还没做呢。

如果e 是一个精确的方法引用表达式 (§15.13.1)，那么 i) 对于所有 i (1 ≤ i ≤ k)，@987654337 @_i 与V_i 相同，且 ii) 以下其中一项为真：

• R₂ 是 void。
• R₁ <: R₂。
• R₁ 是原始类型，R₂ 是引用类型，方法引用的编译时声明具有原始类型的返回类型。
• R₁ 是引用类型，R₂ 是原始类型，方法引用的编译时声明有一个返回类型，即引用类型。

上述规则已在 §15.12.2.5 中说明。对于非泛型方法，针对泛型方法重定向到 §18.5.4（此处适用，因为您的 foo 方法是泛型的），包含 exactly the same rule，措辞略有不同。

由于在选择最具体的方法时没有考虑方法引用的签名，所以没有最具体的方法，foo的调用是模棱两可的。第二个编译器错误是继续处理源代码并可能报告更多错误的策略的结果，而不是在第一个错误处立即停止编译。 foo 的两次调用之一会导致“不兼容的类型”错误，如果该调用正在发生，但实际上由于“歧义调用”错误已被排除。

Answer 2

我个人认为这是某种递归，有点像这样：我们需要解析方法才能找到目标类型，但我们需要知道目标类型才能解析方法时间>。这与 特殊的 void 兼容性规则有关，但我承认我并不完全明白。

如果你有这样的东西，事情会更有趣：

public static void cool(Predicate<String> predicate) {

}

public static void cool(Function<String, Integer> function) {

}

并尝试通过以下方式调用它：

cool(i -> "Test"); // this will fail compilation 

顺便说一句，如果你让你的 lambda 显式，这将起作用：

foo((Long t) -> Thread.sleep(t), 1000L);

Answer 3

您可以在自己的类中重新创建问题，方法是向类 Test 添加一个带有两个参数的方法 sleep，如下所示：

public static void sleep(long millis) {
}

public static void sleep(long millis, int nanos) {
}

所以问题确实是方法sleep过载造成的。

JLS 表明初始方法选择代码只查看功能接口的类型参数的数量 - 只有在第二阶段，它才查看功能接口内方法的签名。

JLS 15.13:

无法指定要匹配的特定签名， 例如，Arrays::sort(int[])。相反，功能接口 提供用作重载输入的参数类型 分辨率算法（§15.12.2）。

（本节倒数第二段）

所以在Thread::sleep 的情况下，void sleep(long) 可能匹配功能接口FooVoid<P>，而重载void sleep(long, int) 可能匹配功能接口Foo<P, R>。这就是为什么您会收到“对 foo 的引用不明确”的错误。

当它尝试进一步查看如何将Foo<P, R> 与函数方法R call(P param1) 匹配到方法void sleep(long, int) 时，它发现这实际上是不可能的，并且您会得到另一个编译错误：

test/Test.java:7: error: incompatible types: cannot infer type-variable(s) P,R
        foo(Thread::sleep, 1000L); // error
           ^
    (argument mismatch; bad return type in method reference
      void cannot be converted to R)