Java 8 - 04 类型检查、类型推断以及限制

Pre

当我们第一次提到Lambda表达式时，说它可以为函数式接口生成一个实例。然而，Lambda 表达式本身并不包含它在实现哪个函数式接口的信息。为了全面了解Lambda表达式，women 应该知道Lambda的实际类型是什么 .

类型检查

Lambda的类型是从使用Lambda的上下文推断出来的。 上下文（比如，接受它传递的方法的参数，或接受它的值的局部变量）中Lambda表达式需要的类型称为目标类型。

举个例子

List<Apple> heavierThan150g = filter(inventory, (Apple a) -> a.getWeight() > 150);

类型检查过程可以分解为如下所示。  首先，我们要找出 filter 方法的声明。  第二，要求它是 Predicate （目标类型）对象的第二个正式参数。  第三， Predicate 是一个函数式接口，定义了一个叫作 test 的抽象方法。  第四， test 方法描述了一个函数描述符，它可以接受一个 Apple ，并返回一个 boolean 。  最后， filter 的任何实际参数都必须匹配这个要求

这段代码是有效的，因为我们所传递的Lambda表达式也同样接受 Apple 为参数，并返回一个boolean 。请注意，如果Lambda表达式抛出一个异常，那么抽象方法所声明的 throws 语句也必须与之匹配

同样的 Lambda，不同的函数式接口

有了目标类型的概念，同一个Lambda表达式就可以与不同的函数式接口联系起来，只要它们的抽象方法签名能够兼容.

我们来看下这两个函数式接口

这两个函数式接口 都是 什么也不接受且返回一个泛型 T 的函数， 所以 下面两个赋值是有效的

 Callable<Integer> integerCallable = () -> 18;
 PrivilegedAction<Integer> privilegedAction = () -> 18;

第一个赋值的目标类型是 Callable 第二个赋值的目标类型是PrivilegedAction

再举个栗子 ： 同一个Lambda可用于多个不同的函数式接口

    Comparator<Enginner> enginnerComparator = (e1, e2) -> e1.getJob().compareTo(e2.getJob());
    ToIntBiFunction<Enginner, Enginner> toIntBiFunction = (e1, e2) -> e1.getJob().compareTo(e2.getJob());
    BiFunction<Enginner, Enginner, Integer> toIntFunction = (e1, e2) -> e1.getJob().compareTo(e2.getJob());

Comparator 、 ToIntBiFunction 、 BiFunction 都是返回一个int类型的的函数

菱形运算符

Java 7中已经引入了菱形运算符（ <> ），利用泛型推断从上下文推断类型的思想。 一个类实例表达式可以出现在两个或更多不同的上下文中，并会像下面这样推断出适当的类型参数。

List<String> listOfStrings = new ArrayList<>();
List<Integer> listOfIntegers = new ArrayList<>();

特殊的void兼容规则

如果一个Lambda的主体是一个语句表达式， 它就和一个返回 void 的函数描述符兼容（当然需要参数列表也兼容）。

举个例子：

以下两行都是合法的，尽管 List 的 add 方法返回了一个boolean ，而不是 Consumer 上下文（ T -> void ）所要求的 void

   List<String> stringList = new ArrayList<>();
  // Predicate返回了一个boolean
  Predicate<String> predicate = s -> stringList.add(s);
   // Consumer返回了一个void
   Consumer<String> consumer =    s -> stringList.add(s);

经过了这几个小demo ,是不是能够很好地理解在什么时候以及在哪里可以使用Lambda表达式了。Lambda表达式可以从赋值的上下文、方法调用的上下文（参数和返回值），以及类型转换的上下文中获得目标类型

来个小测验

类型检查——为什么下面的代码不能编译呢？
Object o = () -> {System.out.println("Tricky example"); };

答案： 
Lambda表达式的上下文是 Object （目标类型）。但 Object 不是一个函数式接口 。 为了解决这个问题，可以把目标类型改成 Runnable ，它的函数描述符是 () -> void ：

Runnable r = () -> {System.out.println("Tricky example"); };

类型推断

刚才已经讨论了如何利用目标类型来检查一个Lambda是否可以用于某个特定的上下文。其实， 它也可以用来做一些略有不同的事：推断Lambda参数的类型，我们来看下。

Java编译器会从上下文（目标类型）推断出用什么函数式接口来配合Lambda表达式，这意味着它也可以推断出适合Lambda的签名，因为函数描述符可以通过目标类型来得到。这样做的好处在于，编译器可以了解Lambda表达式的参数类型，这样就可以在Lambda语法中省去标注参数类型.

举个例子

 List<Enginner> goEngineerList = filter(enginnerList,a-> a.getJob().equals("GO"));

参数 a 没有显式类型 .

再举个栗子 ，Lambda表达式有多个参数，代码可读性的好处就更为明显

     // 没有类型推断，因为给o1,o2指定了Enginner 类型
    Comparator<Enginner> comparator = (Enginner o1, Enginner o2) -> o1.getJob().compareTo(o2.getJob());
    

     //  有类型推断，因为没有给o1,o2指定了Enginner 类型
     Comparator<Enginner> comparator2 = ( o1,  o2) -> o1.getJob().compareTo(o2.getJob());

个人感觉，第二种写法更简单 。

当Lambda仅有一个类型需要推断的参数时，参数名称两边的括号也可以省略。

使用局部变量

上面所介绍的所有Lambda表达式都只用到了其主体里面的参数。但Lambda表达式也允许使用自由变量（不是参数，而是在外层作用域中定义的变量），就像匿名类一样。 它们被称作捕获Lambda。

举个例子

  int num = 1;
  Runnable runnable = ()->System.out.println(num);

这么做虽然有点啰嗦，我们这里想要讨论的是 使用外部的变量有什么限制吗？

如果你想要对这个变量进行操作，之前的lambda就报错了。所以说Lambda可以没有限制地捕获（也就是在其主体中引用）实例变量和静态变量,但是局部变量必须显式声明为 final.

换句话说，Lambda表达式只能捕获指派给它们的局部变量一次。（注：捕获实例变量可以被看作捕获最终局部变量 this 。） 如上图。

为什么会这样呢？

• 第一： 实例变量都存储在堆中，而局部变量则保存在栈上。如果Lambda可以直接访问局部变量，而且Lambda是在一个线程中使用的，则使用Lambda的线程，可能会在分配该变量的线程将这个变量收回之后，去访问该变量。因此，Java在访问自由局部变量时，实际上是在访问的副本，而不是访问原始变量。如果局部变量仅仅赋值一次那就没有什么区别了——因此就有了这个限制
• 第二，这一限制不鼓励你使用改变外部变量的典型命令式编程模式,这种模式会阻碍很容易做到的并行处理.