基本信息.jpg

书 名:kotlin核心编程

定价:89元

作者:水滴技术团队

出版社:机械工业出版社

出版日期:2019-04-15

ISBN 号:9787111624318

开本:16开

页数:371

版次:1-1

 内容简介.jpg

本书不是一本简单介绍Kotlin语法应用的图书，而是一部专注于帮助读者深入理解Kotlin的设计理念，指导读者实现Kotlin高层次开发的实战型著作。书中深入介绍了Kotlin的核心语言特性、设计模式、函数式编程、异步开发等内容，并以Android和Web两个平台为背景，演示了Kotlin的实战应用。

全书共13章，分为4个部分：

热身篇—Kotlin基础（1~2章），简单介绍了Kotlin设计哲学、生态及基础语法，其中包括Kotlin与Scala、Java之间的关联与对比，以及Kotlin的类型声明的特殊性、val和var的使用、高阶函数的使用、面向表达式编程的使用、字符串的定义与操作等内容；

下水篇—Kotlin核心（3~8章），深入介绍了面向对象、代数数据类型、模式匹配、类型、Lambda、集合、多态、扩展、元编程等Kotlin开发核心知识，这是本书的重点，其中涉及很多开发者特别关心的问题，比如多继承问题、模式匹配问题、用代数数据类型抽象业务问题、泛型问题、反射问题等。

潜入篇—Kotlin探索（9~11章），探otlin在设计模式、函数式编程、异步和并发等编程领域的应用，其中包括对4大类设计模式、Typeclass实现、函数式通用结构设计、类型替代异常处理、共享资源控制、CQRS架构等重点内容的深入剖析；

遨游篇—Kotlin实战（12~13章），着重演示了Kotlin在Android和Web平台的实战案例，其中涉及架构方式、单向数据流模型、解耦视图导航、响应式编程、Spring 5响应式框架和编程等内容。

前言

热身篇 Kotlin基础

1章 认识Kotlin2

1.1 Java的发展2

1.1.1 Java 8的探索3

1.1.2 Java未来的样子3

1.2 Scala的百宝箱3

1.2.1 学术和工业的平衡4

1.2.2 复合但不复杂4

1.2.3 简单却不容易5

1.3 Kotlin—改良的Java5

1.3.1 Kotlin的实用主义6

1.3.2 更好的Java6

1.3.3 强大的生态8

1.4 本章小结8

2章 基础语法10

2.1 不一样的类型声明10

2.1.1 增强的类型推导11

2.1.2 声明函数返回值类型11

2.2 val和var的使用规则13

2.2.1 val的含义：引用不可变13

2.2.2 优先使用val来避免副作用14

2.2.3 var的适用场景15

2.3 高阶函数和Lambda16

2.3.1 抽象和高阶函数17

2.3.2 实例：函数作为参数的需求17

2.3.3 函数的类型19

2.3.4 方法和成员引用21

2.3.5 匿名函数22

2.3.6 Lambda是语法糖22

2.3.7 函数、Lambda和闭包25

2.3.8 “柯里化”风格、扩展函数26

2.4 面向表达式编程29

2.4.1 表达式比语句更安全30

2.4.2 Unit类型：让函数调用皆为表达式32

2.4.3 复合表达式：更好的表达力33

2.4.4 枚举类和when表达式34

2.4.5 for循环和范围表达式37

2.4.6 中缀表达式39

2.5 字符串的定义和操作41

2.5.1 定义原生字符串41

2.5.2 字符串模板42

2.5.3 字符串判等43

2.6 本章小结43

下水篇 Kotlin核心

3章 面向对象46

3.1 类和构造方法46

3.1.1 Kotlin中的类及接口46

3.1.2 更简洁地构造类的对象49

3.1.3 主从构造方法55

3.2 不同的访问控制原则56

3.2.1 限制修饰符57

3.2.2 可见性修饰符61

3.3 解决多继承问题64

3.3.1 骡子的多继承困惑64

3.3.2 接口实现多继承65

3.3.3 内部类解决多继承问题的方案67

3.3.4 使用委托代替多继承69

3.4 真正的数据类71

3.4.1 烦琐的JavaBean 71

3.4.2 用data class创建数据类 73

3.4.3 copy、componentN与解构75

3.4.4 数据类的约定与使用78

3.5 从static到object79

3.5.1 什么是伴生对象79

3.5.2 天生的单例：object81

3.5.3 object表达式82

3.6 本章小结84

4章 代数数据类型和模式匹配85

4.1 代数数据类型85

4.1.1 从代数到类型86

4.1.2 计数87

4.1.3 积类型87

4.1.4 和类型与密封类88

4.1.5 构造代数数据类型89

4.2 模式匹配90

4.2.1 何为模式91

4.2.2 常见的模式92

4.2.3 处理嵌套表达式93

4.2.4 通过Scala找点灵感95

4.2.5 用when力挽狂澜97

4.3 增强 Kotlin 的模式匹配99

4.3.1 类型测试/类型转换99

4.3.2 面向对象的分解100

4.3.3 访问者设计模式102

4.3.4 总结104

4.4 用代数数据类型来抽象业务105

4.4.1 从一个实际需求入手105

4.4.2 糟糕的设计105

4.4.3 利用ADT106

4.4.4 更高层次的抽象108

4.5 本章总结110

5章 类型112

5.1 null引用：10亿美元的112

5.1.1 null做了哪些恶112

5.1.2 如何解决NPE问题114

5.2 可空类型115

5.2.1 Java 8中的Optional115

5.2.2 Kotlin的可空类型118

5.2.3 类型检查121

5.2.4 类型智能转换122

5.3 比Java更面向对象的设计124

5.3.1 Any：非空类型的根类型124

5.3.2 Any：所有类型的根类型127

5.3.3 Nothing与Nothing128

5.3.4 自动装箱与拆箱128

5.3.5 “新”的数组类型129

5.4 泛型：让类型更加安全130

5.4.1 泛型：类型安全的利刃130

5.4.2 如何在Kotlin中使用泛型131

5.4.3 类型约束：设定类型上界133

5.5 泛型的背后：类型擦除135

5.5.1 Java为什么无法声明一个泛型数组135

5.5.2 向后兼容的罪136

5.5.3 类型擦除的矛盾138

5.5.4 使用内联函数获取泛型139

5.6 打破泛型不变140

5.6.1 为什么List不能赋值给List140

5.6.2 一个支持协变的List141

5.6.3 一个支持逆变的Comparator143

5.6.4 协变和逆变144

5.7 本章小结147

6章 Lambda和集合148

6.1 Lambda简化表达148

6.1.1 调用Java的函数式接口148

6.1.2 带接收者的Lambda149

6.1.3 with和apply150

6.2 集合的高阶函数API151

6.2.1 以简驭繁：map151

6.2.2 对集合进行筛选：filter、count152

6.2.3 别样的求和方式：sumBy、sum、fold、reduce154

6.2.4 根据学生性别进行分组：groupBy156

6.2.5 扁平化—处理嵌套集合：flatMap、flatten157

6.3 集合库的设计159

6.3.1 集合的继承关系159

6.3.2 可变集合与只读集合160

6.4 惰性集合163

6.4.1 通过序列提高效率163

6.4.2 序列的操作方式164

6.4.3 序列可以是无限的166

6.4.4 序列与Java 8 Stream对比166

6.5 内联函数167

6.5.1 优化Lambda开销168

6.5.2 内联函数具体语法169

6.5.3 noinline：避免参数被内联171

6.5.4 非局部返回172

6.5.5 crossinline174

6.5.6 具体化参数类型174

6.6 本章小结175

7章 多态和扩展176

7.1 多态的不同方式176

7.1.1 子类型多态176

7.1.2 参数多态177

7.1.3 对三方类进行扩展178

7.1.4 特设多态与运算符重载178

7.2 扩展：为别的类添加方法、属性179

7.2.1 扩展与开放封闭原则179

7.2.2 使用扩展函数、属性180

7.2.3 扩展的特殊情况183

7.2.4 标准库中的扩展函数：run、let、also、takeIf186

7.3 Android中的扩展应用188

7.3.1 优化Snackbar188

7.3.2 用扩展函数封装Utils189

7.3.3 解决烦人的findViewById190

7.4 扩展不是的193

7.4.1 调度方式对扩展函数的影响193

7.4.2 被滥用的扩展函数196

7.5 本章小结197

8章 元编程198

8.1 程序和数据199

8.1.1 什么是元编程199

8.1.2 常见的元编程技术201

8.2 Kotlin的反射202

8.2.1 Kotlin和Java反射202

8.2.2 Kotlin的KClass205

8.2.3 Kotlin的KCallable206

8.2.4 获取参数信息208

8.3 Kotlin的注解210

8.3.1 无处不在的注解211

8.3.2控制注解的位置212

8.3.3 获取注解信息213

8.4 本章小结216

潜入篇 Kotlin探索

9章 设计模式218

9.1 创建型模式218

9.1.1 伴生对象增强工厂模式219

9.1.2 内联函数简化抽象工厂222

9.1.3 用具名可选参数而不是构建者模式224

9.2 行为型模式228

9.2.1 Kotlin中的观察者模式228

9.2.2 高阶函数简化策略模式、模板方法模式231

9.2.3 运算符重载和迭代器模式235

9.2.4 用偏函数实现责任链模式237

9.2.5 ADT实现状态模式241

9.3 结构型模式244

9.3.1 装饰者模式：用类委托减少样板代码245

9.3.2 通过扩展代替装饰者246

9.4 本章小结248

10章 函数式编程249

10.1 函数式编程的特征249

10.1.1 函数式语言之争250

10.1.2 纯函数与引用透明性251

10.1.3 代换模型与惰性求值253

10.2 实现Typeclass254

10.2.1 高阶类型：用类型构造新类型255

10.2.2 高阶类型和Typeclass256

10.2.3 用扩展方法实现Typeclass257

10.2.4 Typeclass设计常见功能258

10.3 函数式通用结构设计262

10.3.1 Monoid262

10.3.2 Monad264

10.3.3 Monad组合副作用269

10.4 类型代替异常处理271

10.4.1 Option与OptionT272

10.4.2 Either与EitherT276

10.5 本章小结279

11章 异步和并发281

11.1 同步到异步281

11.1.1 同步与阻塞的代价281

11.1.2 利用异步非阻塞来提高效率284

11.1.3 回调地狱284

11.2 Kotlin的Coroutine286

11.2.1 多线程一定优于单线程吗287

11.2.2 协程：一个更轻量级的“线程”287

11.2.3 合理地使用协程288

11.2.4 用同步方式写异步代码290

11.3 共享资源控制293

11.3.1 锁模式293

11.3.2 Actor：有状态的并行计算单元296

11.4 CQRS架构302

11.4.1 Event Sourcing事件溯源—记录对象操作轨迹302

11.4.2 Kotlin with Akka Persistence-Actor304

11.5 本章小结310

遨游篇 Kotlin实战

12章 基于Kotlin的Android架构314

12.1 架构方式的演变314

12.1.1 经典的 MVC 问题315

12.1.2 MVP316

12.1.3 MVVM320

12.2 单向数据流模型327

12.2.1 Redux327

12.2.2 单向数据流的优势329

12.3 ReKotlin331

12.3.1 初见 ReKotlin331

12.3.2 创建基于ReKotlin的项目332

12.4 解耦视图导航341

12.4.1 传统导航的问题341

12.4.2 rekotlin-router342

12.5 本章小结343

13章 开发响应式Web应用345

13.1 响应式编程的关键：非阻塞异步编程模型345

13.1.1 使用CompletableFuture实现异步非阻塞346

13.1.2 使用RxKotlin进行响应式编程347

13.1.3 响应式Web编程框架348

13.2 Spring 5：响应式Web框架349

13.2.1 支持响应式编程349

13.2.2 适配Kotlin350

13.2.3 函数式路由351

13.2.4 异步数据库驱动353

13.3 Spring 5响应式编程实战354

13.4 本章小结360

ISBN编号: 9787111650409

书名: Kotlin编程之美

作者: 皮埃尔-伊夫斯·索蒙特

作者地区: 法国

定价: 119.00元

书名: Kotlin编程之美

是否是套装: 否

出版社名称: 机械工业出版社

作为Java开发人员，维护糟糕的遗留代码、解释晦涩的注释、反复编写相同的样板文件可能会让编程失去乐趣。《Kotlin编程之美》讲述用Kotlin编写易于理解、易于维护、安全的程序的方法和技巧。在本书中，经验丰富的工程师皮埃尔-伊夫斯?索蒙特将以全新的、以函数式编程的视角来处理常见的编程挑战，并用示例深入讲解如何正确处理和数据、如何管理状态以及如何利用惰性。

《Kotlin编程之美》的内容包括编程功能、处理可选数据、安全处理和异常以及处理和共享状态突变等。《Kotlin编程之美》的读者对象为中级Java或Kotlin开发人员、高等院校计算机相关学生以及对安全编程感兴趣的工程技术人员等。

目  录

封  面

译者序

致  谢

前  言

关于本书

关于读者

关于封面插图

1章 让程序更安全

1.1 编程陷阱

1.1.1 安全的处理作用

1.1.2 用引用透明性使程序更安全

1.2 安全编程的好处

1.2.1 使用替换模型对程序进行推理

1.2.2 应用安全原则的简单示例

1.2.3 将抽象推向极限

1.3 本章小结

2章 Kotlin中的函数式编程:概述

2.1 Kotlin中的字段和变量

2.1.1 省略类型以简化

2.1.2 使用可变字段

2.1.3 理解初始化

2.2 Kotlin中的类和接口

2.2.1 使代码更加简洁

2.2.2 实现接口或扩展类

2.2.3 实例化一个类

2.2.4 重载属性构造函数

2.2.5 创建equals和hashCode方法

2.2.6 解构数据对象

2.2.7 在Kotlin中实现静态成员

2.2.8 使用单例模式

2.2.9 防止工具类实例化

2.3 Kotlin没有原语

2.4 Kotlin的两种集合类型

2.5 Kotlin的包

2.6 Kotlin的可见性

2.7 Kotlin中的函数

2.7.1 函数声明

2.7.2 使用局部函数

2.7.3 覆盖函数

2.7.4 使用扩展函数

2.7.5 使用lamdba表达式

2.8 Kotlin中的null

2.8.1 处理可空类型

2.8.2 Elvis和默认值

2.9 程序流程和控制结构

2.9.1 使用条件选择器

2.9.2 使用多条件选择器

2.9.3 使用循环

2.10 Kotlin的未检查异常

2.11 自动关闭资源

2.12 Kotlin的智能转换

2.13 相等性VS一致性

2.14 字符串插值

2.15 多行字符串

2.16 型变:参数化类型和子类型

2.16.1 为什么型变是一个潜在的问题

2.16.2 何时使用协变以及何时使用逆变

2.16.3 声明端型变与使用端型变

2.17 本章小结

3章 用函数编程

3.1 函数是什么?

3.1.1 理解两个函数集之间的关系

3.1.2 Kotlin中反函数概述

3.1.3 处理偏函数

3.1.4 理解函数复合

3.1.5 使用多参数函数

3.1.6 柯里化函数

3.1.7 使用偏应用函数

3.1.8 没有作用的函数

3.2 Kotlin中的函数

3.2.1 将函数理解为数据

3.2.2 将数据理解为函数

3.2.3 使用对象构造函数作为函数

3.2.4 使用Kotlin的fun函数

3.2.5 使用对象表示法和函数表示法

3.2.6 使用值函数

3.2.7 使用函数引用

3.2.8 复合函数

3.2.9 重用函数

3.3函数特征

3.3.1 多参数函数如何?

3.3.2 应用柯里化函数

3.3.3 实现高阶函数

3.3.4 创建多态高阶函数

3.3.5 使用匿名函数

3.3.6 定义局部函数

3.3.7 实现闭包

3.3.8 应用偏函数和自动柯里化

3.3.9 切换偏应用函数的参数

3.3.10 声明单位函数

3.3.11 使用正确的类型

3.4 本章小结 

4章 递归、尾递归和记忆化

4.1 共递归与递归

4.1.1 实现共递归

4.1.2 实现递归

4.1.3 区分递归函数和共递归函数

4.1.4 选择递归或尾递归

4.2 尾调用消除

4.2.1 使用尾调用消除

4.2.2 从循环切换到共递归

4.2.3 使用递归值函数

4.3 递归函数和列表

4.3.1 使用双递归函数

4.3.2 对列表抽象递归

4.3.3 反转列表

4.3.4 构建共递归列表

4.3.5 严格的后果

4.4 记忆化

4.4.1 在基于循环的编程中使用记忆化

4.4.2 在递归函数中使用记忆化

4.4.3 使用隐式记忆化

4.4.4 使用自动记忆化

4.4.5 实现多参数函数的记忆化

4.5 记忆函数纯吗?

4.6 本章小结

5章 用列表处理数据

5.1 如何对数据集合进行分类

5.2 不同类型的列表

5.3 相对期望列表性能

5.3.1 用时间来交换内存空间和复杂性

5.3.2 避免就地突变

5.4 KOTLIN有哪些可用列表?

5.4.1 使用持久数据结构

5.4.2 实现不可变的、持久的单链表

5.5 列表作中的数据共享

5.6 更多列表作

5.6.1 标注的益处

5.6.2 连接列表

5.6.3 从列表末尾删除

5.6.4 使用递归对具有高阶函数(HOFs)的列表进行折叠

5.6.5 使用型变

5.6.6 创建foldRight的一个栈安全递归版本

5.6.7 映和过滤列表

5.7 本章小结

6章 处理可选数据

6.1 空指针问题

6.2 Kotlin如何处理空引用

6.3 空引用的替代方法

6.4 使用OPTION类型

6.4.1 从一个Option中获取值

6.4.2 将函数应用于可选值

6.4.3 处理Option组合

6.4.4 Option用例

6.4.5 其他组合选项的方法

6.4.6 用Option组合List

6.4.7 何时使用Option

6.5 本章小结

7章 处理和异常

7.1 数据缺失的问题

7.2 Either类型

7.3 Result类型

7.4 Result模式

7.5Result处理

7.6 映Failture

7.7 添加工厂函数

7.8 应用作用

7.9结果组合

7.10 本章小结

8章列表处理

8.1 长度问题

8.2 性能问题

8.3 记忆化的好处

8.3.1 处理记忆化的缺点

8.3.2 评估性能改进

8.4 List和Result组成

8.4.1 处理List返回Result

8.4.2 从List转换为Result

8.5 常见列表抽象

8.5.1 压缩和解压缩列表

8.5.2 通过索引访问元素

8.5.3 列表分裂

8.5.4 搜索子列表

8.5.5 处理列表的其它函数

8.6 列表的自动并行处理

8.6.1 并不是所有的计算都可以并行化

8.6.2 将列表分解为子列表

8.6.3 并行处理子列表

8.7 本章小结

9章 与惰性配合

9.1 严格VS惰性

9.2 Kotlin和严格

9.3 Kotlin和惰性

9.4 懒惰的实现

9.4.1 组合惰性值

9.4.2 提升函数

9.4.3 映和flatMapping惰性

9.4.4 用列表组成惰性

9.4.5 处理异常

9.5 深层次的惰性构成

9.5.1 惰性应用作用

9.5.2 不能没有惰性

9.5.3 创建一个惰性列表数据结构

9.6 处理流

9.6.1 折叠流

9.6.2 跟踪计算和函数应用

9.6.3 将流应用于具体问题

9.7 本章小结

10章 使用树处理更多的数据

10.1 二树

10.2 了解平衡和不平衡的树

10.3 树的大小、高度和深度

10.4 空树和递归定义

10.5 多叶树

10.6 有序二树或二搜索树

10.7 插入顺序和树的结构

10.8 递归和非递归树遍历顺序

10.8.1 递归遍历树

10.8.2 非递归遍历树

10.9 实现二搜索树

10.9.1 理解型变和树

10.9.2 Tree类中的抽象函数

10.9.3 重载作符

10.9.4 树中递归

10.9.5 从树中移除元素

10.9.6 合并任意树

10.10 关于折叠树

10.10.1 双函数折叠

10.10.2 单函数折叠

10.10.3 如何选择折叠实现

10.11 映树

10.12 平衡树

10.12.1 旋转树

10.12.2 使用Day-Stout-Warren算法

10.12.3 自动平衡树

11章 用树解决问题

11.1 自平衡树的性能更好，栈更安全

11.1.1 了解基本的红黑树结构

11.1.2 向红黑树中添加元素

11.1.3 从红黑树中移除元素

11.2 一个红黑树的用例：Map

11.2.1 实现Map

11.2.2 扩展Map

11.2.3 使用具有不可比较键的Map

11.3 实现功能优先队列

11.3.1 查看优先队列访问协议

11.3.2 探索优先级队列用例

11.3.3 查看实现需求

11.3.4 左倾堆数据结构

11.3.5 实现左倾堆

11.3.6 实现类似队列的接口

11.4 元素和有序列表

11.5 不可比较元素的优先队列

11.6 本章小结

12章 函数式输入/输出

12.1 作用在上下文中是什么意思

12.1.1 处理作用

12.1.2 实现作用

12.2 读取数据

12.2.1 从控制台读取数据

12.2.2 从文件中读取数据

12.3 输入测试

12.4 全函数式输入/输出

12.4.1 使输入/输出全函数式

12.4.2 实现纯函数式的输入/输出

12.4.3 结合输入/输出

12.4.4 用IO处理输入

12.4.5 扩展IO类型

12.4.6 使IO类型堆栈安全

12.5 本章小结

13章 与参与者共享可变状态

13.1 角色模型

13.1.1 理解异步消息传递

13.1.2 并行化处理

13.1.3 处理角色状态突变

13.2 角色框架实现

13.2.1 理解局限性

13.2.2 设计角色框架接口

13.3 AbstractActor的实现

13.4 让角色投入工作

13.4.1 实现乒乓球例子

13.4.2 并行运行计算

13.4.3 重排结果

13.4.4 优化性能

13.5 本章小结

14章 解决常见功能性问题

14.1 断言和数据验证

14.2 函数和作用的重试

14.3 从文件中读入属性

14.3.1 加载属性文件

14.3.2 以字符串形式读取属性

14.3.3 生成更好的消息

14.3.4 将属性作为列表读取

14.3.5 读取枚举值

14.3.6 读取任意类型的属性

14.4 转换命令式风格的程序：XML阅读器

14.4.1 1步：命令式风格的解决方案

14.4.2 2步：将命令式风格的代码转换为函数式

14.4.3 3步：将程序转换得更函数式

14.4.4 4步：修复参数类型问题

14.4.5 5步：使元素处理函数成为参数

14.4.6 6步：对元素名称进行处理

14.4.7 7步：对先前命令式代码的额外改进

14.5 本章小结

附录 A-将Kotlin与Java结合

A.1 创建和管理混合项目402

A.1.1 利用Gradle创建一个简单的项目

A.1.2 将Gradle项目导入IntelliJ

A.1.3 为项目增加依赖

A.1.4 创建多模块项目

A.1.5 为多模块项目增加依赖

A.2 Java库方法和Kotlin代码

A.2.1 使用Java基本类型

A.2.2 使用Java数值对象类型

A.2.3 对null值快速失败

A.2.4 使用Kotlin和Java的字符串类型

A.2.5 实现其他类型的转换

A.2.6 使用Java可变参数

A.2.7 在Java中指定可空性

A.2.8 调用getter方法和setter方法

A.2.9 使用保留字获取Java属性

A.2.10 调用已检查异常

A.3 SAM接口

A.4 Kotlin函数和Java代码

A.4.1 转换Kotlin属性

A.4.2 使用Kotlin公共字段

A.4.3 静态字段

A.4.4 将Kotlin函数作为Java方法调用

A.4.5 将Kotlin的类型转换为Java类型

A.4.6 函数类型

A.5 混合Kotlin/Java项目的特定问题

附录B-Kotlin中基于属性的测试

B.1 为何使用基于属性的测试

B.1.1 编写接口

B.1.2 编写测试程序

B.2 什么是基于属性的测试

B.3 抽象及基于属性的测试

B.4 基于属性的单元测试的依赖

B.5 编写基于属性的测试程序

B.5.1 创建自定义生成器

B.5.2 使用自定义生成器

B.5.3 通过更进一步抽象来简化代码

^_^:daeeb9c825fc4bbb43205bdc0966dd59

^_^:e7ac06b31fc3371079b7f4dd242f8033