目录

面向对象和函数式编程的混合_Java8和Scala的比较

本章内容

  • 什么是Scala语言
  • Java 8与Scala是如何相生相承的
  • Scala中的函数与Java 8中的函数有哪些区别
  • 类和trait

Scala是一种混合了面向对象和函数式编程的语言。它常常被看作Java的一种替代语言,程序 员们希望在运行于JVM上的静态类型语言中使用函数式特性,同时又期望保持Java体验的一致 性。和Java比较起来,Scala提供了更多的特性,包括更复杂的类型系统、类型推断、模式匹配(我 们在14.4节提到过)、定义域语言的结构等。除此之外,你可以在Scala代码中直接使用任何一个 Java类库。

你可能会有这样的疑惑,我们为什么要在一本介绍Java 8的书里特别设计一章讨论Scala。本 书的绝大部分内容都在介绍如何在Java中应用函数式编程。Scala和Java 8极其类似,它们都支持 对集合的函数式处理(类似于对Stream的操作)、一等函数、默认方法。不过Scala将这些思想向 前又推进了一大步:它为实现这些思想提供了大量的特性,这方面它领先了Java 8一大截。我们 相信你会发现,对比Scala和Java 8在实现方式上的不同以及了解Java 8目前的局限是非常有趣的。 通过这一章,我们希望能针对这些问题为你提供一些线索,解答一些疑惑。

请记住,本章的目的并非让你掌握如何编写纯粹的Scala代码,或者了解Scala的方方面面。 不少的特性,比如模式匹配,在Scala中是天然支持的,也非常容易理解,不过这些特性在Java 8 中却并未提供,这部分内容我们在这里不会涉及。本章着重对比Java 8中新引入的特性和该特性 在Scala中的实现,帮助你更全面地理解该特性。比如,你会发现,用Scala重新实现原先用Java 完成的代码更简单,可读性也更好。

本章从对Scala的介绍入手:让你了解如何使用Scala编写简单的程序,以及如何处理集合。 紧接着我们会讨论Scala中的函数式,包括一等函数、闭包以及科里化。最后,我们会一起看看 Scala中的类,以及一种名为trait的特性,它是Scala中带默认方法的接口。

Scala简介

本节会简要地介绍Scala的一些基本特性,让你有一个比较直观的感受:到底简单的Scala程序 怎么编写。我们从一个略微改动的Hello World示例入手,该程序会以两种方式编写,一种以命令 式的风格编写,另一种以函数式的风格编写。接着,我们会看看Scala支持哪些数据结构——List、 Set、Map、Stream、Tuple以及Option——并将它们与Java 8中对应的数据结构一一进行比较。 最后,我们会介绍trait,它是Scala中接口的替代品,支持在对象实例化时对方法进行继承。

你好,啤酒

让我们看一个简单的例子,这样你能对Scala的语法、语言特性,以及它与Java的差异有一个 比较直观的认识。我们对经典的Hello World示例进行了微调,让我们来点儿啤酒。你希望在屏幕 上打印输出下面这些内容:

1
2
3
4
5
Hello 2 bottles of beer 
Hello 3 bottles of beer 
Hello 4 bottles of beer 
Hello 5 bottles of beer 
Hello 6 bottles of beer

命令式Scala

下面这段代码中,Scala以命令式的风格打印输出这段内容:

https://gitee.com/lienhui68/picStore/raw/master/null/20200818010901.png

如何运行这段代码的指导信息可以在 Scala的官方网站 找到。这段代码看起来和你用Java编 写的程序相当类似。它的结构和Java程序几乎一样:它包含了一个名为main的方法,该方法接受 一个由参数构成的数组(类型注释遵循这样的语法s : String,不像Java那样用String s)。 由于main方法不返回值,所以使用Scala不需要像Java那样声明一个类型为void的返回值。

通常而言,在Scala中声明非递归的方法时,不需要显式地返回类型,因为Scala会自动地 替你推断生成一个。

转入main的方法体之前,我们想先讨论下对象的声明。不管怎样,Java中的main方法都需要在某个类中声明。对象的声明产生了一个单例的对象:它声明了一个对象,比如Bear,与此 同时又对其进行了实例化。整个过程中只有一个实例被创建。这是第一个以经典的设计模式(即 单例模式)实现语言特性的例子——尽量不拘一格地使用它!此外,你可以将对象声明中的方法 看成静态的,这也是main方法的方法签名中并未显式地声明为静态的原因。

现在让我们看看main的方法体。它看起来和Java非常类似,但是语句不需要再以分号结尾了 (它成了一种可选项)。方法体中包含了一个while循环,它会递增一个可修改变量n。通过预定 义的方法println,你可以打印输出n的每一个新值。println这一行还展示了Scala的另一个特 性:字符串插值字符串插值在字符串的字面量中内嵌变量和表达式。前面的这段代码中,你在 字符串字面量s"Hello ${n} bottles of beer"中直接使用了变量n。字符串前附加的插值操作符s,神奇地完成了这一转变。而在Java中,你通常需要使用显式的连接操作,比如"Hello " + n + " bottles of beer",才能达到同样的效果。

函数式Scala

那么,Scala到底能带来哪些好处呢?毕竟我们在本书里主要讨论的还是函数式。前面的这段 代码利用Java 8的新特性能以更加函数式的方式实现,如下所示:

1
2
3
4
5
public class Foo {
    public static void main(String[] args) {
        IntStream.rangeClosed(2, 6).forEach(n -> System.out.println("Hello " + n + " bottles of beer"));
    }
}

如果以Scala来实现,它是下面这样的:

https://gitee.com/lienhui68/picStore/raw/master/null/20200818011412.png

这种实现看起来和基于Java的版本有几分相似,不过Scala的实现更加简洁。首先,你使用表 达式2 to 6创建了一个区间。这看起来相当特别: 2在这里并非原始数据类型,在Scala中它是 一个类型为Int的对象。Scala语言里,任何事物都是对象;不像Java那样,Scala没有原始数据类 型一说了。通过这种方式,Scala被转变成为了纯粹的面向对象语言。Scala语言中Int对象支持名 为to的方法,它接受另一个Int对象,返回一个区间。所以,你还可以通过另一种方式实现这一 语句,即2.to(6)。由于接受一个参数的方法可以采用中缀式表达,所以你可以用开头的方式实现这一语句。紧接着,我们看到了foreach(这里的e采用的是小写),它和Java 8中的forEach (使用了大写的E)也很类似。它是对一个区间进行操作的函数(这里你可以再次使用中缀表达式), 它可以接受Lambda表达式做参数,对区间的每一个元素顺次执行操作。这里Lambda表达式的语 法和Java 8也非常类似,区别是箭头的表示用=>替换了-> ① 。前面的这段代码是函数式的:因为就像我们早期使用while循环时示例的那样,你并未修改任何变量。

① 注意,在Scala语言中,我们使用“匿名函数”或者“闭包”(可以互相替换)来指代Java 8中的Lambda表达式。

基础数据结构:List、Set、Map、Tuple、Stream以及Option

几杯啤酒之后,你一定已经止住口渴,精神一振了吧?大多数的程序都需要操纵和存储数据, 那么,就让我们一起看看如何在Scala中操作集合,以及它与Java 8中操作的不同。

创建集合

在Scala中创建集合是非常简单的,这主要归功于它对简洁性的一贯坚持。比如,创建一个 Map,你可以用下面的方式:

1
val authorsToAge = Map("Raoul" -> 23, "Mario" -> 40, "Alan" -> 53)

这行代码中,有几件事情是我们首次碰到的。首先,你使用->语法轻而易举地创建了一个 Map,并完成了键到值的映射,整个过程令人吃惊地简单。你不再需要像Java中那样手工添加每 一个元素:

1
2
3
4
Map<String, Integer> authorsToAge = new HashMap<>();
authorsToAge.put("Raoul", 23);
authorsToAge.put("Mario", 40);
authorsToAge.put("Alan", 53);

关于这一点,也有一些讨论,希望在未来的Java版本中添加类似的语法糖,不过在Java 8中 暂时还没有这样的特性。第二件让人耳目一新的事是你可以选择不对变量authorsToAge的类型进行注解。实际上,你可以编写val authorsToAge : Map[String, Int]这样的代码,显式地声明变量类型,不过Scala可以替你推断变量的类型(请注意,即便如此,代码依旧是静态检查 的!所有的变量在编译时都具有确定的类型)。我们会在本章后续部分继续讨论这一特性。第三, 你可以使用val关键字替换var。这二者之间存在什么差别吗?关键字val表明变量是只读的,并 由此不能被赋值(就像Java中声明为final的变量一样)。而关键字var表明变量是可以读写的。

听起来不错,那么其他的集合类型呢?你可以用同样的方式轻松地创建List(一种单向链 表)或者Set(不带冗余数据的集合),如下所示:

1
2
val authors = List("Raoul", "Mario", "Alan") 
val numbers = Set(1, 1, 2, 3, 5, 8)

这里的变量authors包含3个元素,而变量numbers包含5个元素。

不可变与可变的比较

Scala的集合有一个重要的特质我们应该牢记在心,那就是我们之前创建的集合在默认情况下 都是只读的。这意味着它们从创建开始就不能修改。这是一种非常有用的特性,因为有了它,你 知道任何时候访问程序中的集合都会返回包含相同元素的集合。

那么,你怎样才能更新Scala语言中不可变的集合呢?回到前面章节介绍的术语,Scala中的 这些集合都是持久化的:更新一个Scala集合会生成一个新的集合,这个新的集合和之前版本的集合共享大部分的内容,最终的结果是数据尽可能地实现了持久化,避免了图14-3和图14-4中那样 由于改变所引起的问题。由于具备这一属性,你代码的隐式数据依赖更少: 对你代码中集合变 更的困惑(比如在何处更新了集合,什么时候做的更新)也会更少。

让我们看一个实际的例子,具体分析下这一思想是如何影响你的程序设计的。下面这段代码 中,我们会为Set添加一个元素:

https://gitee.com/lienhui68/picStore/raw/master/null/20200818012205.png

这个例子中,原始Set对象中的数字没有发生变更。实际的效果是该操作创建了一个新的 Set,并向其中加入了一个新的元素。

注意,Scala语言并未强制你必须使用不可变集合,它只是让你能更轻松地在你的代码中应用 不可变原则。scala.collection.mutable包中也包含了集合的可变版本。

不可修改与不可变的比较

Java中提供了多种方法创建不可修改的(unmodifiable)集合。 下面的代码中, 变量newNumbers是集合Set对象numbers的一个只读视图:

1
2
3
Set<Integer> numbers = new HashSet<>();

Set<Integer> newNumbers = Collections.unmodifiableSet(numbers);

这意味着你无法通过操作变量newNumbers向其中加入新的元素。不过,不可修改集合仅仅是对可变集合进行了一层封装。通过直接访问numbers变量,你还是能向其中加入元素。

与此相反,不可变(immutable)集合确保了该集合在任何时候都不会发生变化,无论有多少个变量同时指向它。

我们在第14章介绍过如何创建一个持久化的数据结构:要操作不可变数据结构时,你需要重新创建一个不可变数据结构,该数据结构会保存它自身修改之前的版本。任何的修改都会创建一个更新的数据结构。

使用集合

现在你已经了解了如何创建结合,你还需要了解如何使用这些集合开展工作。我们很快会看 到Scala支持的集合操作和Stream API提供的操作极其类似。比如,在下面的代码片段中,你会发 现熟悉的filter和map,图15-1对这段代码逻辑进行了阐释。

1
2
val fileLines = Source.fromFile("data.txt").getLines.toList() 
val linesLongUpper = fileLines.filter(l => l.length() > 10).map(l => l.toUpperCase())

https://gitee.com/lienhui68/picStore/raw/master/null/20200818012626.png

不用担心第一行的内容,它实现的基本功能是将文件中的所有行转换为一个字符串列表(类 似Java 8提供的Files.readAllLines)。第二行创建了一个由两个操作构成的流水线:

  • filter操作会过滤出所有长度超过10的行
  • map操作会将这些长的字符串统一转换为大写字符

这段代码也可以用下面的方式实现:

1
val linesLongUpper = fileLines filter (_.length() > 10) map(_.toUpperCase())

这段代码使用了中缀表达式和下划线_下划线是一种占位符,它按照位置匹配对应的参数。这个例子中,你可以将_.length()解读为l =>l.length()。在传递给filter和map的函 数中,下划线会被绑定到待处理的line参数。

Scala的集合API提供了很多非常有用的操作。我们强烈建议你抽空浏览一下Scala的文档, 对这些API有一个大致的了解。注意,Scala的集合类提供的功能比Stream API提供的功能还丰 富很多,比如,Scala的集合类支持压缩操作,你可以将两个列表中的元素整合到一个列表中。 通过学习,一定能大大增强你的功力。这些编程技巧在将来的Java版本中也可能会被Stream API 所引入。

最后,还记得吗?Java 8中你可以对Stream调用parallel方法,将流水线转化为并行执行。 Scala提供了类似的技巧;你只需要使用方法par就能实现同样的效果:

1
val linesLongUpper = fileLines.par filter (_.length() > 10) map(_.toUpperCase())

元祖

现在,让我们看看另一个特性,该特性使用起来通常异常繁琐,它就是元组。你可能希望 使用元组将人的名字和电话号码组合起来,同时又不希望额外声明新的类,并对其进行实例化。 你希望元组的结构就像:(“Raoul”,“+ 44 007007007”)、 (“Alan”,“+44 003133700”),诸 如此类。 非常不幸,Java目前还不支持元组,所以你只能创建自己的数据结构。下面是一个简单的Pair 类定义:

1
2
3
4
5
6
7
8
9
public class Pair<X, Y> {
    public final X x;
    public final Y y;

    public Pair(X x, Y y) {
        this.x = x;
        this.y = y;
    }
}

当然,你还需要显式地实例化Pair对象:

1
2
Pair<String, String> raoul = new Pair<>("Raoul", "+ 44 007007007");
Pair<String, String> alan = new Pair<>("Alan", "+44 003133700");

好了,看起来一切顺利,不过如果是三元组呢?如果是自定义大小的元组呢?这个问题就变 得相当繁琐,最终会影响你代码的可读性和可维护性。

Scala提供了名为元组字面量的特性来解决这一问题,这意味着你可以通过简单的语法糖创建 元组,就像普通的数学符号那样:

1
2
val raoul = ("Raoul", "+ 44 887007007") 
val alan = ("Alan", "+44 883133700")

Scala支持任意大小的元组(元组中元素的最大上限为23),所以下面的这些声明都是合法的:

https://gitee.com/lienhui68/picStore/raw/master/null/20200818013238.png

你可以依据它们的位置,通过存取器(accessor) _1、_2(从1开始的一个序列)访问元组 中的元素,比如:

https://gitee.com/lienhui68/picStore/raw/master/null/20200818013309.png

是不是比Java语言中现有的实现方法简单很多?好消息是关于将元组字面量引入到未来Java 版本的讨论正在进行中(我们会在第16章围绕这一主题进行更深入的讨论)。

Stream

到目前为止,我们讨论的集合,包括List、Set、Map和Tuple都是即时计算的(即在第一 时间立刻进行计算)。当然,你也已经了解Java 8中的Stream是按需计算的(即延迟计算)。通过 第5章,你知道由于这一特性,Stream可以表示无限的序列,同时又不消耗太多的内存。

Scala也提供了对应的数据结构,它采用延迟方式计算数据结构,名称也叫Stream!不过Scala 中的Stream提供了更加丰富的功能,让Java中的Stream有些黯然失色。Scala中的Stream可以记 录它曾经计算出的值,所以之前的元素可以随时进行访问。除此之外,Stream还进行了索引, 所以Stream中的元素可以像List那样通过索引访问。注意,这种抉择也附带着开销,由于需要 存储这些额外的属性,和Java 8中的Stream比起来,Scala版本的Stream内存的使用效率变低了, 因为Scala中的Stream需要能够回溯之前的元素,这意味着之前访问过的元素都需要在内存“记 录下来”(即进行缓存)。

Option

另一个你熟悉的数据结构是Option。我们在第10章中讨论过Java的Optional,Option是 Java 8中Optional类型的Scala版本。我们建议你在设计API时尽可能地使用Optional,这种方式下,接口用户只需要阅读方法签名就能了解他们是否应该传递一个optional值。我们应该尽 量地用它替代null,避免发生空指针异常。

第10章中,你了解了我们可以使用Optional返回客户的保险公司名称——如果客户的年龄 超过设置的最低值,就返回该客户对应的保险公司名称,具体代码如下:

1
2
3
4
5
6
7
public String getCarInsuranceName(Optional<Person> person, int minAge) {
    return person.filter(p -> p.getAge() >= minAge)
            .flatMap(Person::getCar)
            .flatMap(Car::getInsurance)
            .map(Insurance::getName)
            .orElse("Unknown");
}

在Scala语言中,你可以使用Option使用Optional类似的方法实现该函数:

1
2
3
4
5
6
def getCarInsuranceName(person: Option[Person], minAge: Int) = 
	person.filter(_.getAge() >= minAge) 
	.flatMap(_.getCar) 
	.flatMap(_.getInsurance) 
	.map(_.getName)
	.getOrElse("Unknown")

这段代码中除了getOrElse方法,其他的结构和方法你一定都非常熟悉,getOrElse是与Java 8中orElse等价的方法。你看到了吗?在本书中学习的新概念能直接应用于其他语言!然而,不 幸的是,为了保持同Java的兼容性,在Scala中依旧保持了null,不过我们极度不推荐你使用它。

在前面的代码中,你使用的是 _.getCar (并未使用圆括号),而不是 _.getCar() (带 圆括号)Scala语言中, 执行方法调用时,如果不需要传递参数,那么函数的圆括号是可以省略的。

函数

Scala中的函数可以看成为了完成某个任务而组合在一起的指令序列。它们对于抽象行为非常 有帮助,是函数式编程的基石。

对于Java语言中的方法,你已经非常熟悉了:它们是与类相关的函数。你也已经了解了Lambda 表达式,它可以看成一种匿名函数。跟Java比较起来,Scala为函数提供的特性要丰富得多,我们 在这一节中会逐一讲解。Scala提供了下面这些特性。

  • 函数类型,它是一种语法糖,体现了Java语言中函数描述符的思想,即,它是一种符号, 表示了在函数接口中声明的抽象方法的签名。这些内容我们在第3章中都介绍过。
  • 能够读写非本地变量的匿名函数, 而Java中的Lambda表达式无法对非本地变量进行写能够读写非本地变量的匿名函数, 而Java中的Lambda表达式无法对非本地变量进行写
  • 对科里化的支持,这意味着你可以将一个接受多个参数的函数拆分成一系列接受部分参数的函数。

Scala中的一等函数

函数在Scala语言中是一等值。这意味着它们可以像其他的值,比如Integer或者String那 样,作为参数传递,可以作为结果值返回。正如我们在前面章节所介绍的那样,Java 8中的方法 引用和Lambda表达式也可以看成一等函数。

让我们看一个例子,看看Scala中的一等函数是如何工作的。我们假设你现在有一个字符串列 表,列表中的值是朋友们发送给你的消息(tweet)。你希望依据不同的筛选条件对该列表进行过 滤,比如,你可能想要找出所有提及Java这个词或者短于某个长度的消息。你可以使用谓词(返 回一个布尔型结果的函数)定义这两个筛选条件,代码如下:

1
2
def isJavaMentioned(tweet: String) : Boolean = tweet.contains("Java")
def isShortTweet(tweet: String) : Boolean = tweet.length() < 20

Scala语言中,你可以直接传递这两个方法给内嵌的filter,如下所示(这和你在Java中使用方法引用将它们传递给某个函数大同小异):

1
2
3
4
5
6
7
val tweets = List( 
	"I love the new features in Java 8", 
	"How's it going?", 
	"An SQL query walks into a bar, sees two tables and says 'Can I join you?'" 
)
tweets.filter(isJavaMentioned).foreach(println) 
tweets.filter(isShortTweet).foreach(println)

现在,让我们一起审视下内嵌方法filter的函数签名:

1
def filter[T](p: (T) => Boolean): List[T]

你可能会疑惑参数p到底代表的是什么类型(即(T) => Boolean),因为在Java语言里你期 望看到的是一个函数接口!这其实是一种新的语法,Java中暂时还不支持。它描述的是一个函数类型。这里它表示的是这样一个函数,它接受类型为T的对象,返回一个布尔类型的值。Java语 言 中 , 它 被 编 码 为 Predicate<T> 或 者 Function<T, Boolean> 所 以 它 实 际 上 和 isJavaMentioned和isShortTweet具有类似的函数签名,所以你可以将它们作为参数传递给 filter方法。Java 8语言的设计者们为了保持语言与之前版本的一致性,决定不引入类似的语法。 对于一门语言的新版本,引入太多的新语法会增加它的学习成本,带来额外学习负担。

匿名函数和闭包

匿名函数

Scala也支持匿名函数。匿名函数和Lambda表达式的语法非常类似。下面的这个例子中,你将一个匿名函数赋值给了名为isLongTweet的变量,该匿名函数的功能是检查给定的消息长度, 判断它是否超长:

https://gitee.com/lienhui68/picStore/raw/master/null/20200818015630.png

在新版的Java中,你可以使用Lambda表达式创建函数式接口的实例。Scala也提供了类似的机制。前面的这段代码是Scala中声明匿名类的语法糖。Function1(只带一个参数的函数)提供了apply方法的实现:

1
2
3
4
val isLongTweet : String => Boolean
= new Function1[String, Boolean] { 
	def apply(tweet: String): Boolean = tweet.length() > 60 
}

由于变量isLongTweet中保存了类型为Function1的对象,你可以调用它的apply方法, 这看起来就像下面的方法调用:

1
isLongTweet.apply("A very short tweet")

如果用Java,你可以采用下面的方式:

1
2
Function<String, Boolean> isLongTweet = (String s) -> s.length() > 60; 
boolean long = isLongTweet.apply("A very short tweet");

为了使用Lambda表达式,Java提供了几种内置的函数式接口,比如Predicate、Function、 Consumer。Scala提供了trait(你可以暂时将trait想象成接口,我们会在接下来的一节介绍它们) 来实现同样的功能:从Function0(一个函数不接受任何参数,并返回一个结果)到Function22 (一个函数接受22个参数),它们都定义了apply方法。

Scala还提供了另一个非常酷炫的特性,你可以使用语法糖调用apply方法,效果就像一次函 数调用:

1
isLongTweet("A very short tweet") // 返回false

编译器会自动地将方法调用f(a)转换为f.apply(a)。更一般地说,如果f是一个支持apply 方法的对象(注,apply可以有任意数目的参数),对方法f(a1, ..., an)的调用会被转换为 f.apply(a1, ..., an)

闭包

第3章中我们曾经抛给大家一个问题:Java中的Lambda表达式是否是借由闭包组成的。温习 一下,那么什么是闭包呢?闭包是一个函数实例,它可以不受限制地访问该函数的非本地变量。 不过Java 8中的Lambda表达式自身带有一定的限制:它们不能修改定义Lambda表达式的函数中的 本地变量值。这些变量必须隐式地声明为final。这些背景知识有助于我们理解“Lambda避免了 对变量值的修改,而不是对变量的访问”。

与此相反,Scala中的匿名函数可以取得本地变量,但并非变量当前指向的变量值。比如, 下面这段代码在Scala中是可能的:

https://gitee.com/lienhui68/picStore/raw/master/null/20200818020302.png

我们在第7、13以及14章多次提到你应该尽量避免修改,这样你的代码更加易于维护和并发 运行,所以请在绝对必要时才使用这一特性。

科里化

第14章中,我们描述了一种名为科里化的工作:带有两个参数(比如x和y)的函数f可以看 成一个仅接受一个参数的函数g,函数g的返回值也是一个仅带一个参数的函数。这一定义可以归 纳为接受多个参数的函数可以转换为多个接受一个参数的函数。换句话说,你可以将一个接受多个参数的函数切分为一系列接受该参数列表子集的函数。Scala为此特别提供了一个构造器,帮助 你更加轻松地科里化一个现存的方法。

为了理解Scala到底带来了哪些变化,让我们先回顾一个Java的示例。你定义了一个简单的函 数对两个正整数做乘法运算:

1
2
static int multiply(int x, int y) { return x * y; } 
int r = multiply(2, 10);

不过这种定义方式要求向其传递所有的参数才能开始工作。你可以人工地对multiple方法 进行切分,让其返回另一个函数:

1
2
3
static Function<Integer, Integer> multiplyCurry(int x) {
    return (Integer y) -> x * y;
}

由multiplyCurry返回的函数会捕获x的值,并将其与它的参数y相乘,然后返回一个整型 结果。这意味着你可以像下面这样在一个map中使用multiplyCurry,对每一个元素值乘以2:

1
Stream.of(1, 3, 5, 7).map(multiplyCurry(2)).forEach(System.out::println);

这样就能得到计算的结果2、6、10、14。这种方式工作的原因是map期望的参数为一个函数, 而multiplyCurry的返回结果就是一个函数

现在的Java语言中,为了构造科里化的形式需要你手工地切分函数(尤其是函数有非常多的 参数时),这是极其枯燥的事情。Scala提供了一种特殊的语法可以自动完成这部分工作。比如, 正常情况下,你定义的multiply方法如下所示:

1
2
def multiply(x : Int, y: Int) = x * y
val r = multiply(2, 10);

该函数的科里化版本如下:

1
2
def multiplyCurry(x :Int)(y : Int) = x * y // 定义一个科里化函数
val r = multiplyCurry(2)(10) // 调用该科里化函数

使用语法(x: Int)(y: Int),方法multiplyCurry接受两个由一个Int参数构成的参数 列表。与此相反,multiply接受一个由两个Int参数构成的参数列表。当你调用multiplyCurry 时 会 发 生 什 么 呢 ? multiplyCurry 的第一次调用使用了单一整型参数( 参数 x), 即 multiplyCurry(2),返回另一个函数,该函数接受参数y,并将其与它捕获的变量x(这里的 值为2)相乘。正如我们在14.1.2节介绍的,我们称这个函数是部分应用的,因为它并未提供所有的参数。第二次调用对x和y进行了乘法运算。这意味着你可以将对multiplyCurry的第一次调 用保存到一个变量中,进行复用:

1
2
val multiplyByTwo : Int => Int = multiplyCurry(2) 
val r = multiplyByTwo(10)

和Java比较起来,在Scala中你不再需要像这里这样手工地提供函数的科里化形式。Scala提供了一种方便的函数定义语法,能轻松地表示函数使用了多个科里化的参数列表。

类和trait

现在我们看看类与接口在Java和Scala中的不同。这两种结构在我们设计应用时都很常用。你 会看到相对于Java的类和接口,Scala的类和接口提供了更多的灵活性。

更加简洁的Scala类

由于Scala也是一门完全的面向对象语言,你可以创建类,并将其实例化生成对象。最基础的 形态上,声明和实例化类的语法与Java非常类似。比如,下面是一个声明Hello类的例子:

1
2
3
4
5
6
7
class Hello { 
  def sayThankYou(){ 
    println("Thanks for reading our book")                  
  } 
} 
val h = new Hello() 
h.sayThankYou()

getter方法和setter方法

一旦你定义的类具有了字段,这件事情就变得有意思了。你碰到过单纯只定义字段列表的 Java类吗?很明显,你还需要声明一长串的getter方法、setter方法,以及恰当的构造器。多麻烦 啊!除此之外,你还需要为每一个方法编写测试。在企业Java应用中,大量的代码都消耗在了这 样的类中。比如下面这个简单的Student类:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Student {

    private String name;
    private int id;

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

}

你需要手工定义构造器对所有的字段进行初始化,还要实现2个getter方法、2个setter方法。 一个非常简单的类现在需要超过20行的代码才能实现!有的集成开发环境或者工具能帮你自动生 成这些代码,不过你的代码库中还是需要增加大量额外的代码,而这些代码与你实际的业务逻辑并没有太大的关系。

Scala语言中构造器、getter方法以及setter方法都能隐式地生成,从而大大降低你代码中的冗余:

https://gitee.com/lienhui68/picStore/raw/master/null/20200818021409.png

Scala的trait与Java8的接口对比

Scala还提供了另一个非常有助于抽象对象的特性,名称叫trait。它是Scala为实现Java中的接 口而设计的替代品。trait中既可以定义抽象方法,也可以定义带有默认实现的方法。trait同时还支持Java中接口那样的多继承,所以你可以将它们看成与Java 8中接口类似的特性,它们都支持 默认方法。。trait中还可以包含像抽象类这样的字段,而Java 8的接口不支持这样的特性。那么,trait 就类似于抽象类吗?显然不是,因为trait支持多继承,而抽象类不支持多继承。Java支持类型的 多继承,因为一个类可以实现多个接口。现在,Java 8通过默认方法又引入了对行为的多继承, 不过它依旧不支持对状态的多继承,而这恰恰是trait支持的。

为了展示Scala中的trait到底是什么样,让我们看一个例子。我们定义了一个名为 Sized 的 trait,它包含一个名为size的可变字段,以及一个带有默认实现的isEmpty方法:

https://gitee.com/lienhui68/picStore/raw/master/null/20200818021558.png

你现在可以使用一个类在声明时继承它,下面这个例子中Empty类的size恒定为0:

https://gitee.com/lienhui68/picStore/raw/master/null/20200818021625.png

有一件事非常有趣,trait和Java的接口类似,也是在对象实例化时被创建(不过这依旧是一 个编译时的操作)。比如,你可以创建一个Box类,动态地决定到底选择哪一个实例支持由trait Sized定义的操作:

https://gitee.com/lienhui68/picStore/raw/master/null/20200818021705.png

如果一个类继承了多个trait,各trait中声明的方法又使用了相同的签名或者相同的字段,这 时会发生什么情况?为了解决这些问题,Scala中定义了一系列限制,这些限制和我们之前在第9 章介绍默认方法时的限制极其类似。

小结

下面是这一章中介绍的关键概念和你应该掌握的要点。

  • Java 8和Scala都是整合了面向对象编程和函数式编程特性的编程语言,它们都运行于JVM 之上,在很多时候可以相互操作。
  • Scala支持对集合的抽象,支持处理的对象包括List、Set、Map、Stream、Option,这些和Java 8非常类似。不过,除此之外Scala还支持元组。
  • Scala为函数提供了更加丰富的特性,这方面比Java 8做得好,Scala支持:函数类型、可以不受限制地访问本地变量的闭包,以及内置的科里化表单。
  • Scala中的类可以提供隐式的构造器、getter方法以及setter方法。
  • Scala还支持trait,它是一种同时包含了字段和默认方法的接口。