Kotlin 委托

Kotlin 委托是一种强大的功能，它允许你通过将功能委托给其他对象来简化代码。这不仅可以减少冗余代码，还能实现更灵活的代码复用。委托广泛用于各种场景，例如属性的延迟初始化、观察属性变化以及条件属性赋值等。

委托的定义和使用

在 Kotlin 中，委托可以是类委托或属性委托。类委托允许一个类将其某些功能委托给另一个类，而属性委托则允许一个属性将其 getter 和 setter 委托给另一个对象。

类委托

类委托是通过 by 关键字实现的。假设我们有一个接口 Base，以及该接口的一个具体实现 BaseImpl：

interface Base {
    fun printMessage()
}

class BaseImpl(val message: String) : Base {
    override fun printMessage() {
        println(message)
    }
}

我们可以创建一个类 Derived，并将 Base 的实现委托给 BaseImpl：

class Derived(b: Base) : Base by b

使用示例如下：

fun main() {
    val b = BaseImpl("Hello, Kotlin!")
    val d = Derived(b)
    d.printMessage() // 输出：Hello, Kotlin!
}

属性委托

属性委托也使用 by 关键字。Kotlin 提供了几种标准的属性委托，包括 lazy、observable 和 vetoable。

Lazy

lazy 委托用于实现属性的延迟初始化。只有在首次访问该属性时，才会执行初始化代码。适用于只读属性（val）。

val lazyValue: String by lazy {
    println("Computed!")
    "Hello, Lazy!"
}

当我们第一次访问 lazyValue 时，才会输出 “Computed!” 并返回 “Hello, Lazy!”。

fun main() {
    println(lazyValue) // 输出：Computed! 和 Hello, Lazy!
    println(lazyValue) // 仅输出：Hello, Lazy!
}

Observable

observable 委托用于在属性发生变化时执行某些操作。它接受两个参数：初始值和一个回调函数。

var observableValue: String by Delegates.observable("Initial Value") { property, oldValue, newValue ->
    println("Property ${property.name} changed from $oldValue to $newValue")
}

每当 observableValue 发生变化时，都会执行回调函数。

fun main() {
    observableValue = "New Value" // 输出：Property observableValue changed from Initial Value to New Value
}

Vetoable

vetoable 委托允许在属性赋值前进行验证，决定是否接受新值。它也接受两个参数：初始值和一个回调函数。

var vetoableValue: Int by Delegates.vetoable(0) { property, oldValue, newValue ->
    newValue >= 0 // 只有新值为非负数时才会赋值
}

如果新值不满足条件，则不会更新属性值。

fun main() {
    vetoableValue = 10
    println(vetoableValue) // 输出：10

    vetoableValue = -5
    println(vetoableValue) // 仍然输出：10
}

总结

Kotlin 委托和 Java 中类似机制的主要区别在于，Kotlin 提供了语言级别的支持，使得委托更加简洁和自然。

以下是 Kotlin 委托与 Java 类似机制的一些主要区别：

特性	Kotlin 委托	Java 类似机制
语法	使用 by 关键字，简洁易懂	需要手动实现接口，代码冗长
属性委托	直接支持属性委托，无需定义getter/setter	需要手动实现代理类，并转发方法调用
标准委托	提供 lazy, observable, vetoable 等标准委托，方便实现常见功能	需要自行实现类似功能
类型安全	编译时类型安全，避免运行时错误	需要强制类型转换，容易出现 ClassCastException
代码量	代码更简洁，可读性更高	代码量较大，可读性相对较低

Kotlin 委托相比 Java 中的类似机制更加简洁、灵活、类型安全，并且更容易理解和使用。