Kotlin 基础学习

NULL检查机制

 Kotlin的空安全设计对于声明可为空的参数，在使用是进行空判断处理，有两种处理方式，字段后加 !! 像 java 一样抛出空异常，另外字段后面加 ? 可不做处理返回值为 null 或者配合 ?: 做空判断处理。

    //类型后面加 ? 表示可为空
    val age: String? = null

    //抛出空指针异常
    val ages = age!!.toInt()
    //不做处理返回 null
    val ages1 = age?.toInt()
    //age 为空返回 -1
    val ages2 = age?.toInt() ?: -1

 类型检测及自动类型转换

我们可以使用 is 运算符检测一个表达式是否某类型的一个实例（类似于 java 中的 instanceof关键字）

fun getStringLength(obj: Any): Int? {
    if (obj !is String) return null
    //在这个分支中，‘obj’ 的类型会被自动转换为 ‘String’
    return obj.length
}

区间

 区间表达式由具有操作符形式 .. 的rangeTo 函数辅以 in 和 !in 形成。

    for (i in 1..4) print(i) //输出 1234
    for (i in 4..1) print(i) // 什么都不输出

    //使用 step 指定步长
    for (i in 1..4 step 2) print(i) //设置跳过 2 步 执行：输出 13
    for (i in 4 downTo 1 step 2) print(i)//输出 42

    //使用 until 函数排除结束元素
    for (i in 1 until 10) print(i) // i in [1,10) 排除了 10 ：输出: 123456789

字面常量

    val int = 123 // 十进制
    val int1 = 123L //长整型以大写的 L 结尾
    val data = 0x0f //16进制以 0x 开头: 0x0F
    val data2 = 0b00001011 //2 进制以 0b 开头

    //Doubles 默认写法 123.5 123.5e10
    val double = 123.5
    val double2 = 123.5e10
    val floats = 123.5f

    //可以使用下划线使数字常量更易读
    val oneMillion: Int = 1_000_100

比较两个数字

Kotlin 中没有基础数据类型，只有封装的数字类型，你每定义的一个变量，其实 Kotlin 帮你封装了一个对象，这样可以保证不会出现空指针。数字类型也一样，所以在比较两个数字的时候，就有比较数据大小和比较两个对象是否相同的区别。

在 Kotlin 中，三个等号 === 表示比较对象地址，两个 == 表示比较两个值大小。

fun test4() {
    val a = 1000
    println(a === a) //值相等，对象地址相等 输出：true

    //经过了装箱，创建了两个不同的对象
    val boxedA: Int? = a
    val anotherBoxedA: Int? = a

    //虽然经过了装箱，但是值是相等的
    println(boxedA === anotherBoxedA) //值相等，对象地址不一样 输出：false
    println(boxedA == anotherBoxedA) //值相等 输出：true
}

类型转换

由于不同的表示方式，较小类型并不是较大类型的子类型，较小的类型不能隐式转换较大的类型，这意味着在不进行显式转换的情况下沃恩不能把 Byte 型值赋给一个 Int 变量

fun test5(){
    val b: Byte = 1// OK 字面值是静态检测的
    val i:Int = b//错误
}

位操作符

对于 Int 和 Long 类型，还有一系列的位操作符可以使用

字符 Char

fun decimalDigitValue(c: Char): Int {
    if (c !in '0'..'9')
        throw IllegalArgumentException("Out of range")
    return c.toInt() - '0'.toInt() // 显式转换为数字
}

数组

数组用类 Array 实现，并且还有一个 size 属性及 get 和 set 方法，由于使用  [] 重载了 get 和 set 方法，所以我们可以通过下标很方便的获取或者设置数组对应位置的值。

数组的创建两种方式：一种是使用函数 arrayOf(); 另外一种是使用工厂函数，如下所示，我们分别是两种方式创建了两个数组：

fun test6() {
    val a = arrayOf(1, 2, 3) //输出：[1,2,3]
    for (i in a) print(i)

    print("-------------------------")

    val b = Array(3) { i -> (i * 2) }//输出： [0,2,4]
    for (i in b) print(i)
}

字符串

Kotlin支持三个引号 “”” 扩起来的字符串，支持多行字符串.String 可以通过 trimMargin() 方法来删除多余的空白。

fun test7() {
    val text = """
        多行字符串
        多行字符串
        """
    println(text)//输出有一些前置空格
}

fun test7() {
    val text = """
        |多行字符串
        |多行字符串
        """.trimMargin()
    print(text)//输出有一些前置空格

    //print(text.trimMargin())
}

字符串模版

字符串可以包含模版表达式，即一些小段代码，会求值并把结果合并到字符串中，模版表达式以美元符 $ 开头，由一个简单的名字构成

fun test8() {
    val i = 10
    val s = "i = $i"
    print(s)
}

或者用花括号括起来的任意表达式

fun test8() {
    val i = 10
    val s = "i = $i"
    println(s)

    val s2 = "runoob"
    val str = "$s2.length is ${s2.length}"
    println(str)
}

IF表达式

fun test9() {
    val a = 1
    val b = 2
    val max = if (a > b) a else b
    println(max)
}

使用区间

fun test10() {
    val x = 1 //输出：x 在区间内
    if (x in 1..9) {
        println("x 在区间内")
    }
}

When 表达式

when 将它的参数和所有的分支条件顺序比较，直到某个分支满足条件。

when 既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式，符合条件的分支的值就是整个表达式的值，如果当做语句使用，则忽略个别分支的值。

when 类似其他语言的 switch 操作符，其最简单的形式如下：

fun test11(){
    val x = 1 //输出：x == 1
    when(x){
        1 -> print("x == 1")
        else ->{
            print("x 不是 1，也不是 2")
        }
    }
}

when 中使用 in 运算符来判断集合内是否包含某实例：

fun test12() {
    val items = setOf("apple", "banana", "kiwi")
    when {
        "orange" in items -> println("juicy")
        "apple" in items -> println("apple is fine too")
    }
    //输出：apple is fine too
}

For 循环

for 循环可以对任何提供迭代器 iterator 的对象进行遍历，语法如下：

for (item in collection) print( item )

fun test13() {
    val items = listOf("apple", "banana", "kiwi")
    for (item in items) println(item)

    println("--------------------------")
    for (index in items.indices)
        println("item at $index is ${items[index]}")

    println("--------------------------")

    for ((index, value) in items.withIndex())
        println("item at $index is $value")
}

while 与 do...while 循环

while 是最基本的循环，它的结构为：

while(布尔表达式) {

        //循环内容

}

返回和跳转

Kotlin 有三种结构化跳转表达式：

return 默认从最直接包围它的函数或者匿名函数返回

break 终止最直接包围它的循环

continue 继续下一次最直接包围它的循环

fun test14() {
    for (i in 1..10) {
        if (i == 3) continue// i 为 3 时跳出当前循环，继续下一次循环
        print(i)
        if (i > 5) break
    }
    //输出：12456
}

Kotlin 类和对象

类定义

Kotlin 类可以包含：构造函数和初始化代码块、函数、属性、内部类、对象声明

Kotlin 中使用关键字 class 声明类，声明紧跟类名：

class Runoob{

             //大括号内是类的体构成

}

类属性

class Runoob{

        var name:String = "Runoob"

}

//Kotlin 中的类可以有一个 主构造器，以及一个或多个次构造器，主构造器是类头部的一部分，位于类名称之后
class Person constructor(firstName: String) {

}

//如果主构造器没有任何注解，也没有任何可见度修饰符，那么 constructor关键字可以省略
class Person2(firstName: String) {
    
}

getter 和 setter

fun test15() {
    var person = Person3()
    println("person.lastName:${person.lastName}")
    person.no = 99
    println("no:${person.no}")
    //输出：
    // person.lastName:LONG
    //no:-1
}

class Person3 {
    var lastName = "long"
        get() = field.toUpperCase()

    var no = 100
        set(value) {
            field = if (value < 10) {
                value
            } else {
                -1
            }
        }
}

lateinit

非空属性必须在定义的时候初始化，kotlin提供了一种可以延迟初始化的方案使用 lateinit 关键字描述属性；

主构造器

主构造器中不能包含任何代码，初始化代码可以放在初始哈代码段中，初始化代码段使用 init 关键字作为前缀。

//Kotlin 中的类可以有一个 主构造器，以及一个或多个次构造器，主构造器是类头部的一部分，位于类名称之后
class Person constructor(firstName: String) {

    init {
        println("firstName is $firstName")
    }
}

次构造函数

如果类有主构造函数，每个次构造函数都要，或直接或间接通过另外一个次构造函数代理主构造函数。在同一个类中代理另外一个次构造函数使用 this 关键字：

class Person4(val name: String) {

    constructor(name: String, age: Int) : this(name) {

    }
}

//私有构造函数
class Customer private constructor(){
    
}

抽象

抽象是面向对象编程的特征之一，类本身，或类中的部分成员，都可以声明为 abstract 的。抽象成员在类中不存在具体的视线。

注意：无需对抽象类或抽象成员标注 open 注解。

open class Base{
    open fun f(){}
}

abstract class Derived:Base(){
    override fun f() { }
}

嵌套类

class Outer {
    private val bar = 1

    class Nested {
        fun foo() = 2
    }
}

fun test17() {
    val demo = Outer.Nested().foo() //调用格式： 外部类.嵌套类().嵌套类方法/属性
    println(demo)
    //输出： 2
}

内部类

内部类使用 inner 关键字来表示

内部类会带有一个对外部类的对象引用，所以内部类可以访问外部类成员属性和成员函数。

class Outer2 {
    private val bar = 1
    var v = "成员属性"

    /*嵌套内部类*/
    inner class Inner {
        fun foo() = bar//访问外部类成员
        fun innerTest() {
            var o = this@Outer2
            println("内部类可以引用外部类的成员 例如：${o.v}")
        }
    }
}

fun test18() {
    val demo = Outer2().Inner().foo()
    println(demo)
    val demo2 = Outer2().Inner().innerTest()
    println(demo2) // 内部类可以引用外部类的成员，例如：成员属性
}

为了消除歧义，要访问来自外部作用域的 this ，我们使用 this@label, 使用 @label 是一个代指 this 来源的标签。

匿名内部类

使用对象表达式来创建匿名内部类

class Test {
    var v = "成员属性"
    fun setInterFace(test: TestInterFace) {
        test.test()
    }
}

/**
 * 定义接口
 */
interface TestInterFace {
    fun test()
}

fun test19() {
    var test = Test()
    /**
     * 采用对象表达式来创建接口对象，即匿名内部类的实例
     */
    test.setInterFace(object : TestInterFace {
        override fun test() {
            println("对象表达式创建匿名内部类的实例")
        }
    })
}

类的修饰符

类的修饰符包括 classModifier 和 acessModifier

classModifier 类属性修饰符，表示类本身特性

abstract    //抽象类
final       //类不可集成，默认属性
enum        //枚举类
open        //类可继承，类默认是 final
anotation   //注解类

accessModifier 访问权限修饰符

private     //仅在同一个文件中可见
protected   //同一个文件夹中或子类可见
public      // 所有调用的地方可见
internal    // 同一个模块中可见

 Kotlin 继承

Kotlin 中所有类都继承该 Any类，它是所有类的超类，对于没有超类型声明的类是默认超类：

class Example //从 Any 隐式继承

构造函数

子类有主构造函数

如果子类有主构造函数，则基类必须在主构造函数中立即初始化

class Student(firstName: String) :Example(firstName){

}

open class Example constructor(firstName: String){

}

子类没有主构造函数

如果子类没有主构造函数，则必须在每个二级构造函数中用 super 关键字初始化基类，或者在代理另一个构造函数。初始化基类时，可以调用基类的不同构造方法。

open class Student(firstName: String) : Example(firstName) {

}

open class Example constructor(firstName: String) {

}

class Student2 : Student {
    constructor(firstName: String) : super(firstName) {

    }
}

重写

在基类中，使用 fun 声明函数时，此函数默认为 final 修饰，不能被子类重写。如果允许子类重写该函数，那么就要手动添加 open 修饰它。子类重新方法使用 override 关键词：

/**
 * 用户基类
 */
open class Person5 {
    open fun study() {
        println("我毕业了")
    }
}

/**
 * 子类继承
 */
class Student3 : Person5() {
    override fun study() {//重写方法
        super.study()
        println("我在读大学")
    }
}

fun test20() {
    val s = Student3()
    s.study()
}

如果有多个相同的方法（继承或者实现自其他类，如A类，B类），则必须要重写该方法，使用 super 泛型去选择性地调用父类的实现。

interface B {
    fun f() {
        println("B")
    }
}

class C : A(), B {
    override fun f() {
        super.f()//调用 A.f()
        super.f()//调用 B.f()
    }
}

fun test21() {
    val c = C()
    c.f()
    //输出 A B
}

属性重写

属性重写使用 override 关键字，属性必须具有兼容类型，每一个声明的属性都可以通过初始化程序或者 getter 方法被重写

open class Foo {
    open val x = 100
}

class Bar1 : Foo() {
    override val x: Int
        get() = super.x
}

 Kotlin 接口

Kotlin 接口与 java8 类似，使用 interface 关键字定义接口，允许方法有默认实现。

interface MyInterface {
    fun bar()  //未实现
    fun foo() { //已实现
        //可选的方法体
        println("foo")
    }
}

 实现接口

一个类或者对象可以实现一个或者多个接口

interface MyInterface {
    fun bar()  //未实现
    fun foo() { //已实现
        //可选的方法体
        println("foo")
    }
}

class Child : MyInterface {
    override fun bar() {
        TODO("Not yet implemented")
    }

接口中的属性

接口中的属性只能是抽象的，不允许初始值，接口不会保存属性值，实现接口时，必须重写属性：

interface MyInterface2 {
    var name: String //name 属性，抽象的
}

class MyImpl : MyInterface2 {

    override var name: String = "runoob" //重写属性
}

函数重写

实现多个接口时，可能会遇到同一个方法继承多个实现的问题。

interface D {
    fun foo() {
        println("D") //已实现
    }

    fun bar() //为实现，没有方法体，是抽象的
}

interface E {
    fun foo() { //已实现
        println("E")
    }

    fun bar() { //已实现
        println("bar")
    }
}

class F : D {
    override fun bar() { //重写
        println("bar")
    }
}

class G : D, E {
    override fun foo() {
        super.foo()
        super.foo()
    }

    override fun bar() {
        super.bar()
    }
}

fun test22() {
    val g = G()
    g.foo()
    g.bar()
//输出：D E bar
}

Kotlin 扩展

Kotlin 可以对一个类的属性和方法进行扩展，且不需要继承或使用 decorator 模式。

扩展是一种静态行为，对被扩展的类代码本身不会造成任何影响。

扩展函数

扩展函数可以在已有类中添加新方法，不会对原类做修改，扩展函数定义形式：

class User(var name: String)

fun User.print() {
    println("用户名 $name")
}

fun test23() {
    val user = User("longsq")
    user.print()
    //输出：用户名 longsq
}

 扩展函数是静态解析的

扩展函数是静态解析的，并不是接受者类型的虚拟成员，在调用扩展函数时，具体被调用的是那个函数，有调用函数的对象表达式决定的，而不是动态类型决定。

open class H
class I : H()

fun H.foo() = "h" //扩展函数 foo
fun I.foo() = "d" //扩展函数 foo

fun printFoo(h: H) {
    println(h.foo()) //类型是 H 类
}

若扩展函数和成员函数一致，则使用该函数时，会优先使用成员函数

class AA {
    fun foo() {
        println("成员函数")
    }
}

fun AA.foo() {
    println("扩展函数")
}

fun test24() {
    val aa = AA()
    aa.foo()
    //输出成员函数
}

扩展一个空对象

在扩展函数内，可以通过 this 来判断接收者是否为 NULL 这样，即使接收者为 NULL ，也可以调用扩展函数，例如

fun Any?.toString(): String {
    if (this == null) return "null"
    // 空检测之后， “this” 会自动转换为非空类型，所以下面的 toString()
    // 解析为 Any 类的成员函数
    return toString()
}

fun test25() {
    val t = null
    println(t.toString())
    //输出：null
}

伴生对象的扩展

伴生对象类似 java 中静态方法

如果一个类定义有一个伴生对象，你也可以为伴生对象定义扩展函数和属性。

伴生对象通过 类名.形式调用伴生对象，伴生对象声明的扩展函数，通过用类名限定符来调用；

class MyClass {
    companion object {}//将被成为 companion
}

fun MyClass.Companion.foo() {
    println("伴随对象的扩展函数")
}

val MyClass.Companion.no: Int
    get() = 10

fun test26() {
    println("no:${MyClass.no}")
    MyClass.foo()
    /**
     * 输出：
     *  no:10
        伴随对象的扩展函数
     */
}

扩展的作用域

通常扩展函数或者属性定义在顶级包下

要使用所定义包之外的一个扩展，通过 import 导入扩展的函数名进行使用

扩展声明为成员

在一个类内部你可以为另一个类声明扩展

在这个扩展中，有个多个隐含的接收者，其中扩展方法定义所在类的实例称为分发接受者，而扩展方法的目标类型的实例称为扩展接受者。

class DD {
    fun bar() {
        println("DD bar")
    }
}

class CC {
    fun baz() {
        println("CC baz")
    }

    fun DD.foo() {
        bar() //调用 DD.bar
        baz() // 调用 CC.baz
    }

    fun caller(d: DD) {
        d.foo() //调用扩展函数
    }
}

fun test27() {
    val dd = DD()
    val cc = CC()
    cc.caller(dd)
    /*
    输出：
    DD bar
    CC baz
    */
}

假如在调用某一个函数，而该函数在分发接受者和扩展接收者均存在，则以扩展接收者优先，要引用分发接收者的成员你可以使用限定的 this 语法。

class DD {
    fun bar() {
        println("DD bar")
    }
}

class CC {

    fun bar() {
        println("CC bar")
    }

    fun baz() {
        println("CC baz")
    }


    fun DD.foo() {
        [email protected]() //调用 DD.bar
        baz() // 调用 CC.baz
    }

    fun caller(d: DD) {
        d.foo() //调用扩展函数
    }
}

Kotlin 数据类与密封类

数据类

kotlin 可以创建一个只包含数据的类，关键字 data

data class User2(val name: String, val age: Int)

复制

复制使用 copy() 函数，我们可以使用该函数复制对象并修改部分属性，对上文的User2 类

密封类

sealed class Expr
data class Const(val number: Double) : Expr()
data class Sun(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()

fun eval(expr: Expr): Double = when (expr) {
    is Const -> expr.number
    is Sun -> eval(expr.e1) + eval(expr.e2)
    NotANumber -> Double.NaN
    //不再需要 else 子句，因为我们已经覆盖了所以的情况
}

Kotlin 泛型

泛型，即 参数类型 ，将类型参数化，可以用在类，接口，方法上。

声明一个泛型类

class Box(t: T) {
    val value = t
}

创建类的实例时我们需要指定类型参数

class Box(t: T) {
    val value = t
}

fun test28() {
    val box = Box(1);
    val box2 = Box(1)
}

泛型函数

kotlin 泛型函数的声明与 java 相同，类型参数要放在函数名的前面

class Box(t: T) {
    val value = t
}

fun  boxInt(value: T) = Box(value)

泛型约束

我们可以使用泛型约束来设定一个给定参数允许使用的类型

kotlin 中使用：对泛型的类型上限进行约束。

fun > sort(list:List){

}

型变

声明处型变

声明处的类型变异使用协变修饰符：in、out、消费者in、生产者out

使用 out 使得一个类型参数协变，协变类型参数只能用作输出，可以作为返回值类型但是无法作为入参的类型：

class Runoob(val a: A) {
    fun foo(): A {
        return a
    }
}

fun test29() {
    var strCo = Runoob("a")
    var anyCo = Runoob("b")
    anyCo = strCo
    println(anyCo.foo())
    //输出：a
}

in 使得一个类型参数逆变，逆变类型参数只能用作输入，可以作为入参的类型但是无法作为返回值的类型；

//定义一个支持逆变的类
class Runoob2(a: A) {
    fun foo(a: A) {
        
    }
}

 Kotlin枚举类

枚举类最基本的用法是实现一个类型安全的枚举。

枚举常量用逗号分隔，每个枚举常量都是一个对象。

enum class Color {
    RED,
    BLACK,
    BLUE,
    GREEN,
    WHITE
}

枚举初始化

每一个枚举都是枚举类的实例，他们可以被初始化

enum class Color2(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00ff00),
    BLUE(0x0000FF)
}

enum class Color {
    RED,
    BLACK,
    BLUE,
    GREEN,
    WHITE
}

fun test30() {
    val color = Color.BLUE

    println(Color.values())
    println(Color.valueOf("RED"))
    println(color.name)
    println(color.ordinal)
}

可以使用 enumValues() 和 enumValueOf() 函数以泛型方式访问枚举中的常量。

enum class RGB { RED, GREEN, BLUE }

inline fun > printAllValue() {
    print(enumValues().joinToString { it.name })
}

fun test31() {
    printAllValue()
}

Kotlin 对象表达式和对象声明

Kotlin 用对象表达式和对象声明来实现创建一个对某个类做了轻微改动的类的对象，且不需要去声明一个新的子类。

fun test32() {
    val site = object {
        val name = "菜鸟教程"
        val url = "www.runoob.com"
    }
    println(site.name)
    println(site.url)
}

class J{
    //私有函数，所以其返回类型是匿名对象类型
    private fun foo() = object {
        val x = "x"
    }
    //共有函数，所以其返回类型是 Any
    fun publicFoo() = object {
        val x = "x"
    }
     
    fun bar(){
        val x1 = foo().x //没有问题
        //val x2 = publicFoo().x //错误：未能解析的引用 "x"
    }
}

对象声明

Kotlin 使用 object 关键字来声明一个对象。

kotlin 中我们可以方便的通过对象声明来获得一个单例。

class Site{
    val name = "菜鸟教程"
    object DeskTop{
        val url = "www.runoob.com"
        fun showName(){
            //println("desk legs $name") //错误，不能访问到外部类的方法和变量
        }
    }
}

fun test33(){
    val site = Site()
    //site.DeskTop.url //错误，不能通过外部类的实例访问到该对象
    Site.DeskTop.url //正确
}

伴生对象

类内部的对象声明可以用 companion 关键字标记，这样它就与外部类关联在一起，我们就可以直接通过外部类访问对象的内部元素。

class MyClass2 {
    companion object Factory {
        fun create() = MyClass()
    }
}

fun test34() {
    val instance = MyClass2.create()//访问到对象的内部元素
}

对象表达式和对象声明之间的语义差异

对象表达式是在使用他们的地方立即执行

对象声明是在第一次被访问到时延时初始化

伴生对象的初始化是在相应的类被加载时，与 java 静态初始化器的语义相匹配

Kotlin 委托

委托模式是软件设计模式中的一项基本技巧。在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。

类委托

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

//创建接口
interface Base2 {
    fun print()
}

//实现此接口的被委托的类
class Base2Impl(val x: Int) : Base2 {
    override fun print() {
        print(x)
    }
}

//通过关键字 by 建立委托类
class Derived2(b: Base2) : Base2 by b

fun test35() {
    val b = Base2Impl(10)
    Derived2(b).print()
    //输出：10
}

属性委托

属性委托指的是一个类的某个属性值不是在类中直接进行定义，而是将其托付给一个代理类，从而实现对该类的属性统一管理。

属性委托语法格式：

var/val  <属性名>: <类型> by <表达式> 

定义一个被委托的类

该类需要包含 getValue() 方法 和 setValue() 方法，且参数 thisRef 为惊醒委托的类对象，prop为进行委托的属性的对象。

//定义包含属性委托的类
class Example2 {
    var p: String by Delegate()
}

//委托的类
class Delegate {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "$thisRef, 这里委托了 ${property.name}属性"
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("$thisRef 的 ${property.name} 属性赋值为 $value")
    }
}

fun test36() {
    val e = Example2()
    println(e.p) //访问该属性，调用 getValue() 函数

    e.p = "Runoob" //调用 setValue 函数
    println(e.p)
    /**
     * 输出：
     * com.gxx.testkotlindemo.Example2@77459877, 这里委托了 p属性
    com.gxx.testkotlindemo.Example2@77459877 的 p 属性赋值为 Runoob
    com.gxx.testkotlindemo.Example2@77459877, 这里委托了 p属性
     */
}

标准委托

Kotlin 的标准库中已经内置了很多工厂方法来实现属性的委托

延迟属性 Lazy

lazy() 是一个函数。接受一个 Lambda 表达式作为参数，返回一个Lazy 实例的函数。返回的实例可以作为实现延迟属性的委托：

第一次调用 get() 会执已传递给 lazy() 的lambda 表达式并记录结果，后续调用 get() 只是返回记录的结果。

val lazyValue: String by lazy {
    println("computed!") //第一次调用输出，第二次调用不执行
    "Hello"
}

fun test37() {
    println(lazyValue) //第一次执行，执行两次输出表达式
    println(lazyValue) //第二次执行，只输出返回值
    /**
     * 输出：
     * computed!
    Hello
    Hello
     */
}

可观察属性 Observable

observable 可以用于实现观察者模式。

Delegates.observable() 函数接受两个参数，第一个是初始值，第二个是属性值变化事件的响应器。

class User3 {
    var name: String by Delegates.observable("初始值") { property, oldValue, newValue ->
        println("旧值： $oldValue -> 新值：$newValue")
    }
}

fun test38() {
    val user = User3()
    user.name = "第一次赋值"
    user.name = "第二次赋值"
    /**
     * 输出：
     * 旧值： 初始值 -> 新值：第一次赋值
    旧值： 第一次赋值 -> 新值：第二次赋值
     */
}

把属性储存在映射中

class Site2(val map: Map) {
    val name: String by map
    val url: String by map
}

fun test39() {
    val site = Site2(
        mapOf(
            "name" to "菜鸟教程",
            "url" to "www.runoob.com"
        )
    )
    //读取映射值
    println(site.name)
    println(site.url)
    /**
     * 输出：
     * 菜鸟教程
    www.runoob.com
     */
}