# 属性与字段
参考[Java中的属性和字段](https://www.kancloud.cn/alex_wsc/java/1328553)
[TOC]
## 声明属性
Kotlin 类中的属性既可以用关键字 *var* 声明为可变的，也可以用关键字 *val*声明为只读的。
```kotlin
class Address {
var name: String = "Holmes, Sherlock"
var street: String = "Baker"
var city: String = "London"
var state: String? = null
var zip: String = "123456"
}
```
要使用一个属性，只要用名称引用它即可(和使用Java类字段(成员变量)差不多)：
```kotlin
fun copyAddress(address: Address): Address {
val result = Address() // Kotlin 中没有“new”关键字
result.name = address.name // 将调用访问器
result.street = address.street
// ……
return result
}
```
* 用`val`修饰符修饰的属性是只读的，即不能被修改，只可使用
* 用`var`修饰符修饰的属性是可读写的，即能用能改
示例：
```
class Mime{
val id : String = "123"
var name : String? = "kotlin"
var age : Int? = 22
var sex : String? = "男"
var weight : Float = 120.3f
private var test : String = ""
get() = "123"
set(value){field = value}
}
fun main(args: Array<String>) {
val mime = Mime()
println("id = ${mime.id} \t name = ${mime.name} \t age = ${mime.age}\t sex = ${mime.sex} \t weight = ${mime.weight}")
}
```
输出结果
```
id = 123 name = kotlin age = 22 sex = 男 weight = 120.3
```
## Getters（读访问器） 与 Setters（写访问器）
在Kotlin中`getter`和`setter` 跟Java 中的getXX 和 setXX方法作用一样，叫做**访问器**。
> getter 叫读访问器，setter叫写访问器。`val` 声明的变量只有读访问器getter，`var`声明的变量读写访问器都有。
声明一个属性的完整语法是
```
// 可变属性
var <propertyName>[: <PropertyType>] [= <property_initializer>]
[<getter>]
[<setter>]
// 只读属性
val <propertyName>[: <PropertyType>] [= <property_initializer>]
[<getter>]
```
其初始器（initializer）、getter 和 setter 都是可选的。
属性类型PropertyType如果可以从初始器（或者从其 getter 返回值，如下文所示）中推断出来，也可以省略。
例如:
```kotlin
var allByDefault: Int? // 错误：需要显式初始化器，隐含默认 getter 和 setter
var initialized = 1 // 能推断出属性类型Int，使用默认的getter 和setter
```
一个只读属性的语法和一个可变的属性的语法有两方面的不同：
1、只读属性的用 `val`开始代替`var`
2、只读属性不允许 setter
```kotlin
val simple: Int? // 类型 Int、默认 getter、必须在构造函数中初始化
val inferredType = 1 // 类型 Int 、默认 getter
```
在Kotlin中，`getter`、`setter` 是属性声明的一部分，声明一个属性默认提供`getter`和`setter` ，当然了，如果有需要，你也可以自定义`getter`和`setter`。
* [ ] 在Kotlin 中，访问一个属性的实质是什么呢？
读一个属性，通过`.`表示，它的实质就是执行了属性的getter访问器，正如上面示例中的`mime.id`，**类似的，在Kotlin中，写一个属性的实质就是执行了属性的写访问器setter**。示例如下
```
class Person {
var name:String = "Paul"
set(value) {
println("执行了写访问器，参数为：$value")
}
}
//测试
fun main(args: Array<String>) {
var person = Person()
// 写name属性
person.name = "hi,this is new value"
println("打印结果:${person.name}")
}
```
运行结果
```
执行了写访问器，参数为：hi,this is new value
打印结果:Paul
```
可以看到给一个给一个属性赋值时，确实是执行了写访问器setter，但是为什么结果还是默认值Paul呢？因为我们重写了setter，却没有给属性赋值，当然还是默认值。如果需要给属性赋值，则应如下操作：更改set方法
```
set(value) {
println("执行了写访问器，参数为：$value")
this.name = value
}
```
但是，如果这样运行，会报错oom:`Your program produces too much output!`，一运行就会报错，直接StackOverFlow了，内存溢出，为什么呢？转换为Java代码看一下你就明白了，将Person类转为Java类：
```
public final class Person {
@NotNull
private String name = "Paul";
@NotNull
public final String getName() {
return this.name;
}
public final void setName(@NotNull String value) {
this.setName(value);
}
}
```
我们可以从set方法中看到，方法循环调用了，`setName` 中又调用了`setName` ，死循环了，直到内存溢出，程序崩溃。Kotlin代码也一样，在setter中又给属性赋值，导致一直执行setter， 陷入死循环，直到内存溢出崩溃。那么这个怎么解决了？这就引入了Kotlin一个重要的东西**幕后字段（下面会讲解到，这里留个疑问）**。
### 自定义Getter()与Setter()
我们可以为属性自定义访问器。如果我们定义了一个自定义的 getter，那么每次访问该属性时都会调用它（这让我们可以实现计算出的属性）。以下是一个自定义 getter 的示例：
```kotlin
val isEmpty: Boolean
get() = this.size == 0
```
* [ ] **示例1**：用`val`修饰的属性自定义情况
```
class Mime{
// size属性
private val size = 0
// 即isEmpty这个属性，是判断该类的size属性是否等于0
val isEmpty : Boolean
get() = this.size == 0
// 另一个例子
val num = 2
get() = if (field > 5) 10 else 0
}
// 测试
fun main(args: Array<String>) {
val mime = Mime()
println("isEmpty = ${mime.isEmpty}")
println("num = ${mime.num}")
}
```
运行结果
```
isEmpty = true
num = 0
```
如果我们自定义了一个setter，那么每次给属性赋值时都会调用它。一个自定义的 setter 如下所示：
```kotlin
var stringRepresentation: String
get() = this.toString()
set(value) {
setDataFromString(value) // 解析字符串并赋值给其他属性
}
```
按照惯例，setter 参数的名称是 `value`，但是如果你喜欢也可以选择一个不同的名称（`value`是`Koltin`写`setter()`函数时其参数的约定俗成的习惯。你也可以换成其他的值）。自 Kotlin 1.1 起，如果可以从 getter 推断出属性类型，则可以省略它：
```kotlin
val isEmpty get() = this.size == 0 // 具有类型 Boolean
```
* [ ] **示例2**：用`var`修饰的属性自定义情况
```
class Mime{
var str1 = "test"
get() = field // 这句可以省略，kotlin默认实现的方式
set(value){
field = if (value.isNotEmpty()) value else "null"
}
var str2 = ""
get() = "随意怎么修改都不会改变"
set(value){
field = if (value.isNotEmpty()) value else "null"
}
}
// 测试
fun main(args: Array<String>) {
val mime = Mime()
println("str = ${mime.str1}")
mime.str1 = ""
println("str = ${mime.str1}")
mime.str1 = "kotlin"
println("str = ${mime.str1}")
println("str = ${mime.str2}")
mime.str2 = ""
println("str = ${mime.str2}")
mime.str2 = "kotlin"
println("str = ${mime.str2}")
}
```
运行结果
```
str = test
str = null
str = kotlin
str = 随意怎么修改都不会改变
str = 随意怎么修改都不会改变
str = 随意怎么修改都不会改变
```
* [ ] **结论**：
1. 使用了`val`修饰的属性，不能有`setter()`.
2. 不管是`val`还是`var`修饰的属性，只要存在`getter()`,其值再也不会变化
3. 使用`var`修饰的属性，可以省略掉`getter()`,不然`setter()`毫无意义。当然`get() = field`除外。而`get() = field`是`Koltin`默认的实现，是可以省略这句代码的。
PS：在实际的项目开发中，这个自定义的`getter`与`setter`的意义不是太大。
### 修改访问器的可见性
如果你需要改变一个访问器的可见性或者需要对其注解，但是不需要改变默认的实现，你可以定义访问器而不定义其实现:
```kotlin
var setterVisibility: String = "abc"
private set // 此 setter 是私有的并且有默认实现，私有，不改变默认实现
var setterWithAnnotation: Any? = null
@Inject set // 用 Inject 注解此 setter，注解，不改变默认实现
```
示例：
```
var str1 = "kotlin_1"
private set // setter()访问器的私有化，并且它拥有kotlin的默认实现
var test : String?
@Inject set // 用`Inject`注解去实现`setter()`
val str2 = "kotlin_2"
private set // 编译错误，因为val修饰的属性，不能有setter
var str3 = "kotlin_3"
private get // 编译出错，因为不能有getter()的访问器可见性
fun main(args: Array<String>) {
// 这里伪代码
str1 = "能不能重新赋值呢？" // 编译出错，因为上面的setter是私有的
}
```
**注意**：如果，属性访问器的可见性修改为`private`或者该属性直接使用`private`修饰时，我们只能手动提供一个公有的函数去修改其属性了。就像`Java`中的`Bean`的`setXXXX()`，另外，修改属性访问器在实际的开发中其实也没有太大的作用。
>[success] 注意，
> 1、不存在`Getter()与Setter()`的，这只是`Kotlin`中的叫法而已，真正的写法，还是用`get()、set()`
> 2、在`Kotlin`中，普通的类中一般是不提供`getter()`与`setter()`函数的，因为在普通的类中几乎用不到，这一点和`Java`是相同的，但是`Java`中在定义纯粹的数据类时，会用到`get()`与`set()`函数，但是`Kotlin`专门这种情况定义了`数据类`,这个特征。而`数据类`是系统已经为我们实现了`get()`和`set()`函数。
## 幕后字段
**在 Kotlin 类中不能直接声明字段（fields）。然而，当一个属性需要一个幕后字段时，Kotlin 会自动提供**。这个幕后字段可以**使用`field`标识符在访问器中引用**，或者换一个说法就是，**在Kotlin中，如果属性至少一个访问器使用默认实现，那么Kotlin会自动提供幕后字段，用关键字`field`表示，幕后字段主要用于自定义getter和setter中，并且只能在getter 和setter中访问**：
```kotlin
var counter = 0 // 注意：这个初始器直接为幕后字段赋值
set(value) {
if (value >= 0) field = value
}
```
```
var count = 0 // 初始化值会直接写入备用字段
set(value){
field = if(value > 10) value else 0 // 通过field来修改属性的值。
}
```
`field` 标识符只能用在属性的访问器内。
如果属性至少一个访问器使用默认实现，或者自定义访问器通过 `field` 引用幕后字段，将会为该属性生成一个幕后字段。
例如，下面的情况下，不会生成幕后字段的属性，就没有幕后字段：
```kotlin
val size = 0
/*
没有幕后字段的原因：
1. 并且`getter()`不是默认的实现。没有使用到`field`标识符
2. 使用`val`修饰，故而不存在默认的`setter()`访问器，也没有`field`修饰符
*/
val isEmpty: Boolean
get() = this.size == 0
```
>[info] 注意：不管是幕后字段或者下面的幕后属性，都是`Kotlin`对于空指针的一种解决方案，可以避免函数访问私有属性而破坏它的结构。
正如前面我们讲到的在[Getters（读访问器） 与 Setters（写访问器）](https://www.kancloud.cn/alex_wsc/android_kotlin/1318250#Getters__Setters_49)这一小节中，自定义写访问器中，
```
set(value) {
println("执行了写访问器，参数为：$value")
this.name = value
}
```
这样会陷入死循环（原因见前面），这时就需要幕后字段，给幕后字段field赋值
```
class Person {
//错误的演示
var name = ""
set(value) {
field = value
}
}
```
getter 也一样，返回了幕后字段：
```
// 例子一
class Person {
var name:String = ""
get() = field
set(value) {
field = value
}
}
// 例子二
class Person {
var name:String = ""
}
```
上面两个属性的声明是等价的，例子一中的`getter`和`setter` 就是默认的`getter`和`setter`。其中幕后字段`field`指的就是当前的这个属性，它不是一个关键字，只是在setter和getter的这个两个特殊作用域中有着特殊的含义，就像一个类中的`this`，代表当前这个类。
用幕后字段，我们可以在getter和setter中做很多事，一般用于让一个属性在不同的条件下有不同的值，比如下面这个场景
**场景：** 我们可以根据性别的不同，来返回不同的姓名
```
class Person(var gender:Gender){
var name:String = ""
set(value) {
field = when(gender){
Gender.MALE -> "Jake.$value"
Gender.FEMALE -> "Rose.$value"
}
}
}
enum class Gender{
MALE,
FEMALE
}
fun main(args: Array<String>) {
// 性别MALE
var person = Person(Gender.MALE)
person.name="Love"
println("打印结果:${person.name}")
//性别：FEMALE
var person2 = Person(Gender.FEMALE)
person2.name="Love"
println("打印结果:${person2.name}")
}
```
打印结果
```
打印结果:Jake.Love
打印结果:Rose.Love
```
如上，我们实现了name 属性通过gender 的值不同而行为不同。幕后字段大多也用于类似场景。
是不是Kotlin 所有属性都会有幕后字段呢？当然不是，需要满足下面条件之一：
* 使用默认 getter / setter 的属性，一定有幕后字段。对于 var 属性来说，只要 getter / setter 中有一个使用默认实现，就会生成幕后字段；
* 在自定义 getter / setter 中使用了 field 的属性
正如下面的示例就没有幕后字段
```
class NoField {
var size = 0
//isEmpty没有幕后字段
var isEmpty
get() = size == 0
set(value) {
size \*= 2
}
}
```
如上，`isEmpty`是没有幕后字段的，重写了setter和getter,没有在其中使用 `field`，这或许有点不好理解，我们把它转换成Java代码看一下你可能就明白了，Java 代码如下
```
public final class NoField {
private int size;
public final int getSize() {
return this.size;
}
public final void setSize(int var1) {
this.size = var1;
}
public final boolean isEmpty() {
return this.size == 0;
}
public final void setEmpty(boolean value) {
this.size *= 2;
}
}
```
看到没，翻译成Java代码，只有一个size变量，isEmpty 翻译成了 `isEmpty()`和`setEmpty()`两个方法。返回值取决于size的值。
**有幕后字段的属性转换成Java代码一定有一个对应的Java变量**
## 幕后属性
### 官方文档介绍
如果你的需求不符合这套“隐式的幕后字段”方案，那么总可以使用 *幕后属性（backing property）*：
```kotlin
private var _table: Map<String, Int>? = null
public val table: Map<String, Int>
get() {
if (_table == null) {
_table = HashMap() // 类型参数已推断出
}
return _table ?: throw AssertionError("Set to null by another thread")
}
```
> **对于 JVM 平台**：通过默认 getter 和 setter 访问私有属性会被优化，所以本例不会引入函数调用开销。
### 个人见解
有时候有这种需求，我们希望一个属性：**对外表现为只读，对内表现为可读可写**，我们将这个属性成为**幕后属性**。 如：
```
private var _table: Map<String, Int>? = null
public val table: Map<String, Int>
get() {
if (_table == null) {
_table = HashMap() // 类型参数已推断出
}
return _table ?: throw AssertionError("Set to null by another thread")
}
```
将`_table`属性声明为`private`，因此外部是不能访问的，内部可以访问，外部访问通过`table`属性，而`table`属性的值取决于`_table`，这里`_table`就是幕后属性。
幕后属性这种设计在Kotlin 的的集合Collection中用得非常多，Collection 中有个`size`字段，`size` 对外是只读的，`size`的值的改变根据集合的元素的变换而改变，这是在集合内部进行的，这用幕后属性来实现非常方便。
如Kotlin `AbstractList`中`SubList`源码：
```
private class SubList<out E>(private val list: AbstractList<E>, private val fromIndex: Int, toIndex: Int) : AbstractList<E>(), RandomAccess {
// 幕后属性
private var _size: Int = 0
init {
checkRangeIndexes(fromIndex, toIndex, list.size)
this._size = toIndex - fromIndex
}
override fun get(index: Int): E {
checkElementIndex(index, _size)
return list[fromIndex + index]
}
override val size: Int get() = _size
}
```
`AbstractMap` 源码中的keys 和 values 也用到了幕后属性
```
/**
* Returns a read-only [Set] of all keys in this map.
*
* Accessing this property first time creates a keys view from [entries].
* All subsequent accesses just return the created instance.
*/
override val keys: Set<K>
get() {
if (_keys == null) {
_keys = object : AbstractSet<K>() {
override operator fun contains(element: K): Boolean = containsKey(element)
override operator fun iterator(): Iterator<K> {
val entryIterator = entries.iterator()
return object : Iterator<K> {
override fun hasNext(): Boolean = entryIterator.hasNext()
override fun next(): K = entryIterator.next().key
}
}
override val size: Int get() = this@AbstractMap.size
}
}
return _keys!!
}
@kotlin.jvm.Volatile
```
## 编译期常量
已知值的属性可以使用 *const*修饰符标记为 _编译期常量_。这些属性需要满足以下要求：
* 位于顶层或者是 [object声明](http://www.kotlincn.net/docs/reference/object-declarations.html#%E5%AF%B9%E8%B1%A1%E5%A3%B0%E6%98%8E) 或 [companion object(伴生对象)](http://www.kotlincn.net/docs/reference/object-declarations.html#%E4%BC%B4%E7%94%9F%E5%AF%B9%E8%B1%A1) 的一个成员
* 以 `String` 或原生类型值初始化（初始化为`String`类型或基本类型的值）
* 没有自定义 getter
如
```
const val CONST_NUM = 5
const val CONST_STR = "Kotlin"
```
这些属性可以用在注解中：
```kotlin
const val SUBSYSTEM_DEPRECATED: String = "This subsystem is deprecated"
@Deprecated(SUBSYSTEM_DEPRECATED) fun foo() { …… }
```
可参考：[Kotlin之常量的用法](https://www.kancloud.cn/alex_wsc/android_kotlin/1037791#Kotlin_170)
## 延迟初始化属性与变量
**一般地，属性声明为非空类型必须在构造函数中初始化**。然而，这经常不方便。例如：**属性可以通过依赖注入来初始化，或者在单元测试的 setup 方法中初始化。 这种情况下，你不能在构造函数内提供一个非空初始器。但你仍然想在类体中引用该属性时避免空检测。**
为处理这种情况，你**可以用 `lateinit` 修饰符标记该属性**：
```kotlin
public class MyTest {
lateinit var subject: TestSubject
@SetUp fun setup() {
subject = TestSubject()
}
@Test fun test() {
subject.method() // 直接解引用
}
}
```
*****
该修饰符只能用于在类体中的属性（不是在主构造函数中声明的 `var` 属性，并且仅当该属性没有自定义 getter 或 setter 时），而自 Kotlin 1.2 起，也用于顶层属性与局部变量。该属性或变量必须为非空类型，并且不能是原生类型（原生类型指 Int、Float、Double、Short等，String类型是可以的）。
*****
在初始化前访问一个 `lateinit` 属性会抛出一个特定异常，该异常明确标识该属性被访问及它没有初始化的事实。
### 检测一个 lateinit var 是否已初始化（自 1.2 起）
要检测一个 `lateinit var` 是否已经初始化过，请在[该属性的引用](http://www.kotlincn.net/docs/reference/reflection.html#%E5%B1%9E%E6%80%A7%E5%BC%95%E7%94%A8)上使用`.isInitialized`：
```kotlin
if (foo::bar.isInitialized) {
println(foo.bar)
}
```
此检测仅对可词法级访问的属性可用，即声明位于同一个类型内、位于其中一个外围类型中或者位于相同文件的顶层的属性。
## 覆盖属性
参见[覆盖属性](http://www.kotlincn.net/docs/reference/classes.html#%E8%A6%86%E7%9B%96%E5%B1%9E%E6%80%A7)
## 委托属性
最常见的一类属性就是简单地从幕后字段中读取（以及可能的写入）。另一方面，使用自定义 getter 和 setter 可以实现属性的任何行为。介于两者之间，属性如何工作有一些常见的模式。一些例子：惰性值、通过键值从映射读取、访问数据库、访问时通知侦听器等等。
这些常见行为可以通过使用[_委托属性_](http://www.kotlincn.net/docs/reference/delegated-properties.html)实现为库。
- 前言
- Kotlin简介
- IntelliJ IDEA技巧总结
- idea设置类注释和方法注释模板
- 像Android Studion一样创建工程
- Gradle
- Gradle入门
- Gradle进阶
- 使用Gradle创建一个Kotlin工程
- 环境搭建
- Androidstudio平台搭建
- Eclipse的Kotlin环境配置
- 使用IntelliJ IDEA
- Kotlin学习路线
- Kotlin官方中文版文档教程
- 概述
- kotlin用于服务器端开发
- kotlin用于Android开发
- kotlin用于JavaScript开发
- kotlin用于原生开发
- Kotlin 用于数据科学
- 协程
- 多平台
- 新特性
- 1.1的新特性
- 1.2的新特性
- 1.3的新特性
- 开始
- 基本语法
- 习惯用法
- 编码规范
- 基础
- 基本类型
- 包与导入
- 控制流
- 返回与跳转
- 类与对象
- 类与继承
- 属性与字段
- 接口
- 可见性修饰符
- 扩展
- 数据类
- 密封类
- 泛型
- 嵌套类
- 枚举类
- 对象
- 类型别名
- 内嵌类
- 委托
- 委托属性
- 函数与Lambda表达式
- 函数
- Lambda表达式
- 内联函数
- 集合
- 集合概述
- 构造集合
- 迭代器
- 区间与数列
- 序列
- 操作概述
- 转换
- 过滤
- 加减操作符
- 分组
- 取集合的一部分
- 取单个元素
- 排序
- 聚合操作
- 集合写操作
- List相关操作
- Set相关操作
- Map相关操作
- 多平台程序设计
- 平台相关声明
- 以Gradle创建
- 更多语言结构
- 解构声明
- 类型检测与转换
- This表达式
- 相等性
- 操作符重载
- 空安全
- 异常
- 注解
- 反射
- 作用域函数
- 类型安全的构造器
- Opt-in Requirements
- 核心库
- 标准库
- kotlin.test
- 参考
- 关键字与操作符
- 语法
- 编码风格约定
- Java互操作
- Kotlin中调用Java
- Java中调用Kotlin
- JavaScript
- 动态类型
- kotlin中调用JavaScript
- JavaScript中调用kotlin
- JavaScript模块
- JavaScript反射
- JavaScript DCE
- 原生
- 并发
- 不可变性
- kotlin库
- 平台库
- 与C语言互操作
- 与Object-C及Swift互操作
- CocoaPods集成
- Gradle插件
- 调试
- FAQ
- 协程
- 协程指南
- 基础
- 取消与超时
- 组合挂起函数
- 协程上下文与调度器
- 异步流
- 通道
- 异常处理与监督
- 共享的可变状态与并发
- Select表达式（实验性）
- 工具
- 编写kotlin代码文档
- 使用Kapt
- 使用Gradle
- 使用Maven
- 使用Ant
- Kotlin与OSGI
- 编译器插件
- 编码规范
- 演进
- kotlin语言演进
- 不同组件的稳定性
- kotlin1.3的兼容性指南
- 常见问题
- FAQ
- 与Java比较
- 与Scala比较（官方已删除）
- Google开发者官网简介
- Kotlin and Android
- Get Started with Kotlin on Android
- Kotlin on Android FAQ
- Android KTX
- Resources to Learn Kotlin
- Kotlin样品
- Kotlin零基础到进阶
- 第一阶段兴趣入门
- kotlin简介和学习方法
- 数据类型和类型系统
- 入门
- 分类
- val和var
- 二进制基础
- 基础
- 基本语法
- 包
- 示例
- 编码规范
- 代码注释
- 异常
- 根类型“Any”
- Any? 可空类型
- 可空性的实现原理
- kotlin.Unit类型
- kotlin.Nothing类型
- 基本数据类型
- 数值类型
- 布尔类型
- 字符型
- 位运算符
- 变量和常量
- 语法和运算符
- 关键字
- 硬关键字
- 软关键字
- 修饰符关键字
- 特殊标识符
- 操作符和特殊符号
- 算术运算符
- 赋值运算符
- 比较运算符
- 逻辑运算符
- this关键字
- super关键字
- 操作符重载
- 一元操作符
- 二元操作符
- 字符串
- 字符串介绍和属性
- 字符串常见方法操作
- 字符串模板
- 数组
- 数组介绍创建及遍历
- 数组常见方法和属性
- 数组变化以及下标越界问题
- 原生数组类型
- 区间
- 正向区间
- 逆向区间
- 步长
- 类型检测与类型转换
- is、!is、as、as-运算符
- 空安全
- 可空类型变量
- 安全调用符
- 非空断言
- Elvis操作符
- 可空性深入
- 可空性和Java
- 函数
- 函数式编程概述
- OOP和FOP
- 函数式编程基本特性
- 组合与范畴
- 在Kotlin中使用函数式编程
- 函数入门
- 函数作用域
- 函数加强
- 命名参数
- 默认参数
- 可变参数
- 表达式函数体
- 顶层、嵌套、中缀函数
- 尾递归函数优化
- 函数重载
- 控制流
- if表达式
- when表达式
- for循环
- while循环
- 循环中的 Break 与 continue
- return返回
- 标签处返回
- 集合
- list集合
- list集合介绍和操作
- list常见方法和属性
- list集合变化和下标越界
- set集合
- set集合介绍和常见操作
- set集合常见方法和属性
- set集合变换和下标越界
- map集合
- map集合介绍和常见操作
- map集合常见方法和属性
- map集合变换
- 集合的函数式API
- map函数
- filter函数
- “ all ”“ any ”“ count ”和“ find ”：对集合应用判断式
- 别样的求和方式：sumBy、sum、fold、reduce
- 根据人的性别进行分组：groupBy
- 扁平化——处理嵌套集合：flatMap、flatten
- 惰性集合操作：序列
- 区间、数组、集合之间转换
- 面向对象
- 面向对象-封装
- 类的创建及属性方法访问
- 类属性和字段
- 构造器
- 嵌套类（内部类）
- 枚举类
- 枚举类遍历&枚举常量常用属性
- 数据类
- 密封类
- 印章类（密封类）
- 面向对象-继承
- 类的继承
- 面向对象-多态
- 抽象类
- 接口
- 接口和抽象类的区别
- 面向对象-深入
- 扩展
- 扩展：为别的类添加方法、属性
- Android中的扩展应用
- 优化Snackbar
- 用扩展函数封装Utils
- 解决烦人的findViewById
- 扩展不是万能的
- 调度方式对扩展函数的影响
- 被滥用的扩展函数
- 委托
- 委托类
- 委托属性
- Kotlin5大内置委托
- Kotlin-Object关键字
- 单例模式
- 匿名类对象
- 伴生对象
- 作用域函数
- let函数
- run函数
- with函数
- apply函数
- also函数
- 标准库函数
- takeIf 与 takeUnless
- 第二阶段重点深入
- Lambda编程
- Lambda成员引用高阶函数
- 高阶函数
- 内联函数
- 泛型
- 泛型的分类
- 泛型约束
- 子类和子类型
- 协变与逆变
- 泛型擦除与实化类型
- 泛型类型参数
- 泛型的背后：类型擦除
- Java为什么无法声明一个泛型数组
- 向后兼容的罪
- 类型擦除的矛盾
- 使用内联函数获取泛型
- 打破泛型不变
- 一个支持协变的List
- 一个支持逆变的Comparator
- 协变和逆变
- 第三阶段难点突破
- 注解和反射
- 声明并应用注解
- DSL
- 协程
- 协程简介
- 协程的基本操作
- 协程取消
- 管道
- 慕课霍丙乾协程笔记
- Kotlin与Java互操作
- 在Kotlin中调用Java
- 在Java中调用Kotlin
- Kotlin与Java中的操作对比
- 第四阶段专题练习
- 朱凯Kotlin知识点总结
- Kotlin 基础
- Kotlin 的变量、函数和类型
- Kotlin 里那些「不是那么写的」
- Kotlin 里那些「更方便的」
- Kotlin 进阶
- Kotlin 的泛型
- Kotlin 的高阶函数、匿名函数和 Lambda 表达式
- Kotlin协程
- 初识
- 进阶
- 深入
- Kotlin 扩展
- 会写「18.dp」只是个入门——Kotlin 的扩展函数和扩展属性（Extension Functions / Properties）
- Kotlin实战-开发Android