正版 Scala编程 [德]Martin Odersky,[美]Lex Spoon,[美]Bill Ven

序 .........................................................................................................XXII
致谢 .....................................................................................................XXIV
引言 ....................................................................................................XXVII
第1章 一门可伸缩的语言 ..........................................................................1
1.1 一门按需伸缩的语言 ..................................................................... 2
1.2 是什么让Scala能屈能伸 ................................................................. 7
1.3 为什么要用Scala ...........................................................................11
1.4 Scala寻根 ..................................................................................... 17
1.5 结语 ............................................................................................. 19
第2章 Scala入门 ....................................................................................20
第1步 使用Scala解释器 ..................................................................... 21
第2步 定义变量 ................................................................................. 22
第3步 定义函数 ................................................................................. 24
第4步 编写Scala脚本 ......................................................................... 26
第5步 用while做循环；用if做判断 .................................................... 27
第6步 用foreach和for遍历 ................................................................. 30
结语 ...................................................................................................... 32
第3章 Scala入门（续） ..........................................................................33
第7步 用类型参数化数组 .................................................................. 33
第8步 使用列表 ................................................................................. 38
第9步 使用元组 ................................................................................. 42
第10步 使用集和映射 ........................................................................ 43
第11步 识别函数式编程风格 ............................................................. 48
第12步 从文件读取文本行 ................................................................. 51
结语 ...................................................................................................... 55
第4章 类和对象 ......................................................................................56
4.1 类、字段和方法 ........................................................................... 56
4.2 分号推断 ...................................................................................... 61
4.3 单例对象 ...................................................................................... 62
4.4 Scala应用程序 ............................................................................. 65
4.5 App特质 ....................................................................................... 68
4.6 结语 ............................................................................................. 68
第5章 基础类型和操作 ............................................................................69
5.1 一些基础类型 .............................................................................. 69
5.2 字面量 .......................................................................................... 70
5.3 字符串插值 .................................................................................. 77
5.4 操作符即方法 .............................................................................. 78
5.5 算术操作 ...................................................................................... 81
5.6 关系和逻辑操作 ........................................................................... 83
5.7 位运算操作 .................................................................................. 85
5.8 对象相等性 .................................................................................. 86
5.9 操作符优先级和结合性 ............................................................... 88
5.10 富包装类 .................................................................................... 91
5.11 结语............................................................................................ 91
第6章 函数式对象 ...................................................................................93
6.1 Rational类的规格定义 ................................................................. 93
6.2 构建Rational ................................................................................ 94
6.3 重新实现toString方法 .................................................................. 96
6.4 检查前置条件 .............................................................................. 97
6.5 添加字段 ...................................................................................... 98
6.6 自引用 .........................................................................................100
6.7 辅助构造方法 .............................................................................101
6.8 私有字段和方法 ..........................................................................102
6.9 定义操作符 .................................................................................104
6.10 Scala中的标识符 .......................................................................106
6.11 方法重载 ...................................................................................108
6.12 隐式转换 ...................................................................................111
6.13 注意事项 ...................................................................................112
6.14 结语 ..........................................................................................112
第7章 内建的控制结构 ..........................................................................114
7.1 if表达式 ......................................................................................115
7.2 while循环 ....................................................................................116
7.3 for表达式 ....................................................................................119
7.4 用try表达式实现异常处理 ..........................................................125
7.5 match表达式 ...............................................................................129
7.6 没有break和continue的日子 ........................................................131
7.7 变量作用域 .................................................................................134
7.8 对指令式代码进行重构 ..............................................................137
7.9 结语 ............................................................................................139
第8章 函数和闭包 .................................................................................140
8.1 方法 ............................................................................................140
8.2 局部函数 .....................................................................................142
8.3 一等函数 .....................................................................................144
8.4 函数字面量的简写形式 ..............................................................147
8.5 占位符语法 .................................................................................147
8.6 部分应用的函数 ..........................................................................149
8.7 闭包 ............................................................................................152
8.8 特殊的函数调用形式 ..................................................................156
8.9 尾递归 .........................................................................................159
8.10 结语 ..........................................................................................163
第9章 控制抽象 ....................................................................................164
9.1 减少代码重复 .............................................................................164
9.2 简化调用方代码 ..........................................................................169
9.3 柯里化 .........................................................................................170
9.4 编写新的控制结构 ......................................................................173
9.5 传名参数 .....................................................................................176
9.6 结语 ............................................................................................178
第10章 组合和继承 ...............................................................................179
10.1 一个二维的布局类库 ................................................................179
10.2 抽象类 .......................................................................................180
10.3 定义无参方法 ...........................................................................182
10.4 扩展类 .......................................................................................184
10.5 重写方法和字段 ........................................................................186
10.6 定义参数化字段 ........................................................................188
10.7 调用超类构造方法 ....................................................................189
10.8 使用override修饰符 ..................................................................190
10.9 多态和动态绑定 ........................................................................192
10.10 声明final成员 ..........................................................................195
10.11 使用组合和继承 ......................................................................196
10.12 实现above、beside和toString ..................................................198
10.13 定义工厂对象 ..........................................................................201
10.14 增高和增宽 .............................................................................204
10.15 放在一起 .................................................................................206
10.16 结语 ........................................................................................207
第11章 Scala的继承关系 ......................................................................208
11.1 Scala的类继承关系 ...................................................................208
11.2 基本类型的实现机制 ................................................................212
11.3 底类型（bottom types） ...........................................................215
11.4 定义自己的值类型 ....................................................................216
11.5 结语...........................................................................................219
第12章 特质 .........................................................................................220
12.1 特质如何工作 ...........................................................................220
12.2 瘦接口和富接口 ........................................................................224
12.3 示例：矩形对象 ........................................................................225
12.4 Ordered特质 ..............................................................................227
12.5 作为可叠加修改的特质 .............................................................229
12.6 为什么不用多重继承 ................................................................234
12.7 要特质还是不要特质 ................................................................238
12.8 结语 ..........................................................................................238
第13章 包和引入 ..................................................................................240
13.1 将代码放进包里 ........................................................................240
13.2 对相关代码的精简访问 .............................................................242
13.3 引入 ..........................................................................................246
13.4 隐式引入 ...................................................................................249
13.5 访问修饰符 ...............................................................................250
13.6 包对象 .......................................................................................256
13.7 结语 ..........................................................................................257
第14章 断言和测试 ...............................................................................258
14.1 断言 ..........................................................................................258
14.2 用Scala写测试 ...........................................................................260
14.3 翔实的失败报告 ........................................................................262
14.4 作为规格说明的测试 ................................................................263
14.5 基于性质的测试 ........................................................................267
14.6 组织和运行测试 ........................................................................268
14.7 结语 ..........................................................................................270
第15章 样例类和模式匹配 ....................................................................271
15.1 一个简单的例子 ........................................................................271
15.2 模式的种类 ...............................................................................276
15.3 模式守卫 ...................................................................................286
15.4 模式重叠 ...................................................................................287
15.5 密封类 .......................................................................................289
15.6 Option类型 ................................................................................291
15.7 到处都是模式 ...........................................................................293
15.8 一个复杂的例子 ........................................................................298
15.9 结语 ..........................................................................................306
第16章 使用列表 ..................................................................................307
16.1 List字面量 .................................................................................307
16.2 List类型 ....................................................................................308
16.3 构建列表 ...................................................................................309
16.4 列表的基本操作 ........................................................................309
16.5 列表模式 ...................................................................................310
16.6 List类的初阶方法 .....................................................................312
16.7 List类的高阶方法 .....................................................................324
16.8 List对象的方法 .........................................................................332
16.9 同时处理多个列表 ....................................................................335
16.10 理解Scala的类型推断算法 ......................................................336
16.11 结语 .........................................................................................339
第17章 使用其他集合类 ........................................................................341
17.1 序列 ..........................................................................................341
17.2 集和映射 ...................................................................................345
17.3 在可变和不可变集合类之间选择 ..............................................353
17.4 初始化集合 ...............................................................................356
17.5 元组 ..........................................................................................360
17.6 结语 ..........................................................................................362
第18章 可变对象 ..................................................................................363
18.1 什么样的对象是可变的 .............................................................363
18.2 可被重新赋值的变量和属性 .....................................................366
18.3 案例分析：离散事件模拟 .........................................................369
18.4 用于描述数字电路的语言 .........................................................370
18.5 Simulation API ..........................................................................373
18.6 电路模拟 ...................................................................................377
18.7 结语 ..........................................................................................385
第19章 类型参数化 ...............................................................................386
19.1 函数式队列 ...............................................................................386
19.2 信息隐藏 ...................................................................................390
19.3 型变注解 ...................................................................................393
19.4 检查型变注解 ...........................................................................398
19.5 下界 ..........................................................................................401
19.6 逆变 ..........................................................................................403
19.7 对象私有数据 ...........................................................................406
19.8 上界 ..........................................................................................408
19.9 结语 ..........................................................................................411
第20章 抽象成员 ..................................................................................412
20.1 抽象成员概览 ...........................................................................412
20.2 类型成员 ...................................................................................413
20.3 抽象的val ..................................................................................414
20.4 抽象的var ..................................................................................415
20.5 初始化抽象的val .......................................................................416
20.6 抽象类型 ...................................................................................424
20.7 路径依赖类型 ...........................................................................426
20.8 改良类型 ...................................................................................429
20.9 枚举 ..........................................................................................430
20.10 案例分析：货币 ......................................................................432
20.11 结语 .........................................................................................442
第21章 隐式转换和隐式参数 .................................................................443
21.1 隐式转换 ...................................................................................443
21.2 隐式规则 ...................................................................................446
21.3 隐式转换到一个预期的类型 .....................................................449
21.4 转换接收端 ...............................................................................451
21.5 隐式参数 ...................................................................................455
21.6 上下文界定 ...............................................................................461
21.7 当有多个转换可选时 ................................................................464
21.8 调试 ..........................................................................................466
21.9 结语 ..........................................................................................468
第22章 实现列表 ..................................................................................469
22.1 List类的原理 .............................................................................469
22.2 ListBuffer类 ..............................................................................475
22.3 List类的实践 .............................................................................477
22.4 外部可见的函数式 ....................................................................480
22.5 结语 ..........................................................................................481
第23章 重访for表达式...........................................................................482
23.1 for表达式 ..................................................................................484
23.2 N皇后问题 ................................................................................485
23.3 用for推导式进行查询 ...............................................................488
23.4 用for推导式进行翻译 ...............................................................490
23.5 反过来 .......................................................................................495
23.6 泛化for表达式 ...........................................................................496
23.7 结语 ..........................................................................................498
第24章 深入集合类 ...............................................................................499
24.1 可变和不可变集合 ....................................................................500
24.2 集合的一致性 ...........................................................................502
24.3 Iterable特质 ...............................................................................504
24.4 序列型特质Seq、IndexedSeq和LinearSeq ................................511
24.5 集 ..............................................................................................517
24.6 映射 ..........................................................................................521
24.7 具体的不可变集合类 ................................................................525
24.8 具体的可变集合类 ....................................................................534
24.9 数组 ..........................................................................................540
24.10 字符串 .....................................................................................545
24.11 性能特征 .................................................................................546
24.12 相等性 .....................................................................................548
24.13 视图 ........................................................................................549
24.14 迭代器 .....................................................................................554
24.15 从头创建集合 ..........................................................................561
24.16 Java和Scala集合互转 ..............................................................563
24.17 结语 ........................................................................................565
第25章 Scala集合架构 .........................................................................566
25.1 抽取公共操作 ...........................................................................566
25.2 集成新的集合 ...........................................................................575
25.3 结语 ..........................................................................................600
第26章 提取器 .....................................................................................601
26.1 示例：提取电子邮箱地址 .........................................................601
26.2 提取器 .......................................................................................603
26.3 提取0或1个变量的模式 ............................................................606
26.4 提取可变长度参数的模式 .........................................................608
26.5 提取器和序列模式 ....................................................................610
26.6 提取器和样例类的对比 .............................................................611
26.7 正则表达式 ...............................................................................613
26.8 结语 ..........................................................................................616
第27章 注解 .........................................................................................618
27.1 为什么要有注解 ........................................................................618
27.2 注解的语法 ...............................................................................619
27.3 标准注解 ...................................................................................621
27.4 结语 ..........................................................................................625
第28章 使用XML ..................................................................................626
28.1 半结构化数据 ...........................................................................626
28.2 XML概览 ..................................................................................627
28.3 XML字面量 ..............................................................................628
28.4 序列化 .......................................................................................630
28.5 拆解XML ..................................................................................632
28.6 反序列化 ...................................................................................634
28.7 加载和保存 ...............................................................................635
28.8 对XML做模式匹配 ...................................................................636
28.9 结语 ..........................................................................................640
第29章 用对象实现模块化编程 ..............................................................641
29.1 问题描述 ...................................................................................642
29.2 食谱应用程序 ...........................................................................643
29.3 抽象 ..........................................................................................646
29.4 将模块拆分成特质 ....................................................................650
29.5 运行时链接 ...............................................................................652
29.6 跟踪模块实例 ...........................................................................654
29.7 结语 ..........................................................................................655
第30章 对象相等性 ...............................................................................657
30.1 Scala中的相等性 .......................................................................657
30.2 编写相等性方法 ........................................................................658
30.3 为参数化类型定义相等性 .........................................................672
30.4 如何编写equals和hashCode方法 ...............................................676
30.5 结语 ..........................................................................................680
第31章 结合Scala和Java .....................................................................681
31.1 从Java使用Scala .......................................................................681
31.2 注解 ..........................................................................................684
31.3 通配类型 ...................................................................................690
31.4 同时编译Scala和Java ................................................................692
31.5 Java 8集成 .................................................................................693
31.6 结语 ..........................................................................................697
第32章 Future和并发编程 .....................................................................698
32.1 天堂里的烦恼 ...........................................................................699
32.2 异步执行和Try ..........................................................................700
32.3 使用Future ................................................................................702
32.4 测试Future ................................................................................717
32.5 结语 ..........................................................................................720
第33章 组合子解析 ...............................................................................721
33.1 示例：算术表达式 ....................................................................722
33.2 运行你的解析器 ........................................................................724
33.3 基本的正则表达式解析器 .........................................................725
33.4 另一个示例：JSON ..................................................................726
33.5 解析器输出 ...............................................................................729
33.6 实现组合子解析器 ....................................................................735
33.7 字符串字面量和正则表达式 .....................................................744
33.8 词法分析和解析 ........................................................................745
33.9 错误报告 ...................................................................................746
33.10 回溯和LL(1) ............................................................................748
33.11 结语 .........................................................................................749
第34章 GUI编程 ...................................................................................752
34.1 第一个Swing应用程序 ..............................................................752
34.2 面板和布局 ...............................................................................755
34.3 处理事件 ...................................................................................757
34.4 示例：摄氏/华氏转换器 ...........................................................760
34.5 结语 ..........................................................................................762
第35章 SCells试算表 ...........................................................................764
35.1 可视化框架 ...............................................................................764
35.2 将数据录入和显示分开 .............................................................767
35.3 公式 ..........................................................................................770
35.4 解析公式 ...................................................................................772
35.5 求值 ..........................................................................................777
35.6 操作类库 ...................................................................................780
35.7 变更通知 ...................................................................................783
35.8 结语 ..........................................................................................787
附录 Unix和Windows环境的Scala脚本 .................................................789
术语表 ...................................................................................................790
关于作者 ................................................................................................810

[德]马丁·奥德斯基(Martin Odersky)，是Scala语言的缔造者。他是瑞士洛桑理工学院(EPFL)的教授，自2001年起，由他带领的团队开发了Scala语言、类库和编译器。他同时是Lightbend公司的创始人，参与设计了Java泛型，还是当前javac编译器参考实现的原作者。
莱斯·彭(Lex Spoon)，在EPFL开展了为期两年的Scala编程工作，目前是Square公司的软件工程师。
比尔·文纳斯(Bill Venners)，是Artima公司总裁，是Scala Center咨询委员会的社区代表，还是测试框架ScalaTest和针对函数式、面向对象编程类库Scalactic的主要开发者和设计者。
高宇翔，资深软件开发工程师和系统架构师，同时也是Scala在国内的早期布道者和实践者，曾译有和《Scala编程》(第1版)、《Scala编程》(第3版)《快学Scala》(第1版)、《快学Scala》(第2版)等Scala语言的名著。

由Scala缔造者精心编写的领域圣经||紧跟语言版本持续迭代的长青经典√ 本书作者Martin Odersky教授2001年率领团队开发了Scala语言、类库和编译器，其核心成员精心编写了这本官方教程。
√ Java之父James Gosling说过“如果让我在Java之外选一门语言，我会选Scala”，它是面向对象与函数式编程的完美融合。
√ 本书全面涵盖整个编程语言、重要类库及其背后理念，经多版本迭代优化后，编排、组织和示例设置堪称语言学习典范。
√ 第4版大幅增加新内容，覆盖Scala 2.13新特性并重塑集合类库：集合类继承关系|集合类型实现|集合方法|自定义|视图。

《Scala 编程》可能是我读过最好的编程书之一。我喜欢它的写作风格、简明扼要的描述，还有细致入微的讲解。这本书总能在我有某个问题时，适时地给出答案 ：它总是先我一步。作者们并不只是简单地秀代码，想当然地认为你会理解，他们会让你真正明白代码背后的东西。我非常欣赏这一点。
— Ken Egervari，首席软件架构师《Scala 编程》行文清晰、深入细致、易于理解，示例和提示建议贯穿全书。这本书让我们公司快速高效地掌握了 Scala 这门编程语言。对于想要理解 Scala的灵活性和优雅的程序员来说，这本书非常棒。
— Larry Morroni，公司老板，Morroni Technologies，Inc.

《Scala 编程》是一本非常好的 Scala 入门教材。通读这本书，每一章都构建在之前章节的概念和示例之上，循序渐进，很容易上手。对组成 Scala 的各个语法结构的解释都很深入，会给出示例解释 Scala 与 Java 的不同。除了介绍语言本身外，还包含了对类库的讲解，比如容器类和 actor 等。我认为这本书非常易读，属于我最近读过的比较好的技术书。真心推荐给所有想要进一步了解 Scala 编程语言的程序员们。
— Matthew Todd
我对《Scala 编程》的作者们付出的努力表示惊叹。这本书对于 Scala 平台(我喜欢这样来称呼)是一个非常有价值的指南 ：如何写出更好的代码，如何设计和实现可伸缩的软件架构。如果 2003 年我参与设计和实现 2004 雅典奥运会门户网站架构时，Scala 像今天这样成熟，或者书桌上有这样一本参考书，该多好！我想对所有的读者说 ：不论你有怎样的编程背景，我认为你都会发现Scala 编程是多么舒心、释放潜能，这本书也会成为你探索之旅的良伴。
— Christos KK Loverdos，软件咨询师，研究员
《Scala 编程》非常棒，对 Scala 进行了深入的讲解，同时也是很好的参考书。它会在我的书架上占据显著位置(不过最近去哪儿我都会带上它)。
— Brian Clapper，主席，ArdenTex Inc.

这是一本很棒的书，代码示例和讲解都非常到位。不论编程老手和新手，我都会推荐。
— Howard Lovatt
《Scala 编程》不仅告诉你如何用这门新的编程语言做开发，更重要的是它还告诉你为什么。这本书从务实的角度，向我们介绍将面向对象和函数式编程结合在一起所带来的强大能力，让读者彻底明白 Scala 的真谛。
— Dr. Ervin Varga，CEO/ 创始人，EXPRO I.T. Consulting
对面向对象(OO)程序员而言，这本书很好地介绍了函数式编程。我的首要目标是学习函数式编程(FP)，不过在学习过程中我也发现了一些惊喜，比如样例类(case class)和模式匹配(pattern matching)。Scala 是一门有趣的编程语言，这本书是很好的教程。一本介绍编程语言的书，对于各种细节和背景，讲多讲少，这个度很难拿捏得准。我认为《Scala 编程》在这方面做得非常好。
— Jeff Heon，程序分析师清晰洞察和技术完整性是任何一本好书的标志性特征，我向本书的作者Martin Odersky、Lex Spoon 和 Bill Venners 表示祝贺！《Scala 编程》从坚实的基础概念开始，将 Scala 用户从入门带到中级并继续往上攀升。对任何想学习 Scala 编程的人而言，本书都不容错过。
— Jagan Nambi，企业架构师，GMAC Financial Services
《Scala 编程》的阅读体验非常好。对主题的讲解深入、细致、全面，行文精简、优雅。本书的章节组织非常自然，符合逻辑。不论是对于那些对新鲜事物好奇的技术工作者，还是对于那些想要深入理解 Scala 核心功能点和设计的内在动因的专业人士，都同样适用。对于对函数式编程感兴趣的朋友，我强烈推荐这本书。对于 Scala 开发者，这本书是必读的。
— Igor Khlystov，软件架构师 / 主程，Greystone Inc.

《Scala 编程》从头到尾都让人感受到作者在背后付出的巨大心血和精力。在此之前，我从未读到过哪本教程类的书能够兼顾入门和进阶。大部分教程类的书，为了达到看上去易懂(同时不让读者“困惑”)的效果，悄悄地剔除了相关主题中的那些对于当前讨论而言过于高级的知识点。这对于读者体验来说很糟糕，因为我们并不能确切地知道有没有完全理解，理解到什么程度。我们总会觉察到有些残余的、没有被充分解释的“魔法”，而这些是否属实，我们作为读者也无从评判。这本书不会有这种感觉，它从不把任何事当作理所当然：任何细节，要么在当前章节充分解释，要么清楚地指出在后续哪一个章节会详细介绍。的确，本书的文字交叉引用非常多，索引也非常全，因此，当我们想要在脑海里构建出对某个复杂主题的全貌时，也就相对容易多了。
— Gerald Loeffler，企业级 Java 架构师在当今这个编程好书稀缺的时代，由 Martin Odersky、Lex Spoon 和 Bill Venners 共同撰写的《Scala 编程》，这本面向中级程序员的介绍类图书格外引人注目。在这里，你能找到关于 Scala 这门语言你所需要知道的一切。
— Christian Neukirchen

本书由直接参与 Scala 开发的一线人员编写，因而对原理的解读和对应用的把握更加值得信赖。本书面向具有一定编程经验的开发者，目标是让读者能够全面了解和掌握 Scala 编程语言的核心特性，并能够深入理解 Scala 这门语言在设计取舍背后的动因。即便是不直接使用Scala 的读者或非一线编程从业者，也能从本书中学到大量关于函数式和面向对象的编程概念和技巧。