Scala编程(第3版)
  • 推荐0
  • 收藏1
  • 浏览161

Scala编程(第3版)

Martin Odersky;Lex Spoon;Bill Venners (作者)  高宇翔 (译者)

  • 书  号:978-7-121-32842-8
  • 出版日期:2017-11-20
  • 页  数:832
  • 开  本:16(185*235)
  • 出版状态:上市销售
  • 原书名: Programming in Scala
  • 原书号:9780981531687
  • 维护人:张春雨
纸质版 ¥144.00

相关图书

质量全面管控——从项目管理到容灾测试

葛长芝 (作者)

本书专门为有志于软件测试的工程师打开软件测试的大门,笔者结合案例讲解测试实践技术,主要内容有:项目管理、项目需求管理、代码质量控制、自动化部署、软件测试、安全测...

¥49.00

Spring MVC Cookbook中文版

Alex Bretet (作者) 张龙 (译者)

本书由浅入深地介绍了当今流行的Java Web框架Spring MVC的方方面面,从基础的环境搭建到微服务设计与架构,再到持久化、REST API构建、认证与测...

¥69.00

Web接口开发与自动化测试——基于Python语言

胡志恒 (作者)

本书以接口测试为主线,以Web开发为切入点,全面介绍了Web接口开发与自动化测试过程中使用的相关技术。全书分为15章,第1章介绍了Python的基础知识,解答初...

¥39.00

一路编程

Steven Foote (作者) 佟达 (译者)

这是一本编程入门的书,然而,如果以书中所讲内容作为入门标准,估计十有八九的在职程序员都不能算入门。现代软件开发,已经不仅仅是写出正确的代码这么简单,环境、依赖、...

¥65.00

软件自动化测试开发

邹辉 (作者)

本书全面深入地介绍了软件自动化测试开发领域方方面面的相关知识,包括App 功能自动化测试的<br>方案、环境、代码运行及报告(基于Appium 工具和Java ...

¥39.00

Jenkins权威指南

John Ferguson Smart (作者) 郝树伟 (译者)

本书从实践者的角度,在讲解Jenkins基本原理的同时,深入到持续集成、持续交付领域,为读者梳理出如何使用Jenkins设计和实现一个自动化的、周期性的集成测试...

¥59.00
本书由直接参与Scala开发的一线人员编写,因而对原理的解读和应用的把握更加值得信赖。本书面向具有一定编程经验的开发者,目标是让读者能够全面了解和掌握Scala编程语言的核心特性,并能够深入理解Scala这门语言在设计取舍背后的动因。即便是不直接使用Scala或从事一线编程工作的读者,也能从本书学到大量关于函数式和面向对象的编程概念和技巧。
Scala之父扛鼎巨著 来自语言设计者的精准|深邃|完整 基于2.12全面更新
推荐序
  这本书可以说Scala语言里的圣经。很高兴高宇翔将它的第3版也翻译为了中文,对于国内的Scala爱好者来说真的是一个福音。
  回想起七八年前,刚开始学习Scala时市场上还没有一本中文版的书。阅读英文版《Programming in Scala》的过程还是蛮费力的,即便我当时已经有很多年的Java编程经验。当时函数式编程的影响还比较弱,主流的编程风格还是命令式的(当然目前也依然是,但主流的编程语言里也开始越来越多地融入了函数式的风格),函数式编程里有很多陌生的概念是之前未曾了解过的,阅读的过程磕磕绊绊。
  大概七年前《Scala编程》第1版发行的时候我立即去买了一本,相比英文版阅读速度有极大的提升。后来我陆陆续续地将这本书读过很多遍,每次都能有新的收获。
  这七年来Scala的发展势头很猛,语言也在不断地调整,相比之下第1版的部分内容已经陈旧了,第3版的翻译让国内的Scala开发者可以更好地从中摄取知识和经验,即便你是Scala开发的老手也可以重温这本经典著作,一定会有新的体会。
  或许对于毫无编程经验的初学者来说这本书并不适合作为你的第一本入门编程书,因为Scala本身是一门集大成者的语言,它多范式的风格将很多优秀的特性集成到了一起,具备很灵活的正交性。无编程经验的初学者未必能把握住。但是对于任何有好奇心的程序员来说,我认为它是你书架上必不可少的一本书。三位作者都是大师级人物,里面看似不经意的只言片语仔细体会的话也别有洞天。
  三位大师在书中所说的很多内容,仔细揣摩,你会发现只是冰山一角,背后有更多可以深挖的内容。但这本书的定位也是面向普通的开发人员,大师们也保持得比较克制,不刻意流露一些复杂晦涩的概念,比如本书对流控、for表达式等有极其详尽的描述,但并不刻意提及Monad这样的术语,更多让开发可以去应用和实践它。大师们对偏理论的东西给出了一些线索,如果我们保持好奇心,可以顺着线索去探究编程语言背后庞大的理论体系。
  对于一些语言爱好者,这本书也是一个重要的参考,我记得初次读完"组合子解析"(Combinator Parse)这一部分内容时非常震撼,居然可以用极其简短的代码实现一些非常复杂的解析器工作。对于想要实现自己的DSL来说实在是太轻松了。还有模式匹配部分,这本书也是我见过的讲解得最详细的一本书。还有面向对象设计等方面,原本觉得熟稔于心的东西也有必要重新思考一下。
  总之,这本书值得反复阅读,带着好奇与思考,你会体验到与大师对话的乐趣。
   —— 王宏江   挖财中间件负责人
 
译者序
  这是一本很多人期待了近7年的书。
  时光拉回到2010年的夏天,那个时候,Scala还是2.7.x的版本,Java还不支持lambda表达式。因为好奇心的驱使,一群不甘寂寞、不怕折腾的程序员,通过各种方式自学并开始实践Scala编程,慢慢地形成了小圈子。在国内的大小论坛和一些公开的技术会议上,大家也开始陆续听到关于这门编程语言的介绍和讲解。不过,成体系的中文资料非常少。也是在2010年,电子工业出版社引进了由Martin Odersky、Lex Spoon和Bill Venners合著的《Scala编程》中文版权,由黄海旭翻译,他是国内最早的一批Scala爱好者。同为爱好者的我,非常荣幸,参与了这本《Scala编程》部分章节的翻译。
  那是一个Scala爆炸式增长的时期,各种开源项目层出不穷(著名的Apache Spark项目就是在这个时候诞生的)。Scala自身的版本迭代演进也很快,关于2.8版本的讨论和开发进展非常鼓舞人心。考虑到2.8相比之前的版本有了比较大的改进,作者们为了更好地普及Scala,《Scala编程》原书于2011年初推出了第2版,覆盖了2.8版本的特性。由于此时中文的《Scala编程》(第1版)刚出版不久,错过了引入更新的最佳时机,包括我在内的很多爱好者,开始了对这本中文书的更新版本的漫长等待。
  在等待的过程中,我们共同见证了2012年的《快学Scala》、2014年的《深入理解Scala》、2015年的《Scala编程思想》和2016年的《Scala函数式编程》等多本Scala中文图书的面世。同样是这几年,Java 8正式发布,Scala也公布了2.12版本的线路图,全面拥抱Java 8。2016年5月,《Scala编程》原书第3版正式发售,内容覆盖2.12版本的新特性。当得知电子工业出版社最终确定引进《Scala编程》(第3版)的中文版权并邀请我翻译时,我个人非常激动:终于等来了这次更新。当然了,激动之余是忐忑:一方面翻译需要投入的心力和体力是巨大的;更为重要的是,自己能不能对得起这本书的分量,不要辜负了大家的期望。
  说到这本书的分量,除了篇幅之外,我认为最值得一提的,是它不仅全面覆盖了Scala几乎所有的语言特性,还从语言开发者的视角,向我们介绍了这些语言特性和设计取舍背后的原因,以及要解决的问题。这是《Scala编程》跟其他林林总总的Scala图书最大的区别。从工具和工具书的角度,你也许会觉得:编程语言就是拿来干活儿的,一本编程语言的入门书,当然就是要把怎么用讲明白,让我高效地完成手中的工作,其他都是次要的。这里,我想给读者朋友们分享一个我自己的心得:语言除了表达外(让计算机和其他人类明白),更是思维的载体。学习一门编程语言,局部功利的因素当然有,但更多的,是通过这门语言,拓宽你的知识边界。语言是手段,不是目的。所以,不论你是否从事Scala编程工作,希望这本书,都能够带给你不一样的世界和认知。


  这本书你真是选对了时候!采用Scala的团队和项目越来越多,我们的社区也在不断壮大,Scala相关的职位招聘也十分常见。不论你编程是因为兴趣还是工作(或两者皆有),Scala带给你的愉悦和生产力都难以拒绝。对我而言,编程真正的乐趣来自用简单、精巧的方案解决有意思的挑战。Scala的任务不仅让这件事成为可能,更让它充满乐趣。本书将告诉你Scala是如何做到这些的。
  我从Scala 2.5开始接触这门编程语言,很快就被它的语法和概念的规则一致所吸引。当看到类型参数自己不能有类型参数这样的不规则情况出现时,我在2006年一次开发者大会上(战战兢兢地)走向Martin Odersky,毛遂自荐以实习生的身份参与Scala开发,去掉了这个限制。我的修改最终被采纳,Scala从2.7版本开始正式支持类型构造方法的多态(type constructor polymorphism)。从那时起,我参与了其他大部分编译器模块的开发。2012年,我从Martin的实验室读完博士后,加入了Typesafe的Scala小组。1也差不多是在那个时候,Scala发布了2.10,从实用偏学术的环境“毕业”,成长为适用于企业开发环境的一门强大的编程语言。
  Scala 2.10是Scala发展过程中的拐点,从快节奏的基于学术研究的功能性版本发布,走向关注简单和加速在企业计算领域的落地。我们将注意力转到那些不会出现在论文中的问题,比如跨大版本的二进制兼容。为了保持稳定性和不断改进、完善平台的热望之间的平衡,我们正在往一个更小的核心类库这个方向努力,让它变得更稳定,同时让整个Scala平台继续进化。为此,我作为Scala技术领导的首个项目,便是在2.11中启动对Scala标准类库的模块化。
  为减少变更频率,Typesafe还决定将类库和编译器重构升级安排在不同的版本。这一版《Scala编程》涵盖Scala 2.12版本,该版本是一次编译器升级,支持新的后端以及针对Java 8新特性的优化。为了更好的Java互调用,让用户享受到跟Java一样的来自JVM优化的好处,Scala将函数编译成跟Java 8一样的字节码。Scala的特质现在也同样编译成带有默认方法的Java接口。这两个编译器特性减少了之前版本Scala编译器需要完成的“魔法”,让我们更加贴近Java平台的原生表现,同时提升了编译速度和运行时性能,还让二进制兼容更加平滑!
  Java 8平台的这些改进站在Scala的角度非常振奋人心,我们很高兴看到Java也踏上了Scala在十多年前引领的潮流。毫无疑问,Scala提供了更好的函数式编程体验,默认不可变、语句即表达式(在本书里很难找到return语句)、模式匹配、定义处的型变(Java的使用处型变让子函数的定义非常别扭),等等。这么说吧,函数式编程并不仅仅是支持lambda表达式这样的漂亮语法而已。
  作为Scala这门编程语言的掌舵人,我们的目标是兼顾核心语言的开发和生态的建设。Scala之所以成功,离不开那些优秀的类库、出色的IDE和工具,离不开我们社区中那些友好的、乐于助人的成员们。我非常享受我在Scala的第一个十年(作为Scala的实现者),跟来自数不清的领域里的Scala程序员们一起感受快乐和鼓舞。
  我热爱Scala编程,希望你也一样。代表Scala社区,欢迎你!
   —— Andriaan Moors San Francisco, CA   2016年1月14日

引言
  本书是Scala编程语言的教程,由直接参与Scala开发的人来编写。我们的目标是让读者通过本书,能够了解和掌握成为高产的Scala程序员需要知道的一切。书中的示例,除标记为2.12的之外,均能通过Scala 2.11.7编译,标记为2.12的示例需要Scala 2.12.0-M3(或更高版本)。
谁读本书
  本书主要的目标读者是希望学习如何用Scala编程的人。如果你想在你的下一个项目中使用Scala,本书就是为你准备的。除此之外,本书对于那些想要学习新知识从而扩展自己眼界的程序员也同样有益。比方说,如果你是Java程序员,阅读本书,将让你接触到来自函数式编程领域和高阶面向对象领域的许多概念。我们相信,通过学习Scala,以及Scala背后的观念,将有助于你成为一名更好的程序员。
  我们假定你拥有常规的编程知识。尽管Scala作为用于入门的编程语言并没有什么不妥,但是这本书并不适用于(从零开始)学习编程。
  另一方面,阅读本书并不要求某项具体的编程语言的知识。我们当中大部分人都是在Java平台上使用Scala,但本书并不假定你了解Java本身。不过,我们预期大部分读者都熟悉Java,因此我们有时会拿Scala跟Java做对比,帮助这些读者理解它们之间的区别。
如何使用本书
  由于本书的主旨是教学,我们推荐的阅读顺序是从前到后,依次阅读各章。我们尽可能每次只引入一个主题,同时只用已经介绍过的主题来解释这个新的主题。因此,如果跳过前面的章节,你也许会遇到某些概念并不十分理解。只要按顺序阅读,你会发现掌握Scala是循序渐进、顺理成章的。
  如果你看到某个词汇不明白,记着查看词汇表和索引。许多读者都喜欢快速浏览特定的章节,这没有问题,词汇表和索引能帮助你随时找回阅读的坐标和方位。
  当你读完本书以后,还可以继续用它来当作语言参考。Scala编程语言有一本正式的语言规范,但语言规范强调的是精确,而不是可读性。虽然本书不会覆盖Scala的每一个细节,它也足够全面,应该能够在你逐渐成为Scala编程能手的过程中,承担起语言参考书的职责。
如何学习Scala
  通读本书,可以学到很多关于Scala的知识。不过,如果你做一些额外的尝试,可以学得更快,更彻底。
  首先,可以利用好包含在本书中的代码示例。手动将这些示例录入,有助于在脑海中逐行过一遍代码。尤其是录入过程中尝试一些变化,会非常有趣,也能确信自己真的理解了它们背后的工作原理。
  其次,时常访问在线论坛。这样,你和其他Scala爱好者可以互相促进。网上有大量的邮件列表、讨论组、聊天室、Wiki和Scala特定主题的订阅。花些时间,找到满足你需求的内容,你会在小问题上花更少的时间,有更多的精力投入到更深入、更重要的问题中。
  最后,一旦你读得足够多,可以自己启动一个编程项目。从头编写小程序,或者为某个更大的项目开发组件。仅仅阅读并不会让你走得更远。
内容概览
  第1章,“一门可伸缩的语言”,主要介绍Scala的设计及背后的概念和历史。
  第2章,“Scala入门”,介绍了如何用Scala完成一些基础的编程任务,但并不深入讲解它们是如何工作的。本章的目的是让你可以开始键入Scala代码并执行。
  第3章,“Scala入门(续)”,展示了更多基本的编程任务,帮助你快速上手Scala。学习完本章以后,你应该就能用Scala完成简单的脚本型任务了。
  第4章,“类和对象”,开始深入介绍Scala,描述其基本的面向对象的组成部分,并指导大家如何编译并运行Scala应用程序。
  第5章,“基本类型和操作”,介绍了Scala基本类型、字面量和支持的操作,(操作符的)优先级和结合性,以及对应的富包装类。
  第6章,“函数式对象”,以函数式(即不可变)的分数(rational)为例,更深入地讲解Scala面向对象的特性。
  第7章,“内建的控制结构”,展示了如何使用Scala内建的控制结构:if、while、for、try和match。
  第8章,“函数和闭包”,给出了对函数的深入介绍,而函数是函数式编程语言最基本的组成部分。
  第9章,“控制抽象”,展示了如何通过定义自己的控制抽象来对Scala基本的控制结构进行完善和补充。
  第10章,“组合和继承”,更进一步探讨Scala对面向对象编程的支持。本章的主题不像第4章那么基础,但实践中经常会遇到。
  第11章,“Scala的继承关系”,解释了Scala的继承关系,并探讨了通用方法和底类型等概念。
  第12章,“特质”,介绍了Scala的混入(mixin)组合机制。本章展示了特质的工作原理,描述了特质的常见用法,并解释了特质相对于更传统的多重继承有哪些改进。
  第13章,“包和引入”,讨论了大规模编程实践中我们会遇到的问题,包括顶级包、import语句,以及像protected和private那样的访问控制修饰符。
  第14章,“断言和测试”,展示了Scala的断言机制,并介绍了用Scala编写测试的若干工具,特别是ScalaTest。
  第15章,“样例类和模式匹配”,介绍了这组孪生的结构,让你更好地编写规则的、开放式的数据结构。样例类和模式匹配在处理树形的递归数据时非常有用。
  第16章,“使用列表”,详细地解释了列表这个在Scala程序中使用最普遍的数据结构。
  第17章,“使用其他集合类”,展示了如何使用基本的Scala集合,如列表、数组、元组、集和映射。
  第18章,“可变对象”,解释了可变对象,以及Scala用来表示它们的语法。本章以一个具体的离散事件模拟案例分析收尾,展示了实践中可变对象的适用场景。
  第19章,“类型参数化”,用具体的示例解释了第13章介绍过的信息隐藏的技巧:为纯函数式队列设计的类。本章接下来对类型参数的型变进行了说明,介绍了类型参数化对于信息隐藏的作用。
  第20章,“抽象成员”,描述了Scala支持的各种抽象成员,不仅是方法可以被声明为抽象的,字段和类型也可以。
  第21章,“隐式转换和隐式参数”,介绍了两个能够帮助你从源码中省去那些枯燥细节的概念,让编译器来自动填充或提供。
  第22章,“实现列表”,描述了List类的实现。理解Scala列表的工作原理非常重要,List类的实现也展示了Scala若干特性的运用。
  第23章,“重访for表达式”,展示了Scala如何将for表达式翻译成map、flatMap、filter和foreach。
  第24章,“深入集合类”,详细介绍了Scala集合类库。
  第25章,“Scala集合架构”,展示了集合类的构造,以及如何构建自制的集合。
  第26章,“提取器”,展示了如何对任意的类进行模式匹配,而不是局限于使用样例类(做模式匹配)。
  第27章,“注解”,展示了如何通过注解使用语言扩展。本章描述了若干标准的注解,并解释了如何构建自己的注解。
  第28章,“使用XML”,解释了如何用Scala处理XML。本章展示了生成XML、解析XML和处理XML的常见用法。
  第29章,“用对象实现模块化编程”,展示了如何使用Scala的对象构建模块化的系统。
  第30章,“对象相等性”,指出了编写equals方法时需要考虑的若干问题和需要注意绕开的坑。
  第31章,“结合Scala和Java”,探讨了在同一个工程中组合Scala和Java时会遇到的若干问题,并对如何解决这些问题给出了建议。
  第32章,“Future和并发编程”,展示了如何使用Scala的Future类。尽管完全可以在Scala中使用Java平台的并发编程原语和类库,Scala的Future可以帮助你避开传统的“线程和锁”的并发编程模型里常见的死锁(deadlock)和争用状况(race condition)。
  第33章,“组合子解析”,展示了如何用Scala的组合子(combinator)解析器(parser)类库构建解析器。
  第34章,“GUI编程”,快速地介绍了可大幅简化基于Swing的GUI编程的Scala类库。
  第35章,“SCells试算表”,通过展示一个完整的用Scala编写的试算表应用程序,将本书介绍的所有Scala特性组装串联起来。

目录

序 ........................................................................................................XXIV
致谢 .....................................................................................................XXVI
引言 .....................................................................................................XXIX
第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对象的方法 .........................................................................333
16.9 同时处理多个列表 ....................................................................335
16.10 理解Scala的类型推断算法 ......................................................336
16.11 结语 .........................................................................................339
第17章 使用其他集合类........................................................................340
17.1 序列 ..........................................................................................340
17.2 集和映射...................................................................................344
17.3 在可变和不可变集合类之间选择..............................................352
17.4 初始化集合 ...............................................................................355
17.5 元组 ..........................................................................................358
17.6 结语 ..........................................................................................361
第18章 可变对象 ..................................................................................362
18.1 什么样的对象是可变的?.........................................................362
18.2 可被重新赋值的变量和属性 .....................................................365
18.3 案例分析:离散事件模拟.........................................................368
18.4 用于描述数字电路的语言.........................................................369
18.5 Simulation API ..........................................................................372
18.6 电路模拟...................................................................................376
18.7 结语 ..........................................................................................384
第19章 类型参数化...............................................................................385
19.1 函数式队列 ...............................................................................385
19.2 信息隐藏...................................................................................389
19.3 型变注解...................................................................................392
19.4 检查型变注解 ...........................................................................397
19.5 下界 ..........................................................................................400
19.6 逆变 ..........................................................................................402
19.7 对象私有数据 ...........................................................................405
19.8 上界 ..........................................................................................407
19.9 结语 ..........................................................................................410
第20章 抽象成员 .................................................................................. 411
20.1 抽象成员概览 ...........................................................................411
20.2 类型成员...................................................................................412
20.3 抽象的val ..................................................................................413
20.4 抽象的var ..................................................................................414
20.5 初始化抽象的val .......................................................................415
20.6 抽象类型...................................................................................423
20.7 路径依赖类型 ...........................................................................425
20.8 改良类型...................................................................................428
20.9 枚举 ..........................................................................................429
20.10 案例分析:货币......................................................................431
20.11 结语 .........................................................................................441
第21章 隐式转换和隐式参数 .................................................................442
21.1 隐式转换...................................................................................442
21.2 隐式规则...................................................................................445
21.3 隐式转换到一个预期的类型 .....................................................448
21.4 转换接收端 ...............................................................................450
21.5 隐式参数...................................................................................454
21.6 上下文界定 ...............................................................................460
21.7 当有多个转换可选时 ................................................................463
21.8 调试 ..........................................................................................465
21.9 结语 ..........................................................................................467
第22章 实现列表 ..................................................................................468
22.1 List类的原理 .............................................................................468
22.2 ListBuffer类 ..............................................................................475
22.3 List类的实践 .............................................................................476
22.4 外部可见的函数式 ....................................................................479
22.5 结语 ..........................................................................................480
第23章 重访for表达式...........................................................................481
23.1 for表达式 ..................................................................................483
23.2 N皇后问题 ................................................................................484
23.3 用for推导式进行查询 ...............................................................487
23.4 用for推导式进行翻译 ...............................................................489
23.5 反过来.......................................................................................494
23.6 泛化for表达式 ...........................................................................495
23.7 结语 ..........................................................................................497
第24章 深入集合类...............................................................................498
24.1 可变和不可变集合 ....................................................................499
24.2 集合的一致性 ...........................................................................501
24.3 Traversable特质 ........................................................................503
24.4 Iterable特质 ...............................................................................508
24.5 序列型特质Seq、IndexedSeq和LinearSeq ................................512
24.6 集 ..............................................................................................517
24.7 映射 ..........................................................................................521
24.8 具体的不可变集合类 ................................................................525
24.9 具体的可变集合类 ....................................................................532
24.10 数组 ........................................................................................539
24.11 字符串 .....................................................................................544
24.12 性能特征 .................................................................................545
24.13 相等性 .....................................................................................547
24.14 视图 ........................................................................................548
24.15 迭代器 .....................................................................................554
24.16 从头创建集合..........................................................................561
24.17 Java和Scala集合互转 ..............................................................563
24.18 结语 ........................................................................................564
第25章 Scala集合架构 .........................................................................565
25.1 集合构建器 ...............................................................................565
25.2 抽取公共操作 ...........................................................................567
25.3 集成新的集合 ...........................................................................572
25.4 结语 ..........................................................................................588
第26章 提取器 .....................................................................................589
26.1 示例:提取电子邮箱地址.........................................................589
26.2 提取器.......................................................................................591
26.3 提取0或1个变量的模式 ............................................................594
26.4 提取可变长度参数的模式.........................................................596
26.5 提取器和序列模式 ....................................................................598
26.6 提取器和样例类的对比.............................................................599
26.7 正则表达式 ...............................................................................601
26.8 结语 ..........................................................................................604
第27章 注解 .........................................................................................606
27.1 为什么要有注解? ....................................................................606
27.2 注解的语法 ...............................................................................607
27.3 标准注解...................................................................................609
27.4 结语 ..........................................................................................613
第28章 使用XML ..................................................................................614
28.1 半结构化数据 ...........................................................................614
28.2 XML概览 ..................................................................................615
28.3 XML字面量 ..............................................................................616
28.4 序列化.......................................................................................618
28.5 拆解XML ..................................................................................620
28.6 反序列化...................................................................................622
28.7 加载和保存 ...............................................................................623
28.8 对XML做模式匹配 ...................................................................624
28.9 结语 ..........................................................................................628
第29章 用对象实现模块化编程 ..............................................................629
29.1 问题描述...................................................................................630
29.2 食谱应用程序 ...........................................................................631
29.3 抽象 ..........................................................................................634
29.4 将模块拆分成特质 ....................................................................638
29.5 运行时链接 ...............................................................................640
29.6 跟踪模块实例 ...........................................................................642
29.7 结语 ..........................................................................................643
第30章 对象相等性...............................................................................645
30.1 Scala中的相等性 .......................................................................645
30.2 编写相等性方法 ........................................................................646
30.3 为参数化类型定义相等性.........................................................660
30.4 如何编写equals和hashCode方法 ...............................................664
30.5 结语 ..........................................................................................668
第31章 结合Scala和Java .....................................................................669
31.1 从Java使用Scala .......................................................................669
31.2 注解 ..........................................................................................672
31.3 通配类型...................................................................................678
31.4 同时编译Scala和Java ................................................................680
31.5 基于Scala 2.12特性的Java 8集成 ..............................................681
31.6 结语 ..........................................................................................685
第32章 Future和并发编程 .....................................................................686
32.1 天堂里的烦恼 ...........................................................................687
32.2 异步执行和Try ..........................................................................688
32.3 使用Future ................................................................................690
32.4 测试Future ................................................................................705
32.5 结语 ..........................................................................................708
第33章 组合子解析...............................................................................709
33.1 示例:算术表达式 ....................................................................710
33.2 运行你的解析器 ........................................................................712
33.3 基本的正则表达式解析器.........................................................713
33.4 另一个示例:JSON ..................................................................714
33.5 解析器输出 ...............................................................................717
33.6 实现组合子解析器....................................................................723
33.7 字符串字面量和正则表达式 .....................................................732
33.8 词法分析和解析 ........................................................................733
33.9 错误报告...................................................................................734
33.10 回溯和LL(1) ............................................................................736
33.11 结语 .........................................................................................737
第34章 GUI编程...................................................................................740
34.1 第一个Swing应用程序 ..............................................................740
34.2 面板和布局 ...............................................................................743
34.3 处理事件...................................................................................745
34.4 示例:摄氏/华氏转换器 ...........................................................748
34.5 结语 ..........................................................................................750
第35章 SCells试算表 ...........................................................................752
35.1 可视化框架...............................................................................752
35.2 将数据录入和显示分开.............................................................755
35.3 公式..........................................................................................758
35.4 解析公式...................................................................................760
35.5 求值..........................................................................................765
35.6 操作类库...................................................................................768
35.7 变更通知...................................................................................771
35.8 结语..........................................................................................775
附录A Unix和Windows环境的Scala脚本 ...............................................777
关于作者 ................................................................................................798

本书勘误

印次
  • 页码:VIII  •  行数:10  •  印次: 1

    Combinator Parse改为Combinator Parsing

    lyllyllyl 提交于 2017/12/14 10:37:27
    张春雨 确认于 2017/12/14 10:44:06
  • 页码:46  •  行数:最下面的注释中  •  印次: 1

    示例3.6的集是可变的

    lyllyllyl 提交于 2017/12/11 10:20:56
    张春雨 确认于 2017/12/14 10:22:12

读者评论

  • 有电子版就好了,太厚了。

    kaizener发表于 2017/12/1 10:05:51
  • 请问多久开售?

    breathofrain发表于 2017/11/29 1:37:36