kotlin_委托

kotlin

文章目录

• ​​kotlin​​

• ​​1 类委托​​
• ​​2 委托加强​​
• ​​3 属性委​​
• ​​4 标准委托​​

• ​​4.1 惰性加载:bylazy​​
• ​​4.2 延迟加载:lateinit​​

• ​​5 可观察属性 Observable​​
• ​​6 把属性储存在映射中​​

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

Kotlin 直接支持委托模式，更加优雅，简洁。Kotlin 通过关键字 by 实现委托。

1 类委托

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

以下实例中派生类 Derived 继承了接口 Base 所有方法，并且委托一个传入的 Base 类的对象来执行这些方法。

fun main(args: Array) {
    val small = SmallHeadFather()
    small.wash()
}

interface Water{
    fun wash()
}

class BigHeadSon:Water{
    override fun wash() {
        println("大头儿子")
    }
}
class SmallHeadFather:Water by BigHeadSon()
      

结果

大头儿子

通过by将小头爸爸的工作给了大头儿子,然后委托大头儿子进行洗的操作。

第二种方法的类委托:更方便和可扩展

fun main(args: Array) {
    val big = BigHeadSon1()
    val s1 = SmallHeadSon1(big)
    s1.wash()

}

class BigHeadSon1:Water{
    override fun wash() {
        println("大头儿子")
    }
}

class SmallHeadSon1(var Water:Water):Water by Water
      

class SmallHeadSon1(var Water:Water):Water by Water

注意语法格式

2 委托加强

如果想委托别的事情的话称为委托加强

fun main(args: Array) {
    val big = BigHeadSon2()
    var s1 = SmallHeadSon2(big)
    s1.wash()
}
class BigHeadSon2:Water{
    override fun wash() {
        println("大头儿子")
    }
}

class SmallHeadSon2(var Water:Water):Water by Water{
    override fun wash() {
        println("付钱")
        Water.wash()
        println("干的好,下次加油")
    }
}
      

加强了付钱和干得好,下次加油两句话

3 属性委

托

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

属性委托语法格式：

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

• var/val：属性类型(可变/只读)
• 属性名：属性名称
• 类型：属性的数据类型
• 表达式：委托代理类

by 关键字之后的表达式就是委托, 属性的 get() 方法(以及set() 方法)将被委托给这个对象getValue() 和 setValue() 方法。属性委托不必实现任何接口, 但必须提供 getValue() 函数(对于 var属性,还需要 setValue() 函数)。

fun main(args: Array) {
    var b1 = BigHeadSon3()
    b1.money = 100
    println(b1.money)
}

class BigHeadSon3{
    var money:Int by Mother()
}
class Mother{
    var money = 0
    var sonmoney = 0
    operator fun getValue(bigHeadSon3: BigHeadSon3, property: KProperty<*>): Int {
        return sonmoney
    }

    operator fun setValue(bigHeadSon3: BigHeadSon3, property: KProperty<*>, i: Int) {
        money = i - 50
        sonmoney = 50

    }
}
      

相当于本来儿子有100元钱，妈妈从中拿了50元钱,打印出来的是儿子还有的钱

4 标准委托

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

4.1 惰性加载:bylazy

lazy() 是一个函数, 接受一个 Lambda 表达式作为参数, 返回一个 Lazy 实例的函数，返回的实例可以作为实现延迟属性的委托： 第一次调用 get() 会执行已传递给 lazy() 的 lamda 表达式并记录结果， 后续调用 get() 只是返回记录的结果。

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

fun main(args: Array) {
    println(lazyValue)   // 第一次执行，执行两次输出表达式
    println(lazyValue)   // 第二次执行，只输出返回值
}
      

执行输出结果：

computed!

Hello

Hello

4.2 延迟加载:lateinit

用的时候赋值,不用的时候不可以赋值

fun main(args: Array) {
    var p1 = Person()
    p1.name1 = "amituofue"
    p1.setName("amituofo")
}
class Person{
    lateinit var name1:String
    fun setName(name:String){
        this.name1 = name
    }
}
      

总结

1.bylazy和lateinit都可以单独使用或者放到成员变量中使用

2.bylazy知道具体的值,用的时候再加载

3.lateinit不知道具体的值,后面在赋值

4.bylazy需要用val修饰,lateinit需要用var赋值

5 可观察属性 Observable

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

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

在属性赋值后会执行事件的响应器(handler)，它有三个参数：被赋值的属性、旧值和新值：

import kotlin.properties.Delegates

class User {
    var name: String by Delegates.observable("初始值") {
        prop, old, new ->
        println("旧值：$old -> 新值：$new")
    }
}

fun main(args: Array) {
    val user = User()
    user.name = "第一次赋值"
    user.name = "第二次赋值"
}
      

执行输出结果：

旧值：初始值 -> 新值：第一次赋值

旧值：第一次赋值 -> 新值：第二次赋值

6 把属性储存在映射中

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

fun main(args: Array) {
    // 构造函数接受一个映射参数
    val site = Site(mapOf(
        "name" to "菜鸟教程",
        "url"  to "www.runoob.com"
    ))
    
    // 读取映射值
    println(site.name)
    println(site.url)
}