【记】如何理解kotlin中的委托属性？

1. 什么是委托属性？

委托属性的核心思想是：

• 你可以将一个属性的 getter 和 setter 的逻辑交给一个外部对象（称为委托对象）来处理。
• 这个外部对象负责存储属性的值，并提供自定义的 get 和 set 行为。

通过委托属性，你可以：

1. 简化代码，避免重复。
2. 实现属性的懒加载（Lazy Properties）。
3. 监听属性的变化（Observable Properties）。
4. 将属性的存储和逻辑分离。

---

2. 委托属性的基本语法

在 Kotlin 中，委托属性的语法如下：

class MyClass {
    var property: Type by Delegate
}

• by：用于将属性的 getter 和 setter 委托给一个外部对象（Delegate）。
• Delegate：一个实现了 getProperty 和 setProperty 方法的对象，负责处理属性的存储和逻辑。

---

3. 委托属性的示例

例 1：简单的委托属性

假设我们有一个 Delegate 类，它实现了 getProperty 和 setProperty 方法：

class SimpleDelegate {
    private var value: Int = 0

    operator fun getValue(thisRef: Any?, property: KProperty<*>): Int {
        return value
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: Int) {
        this.value = value
    }
}

• getValue：用于获取属性的值。
• setValue：用于设置属性的值。

然后，我们可以在类中使用这个委托：

class MyClass {
    var number: Int by SimpleDelegate()
}

• number：这个属性的 getter 和 setter 被委托给 SimpleDelegate。

使用效果：

val obj = MyClass()
println(obj.number) // 调用 SimpleDelegate 的 getValue
obj.number = 42 // 调用 SimpleDelegate 的 setValue
println(obj.number) // 输出: 42

例 2：懒加载属性（Lazy Properties）

Kotlin 标准库提供了 lazy 委托，用于实现懒加载属性。懒加载属性的值在第一次访问时才会被初始化。

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

• lazy：一个标准库提供的委托，用于实现懒加载。
• 初始化逻辑：在第一次访问 lazyValue 时，才会执行初始化逻辑。

使用效果：

val obj = MyClass()
println(obj.lazyValue) // 输出: Initializing lazyValue \n Hello, Lazy!

例 3：可观察属性（Observable Properties）

Kotlin 标准库还提供了 observable 委托，用于监听属性的变化。

import kotlin.properties.Delegates

class MyClass {
    var observableValue: String by Delegates.observable("<initial>") {
        _, old, new ->
        println("Property changed from $old to $new")
    }
}

• Delegates.observable：一个标准库提供的委托，用于监听属性的变化。
• 回调函数：在属性值改变时，会调用回调函数。

使用效果：

val obj = MyClass()
obj.observableValue = "New Value" // 输出: Property changed from <initial> to New Value

 4. 委托属性的优势

• 简化代码：通过委托，实现属性的存储和逻辑分离，避免重复代码。
• 懒加载：通过 lazy 委托，可以实现属性的懒加载。
• 监听变化：通过 observable 委托，可以监听属性的变化。
• 灵活性：可以自定义委托对象，实现更复杂的行为。

---

5. 总结

• 委托属性：通过 by 关键字，将属性的 getter 和 setter 委托给一个外部对象。
• 委托对象：负责存储属性的值，并提供自定义的 get 和 set 行为。
• 常见用途：
  • 懒加载属性（lazy）。
  • 可观察属性（observable）。
  • 自定义委托（如 SimpleDelegate）。