一、纯函数—没有副作用
纯函数的执行不会带来对象内部参数、方法参数、数据库等的改变,这些改变都是副作用。比如Integer::sum是一个纯函数,输入为两个int,输出为两数之和,两个输入量不会改变,在Java 中可以申明为final int类型。
小伙伴们有兴趣想了解内容和更多相关学习资料的请点赞收藏+评论转发+关注我,后面会有很多干货。我有一些面试题、架构、设计类资料可以说是程序员面试必备!
所有资料都整理到网盘了,需要的话欢迎下载!私信我回复【111】即可免费获取
副作用的执行
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)的定义:
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,这个法则和本文所说的协变、逆变又有什么关系呢?