目    录

第1章  对象的世界   1

1.1  Kotlin：一门新兴的编程语言   1

1.2  什么是Kotlin   2

1.3  Kotlin是面向对象的语言   3

1.4  设置Kotlin环境   4

1.4.1  安装Kotlin(及IDE)   4

1.4.2  安装Kotlin(并使用命令行)   10

1.5  创建有用的对象   12

1.5.1  使用构造函数将值传递给对象   13

1.5.2  使用toString ()方法打印对象   14

1.5.3  覆盖toString ()方法   15

1.5.4  数据并不都是属性值   17

1.6  初始化对象并更改变量   18

1.6.1  使用代码块初始化类   19

1.6.2  Kotlin自动生成getter和setter   20

1.6.3  常量变量不能改变   21

第2章  Kotlin很难出错   25

2.1  继续探究Kotlin类   25

2.1.1  根据类命名文件   26

2.1.2  用包管理类   27

2.1.3  将Person类放入包中   28

2.1.4  类：Kotlin的终极类型   31

2.2  Kotlin有很多类型   31

2.2.1  Kotlin中的数字   31

2.2.2  字母和事物   32

2.2.3  真值或假值   33

2.2.4  类型不可互换I   33

2.2.5  属性必须初始化   34

2.2.6  类型不可互换II   35

2.2.7  Kotlin很容易出错(某种程度上)   37

2.3  覆盖属性访问器和更改器   38

2.3.1  自定义设置(custom-set)属性不能位于主构造函数中   38

2.3.2  覆盖某些属性的更改器   42

2.4  类可以有自定义行为   44

2.4.1  在类中定义自定义方法   44

2.4.2  每个属性都必须初始化   45

2.4.3  有时并不需要属性   48

2.5  类型安全改变一切   50

2.6  代码的编写很少是线性的   50

第3章  Kotlin非常优雅   53

3.1  对象、类与Kotlin   53

3.2  所有类都需要equals()方法   54

3.2.1  equals(x)用于比较两个对象   54

3.2.2  覆盖equals(x)使其有意义   56

3.2.3  每个对象都是一个特定的类型   58

3.2.4  空值   60

3.3  每个对象实例都需要唯一的hashCode()   61

3.3.1  所有类都继承自Any类   61

3.3.2  始终覆盖hashCode()和equals(x)   64

3.3.3  默认哈希值是基于内存位置的   65

3.3.4  使用哈希值生成哈希值   66

3.4  基于有效和快速的equals(x)和hashCode()方法的搜索   67

3.4.1  在hashCode()中区分多个属性   67

3.4.2  用==代替equals(x)   68

3.4.3  hashCode()的快速检查   69

3.5  基本的类方法非常重要   70

第4章  继承很重要   71

4.1  好的类并不总是复杂的类   71

4.1.1  保持简单、直白   72

4.1.2  保持灵活、直白   73

4.2  类可以定义属性的默认值   75

4.2.1  构造函数可以接收默认值   76

4.2.2  Kotlin希望参数有序排列   76

4.2.3  按名称指定参数   77

4.2.4  更改参数顺序   77

4.3  次构造函数可以提供额外的构造选项   78

4.3.1  次构造函数排在主构造函数之后   79

4.3.2  次构造函数可给属性赋值   80

4.3.3  有时，可以将null值赋给属性   82

4.3.4  null属性可能会导致问题   85

4.4  使用自定义更改器处理依赖值   85

4.4.1  在自定义更改器中设置依赖值   86

4.4.2  所有属性赋值都会使用属性的更改器   86

4.4.3  可为空的值可以设置为空   87

4.4.4  限制对依赖值的访问   90

4.4.5  尽可能地计算依赖值   91

4.4.6  只读属性可不用括号   93

4.5  具体应用——子类   95

4.5.1  Any是所有Kotlin类的基类   96

4.5.2   {...}是折叠代码的简略表达   97

4.5.3  类必须是开放的才能有子类   99

4.5.4  术语：子类、继承、基类等   100

4.5.5  子类必须遵循其父类的规则   100

4.5.6  子类拥有其父类的所有行为   101

4.6  子类应不同于父类   101

4.6.1  子类的构造函数经常添加参数   101

4.6.2  不要让不可变属性成为可变属性   102

4.6.3  有时，对象并不完全映射现实世界   103

4.6.4  通常，对象应当映射现实世界   104

第5章  List、Set和Map   105

5.1  List只是事物的集合   105

5.1.1  Kotlin的List：一种集合类型   105

5.1.2  更改可变列表   109

5.1.3  从可变列表获取属性   110

5.2  List(集合)的类型   111

5.2.1  给列表定义类型   111

5.2.2  遍历列表   113

5.2.3  Kotlin会揣摩你的意思   116

5.3  List：有序且可重复   117

5.3.1  有序可以使你按顺序访问列表项   117

5.3.2  List可以包含重复项   118

5.4  Set：无序但唯一   119

5.4.1  在Set中，无法保证顺序   119

5.4.2  何时顺序至关重要   120

5.4.3  动态排序List(和Set)   121

5.4.4  Set不允许有重复项   121

5.4.5  迭代器不(总)是可变的   125

5.5  Map：当单值不够用时   125

5.5.1  Map是由工厂方法创建的   126

5.5.2  使用键查找值   126

5.5.3  你希望值是什么   127

5.6  如何过滤集合   127

5.6.1  基于特定条件的过滤   128

5.6.2  更多有用的过滤器变体   129

5.7  集合：用于基本类型和自定义类型   130

5.7.1  向Person类添加集合   130

5.7.2  允许将集合添加到集合属性   132

5.7.3  Set和MutableSet不一样   134

5.7.4  集合属性只是集合   135

第6章  Kotlin的未来是泛型   137

6.1  泛型允许推迟类型定义   137

6.1.1  集合是泛型的   137

6.1.2  参数化类型在整个类中都可用   138

6.1.3  泛型到底是什么   139

6.2  泛型会尽可能地推断类型   140

6.2.1  Kotlin会寻找匹配的类型   140

6.2.2  Kotlin会寻找最精确匹配的类型   141

6.2.3  Kotlin不会告诉你泛型类型   142

6.2.4  告诉Kotlin你想要什么   143

6.3  协变：类型与赋值的研究   143

6.3.1  什么是泛型类型   143

6.3.2  有些语言需要额外的工作才能实现协变   145

6.3.3  Kotlin实际上也需要额外的工作才能实现协变   145

6.3.4  有时必须把显而易见的事情说清楚   146

6.3.5  协变类型限制输入类型和输出类型   146

6.3.6  协变实际上是使继承按期望的方式工作   146

6.4  逆变：从泛型类型构建消费者   147

6.4.1  逆变：限制输出而不是输入   147

6.4.2  逆变从基类一直到子类都有效   149

6.4.3  逆变类不能返回泛型类型   150

6.4.4  这些真的重要吗   150

6.5  UnsafeVariance：学习规则，然后打破规则   151

6.6  类型投影允许你处理基类   152

6.6.1  型变可以影响函数，而不只是类   152

6.6.2  类型投影告知Kotlin可将子类作为基类的输入   153

6.6.3  生产者不能消费，消费者也不能生产   153

6.6.4  型变不能解决所有问题   154

第7章  控制结构   155

7.1  控制结构是编程的基础   155

7.2  if和else控制结构   156

7.2.1  !!确保非空值   156

7.2.2  控制结构影响代码的流程   157

7.2.3  if和else遵循基本结构   158

7.2.4  表达式和if语句   159

7.3  when是Kotlin版本的Switch   163

7.3.1  每个比较或条件都是一个代码块   163

7.3.2  用else代码块处理其他一切   164

7.3.3  每个分支可以支持一定范围   165

7.3.4  每个分支通常会有部分表达式   166

7.3.5  分支条件按顺序依次检查   168

7.3.6  分支条件只是表达式   169

7.3.7  when语句也可作为一个整体来赋值   169

7.4  for循环   171

7.4.1  Kotlin中的for循环需要一个迭代器   171

7.4.2  你做得越少，Kotlin做得越多   172

7.4.3  for对迭代有要求   173

7.4.4  可以用for获取索引而不是对象   173

7.5  执行while循环直至条件为假   176

7.5.1  while与Boolean条件有关   176

7.5.2  巧用while：多个运算符，一个变量   178

7.5.3  组合控制结构，获得更有趣的解决方案   179

7.6  do...while循环至少运行一次   180

7.6.1  每个do ... while循环都可以改写成一个while循环   180

7.6.2  如果必须先执行一定的操作，那么使用do ... while   181

7.6.3  选用do ... while可能是基于性能的考虑   186

7.7  break可以立即跳出循环   186

7.7.1  break跳过循环中剩余的部分   186

7.7.2  可以使用带标签的break   187

7.8  使用continue立即进入下一次迭代   189

7.8.1  continue也可以使用标签   189

7.8.2  if和continue对比：通常风格更胜过实质   190

7.9  return语句用于返回   191

第8章  数据类   193

8.1  现实世界中的类是多种多样，但经过广泛研究的   193

8.1.1  许多类具有共同的特征   193

8.1.2  共同的特征导致共同的用法   195

8.2  数据类是指专注于数据的类   195

8.2.1  数据类提供处理数据的基本功能   195

8.2.2  数据的基本功能包括hashCode()和equals(x)方法   197

8.3  通过解构声明获取数据   199

8.3.1  获取类实例中的属性值   199

8.3.2  解构声明并不十分聪明   200

8.3.3  Kotlin使用componentN()方法使声明生效   201

8.3.4  可以向任何类添加componentN()方法   202

8.3.5  能使用数据类则尽量使用   202

8.4  可以“复制”一个对象或创建一个对象副本   203

8.4.1  使用=实际上不会创建副本   203

8.4.2  使用copy()方法才创建真正的副本   204

8.5  数据类需要你做几件事   205

8.5.1  数据类需要有参数并指定val或var   205

8.5.2  数据类不能是抽象的、开放的、密封的或内部的   206

8.6  数据类能为生成的代码添加特殊行为   207

8.6.1  可以覆盖许多标准方法的编译器生成版本   207

8.6.2  父类函数优先   208

8.6.3  数据类仅为构造函数参数生成代码   208

8.6.4  equals()方法仅使用构造函数中的参数   211

8.7  最好单独使用数据类   212

第9章  枚举和密封类，以及更多专业类   215

9.1  字符串是可怕的静态类型表示法   215

9.2  伴生对象为单例   219

9.2.1  常量必须只有一个   220

9.2.2  伴生对象是单例   221

9.2.3  伴生对象仍然是对象   222

9.2.4  可以使用没有名称的伴生对象   224

9.3  枚举定义常量并提供类型安全   228

9.3.1  枚举类提供类型安全值   229

9.3.2  枚举类仍然是类   231

9.4  密封类是类型安全的类层次结构   234

9.4.1  枚举和类层次结构用于共享行为   235

9.4.2  密封类解决了固定选项和非共享行为   236

9.4.3  when需要处理所有密封子类   238

第10章  函数   247

10.1  重温函数的语法   247

10.1.1  函数基本公式   247

10.1.2  函数参数也有模式   249

10.2  函数遵循灵活规则   257

10.2.1  函数实际上默认返回Unit   258

10.2.2  函数可以是单一表达式   259

10.2.3  函数可以有可变数量的入参   264

10.3  Kotlin的函数具有作用域   267

10.3.1  局部函数是函数内部的函数   267

10.3.2  成员函数在类中定义   268

10.3.3  扩展函数可以扩展现有行为而无须继承   268

10.4  函数字面量：Lambda和匿名函数   272

10.4.1  匿名函数没有名称   273

10.4.2  高阶函数接收函数作为入参   276

10.4.3  Lambda表达式是语法精简的函数   280

10.5  功能越多，出现问题的可能性就越大   285

第11章  编写地道的Kotlin代码   287

11.1  作用域函数为代码提供上下文   287

11.2  使用let提供对实例的即时访问   288

11.2.1  let提供it来访问实例   289

11.2.2  作用域代码块实际上就是Lambda   290

11.2.3   let和其他作用域函数主要是为了方便   291

11.2.4  链式作用域函数和嵌套作用域函数不一样   294

11.2.5  可以通过作用域函数得到非空结果   297

11.3  with是用于处理实例的作用域函数   304

11.3.1  with使用this作为其对象引用   305

11.3.2  this引用始终可用   306

11.3.3  with返回Lambda的结果   306

11.4  run是一个代码运行器和作用域函数   307

11.4.1  选择作用域函数是风格和偏好的问题   307

11.4.2  run不必对对象实例进行操作   309

11.5  apply具有上下文对象但没有返回值   309

11.5.1  apply对实例进行操作   310

11.5.2  apply返回的是上下文对象，而不是Lambda的结果   310

11.5.3  ?:是Kotlin的Elvis运算符   311

11.6  also在返回实例前先在实例上进行操作   312

11.6.1  also只是又一个作用域函数   313

11.6.2  also在赋值前执行   314

11.7  作用域函数总结   316

第12章  再次体会继承   321

12.1  抽象类需要延迟实现   321

12.1.1  抽象类无法实例化   322

12.1.2  抽象类定义了与子类的契约   324

12.1.3  抽象类可以定义具体属性和函数   326

12.1.4  子类履行通过抽象类编写的契约   328

12.2  接口定义行为但没有主体   332

12.2.1  接口和抽象类相似   333

12.2.2  接口无法保存状态   335

12.2.3  接口可以定义函数体   337

12.2.4  接口允许多种实现形式   338

12.3  “委托”为扩展行为提供了另一个选项   341

12.3.1  抽象类从通用到特定   341

12.3.2  更多特异性意味着更多的继承   343

12.3.3  委托给属性   346

12.3.4  委托在实例化时发生   348

12.4  继承需要事前事后深思熟虑   350

第13章  学习Kotlin的下一步   351

13.1  用Kotlin编写Android应用程序   351

13.1.1  用于Android开发的Kotlin仍然只是Kotlin   351

13.1.2  从概念到示例   353

13.2  Kotlin和Java是很棒的伙伴   353

13.2.1  IDE是一个关键组件   353

13.2.2  Kotlin被编译为Java虚拟机的字节码   355

13.2.3  使用Gradle构建项目   355

13.3  有关Kotlin的问题仍然存在时   355

13.4  使用互联网来补充自己的需求和学习风格   356

13.5  接下来怎么办   357