Kotlin机制

什么是kotlin？

kotlin是静态类型的编程语言，运行于jvm之上。如果在编译时知道变量的类型，则语言是静态类型的，在运行时知道变量类型，则语言是动态类型。

什么是extension（扩展）函数

Kotlin 可以对一个类的属性和方法进行扩展，对被扩展的类代码本身不会造成任何影响。
扩展函数可以为已经存在的类添加新的方法，并且不会修改原来的类。

class Persons(val name: String, val age: Int, val sex: Char)

//给类增加扩展函数
fun Persons.show() {
    println(name + "--" + age + "--" + sex)
}

//给字符串增加扩展函数
fun String.showStr() {
    println(this)
}

fun extensionTest() {
    Persons("lili", 18, '0').show()

    "当前日志打印".showStr()

    //扩展函数转java之后，就是给当前类新增一个静态方法，方法新增一个参数，把调用者这个类变量作为this参数，并传到方法中
//    class Persons {}
//        public static final void show(Persons $this$show) {
//
//        }
//    }
}

//泛型扩展函数

fun  T.showContentInfo() = println("${this.toString()}")
fun commonFun() {}

fun  INPUTTYPE.showType() =
    when(this) {
        is String -> "你是String类型"
        is Int -> "你是Int类型"
        else -> "未知类型"
    }
fun extensionTest2() {
    345.showContentInfo()
    "sdfs".showContentInfo()
    false.showContentInfo()
    commonFun().showContentInfo() //函数也可以作为泛型

    println("hello".showType())
    println(345.showType())
}

lateinit和by lazy

Kotlin 基于 Java 的空指针提出了一个空安全的概念，即每个属性默认不可为null。 在某个类中，如果某些成员变量没办法在一开始就初始化，并且又不想使用可空类型(也就是带?的类型)。那么，可以使用lateinit或者by lazy来修饰它。

lateinit(延迟初始化属性)

lateinit表示我现在不初始化，等会来初始化，需要能够被修改，所以需要用var修饰，不是用val来修饰。lateinit 可以在任何位置初始化并且可以初始化多次。

lateinit如果没有初始化就使用，会报异常崩溃，即使用于判空也会崩。如果想要判断是否初始化，可先做如下判断：

 class lateinit {

    lateinit var request: String

    fun lateInitUse() {
        request = ""
        if (::request.isInitialized) {
            //判断lateinit属性是否已经初始化，没初始化使用会崩溃
            println("request已经初始化")
        } else {

        }
    }
}

by lazy(惰性初始化)

当初始化过程消耗大量资源并且在使用对象时并不总是需要数据时，这个非常有用。没有用by lazy的属性，会随着类对象的创建直接初始化该属性的值。那么用上by lazy呢？

执行如下程序：

/**
 * 惰性加载
 */
class Bylazy {

    val database = readSqlDataBase()

    val databaseLazy by lazy {
        readSqlDataBase()
    }

    private fun readSqlDataBase(): String {
        println("加载数据库数据...")
        return "加载完成"
    }
}

fun testbyLazy() {
    val bylazy = Bylazy()  //不使用by lazy，创建类对象，就会初始化database成员变量，就会直接调用readSqlDataBase()方法代码块

    Thread.sleep(2000)
    println(bylazy.database) //还没等到使用database，readSqlDataBase方法代码就被初始化了

    println(bylazy.databaseLazy) //databaseLazy的属性，当5秒之后使用才会加载
}

如果用by lazy修饰，那么就不回直接初始化，会在第一次访问该属性的时候初始化，使用最后一行对象作为返回值，并执行lazy{ }闭包里面的代码。而且再次调用属性的时候，只会得到结果，而不会再次执行lazy{}的运行过程。并且，lazy 只能用于修饰常量 val。

密封类

/**
 * 枚举定义单类型
 */
enum class Week {
    Sunday,
    Monday,
    Whensday,
    Twoesday,
    Thersday
}

fun enumTest() {
    println(Week.Sunday)
    println(Week.Whensday)

    //枚举的值等价于 枚举本身
    println(Week.Twoesday is Week)  //这里是true
}

//kotlin想表达枚举也是一个class，可以让枚举附带构造参数，有更丰富的功能
/**
 * 枚举定义函数类型
 */
enum class Limbs(val limbsInfo: LimbsInfo) {  //枚举主构造参数需要和枚举定义的参数数量类型一致
    LEFT_HAND(LimbsInfo("左手", 60)),
    RIGHT_HAND(LimbsInfo("右手", 60)),
    LEFT_FOOT(LimbsInfo("左脚", 80)),
    RIGHT_FOOT(LimbsInfo("右脚", 80));

    fun show() = "四肢是 ${limbsInfo.limbsInfo} 长度是： ${limbsInfo.length}"
}

class LimbsInfo(val limbsInfo: String, val length: Int) {
    fun show() {
        println(limbsInfo + "长度是:" + length)
    }
}

fun showEnumInfo() {
    println(Limbs.LEFT_HAND.show())
}


//密封类  sealed class ，成员必须有具体类型,且各类型可以不一致，且需要继承于自己  (Enum的成员是自己的类型)
sealed class Exam {
    // object类型，不需要任何成员
    // class类型，成员可有可没有
    // data class类型，必须要有成员
    object Fraction1 : Exam() //分数差
    object Fraction2 : Exam() //分数及格
    object Fraction3 : Exam() //分数良好
    class Fraction4(val studentName: String) : Exam() //分数优秀

    data class Fraction5(val studentName: String, val age: Int) : Exam()

    //需求： 得到成绩优秀的孩子姓名
}

class Teachers(private val exam: Exam) {
    fun show() = when(exam) {
        is Exam.Fraction1 -> "成绩很差"
        is Exam.Fraction2 -> "成绩及格"
        is Exam.Fraction3 -> "成绩良好"
        is Exam.Fraction4 -> "该学生 ${exam.studentName} 成绩优秀"  //得到密封类的变量
        is Exam.Fraction5 -> "该学生 ${exam.studentName} 成绩优秀，年龄 ${exam.age}"
    }
}

fun showSealedInfo() {
    println(Teachers(Exam.Fraction1).show())
    println(Teachers(Exam.Fraction2).show())
    println(Teachers(Exam.Fraction4("lily")).show())
    println(Teachers(Exam.Fraction4("libo")).show())
    println(Teachers(Exam.Fraction5("lala", 18)).show())
}

Kotlin委托

委托是一种设计模式，它的基本理念是：操作对象自己不会去处理某段逻辑，而是会把工作委托给另外一个辅助对象去处理。 比如调用A类的methodA方法，其实背后是B类的methodB去执行。

Kotlin将委托功能分为了两种：类委托和委托属性。

• 类委托：即一个类中定义的方法实际是调用另一个类的对象的方法来实现的。

interface User {
    fun login()
}

class UserImpl(val name: String) : User{
    override fun login() {
        println(name)
    }
}

class VipUser(user: User) : User by user

fun main() {
    VipUser(UserImpl("1号用户")).login()
}

可以看到委托类并没有实现User接口，而是通过关键字by,将实现委托给了user。

• 属性委托：委托属性的核心思想是将一个属性（字段）的具体实现委托给另一个类去完成。

class MyClass {
  var p by Delegate()
}

class Delegate {
  var propValue: Any? = null
  
  operator fun getValue(myClass: MyClass, prop: KProperty<*>): Any? {
    return propValue
  }
  
  operator fun setValue(myClass: MyClass, prop: KProperty<*>, value: Any?) {
    propValue = value
  }   
}

这里使用by关键字连接了左边的p属性和右边的Delegate实例，这种写法就代表着将p属性的具体实现委托给了Delegate类去完成。当调用p属性的时候会自动调用Delegate类的getValue()方法，当给p属性赋值的时候会自动调用Delegate类的setValue()方法。

by lazy并不是连在一起的关键字，只有by才是Kotlin中的关键字，lazy在这里只是一个高阶函数而已，返回的实例可以作为实现延迟属性的委托。

val lazyProp: String by lazy {
    println("Hello，第一次调用才会执行我！")
    "Hello"
}
// 打印lazyProp 3次，查看结果
fun main() {
    println(lazyProp)
    println(lazyProp)
    println(lazyProp)
}

打印结果如下：

Hello，第一次调用才会执行我！
Hello
Hello
Hello

• init代码块和构造方法以及伴生对象中代码的调用时机

创建Person类，创建person对象打印方法调用时机：

class Person {
    private var name: String = "jack"
    constructor() {
        println("constructor 方法调用")
    }
    init {
        println("init 方法调用")
    }
    companion object {
        init {
            println("companion init 1")
        }
    }
}

从Tools-->kotlin-->show Kotlin Bytecode，将Person类反编译成java类得到：

伴生对象转为了静态代码块，init代码块插入到了构造方法的开头处。静态代码块在编译期运行，然后依次运行构造方法的代码。打印的结构为：

结论：伴生对象先于init方法，再先于构造方法。首先伴生对象中的代码是在类加载时就会执行。init代码块中的方法会按顺序放在主构造函数中，主构造函数中原来的代码会在后面执行。

• const和val有什么区别？

所述const关键字被用于声明那些不可变在本质即，这些属性是只读属性的属性。
但是，这些属性的值必须仅在编译时已知，这const就是也称为编译时常量的原因，相当于java中的static final修饰。该val关键字还用于只读属性。但是const和之间的主要区别在于val，val属性也可以在运行时进行初始化，即不可变变量。

• Kotlin data类机制

创建Result类：

data class Result(var code:Int,val msg:String)

转成java类，知道为什么Kotlin开发强大了吧。

public final class Result {
   private int code;
   @NotNull
   private final String msg;
    //...省略setter和getter方法
   public Result(int code, @NotNull String msg) {
      Intrinsics.checkNotNullParameter(msg, "msg");
      super();
      this.code = code;
      this.msg = msg;
   }

   public final int component1() {
      return this.code;
   }

   @NotNull
   public final String component2() {
      return this.msg;
   }

   @NotNull
   public final Result copy(int code, @NotNull String msg) {
      Intrinsics.checkNotNullParameter(msg, "msg");
      return new Result(code, msg);
   }

   @NotNull
   public String toString() {
      return "Result(code=" + this.code + ", msg=" + this.msg + ")";
   }

   public int hashCode() {
      int var10000 = this.code * 31;
      String var10001 = this.msg;
      return var10000 + (var10001 != null ? var10001.hashCode() : 0);
   }

   public boolean equals(@Nullable Object var1) {
      if (this != var1) {
         if (var1 instanceof Result) {
            Result var2 = (Result)var1;
            if (this.code == var2.code && Intrinsics.areEqual(this.msg, var2.msg)) {
               return true;
            }
         }

         return false;
      } else {
         return true;
      }
   }

系统自动为数据类生成哪些内容：

• 自动生成了变量的get、set方法
• 生成equals/hashCode的方法。
• 自动重写toString方法返回形如：”User(name=guojingbu,age=18)“的字符串
• 生成copy()方法,方便完成对象复制。
• 如果变量是val修饰，只会生成get方法。

Github代码地址：

https://github.com/running-libo/KotlinPractise