Kotlin委托

类委托

interface Base{
    fun print()
}

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

//通过by来实现委
class Derived(b: Base) : Base by b

fun main(args: Array<String>){
    Derived(BaseImpl(1)).print()
}

属性委托

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

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

fun main(args: Array<String>){
    val e = Example()
    println(e.p)
    e.p = "lalala"
}

延迟属性

第一次调用会花费时间按计算，下面例子即会等待5秒。第二次调用会直接返回上次的计算结果，即马上返回

val lazyValue: String by lazy {
    Thread.sleep(5000)
    "Hello Lazy"
}

fun main(args: Array<String>){
    println(lazyValue)
    println(lazyValue)
}

可观察属性

class USer{
    var name: String by Delegates.observable("<no name>"){
        property, oldValue, newValue ->  println("$oldValue -> $newValue")
    }
}

fun main(args: Array<String>){
    val user = USer()
    user.name = "first"
    user.name = "second"
}
/*
<no name> -> first
first -> second
*/

用Map委托

//不可变类型
data class User(val map: Map<String, Any?>){
    val name: String by map
    val age: Int by map
}

//可变类型
data class MutableUser(val map: MutableMap<String, Any?>){
    var name: String by map
    var age: Int by map
}

fun main(args: Array<String>){
    val user = User(mapOf(
            "name" to "Owen",
            "age" to 25
    ))
    println(user.name)
    println(user.age)
}