Kotlin新手教程七（委托）

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

一、类委托

类的委托实际就是一个类中定义的方法实际是调用另一个类中的对象的方法来实现的。看以下例子：

//定义一个Base()接口
interface Base {
    fun print()
}
//BaseImpl实现Base接口并重写print方法
class BaseImpl(val x: Int) : Base {
    override fun print() { print(x) }
}
//委托
class Derived(b: Base) : Base by b

fun main() {
    val b = BaseImpl(10)
    Derived(b).print()
}

Derived 的超类型列表中的 by-子句表示 b 将会在 Derived 中内部存储， 并且编译器将生成转发给 b 的所有 Base 的方法。

1.覆盖由委托实现的接口成员

编译器会使用 override 覆盖的实现而不是委托对象中的。比如上述的例子，如果Derived类重写了print方法的话，那么调用print方法就会调用的是Derived中的print方法，而不是BaseImpl中的

interface Base {
    fun print()
}
//BaseImpl实现Base接口并重写print方法
class BaseImpl(val x: Int) : Base {
    override fun print() { print(x) }
}
//委托
class Derived(b: Base) : Base by b{
    override fun print() {
        println("Derived")
    }
}

fun main() {
    val b = BaseImpl(10)
    Derived(b).print()
}

输出结果为：

但以这种方式重写的成员不会在委托对象的成员中调用 ，委托对象的成员只能访问其自身对接口成员实现：

interface Base {
    val message: String
    fun print()
}

class BaseImpl(val x: Int) : Base {
    override val message = "BaseImpl: x = $x"
    override fun print() { println(message) }
}

class Derived(b: Base) : Base by b {
    // 在 b 的 `print` 实现中不会访问到这个属性
    override val message = "Message of Derived"
}

fun main() {
    val b = BaseImpl(10)
    val derived = Derived(b)
    derived.print()
    println(derived.message)
}

二、属性委托

属性委托简单来说就是一个类中的属性不直接在这个类中直接定义，而是交给另外一个类，从而方便管理。
属性委托最常用的几种情况为：

1. 延迟属性：其值只在首次访问时计算
2. 可观察属性：监听器会收到有关此属性变更的通知
3. 多个属性储存在一个映射（Map）中，而不是每个存在单独的字段中

1.属性委托语法

val/var <属性名> ：<类型> by <表达式>，表达式也就是想要委托的对象，若声明的属性时val修饰，则需要委托对象提供一个getValue方法，若是var，则需要提供getValue和setValue方法：

import kotlin.reflect.KProperty

class Delegate {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "$thisRef, thank you for delegating '${property.name}' to me!"
    }
 
    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("$value has been assigned to '${property.name}' in $thisRef.")
    }
}

2.延迟属性Lazy

我们可以使用lazy()实现延迟属性，lazy()是当第一次调用get，也就是你第一次使用时会执行lazy中的表达式，但是第一次以后就只会返回结果。

val str:String by lazy {
    println("First")
    "str"
}

fun main() {
    println(str)
    println(str)
}

运行结果：

默认情况下，对于 lazy 属性的求值是同步锁的（synchronized）：该值只在一个线程中计算，并且所有线程会看到相同的值。如果初始化委托的同步锁不是必需的，这样多个线程可以同时执行，那么将 LazyThreadSafetyMode.PUBLICATION 作为参数传递给 lazy() 函数。 而如果你确定初始化将总是发生在与属性使用位于相同的线程， 那么可以使用 LazyThreadSafetyMode.NONE 模式：它不会有任何线程安全的保证以及相关的开销。

3.可观察属性 Observable

Delegates.observable() 接受两个参数：初始值与修改时处理程序（handler）。 每当我们给属性赋值时会调用该处理程序（在赋值后执行）。它有三个参数：被赋值的属性、旧值与新值：

import kotlin.properties.Delegates

class User {
    var name: String by Delegates.observable("<no name>") {
        prop, old, new ->
        println("$old -> $new")
    }
}

fun main() {
    val user = User()
    user.name = "first"
    user.name = "second"
}

运行结果：

4.委托给另一个属性

从1.4版本往后一个属性可以将其getter和setter委托给另一个属性。使用::限定符进行委托：

var MyClass.extDelegated: Int by ::topLevelInt

用法：当想要以一种向后兼容的方式重命名一个属性的时候：引入一个新的属性、 使用 @Deprecated 注解来注解旧的属性、并委托其实现。

class MyClass {
   var newName: Int = 0
   @Deprecated("Use 'newName' instead", ReplaceWith("newName"))
   var oldName: Int by this::newName
}

fun main() {
   val myClass = MyClass()
   // 通知：'oldName: Int' is deprecated.
   // Use 'newName' instead
   myClass.oldName = 42
   println(myClass.newName) // 42
}

5.将属性存储在映射中

我们还可以通过将属性映射在Map中实现属性委托：

class User(val map: Map<String, Any?>) {
    val name: String by map
    val age: Int     by map
}
val user = User(mapOf(
    "name" to "John Doe",
    "age"  to 25
))
println(user.name) // Prints "John Doe"
println(user.age)  // Prints 25

上一篇：Kotlin新手教程六（数据类、密封类、枚举类、泛型）