Java 番石榴期货中的模糊lambda过载

我相信我在这里遇到了eclipse bug，但我想确认一下。
我使用的是Java8（JDK1.8.0102），我的代码编译正常，但eclipse给了我一个错误

我的代码如下所示：

public ListenableFuture<ProtoBufExchange> myMethod(
   //some code here
   return Futures.transform(future,(Request.Builder reqBuilder) -> {

    //some code here

    return Futures.immediateFuture(exchange);
  }

public-ListenableFuture-myMethod(
//这里有一些代码
return Futures.transform（future，（Request.Builder-reqBuilder）->{
//这里有一些代码
回报期货。即时期货（交易所）；
}

eclipse中显示的错误如下：

---

方法转换（ListenableFuture，AsyncFunction在“显式类型的lambda表达式”和“隐式类型的lambda表达式”之间有区别

一个隐式类型的lambda表达式，其形式为

name->expressioorblock

或

（name[，name]*）->expressionOrBlock

需要其上下文（即解析的方法）来确定其类型，因此不用于消除重载方法的歧义。这样做并非不可能，但由于由此产生的复杂性，规范明确排除了它

形式为

（Type name[，Type name]*）->expressionOrBlock

的显式类型lambda表达式具有确定其函数签名所需的一切，包括其返回类型，这允许使用它们消除重载方法的歧义

提供一个简单的示例：

interface F<T,R> {
    R apply(T t);
}
interface AF<T,R> {
    Future<R> apply(T t);
}
static <T,R> Future<R> method(F<T,R> f) {
    return null;
}
static <T,R> Future<R> method(AF<T,R> f) {
    return null;
}
public static void main(String[] args) {
    // these two don't compile
    method(x -> "bla");
    method(x -> new FutureTask<String>(null));

    // these two do compile
    method((Object x) -> "bla");
    method((Object x) -> new FutureTask<String>(null));
}

接口F{
R应用（T）；
}
接口AF{
未来应用（T）；
}
静态未来法（F）{
返回null；
}
静态未来法（AF）{
返回null；
}
公共静态void main（字符串[]args）{
//这两个不可编译
方法（x->“bla”）；
方法（x->new FutureTask（null））；
//这两个都可以编译
方法（（对象x）->“bla”）；
方法（（对象x）->new FutureTask（null））；
}

正式规则在中指定，但也包含非正式提示：

非正式的直觉是，如果第一个方法处理的任何调用都可以传递给另一个方法而不会出现编译时错误，那么一个方法比另一个方法更为具体

我认为，很容易看出，可以由

方法（AF）

处理的每个调用也可以由

方法（F）

处理，而相反的情况不适用，即

方法（（对象x）->“bla”）

调用只能由

方法（F）

处理，因此它并不含糊不清，而

方法（（对象x）->new FutureTask（null））

可以由两者处理，但

方法（AF）

更具体

最重要的是：

对于表达式

e

，如果

T

不是

S

的子类型，且下列情况之一为真，则功能接口类型

S

比功能接口类型

T

更为具体₁英国和英国₁是捕获

S

和

V的函数类型的参数类型和返回类型₁和
R₂
是
T
）函数类型的参数类型和返回类型：


如果e是一个显式类型的lambda表达式（§15.27.1），则以下情况之一为真：

R₂为
无效

R₁
在“显式类型的lambda表达式”和“隐式类型的lambda表达式”之间有区别

一个隐式类型的lambda表达式，其形式为
name->expressioorblock
或
（name[，name]*）->expressionOrBlock
需要其上下文（即解析的方法）来确定其类型，因此不用于消除重载方法的歧义。这样做并非不可能，但由于由此产生的复杂性，规范明确排除了它

形式为
（Type name[，Type name]*）->expressionOrBlock
的显式类型lambda表达式具有确定其函数签名所需的一切，包括其返回类型，这允许使用它们消除重载方法的歧义

提供一个简单的示例：

interface F<T,R> {
    R apply(T t);
}
interface AF<T,R> {
    Future<R> apply(T t);
}
static <T,R> Future<R> method(F<T,R> f) {
    return null;
}
static <T,R> Future<R> method(AF<T,R> f) {
    return null;
}
public static void main(String[] args) {
    // these two don't compile
    method(x -> "bla");
    method(x -> new FutureTask<String>(null));

    // these two do compile
    method((Object x) -> "bla");
    method((Object x) -> new FutureTask<String>(null));
}

接口F{
R应用（T）；
}
接口AF{
未来应用（T）；
}
静态未来法（F）{
返回null；
}
静态未来法（AF）{
返回null；
}
公共静态void main（字符串[]args）{
//这两个不可编译
方法（x->“bla”）；
方法（x->new FutureTask（null））；
//这两个都可以编译
方法（（对象x）->“bla”）；
方法（（对象x）->new FutureTask（null））；
}

正式规则在中指定，但也包含非正式提示：

非正式的直觉是，如果第一个方法处理的任何调用都可以传递给另一个方法而不会出现编译时错误，那么一个方法比另一个方法更为具体

我认为，很容易看出，可以由
方法（AF）
处理的每个调用也可以由
方法（F）
处理，而相反的情况不适用，即
方法（（对象x）->“bla”）
调用只能由
方法（F）
处理，因此它并不含糊不清，而
方法（（对象x）->new FutureTask（null））
可以由两者处理，但
方法（AF）
更具体

最重要的是：

对于表达式
e
，如果
T
不是
S
的子类型，且下列情况之一为真，则功能接口类型
S
比功能接口类型
T
更为具体₁英国和英国₁
是捕获
S
和
V的函数类型的参数类型和返回类型₁和
R₂
是
T
）函数类型的参数类型和返回类型：


如果e是一个显式类型的lambda表达式（§15.27.1），则以下情况之一为真：

R₂为
无效

<代码
transform(ListenableFuture<I> input, AsyncFunction<? super I,? extends O> function)

interface F<T,R> {
    R apply(T t);
}
interface AF<T,R> {
    Future<R> apply(T t);
}
static <T,R> Future<R> method(F<T,R> f) {
    return null;
}
static <T,R> Future<R> method(AF<T,R> f) {
    return null;
}
public static void main(String[] args) {
    // these two don't compile
    method(x -> "bla");
    method(x -> new FutureTask<String>(null));

    // these two do compile
    method((Object x) -> "bla");
    method((Object x) -> new FutureTask<String>(null));
}