Java到Kotlin：代码重构指南

关于封面

关于作者

参考文献

23.6 重构和函数式思维

23.5 重构

23.4 函数式编程和文本推理

23.3 简单设计

23.2 函数式思维

23.1 纹理

第23章 继续旅程

22.8 继续前进

22.7 与Commons CSV比较

22.6 从文件中读取

22.5 序列

22.4 不同的字段分隔符

22.3 标题

22.2 单元测试

22.1 验收测试

第22章 从类到函数

21.4 继续前进

21.3 I/O错误

21.2 表示错误

21.1 识别可能出错的地方

第21章 从异常到值

20.5 继续前进

20.4 高效读取

20.3 高效写入

20.2 从I/O到数据

20.1 监听测试

第20章 从执行I/O操作到传递数据

19.10 继续前进

19.9 层级

19.8 更多修复

19.7 将异常重构为错误

19.6 Kotlin中的错误处理

19.5 超越异常：函数式错误处理

19.4 Kotlin和异常

19.3 Java和受检异常

19.2 异常的错误处理

19.1 异常前的错误处理

第19章 从Throwing到Returning

18.3 继续前进

18.2 将接口转换为密封类

18.1 多态性还是密封类

第18章 从开放类到密封类

17.3 继续前进

17.2 我们真的摆脱了Mock吗

17.1 用Map替代Mock

第17章 从Mock到Map

16.11 继续前进

16.10 将接口重构为函数

16.9 可追溯性

16.8 Java的遗留问题

16.7 面向对象还是函数式

16.6 耦合

16.5 面向对象和函数式的对比

16.4 混合和匹配

16.3 Java中的函数类型

16.2 函数式封装

16.1 面向对象的封装

第16章 从接口到函数

15.4 继续前进

15.3 重构封装集合

15.2 具有其他属性的集合

15.1 组合领域集合

第15章 从封装集合到类型别名

14.5 继续前进

14.4 丰富所发现的抽象

14.3 再来一次

14.2 重构为基于不可变数据的函数

14.1 使用累加器进行参数计算

第14章 从可累积对象到转换对象

13.8 继续前进

13.7 将流重构为可迭代对象和序列

13.6 代数变换

13.5 在流、可迭代对象和序列之间进行选择

13.4 多重迭代

13.3 Kotlin序列

13.2 Kotlin可迭代对象

13.1 Java流

第13章 从流到可迭代对象再到序列

12.6 继续前进

12.5 表示值的约定

12.4 现有Java类的运算符

12.3 从现有Kotlin代码中调用运算符

12.2 添加用户定义的运算符

12.1 基础类：Money

第12章 从函数到运算符

11.5 继续前进

11.4 重构为属性

11.3 可变属性

11.2 如何选择

11.1 字段、访问器和属性

第11章 从方法到属性

10.11 继续前进

10.10 重构为扩展函数

10.9 作为方法的扩展函数

10.8 泛型

10.7 可空接收器

10.6 可空参数

10.5 类型转换

10.4 扩展属性

10.3 扩展和函数类型

10.2 扩展函数

10.1 函数和方法

第10章 从函数到扩展函数

9.5 继续前进

9.4 第4种方式：后退一步

9.3 第3种方式：使用let块

9.2 第2种方式：引入函数

9.1 第1种方式：内联

第9章 从多表达式函数到单表达式函数

8.6 继续前进

8.5 Kotlin化

8.4 移到顶层

8.3 将静态方法重构为顶层函数

8.2 Kotlin顶层函数、对象和伴生对象

8.1 Java中的静态方法

第8章 从静态方法到顶层函数

7.7 继续前进

7.6 将action重构为calculation

7.5 为什么选择calculation

7.4 为什么要关注action和calculation

7.3 action

7.2 calculation

7.1 函数

第7章 从action到calculation

6.4 继续前进

6.3 将Java集合重构为Kotlin集合

6.2 Kotlin集合

6.1 Java集合

第6章 从Java集合到Kotlin集合

5.5 继续前进

5.4 将Bean重构为值

5.3 为什么值类型更受欢迎

5.2 值

5.1 Bean

第5章 从Bean到值

4.4 继续前进

4.3 重构为惯用的Kotlin代码

4.2 从Optional重构为nullable

4.1 表示缺失

第4章 从Optional到nullable

3.3 继续前进

3.2 数据类的局限性

3.1 一个简单的值类型

第3章 从Java类到Kotlin类

2.3 继续前进

2.2 在Java构建中添加对Kotlin的支持

2.1 策略

第2章 从Java项目到Kotlin项目

1.6 启程

1.5 我们要做什么

1.4 重构为Kotlin

1.3 Kotlin的“纹理”

1.2 Java编程风格的主观历史

1.1 编程语言的“纹理”

第1章 引言

前言

译者序

推荐序

本书赞誉

O’Reilly Media Inc.介绍

版权信息

封面

封面

版权信息

O’Reilly Media Inc.介绍

本书赞誉

推荐序

译者序

前言

第1章 引言

1.1 编程语言的“纹理”

1.2 Java编程风格的主观历史

1.3 Kotlin的“纹理”

1.4 重构为Kotlin

1.5 我们要做什么

1.6 启程

第2章 从Java项目到Kotlin项目

2.1 策略

2.2 在Java构建中添加对Kotlin的支持

2.3 继续前进

第3章 从Java类到Kotlin类

3.1 一个简单的值类型

3.2 数据类的局限性

3.3 继续前进

第4章 从Optional到nullable

4.1 表示缺失

4.2 从Optional重构为nullable

4.3 重构为惯用的Kotlin代码

4.4 继续前进

第5章 从Bean到值

5.1 Bean

5.2 值

5.3 为什么值类型更受欢迎

5.4 将Bean重构为值

5.5 继续前进

第6章 从Java集合到Kotlin集合

6.1 Java集合

6.2 Kotlin集合

6.3 将Java集合重构为Kotlin集合

6.4 继续前进

第7章 从action到calculation

7.1 函数

7.2 calculation

7.3 action

7.4 为什么要关注action和calculation

7.5 为什么选择calculation

7.6 将action重构为calculation

7.7 继续前进

第8章 从静态方法到顶层函数

8.1 Java中的静态方法

8.2 Kotlin顶层函数、对象和伴生对象

8.3 将静态方法重构为顶层函数

8.4 移到顶层

8.5 Kotlin化

8.6 继续前进

第9章 从多表达式函数到单表达式函数

9.1 第1种方式：内联

9.2 第2种方式：引入函数

9.3 第3种方式：使用let块

9.4 第4种方式：后退一步

9.5 继续前进

第10章 从函数到扩展函数

10.1 函数和方法

10.2 扩展函数

10.3 扩展和函数类型

10.4 扩展属性

10.5 类型转换

10.6 可空参数

10.7 可空接收器

10.8 泛型

10.9 作为方法的扩展函数

10.10 重构为扩展函数

10.11 继续前进

第11章 从方法到属性

11.1 字段、访问器和属性

11.2 如何选择

11.3 可变属性

11.4 重构为属性

11.5 继续前进

第12章 从函数到运算符

12.1 基础类：Money

12.2 添加用户定义的运算符

12.3 从现有Kotlin代码中调用运算符

12.4 现有Java类的运算符

12.5 表示值的约定

12.6 继续前进

第13章 从流到可迭代对象再到序列

13.1 Java流

13.2 Kotlin可迭代对象

13.3 Kotlin序列

13.4 多重迭代

13.5 在流、可迭代对象和序列之间进行选择

13.6 代数变换

13.7 将流重构为可迭代对象和序列

13.8 继续前进

第14章 从可累积对象到转换对象

14.1 使用累加器进行参数计算

14.2 重构为基于不可变数据的函数

14.3 再来一次

14.4 丰富所发现的抽象

14.5 继续前进

第15章 从封装集合到类型别名

15.1 组合领域集合

15.2 具有其他属性的集合

15.3 重构封装集合

15.4 继续前进

第16章 从接口到函数

16.1 面向对象的封装

16.2 函数式封装

16.3 Java中的函数类型

16.4 混合和匹配

16.5 面向对象和函数式的对比

16.6 耦合

16.7 面向对象还是函数式

16.8 Java的遗留问题

16.9 可追溯性

16.10 将接口重构为函数

16.11 继续前进

第17章 从Mock到Map

17.1 用Map替代Mock

17.2 我们真的摆脱了Mock吗

17.3 继续前进

第18章 从开放类到密封类

18.1 多态性还是密封类

18.2 将接口转换为密封类

18.3 继续前进

第19章 从Throwing到Returning

19.1 异常前的错误处理

19.2 异常的错误处理

19.3 Java和受检异常

19.4 Kotlin和异常

19.5 超越异常：函数式错误处理

19.6 Kotlin中的错误处理

19.7 将异常重构为错误

19.8 更多修复

19.9 层级

19.10 继续前进

第20章 从执行I/O操作到传递数据

20.1 监听测试

20.2 从I/O到数据

20.3 高效写入

20.4 高效读取

20.5 继续前进

第21章 从异常到值

21.1 识别可能出错的地方

21.2 表示错误

21.3 I/O错误

21.4 继续前进

第22章 从类到函数

22.1 验收测试

22.2 单元测试

22.3 标题

22.4 不同的字段分隔符

22.5 序列

22.6 从文件中读取

22.7 与Commons CSV比较

22.8 继续前进

第23章 继续旅程

23.1 纹理

23.2 函数式思维

23.3 简单设计

23.4 函数式编程和文本推理

23.5 重构

23.6 重构和函数式思维

参考文献

关于作者

关于封面