Java 编译错误：方法引用与重载相结合

Question

我有以下具有重载方法的类：

import java.util.ArrayList;
import java.util.concurrent.Callable;

public abstract class Test {

  public void test1 () {
    doStuff (ArrayList::new); // compilation error
  }

  public void test2 () {
    doStuff ( () -> new ArrayList<> ());
  }

  public abstract void doStuff (Runnable runable);

  public abstract void doStuff (Callable<ArrayList<String>> callable);
}

方法test1 导致编译错误并显示错误消息 The method doStuff(Runnable) is ambiguous for the type Test.

我添加了第三种方法test3，如下所示：

public void test3 () {
    doStuff ( () -> {
      new ArrayList<> ();
    });
  }

这里执行了doStuff(Runnable)方法，这是显而易见的。

但是编译器如何决定在test2中执行这两个方法中的哪一个呢？

为什么我可以使用 lambda 表达式而不是方法引用？

test2 中的 lambda 表达式使用返回可调用的方法，为什么方法引用尝试使用其他方法？

在我看来，这就像一个 java 错误。

编辑： 它与ArrayList 和/或它的泛型类型无关。当您有 Callable<String> 或任何其他对象时，同样的错误。

提前致谢

迪米特里

Answer 1

好吧，我们可以简化一下：

// takes a Runnable
public static void doStuff(Runnable runable) {
    System.out.println("Runnable");
}

// takes a Callable
public static void doStuff(Callable<List<String>> callable) {
    System.out.println("Callable");
}

还有两个额外的重载方法。

private static List<String> go() {
    return null;
}

private static List<String> go(int i) {
    return null;
}

如果你这样称呼，你认为会发生什么：

doStuff(YourClass::go);

是的...这将无法匹配。您可能会认为这很愚蠢，因为只有 go 是不带参数的那个才有意义，在这种简单的情况下你很容易做出这个判断，而不是编译器。本质上，这就像一个死锁：

为了知道调用哪个doStuff方法，我们需要知道调用哪个go；同时要了解调用哪个go，我们需要知道调用哪个doStuff，或：

我们需要解析方法才能找到目标类型，但我们需要知道目标类型才能解析方法。

ArrayList 拥有多个构造函数时也会发生同样的情况......

Answer 2

但是编译器如何决定在test2中执行这两个方法中的哪一个呢？

public void test2 () {
    doStuff ( () -> new ArrayList<> ());
}

是隐含的

public void test2 () {
    doStuff ( () -> { return new ArrayList<>(); } );
}

并且只有 Callable 返回一个对象。

为什么我可以使用 lambda 表达式而不是方法引用？

可能是

public void test2 () {
    doStuff ( () -> { new ArrayList<>(); } );
}

Answer 3

已编辑

看看这些例子：

Runnable r = ArrayList::new; // compiled
Callable c = ArrayList::new; // compiled
doStuff(ArrayList::new); // compile error, ambiguous

所以ArrayList::new 被解释为Runnable 和Callable。请注意，不涉及 lambda。

下一个例子：

Runnable r = () -> new ArrayList<>(); // compiled
Callable c = () ->  new ArrayList<>(); // compiled
doStuff(() -> new ArrayList<>()); // compiled, the Callable one

将() -> new ArrayList<>() 传递给方法时

() -> { return new ArrayList<>(); }

优于

() -> { new ArrayList<>(); }

所以，Callable 被调用，没有任何歧义。