1.委托

1.1 委托的实现

委托模式已经证明是实现继承的一个很好的替代方式，而 Kotlin 可以零样板代码地原生支持它。 Derived 类可以通过将其所有公有成员都委托给指定对象来实现一个接口 Base :

interfaceBase {

fun print()

}classBaseImpl(val x: Int) : Base {overridefun print() {

print(x)

}

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

classDerived(b: Base) : Base by b

fun main() {

val b= BaseImpl(10)

Derived (b).print()

}

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

覆盖符合预期:编译器会使用 override 覆盖的实现而不是委托对象中的。如果将 override fun printMessage() { print("abc") } 添加到 Derived，那么当调用 printMessage 时程序 会输出“abc”而不是“10”:

interfaceBase {

fun printMessage()

fun printMessageLine()

}classBaseImpl(val x: Int) : Base {overridefun printMessage() {

print(x)

}overridefun printMessageLine() {

println(x)

}

}classDerived(b: Base) : Base by b {overridefun printMessage() {

print("abc")

}

}

fun main() {

val b= BaseImpl(10)

Derived (b).printMessage()

Derived (b).printMessageLine()

}

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

interfaceBase {

val message: String

fun print()

}classBaseImpl(val x: Int) : Base {override val message = "BaseImpl: x = $x" overridefun print() {

println(message)

}

}classDerived(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)

}

注意：在 JVM 平台:当使用带有 default 方法的接口(包括带有 @JvmDefault 注解的 Kotlin 接口)进行委托时，即使实际的委托类型提供了其自身的实现也会调用默认实现。详细信息请参 ⻅在 Java 中调用 Kotlin。

2.委托属性

有一些常⻅的属性类型，虽然我们可以在每次需要的时候手动实现它们，但是如果能够为大家把他们只 实现一次并放入一个库会更好。例如包括:

— 延迟属性(lazyproperties):其值只在首次访问时计算;

— 可观察属性(observableproperties):监听器会收到有关此属性变更的通知;

— 把多个属性储存在一个映射(map)中，而不是每个存在单独的字段中。

为了涵盖这些(以及其他)情况，Kotlin 支持委托属性:

classExample {varp: String by Delegate()

}

语法是:val/var : by 。在by后面的表达式是该委托，因为属性对应 的 get()(与 set())会被委托给它的 getValue() 与 setValue() 方法。属性的委托不必实现 任何的接口，但是需要提供一个 getValue() 函数(与 setValue() ⸺对于 var 属性)

例如：

import kotlin.reflect.KPropertyclassDelegate {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.")

}

}

当我们从委托到一个 Delegate 实例的 p 读取时，将调用 Delegate 中的 getValue() 函数，所 以它第一个参数是读出 p 的对象、第二个参数保存了对 p 自身的描述(例如你可以取它的名字)。例如

val e =Example()

println(e.p)

输出结果：Example@33a17727, thank you for delegating ‘p’ to me!

类似地，当我们给 p 赋值时，将调用 setValue() 函数。前两个参数相同，第三个参数保存将要被赋予的值

e.p = "NEW"输出结果:

NEW has been assigned to ‘p’in Example@33a17727.

自 Kotlin 1.1 起你可以在函数或代码块中声明一个委托属性，因此它不一定是类的成员

3.标准委托，Kotlin 标准库为几种有用的委托提供了工厂方法。

4.延迟属性 Lazy

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

val lazyValue: String by lazy {

println("computed!")"Hello"}

fun main() {

println(lazyValue)

println (lazyValue)//只输出Hello

}

默认情况下，对于 lazy 属性的求值是同步锁的(synchronized):该值只在一个线程中计算，并且所有 线程会看到相同的值。如果初始化委托的同步锁不是必需的，这样多个线程可以同时执行，那么将

LazyThreadSafetyMode.PUBLICATION 作为参数传递给 lazy() 函数。而如果你确定初始化将 总是发生在与属性使用位于相同的线程，那么可以使用 LazyThreadSafetyMode.NONE 模式:它不 会有任何线程安全的保证以及相关的开销。

5.可观察属性 Observable

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

import kotlin.properties.DelegatesclassUser {var name: String by Delegates.observable("") {

prop, old,new ->println("$old -> $new")

}

}

fun main() {

val user=User()

user.name= "first"user.name= "second"}//如果你想截获赋值并“否决”它们，那么使用 vetoable() 取代observable() 。在属性被赋新值生 效之前会调用传递给 vetoable 的处理程序

6.把属性储存在映射中

一个常⻅的用例是在一个映射(map)里存储属性的值。这经常出现在像解析JSON或者做其他“ 动态”事情的应用中。在这种情况下，你可以使用映射实例自身作为委托来实现委托属性

class User(val map: Map) {

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

这也适用于 var 属性，如果把只读的 Map 换成 MutableMap 的话:

class MutableUser(val map: MutableMap) {varname: String by mapvarage: Int by map

}

7.局部委托属性(自1.1起)

你可以将局部变量声明为委托属性。例如，你可以使一个局部变量惰性初始化

fun example(computeFoo: () ->Foo) {

val memoizedFoo by lazy(computeFoo)if (someCondition &&memoizedFoo.isValid()) {

memoizedFoo.doSomething()

}

}

//memoizedFoo变量只会在第一次访问时计算。如果someCondition失败，那么该变量根本不会计算。

8.属性委托要求

这里我们总结了委托对象的要求。

8.1 对于一个只读属性(即val声明的)，委托必须提供一个操作符函数 getValue()，该函数具有以下参 数

//— thisRef ⸺ 必须与 属性所有者 类型(对于扩展属性⸺指被扩展的类型)相同或者是其超类型。//— property ⸺ 必须是类型 KProperty 或其超类型。//getValue() 必须返回与属性相同的类型(或其子类型)。

classResourceclassOwner {

val valResource: Resource by ResourceDelegate()

}classResourceDelegate {operator fun getValue(thisRef: Owner, property: KProperty): Resource {returnResource()

}

}

8.2 对于一个可变属性(即var声明的)，委托必须额外提供一个操作符函数 setValue()，该函数具有以 下参数:

//— thisRef ⸺ 必须与 属性所有者 类型(对于扩展属性⸺指被扩展的类型)相同或者是其超类型。//— property ⸺ 必须是类型 KProperty 或其超类型。//— value — 必须与属性类型相同(或者是其超类型)。

classResourceclassOwner {varvarResource: Resource by ResourceDelegate()

}class ResourceDelegate(private var resource: Resource =Resource()) {operator fun getValue(thisRef: Owner, property: KProperty): Resource {returnresource

}operator fun setValue(thisRef: Owner, property: KProperty, value: Any?) {if (value isResource) {

resource=value

}

}

}

getValue() 或/与 setValue() 函数可以通过委托类的成员函数提供或者由扩展函数提供。当你 需要委托属性到原本未提供的这些函数的对象时后者会更便利。两函数都需要用 operator 关键字来进行标记

8.3 委托类可以实现包含所需 operator 方法的 ReadOnlyProperty 或 ReadWriteProperty 接口 之一。这俩接口是在 Kotlin 标准库中声明的:

interface ReadOnlyProperty{operator fun getValue(thisRef: R, property: KProperty): T

}interface ReadWriteProperty{operator fun getValue(thisRef: R, property: KProperty): Toperator fun setValue(thisRef: R, property: KProperty, value: T)

}

9.翻译规则

在每个委托属性的实现的背后，Kotlin编译器都会生成辅助属性并委托给它。例如，对于属性 prop，生 成隐藏属性 prop$delegate，而访问器的代码只是简单地委托给这个附加属性

classC {varprop: Type by MyDelegate()

}//这段是由编译器生成的相应代码:

classC {private val prop$delegate =MyDelegate()varprop: Typeget() = prop$delegate.getValue(this, this::prop)set(value: Type) = prop$delegate.setValue(this, this::prop, value)

}

Kotlin 编译器在参数中提供了关于 prop 的所有必要信息:第一个参数 this 引用到外部类 C 的实 例而 this::prop 是 KProperty 类型的反射对象，该对象描述 prop 自身。

请注意，直接在代码中引用绑定的可调用引用的语法 this::prop 自 Kotlin 1.1 起才可用。

10. 提供委托(自1.1 起)

通过定义 provideDelegate 操作符，可以扩展创建属性实现所委托对象的逻辑。如果 by 右侧所使 用的对象将 provideDelegate 定义为成员或扩展函数，那么会调用该函数来创建属性委托实例。

provideDelegate 的一个可能的使用场景是在创建属性时(而不仅在其 getter 或 setter 中)检测属 性一致性。

例如，如果要在绑定之前检测属性名称，可以这样写：

class ResourceDelegate : ReadOnlyProperty{override fun getValue(thisRef: MyUI, property: KProperty): T {

...

}

}class ResourceLoader(id: ResourceID) {operatorfun provideDelegate(

thisRef: MyUI,

prop: KProperty): ReadOnlyProperty{

checkProperty(thisRef, prop.name)//创建委托

returnResourceDelegate()

}privatefun checkProperty(thisRef: MyUI, name: String) {

......

}

}classMyUI {

fun bindResource(id: ResourceID): ResourceLoader{

......

}

val image by bindResource(ResourceID.image_id)

val text by bindResource(ResourceID.text_id)

}

//provideDelegate 的参数与 getValue 相同://— thisRef —— 必须与 属性所有者 类型(对于扩展属性⸺指被扩展的类型)相同或者是它的超类 型;//— property —— 必须是类型 KProperty 或其超类型。//在创建 MyUI 实例期间，为每个属性调用 provideDelegate 方法，并立即执行必要的验证

如果没有这种拦截属性与其委托之间的绑定的能力，为了实现相同的功能，你必须显式传递属性名，这不是很方便:

//检测属性名称而不使用“provideDelegate”功能

classMyUI {

val image by bindResource(ResourceID.image_id,"image")

val text by bindResource(ResourceID.text_id,"text")

}

funMyUI.bindResource(

id: ResourceID,

propertyName: String

): ReadOnlyProperty{

checkProperty(this, propertyName)//创建委托

}

在生成的代码中，会调用 provideDelegate 方法来初始化辅助的 prop$delegate 属性。比较对 于属性声明 val prop: Type by MyDelegate() 生成的代码与上面(当 provideDelegate 方 法不存在时)生成的代码

classC {varprop: Type by MyDelegate()

}//这段代码是当“provideDelegate”功能可用时//由编译器生成的代码:

classC {//调用“provideDelegate”来创建额外的“delegate”属性

private val prop$delegate = MyDelegate().provideDelegate(this, this::prop)varprop: Typeget() = prop$delegate.getValue(this, this::prop)set(value: Type) = prop$delegate.setValue(this, this::prop, value)//请注意，provideDelegate 方法只影响辅助属性的创建，并不会影响为getter或setter生成的代码。

}