Java 8 如何推断 lambdas 参数类型

我目前正在使用 Java 中的 Vert.x，并注意到文档中的示例广泛使用 lambda 作为回调参数。例如：

NetServer server = vertx.createNetServer();
server.listen(1234, "localhost", res -> {
  if (res.succeeded()) {
    System.out.println("Server is now listening!");
  } else {
    System.out.println("Failed to bind!");
  }
});

查看文档listen函数显示如下：

NetServer listen(int port,
                 String host,
                 Handler<AsyncResult<NetServer>> listenHandler)

我的问题是 JVM 如何有机会推导出通用数据类型，例如Handler<AsyncResult<NetServer>>从此类非信息对象中，例如res？对于像 JavaScript 这样执行鸭子类型的语言来说，这似乎很好，但对于像 Java 这样执行强类型的语言来说，这对我来说就不那么明显了。如果我们使用匿名类而不是 lambda，则所有数据类型都将出现。

- 编辑 - 正如@Zircon 已经解释的那样，Vert.x 文档中更好的示例可能是以下声明：

<T> void executeBlocking(Handler<Future<T>> blockingCodeHandler,
                         Handler<AsyncResult<T>> resultHandler)

文档中的用法示例：

vertx.executeBlocking(future -> {
  // Call some blocking API that takes a significant amount of time to return
  String result = someAPI.blockingMethod("hello");
  future.complete(result);
}, res -> {
  System.out.println("The result is: " + res.result());
});

如果 type of 不可用，则只有 on 可用的方法Future and AsyncResults可以使用。

编译器以与您完全相同的方式推断类型。

Netserver.listen需要一个Handler<AsyncResult<NetServer>>作为它的第三个参数。

Handler是一个具有一种方法的顶点功能接口handle(E event)。在这种情况下，E is AsyncResult<NetServer>.

在这里插入 lambda 使其取代Handler.handle。因此，单一论证res必须是类型AsyncResult<NetServer>。这就是为什么它可以调用AsyncResult.succeeded没有问题。

Simply:

第三个论证是不可能的listen绝不是Handler<AsyncResult<NetServer>>，所以 lambda 必须提供一个类型的参数<AsyncResult<NetServer>>.

Edit:

关于在 lambda 中使用嵌套泛型，请考虑此类：

public class myClass<T> {
    public void doSomething(int port, String host, Handler<AsyncResult<T>> handler) {
        //Stuff happens
    }
}

（在这种情况下，我们不关心发生的事情。）

然而，考虑一下我们需要如何call这个方法。我们需要有一个 MyClass 的实例，这也意味着我们需要在调用之前声明泛型类型doSomething:

MyClass<String> myObj = new MyClass<String>();
result = myObj.doSomething(port, host, res -> {
  if (res.succeeded()) {
    System.out.println("I did a thing!");
  } else {
    System.out.println("I did not do a thing!");
  }
});

在这种情况下，编译器可以still infer res as an AsyncResult<String>， 因为T is String在这种情况下。如果我打开包装AsyncResult，然后我可以打电话String方法如toUpperCase等等。

如果您最终引用了MyClass<?>并尝试类似地使用 lambda，res将被推断为AsyncResult<?>。 （您可以打开?类型，但因为它的类型在编译时无法得知，所以您被迫将其视为Object.)

如果我们在声明期间没有声明泛型类型，我们将收到有关它的警告，并且由于原始类型的原因，此代码将无法工作（感谢 Holger）：

MyClass myObj = new MyClass(); //Generic type warning
result = myObj.doSomething(port, host, res -> {
  if (res.succeeded()) { //Error
    System.out.println("I did a thing!");
  } else {
    System.out.println("I did not do a thing!");
  }
});

因为我们已经声明了myObj作为原始类型MyClass, res成为类型Object (Not AsyncResult<Object>），所以我们不能调用succeeded on it.

这样，您就不可能在不确切知道通过其参数推断出什么类型的情况下使用 lambda。

可能有一些高级方法可以使用 lambda 代替泛型类型在其自己的签名中声明的方法，但我需要做一些研究来说明这些观点。本质上，即使可能发生这种情况，您也需要致电MyClass.<MyType>doSomethingStatic为了在声明 lambda 之前声明类型，以便可以推断类型。

Simply:

您不能在无法推断类型的情况下使用 lambda。泛型不会改变这一点。