Java8 函数式【1】：一文读懂逆变

禁止转载

pure function
协变
逆变

Java8 引入了函数式接口，从此方法传参可以传递函数了，有人说：

不就是传一个方法吗，语法糖！

lambda表达式？语法糖！

你是否认为协变和逆变只是定义了集合间的关系，如果你的回答是是，那么这篇文章会改变你原有的看法。

尝试回答一下问题：

函数和方法有区别吗？

协变是什么，有什么使用场景

逆变是什么，有什么使用场景

一、纯函数—没有副作用

纯函数的执行不会带来对象内部参数、方法参数、数据库等的改变，这些改变都是副作用。比如Integer::sum是一个纯函数，输入为两个int，输出为两数之和，两个输入量不会改变，在Java 中可以申明为final int类型。

副作用的执行

Java对于不变类的约束明显不足，比如final array只能保证引用的指向不变，array内部的值还是可以改变的，如果存在第二个引用指向相同的array，那么将无法保证array不可变；标准库中的collection常用的还是属于可变muttable类型，可变类型在使用时很便利。

在函数式思想下，函数是一等公民，函数是有值的，比如Integer::sum就是函数类型BiFunction<Integer, Integer, Integer>的一个值，没有副作用的函数保证了函数可以看做一个黑盒，一个固定的输入便有固定的输出。

那么Java中对象的方法是纯函数吗？

大多数时候不是。对象的方法受到对象的状态影响，如果对象的状态不发生改变，同时不对外部产生影响（比如打印字符串），可以看做纯函数。注意：Java中的final类无法保证内部参数状态不发生改变。

那么纯函数的限制这么多，究竟有什么用呢？相信看到最后你会懂的。

本文之后讨论的函数都默认为纯函数。

二、协变—更抽象的继承关系

协变和逆变描述了继承关系的传递特性，协变比逆变更好理解，逆变我放到后面说。

学习这些概念前先不要考虑Java对泛型的实现，它会影响你的正确认识。当你对这些概念理解了之后，再往Java的实现上面去套用，你就很容易理解了。

协变的简单定义：如果A是B的子类，那么F(A)是F(B) 的子类。F表示的是一直类型变换。

比如：猫是动物，表示为Cat < Animal，那么一群猫是一群动物，表示为List[Cat] < List[Aniaml]。

上面的关系很好理解，在面向对象语言中，is-a表示为继承关系，即猫是动物的子类（subtype）。

所以，协变可以这样表示：

A < B ⇒ F(A) < F(B)

在猫的例子中，F表示集合。

那么如果F是函数呢？

我们定义函数F=Provider，函数的类型定义包括入参和出参，简单地考虑入参为空，出参为Animal和Cat的情况。简单理解为方法F定义为获取猫或动物。

那么Supplier作用Cat和Animal上，原来的类型关系保持吗？

答案是保持，Supplier[Cat] < Supplier[Animal]。也就是说获取一只猫就是获取一只动物。转换成面向对象的语言，Supplier[Cat]是Supplier[Animal]的子类。

在面向对象语言中，子类关系常常表现为不同类型之间的兼容。也就是说传值的类型必须为声明的类型的子类。如下面的代码是好的

List[User] users = List(user1, user2)

List[Animal] animals = cats

Supplier[Animal] supplierWithAnimal = supplierWithCat

// 使用Supplier[Animal],实际上得到的是Cat

Animal animal = supplierWithAnimal.get()

我们来看下百度百科对于里氏替换原则（LSP）的定义：

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。里氏代换原则中说，任何父类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当子类可以替换掉父类，软件单位的功能不受到影响时，父类才能真正被复用，而子类也能够在父类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而子类与父类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

Animal animal = new Cat(”kitty”);

在UML图中，一般父类在上，子类在下。因此，子类赋值到父类声明的过程可以形象地称为向上转型。

总结一下：协变是LSP的体现，形象的理解为向上转型。

三、逆变—难以理解的概念

与协变的定义相反，逆变可以这样表示：

A < B ⇒ F(B) < F(A)

最简单的逆变类是Consumer[T]，考虑Consumer[Fruit] 和 Consumer[Apple]。榨汁机就是一类Consumer，接受的是水果，输出的是果汁。我定义的函数accpt为了避免副作用，返回字符串，然后再打印。

下面我用scala写的示例，其比Java简洁一些，也是静态强类型语言。你可以使用网络上的在线运行环境运行scastie.scala-lang.org。

// scala 变量名在前，类型在后，函数返回类型在括号后，可以省略

class Fruit(val name: String) {}

class Apple extends Fruit("苹果") {}

class Orange extends Fruit("橙子") {}

// 榨汁机,T表示泛型，<:表示匹配上界（榨汁机只能榨果汁），-T 表示T支持逆变

class Juicer[-T <: Fruit] {

  def accept(fruit: T) = s"${fruit.name}汁"

}

val appleJuicer: Juicer[Apple] = Juicer[Fruit]()

println(appleJuicer.accept(Apple()))

// 编译不通过，因为appleJuicer的类型是Juicer[Apple]

// 虽然声明appleJuicer时传递的值是水果榨汁机，但是编译器只做类型检查，Juicer[Apple]类型不能接受其他水果

println(appleJuicer.accept(Orange()))

榨汁机 is-a 榨苹果汁机，因为榨汁机可以榨苹果。

逆变难以理解的点就在于逆变考虑的是函数的功能，而不是函数具体的参数。

参数传参原则上都可以支持逆变，因为对于纯函数而言，参数值并不可变。

再举一个例子，Java8 中stream的map方法需要的参数就是一个函数：

// map方法声明

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

// 此时方法的参数就是T，我们传递的mapper的入参可以为T的父类, 因为mapper支持参数逆变

// 如下程序可以运行

// 你可以对任意一个Stream<T>流使用map(Object::toString)，因为在Java中所有类都继承自Object。

Stream.of(1, 2, 3).map(Object::toString).forEach(System.out::println);

问题可以再复杂一点，如果函数的参数为集合类型，还可以支持逆变吗？

当然可以，如前所述，逆变考虑的是函数的功能，传入一个更为一般的函数也可以处理具体的问题。

// Scala中可以使用 ::: 运算符合并两个List, 下一行是List中对方法:::的声明

// def ::: [B >: A](prefix: List[B]): List[B]

// 这个方法在Java很难实现，你可以看看ArrayList::addAll的参数, 然后想想曲线救国的方案，下一篇文章我会详细讨论

// usage

val list: List[Fruit] = List(Apple()) ::: (List(Fruit("水果")))

println(list)

// output: List(Playground$Apple@74046e99, Playground$Fruit@8f0fecd)

总结一下：函数的入参可以支持逆变，即参数的继承关系和函数的继承关系相反，逆变的函数更通用。

不知道你是否还记得Effective Java中提出的PECS法则，Provider-extends, Consumer-super，这个法则和本文所说的协变、逆变又有什么关系呢？

其实PECS法则从使用角度实现了许多泛型方法，下一篇文章再详细说吧。