Kotlin 委托 #

interface Base {
    fun print()
}

class BaseImpl(val x: Int) : Base {
    override fun print() { println(x) }
}

class Derived(b: Base) : Base by b

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

interface Base {
    fun print()
}

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

class Derived(b: Base) : Base by b {
    override fun print() { println("Derived") }
}

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

interface Repository {
    fun findById(id: Int): User?
    fun save(user: User)
}

class BaseRepository : Repository {
    private val users = mutableMapOf<Int, User>()
    
    override fun findById(id: Int) = users[id]
    override fun save(user: User) { users[user.id] = user }
}

class CachedRepository(
    private val delegate: Repository
) : Repository by delegate {
    private val cache = mutableMapOf<Int, User>()
    
    override fun findById(id: Int): User? {
        return cache.getOrPut(id) { delegate.findById(id)!! }
    }
}

import kotlin.properties.Delegates

class Example {
    var p: String by Delegates.observable("<initial>") { prop, old, new ->
        println("$old -> $new")
    }
}

fun main() {
    val e = Example()
    e.p = "first"   // <initial> -> first
    e.p = "second"  // first -> second
}

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.")
    }
}

class Example {
    var p: String by Delegate()
}

fun main() {
    val e = Example()
    println(e.p)     // Example@..., thank you for delegating 'p' to me!
    e.p = "NEW"      // NEW has been assigned to 'p' in Example@...
}

interface ReadOnlyProperty<in T, out V> {
    operator fun getValue(thisRef: T, property: KProperty<*>): V
}

interface ReadWriteProperty<in T, V> {
    operator fun getValue(thisRef: T, property: KProperty<*>): V
    operator fun setValue(thisRef: T, property: KProperty<*>, value: V)
}

val lazyValue: String by lazy {
    println("computed!")
    "Hello"
}

fun main() {
    println(lazyValue)  // computed! Hello
    println(lazyValue)  // Hello（不重新计算）
}

var name: String by Delegates.observable("<initial>") { _, old, new ->
    println("$old -> $new")
}

var max: Int by Delegates.vetoable(0) { _, old, new ->
    new > old  // 只有新值大于旧值才更新
}

var name: String by Delegates.notNull()

name = "Kotlin"
println(name)  // Kotlin
// println(name)  // 如果未初始化，抛出异常

class User(val map: Map<String, Any?>) {
    val name: String by map
    val age: Int by map
}

fun main() {
    val user = User(mapOf(
        "name" to "Kotlin",
        "age" to 10
    ))
    
    println(user.name)  // Kotlin
    println(user.age)   // 10
}

class User(val map: MutableMap<String, Any?>) {
    var name: String by map
    var age: Int by map
}

fun main() {
    val user = User(mutableMapOf(
        "name" to "Kotlin",
        "age" to 10
    ))
    
    user.name = "Java"
    println(user.map)  // {name=Java, age=10}
}

class ResourceLoader {
    operator fun provideDelegate(
        thisRef: Any?,
        property: KProperty<*>
    ): ReadOnlyProperty<Any?, String> {
        println("Creating delegate for ${property.name}")
        return object : ReadOnlyProperty<Any?, String> {
            override fun getValue(thisRef: Any?, property: KProperty<*>): String {
                return "Value of ${property.name}"
            }
        }
    }
}

val loader = ResourceLoader()
val prop: String by loader  // Creating delegate for prop

class PreferenceDelegate<T>(
    private val key: String,
    private val defaultValue: T
) : ReadWriteProperty<Any?, T> {
    
    @Suppress("UNCHECKED_CAST")
    override fun getValue(thisRef: Any?, property: KProperty<*>): T {
        return sharedPreferences.get(key, defaultValue) as T
    }
    
    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        sharedPreferences.put(key, value)
    }
}

class Settings {
    var username: String by PreferenceDelegate("username", "")
    var isLoggedIn: Boolean by PreferenceDelegate("isLoggedIn", false)
}

class DatabaseProperty<T>(
    private val tableName: String,
    private val id: Long
) : ReadOnlyProperty<Any?, T> {
    
    override fun getValue(thisRef: Any?, property: KProperty<*>): T {
        return database.query("SELECT ${property.name} FROM $tableName WHERE id = $id")
    }
}

class User(id: Long) {
    val name: String by DatabaseProperty("users", id)
    val email: String by DatabaseProperty("users", id)
}

class ObservableProperty<T>(
    initialValue: T,
    private val onChange: (T) -> Unit
) : ReadWriteProperty<Any?, T> {
    
    private var value = initialValue
    
    override fun getValue(thisRef: Any?, property: KProperty<*>): T = value
    
    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        val old = this.value
        this.value = value
        if (old != value) {
            onChange(value)
        }
    }
}

class ViewModel {
    var data: String by ObservableProperty("") {
        println("Data changed to: $it")
        notifyObservers()
    }
}

// 推荐：使用 lazy
val heavyObject: HeavyObject by lazy { HeavyObject() }

// 推荐：使用 observable
var state: State by Delegates.observable(State.Initial) { _, _, new ->
    notifyStateChanged(new)
}

// 将复杂逻辑封装在委托中
class ValidatedProperty<T>(
    initialValue: T,
    private val validator: (T) -> Boolean
) : ReadWriteProperty<Any?, T> {
    
    private var value = initialValue
    
    override fun getValue(thisRef: Any?, property: KProperty<*>): T = value
    
    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        require(validator(value)) { "Invalid value: $value" }
        this.value = value
    }
}

// lazy 默认是线程安全的
val value: String by lazy { compute() }

// 如果不需要线程安全
val valueFast: String by lazy(LazyThreadSafetyMode.NONE) { compute() }