Kotlin闭包，简单理解来说，就是可以在Lambda表达式中引用外层的变量。而在Java中，必须将这个变量声明成final或者是类的成员变量或者是数组，才允许访问和修改。（原理：Kotlin反编译成Java之后，可以看到Kotlin将外层的变量声明成Ref类，进行包装，将变量的引用位置由方法栈移入到堆中）

注解@JvmOverloads的作用：让Kotlin中具有默认参数的函数，可以在Java中生成多个该函数的重载

注解@JvmStatic的作用：让Kotlin的伴生对象的方法，在Java中可以生成对应的静态方法，而不需要调用伴生对象

Kotlin的单例（参考）
1. 饿汉模式：
Kotlin // 声明静态对象时已经初始化。 object SingletonDemo
2. 懒汉模式：

  // 使用时才初始化变量
  class SingletonDemo private constructor() {
    companion object {
      private var instance: SingletonDemo? = null
          get() {
              if (field == null) {
                  field = SingletonDemo()
              }
              return field
          }
      fun get(): SingletonDemo {
          return instance!!
      }
  }
}

3. 线程安全的懒汉模式：

// 使用时才初始化变量，多线程中保证单例对象唯一性的手段。
// 但是，每次都要进行同步，消耗不必要的资源。一般不建议使用。
class SingletonDemo2 private constructor() {
    companion object {
        private var instance: SingletonDemo2? = null
            get() {
                if (field == null) {
                    field = SingletonDemo2()
                }
                return field
            }

        @Synchronized
        fun get(): SingletonDemo2 {
            return instance!!
        }
    }
}

4. Double Check：

// 资源利用率高，第一次加载时，反应稍慢
class SingletonDemo3 private constructor() {
    companion object {
        val instance: SingletonDemo3 by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            SingletonDemo3()
        }
    }
}

5. 静态内部类（如何确保线程安全）

// 通过一个静态内部类，确保线程安全，保证单例唯一，延迟单例的实例化。推荐使用的单例模式。
class SingletonDemo4 private constructor() {
    companion object {
        val instance = SingletonHolder.holder
    }

    // 因为JVM在初始化一个类的时候，会给初始化方法<clinit>加锁
    // 确保只有一个线程会去初始化和加载一个类，且一个类只初始化一次
    private object SingletonHolder {
        val holder = SingletonDemo4()
    }
}

data class（主要用于数据存储的类）

1. 构造函数一定具有参数（默认为成员变量）
2. 默认生成equals, hashCode, copy
3. toString()默认打印所有的构造函数中的成员变量
4. 针对构造函数中的成员变量生成对应的解构函数

解构声明：可以将一个类解构成多个变量进行使用，例：val (name, age) = Person("zhangsan", 18)，然后name和age就可以单独使用

sealed class（密封类）：密封类用来表示受限的类继承结构（个人的理解是是一个抽象的，可以继承的枚举类，枚举的是类型，而不是对应的一个个实例）

构造函数执行顺序：父类companion->子类companion->父类init->父类构造函数->主构造函数成员变量声明->子类init->子类主构造函数->次级构造函数

高阶函数：在Kotlin当中，函数也是一个对象，可以作为另一个函数的参数传入，或者是作为另一个函数的返回值返回。

Kotlin的好处：1.判空处理 2.let, apply 3.扩展函数 4.协程 5.data类

协程

1. 协程本质上来说协程还是运行在某个线程中，但是这个“线程”不用自己手动创建和管理线程，这些操作都由kotlin帮忙实现，由状态机和CPS转换进行管理（参考）
2. 协程的挂起和恢复（参考）：
   • 线程是被动挂起恢复，协程是主动挂起恢复
   • 挂起前判断协程是否已经存在，如果存在则直接取协程结果，如果不存在则将协程挂起，将协程分配到新的线程工作，当前线程继续执行后面的代码
   • 当协程运行完毕之后，通过回调回到挂起的位置，执行后续的回调或者返回结果
   • Kotlin 编译器将每个挂起函数转换为一个状态机，在每次函数需要挂起时使用回调并进行优化。当方法被恢复时，需要被执行的信息全部被存在了 Continuation 对象之中
3. 协程的CoroutineContext是什么（参考）：
   CoroutineContext是协程的上下文，主要承载了资源获取和配置管理等工作。
4. 协程线程切换原理
   通过resumeCancellableWith进行判断，如果需要切换线程，则通过CoroutineDispatcher进行线程切换，而CoroutineDispatcher本质是一个接口，子类通过实现这个接口，在dispatch中进行Handler调用

使用by lazy时，默认会使用synchronized来实现多线程同步，以此避免多线程竞争，所以如果业务场景中不存在多线程问题的，可以使用LazyThreadSafetyMode.NONE进行声明（参考）