Kotlin属性委托（delegated property）
示例代码
class MyDelegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String = "$thisRef,you delegated property name is ${property.name}"
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) = println("${thisRef},new value is $value")
}
class MyPropertyClass {
var str: String by MyDelegate()
}
fun main(args: Array<String>) {
val myPropertyClass = MyPropertyClass();
myPropertyClass.str = "hello world"
println(myPropertyClass.str)
}
输出
com.leofight.kotlin4.MyPropertyClass@439f5b3d,new value is hello world
com.leofight.kotlin4.MyPropertyClass@439f5b3d,you delegated property name is str
语法是： val/var <属性名>: <类型> by <表达式>。在 by 后面的表达式是该委托， 因为属性对应的 get()（和 set()）会被委托给它的 getValue() 和 setValue() 方法。 属性的委托不必实现任何的接口，但是需要提供一个 getValue() 函数（和 setValue()——对于 var 属性）。
有4种情况在实际开发中比较有用：
1.延迟属性。
2.可观测属性
3.非空属性
4.map属性
延迟属性
延迟属性： 指的是属性只在第一次访问的时候才会计算，之后则会将之前的计算结果缓存起来供后续调用
lazy() 是接受一个 lambda 并返回一个 Lazy <T> 实例的函数，返回的实例可以作为实现延迟属性的委托： 第一次调用 get() 会执行已传递给 lazy() 的 lambda 表达式并记录结果， 后续调用 get() 只是返回记录的结果。
默认情况下，对于 lazy 属性的求值是同步锁的（synchronized）：该值只在一个线程中计算，并且所有线程会看到相同的值。如果初始化委托的同步锁不是必需的，这样多个线程可以同时执行，那么将 LazyThreadSafetyMode.PUBLICATION 作为参数传递给 lazy() 函数。 而如果你确定初始化将总是发生在单个线程，那么你可以使用 LazyThreadSafetyMode.NONE 模式， 它不会有任何线程安全的保证和相关的开销。
LazyThreadSafetyMode
1.SYNCHRONIZED:默认情况下，延迟属性的计算是同步的：值只会在一个线程中得到计算，所有线程都会使用相同的一个结果。
2.PUBLICATION:如果不需要初始化委托的同步，这样多个线程可以同时执行。
3.NONE：如果确定初始化操作只会在一个线程中执行，这样会减少线程安全方面的开销。
示例代码：
val myLazyValue: Int by lazy {
println("hello world")
30
}
fun main(args: Array<String>) {
println(myLazyValue)
println(myLazyValue)
}
输出
hello world
30
30
非空属性
示例代码
class MyPerson {
var address: String by Delegates.notNull<String>()
}
fun main(args: Array<String>) {
val myPerson = MyPerson();
myPerson.address = "suzhou"
println(myPerson.address)
}
输出
suzhou
如果注释掉myPerson.address = "suzhou",则输出
Exception in thread "main" java.lang.IllegalStateException: Property address should be initialized before get.
at kotlin.properties.NotNullVar.getValue(Delegates.kt:55)
at com.leofight.kotlin4.MyPerson.getAddress(HelloKotlin4.kt)
at com.leofight.kotlin4.HelloKotlin4Kt.main(HelloKotlin4.kt:15)
notNull适用于那些无法在初始化阶段就确定属性值的场合。
可观察属性（Observable）
示例代码
class Person{
var age: Int by Delegates.observable(20){
prop,oldValue,newValue -> println("${prop.name},oldValue: $oldValue,newValue: $newValue")
}
}
class Person2{
var age: Int by Delegates.vetoable(20){
prop,oldValue,newValue -> when{
oldValue <= newValue -> true
else -> false
}
}
}
fun main(args: Array<String>) {
val person = Person();
person.age = 30
person.age = 40
println("-------")
val person2 = Person2();
println(person2.age)
person2.age = 40
println(person2.age)
println("=========")
person2.age = 30
println(person2.age)
输出
age,oldValue: 20,newValue: 30
age,oldValue: 30,newValue: 40
-------
20
40
=========
40
Delegates.observable接收两个参数：初始值与修改处理器。
处理器会在我们每次对属性赋值时得到调用（在赋值完成之后被调用）
处理器本身接收3个参数：被赋值的属性本身，旧的属性与新的属性
Delegates.vetoable的调用时机与Delegates.observable相反，它是在对属性赋值之前被调用，根据Delegates.vetoable的返回结果是true还是false，来决定是否真正对属性进行赋值。
map委托
将属性存储到map中
一种常见的应用场景是将属性值存储到map当中。
这通常出现在JSON解析或是一些动态行为。
在这种情况中，你可以将map实例作为委托，作为类中属性的委托。
map中的key的名字要与类中属性的名字保持一致
示例代码
class Student(map: Map<String, Any?>) {
val name: String by map
val address: String by map
val age: Int by map
val birthday: Date by map
}
class Student2(map: MutableMap<String, Any?>) {
var address: String by map
}
fun main(args: Array<String>) {
val student = Student(mapOf(
"name" to "zhangsan",
"address" to "beijing",
"age" to 20,
"birthday" to Date()
))
println(student.name)
println(student.address)
println(student.age)
println(student.birthday)
println("--------")
val map: MutableMap<String, Any?> = mutableMapOf(
"address" to "bejing"
)
val student2 = Student2(map)
println(map["address"])
println(student2.address)
println("---------")
student2.address = "shanghai"
println(map["address"])
println(student2.address)
}
输出
zhangsan
beijing
20
Tue May 01 16:55:19 CST 2018
--------
bejing
bejing
---------
shanghai
shanghai
关于属性委托的要求
对于只读属性来说（val修饰的属性），委托需要提供一个名为getValue的方法，该方法接收如下参数：
- thisRef，需要是属性拥有者相同的类型或者其父类型（对于扩展属性来说，这个类型指的被扩展的那个类型）
- property，需要是KProperty<*>类型或是其父类型
getValue方法需要返回与属性相同的类型或是其子类型
对于可变属性来说（var修饰的属性），委托需要再提供一个名为serValue的方法，该方法需要接收如下参数：
- thisRef,与getValue的thisRef要求一致
- property，与getValue方法的property要求一致。
- new value，需要与属性的类型相同或其父类型
getValue与setValue方法既可以作为委托类的成员方法实现，也可以作为其扩展方法来实现。
这两个方法都必须要标记为operator关键字。对于委托类来说，它可以实现ReadOnlyProperty或是ReadWriterProperty接口，这些接口包含了相应的getValue与setValue方法。同时，对于委托类来说，也可以不去实现这两个接口，而是自己单独实现相应的getValue与setValue方法。
委托转换规则
对于每个委托属性来说，Kotlin编译器在底层会生成一个辅助的属性，然后将原有属性的访问委托给这个辅助属性。
比如说，对于属性prop来说，Kotlin编译器所生成的隐含的属性名为prop$delegate属性，然后对原有的prop属性的访问器的访问都只是委托给这个额外的，Kotlin编译器所生成的辅助属性。
提供委托（providing a delegate）
通过定义provideDelegate operator，我们可以扩展委托的创建逻辑过程。如果对象定义了provideDelegate方法，那么该方法就会被调用来创建属性委托实例。
示例代码
class PropertyDelgate : ReadOnlyProperty<People, String> {
override fun getValue(thisRef: People, property: KProperty<*>): String {
return "hello world"
}
}
class PeopleLauncher {
operator fun provideDelegate(thisRef: People, property: KProperty<*>): ReadOnlyProperty<People, String> {
println("welcome")
when (property.name) {
"name", "address" -> return PropertyDelgate()
else -> throw Exception("not valid name")
}
}
}
class People {
val name: String by PeopleLauncher()
val address: String by PeopleLauncher()
}
fun main(args: Array<String>) {
val people = People();
println(people.name)
println(people.address)
}
输出
welcome
welcome
hello world
hello world
