属性委托就是在一个类中，生成一个委托对象来保存被委托的属性。委托对象要求：拥有被 operator修饰的 getValue 和 setValue 函数，当获取属性或者为属性赋值的时候，会自动调用委托对象的getValue 和 setValue 函数。属性委托可以和val、var配合使用，主要是看委托的对象有没有getValue和setValue方法，Delegates.notNull() 返回的ReadWriteProperty对象两个方法都有，所以可以和var、val搭配使用。lazy方法返回的委托对象SynchronizedLazyImpl没有setValue方法，所以只能和val搭配使用。
先来自己定义一个属性委托的对象：
class Person { var age: Int by AgeDelegate() } class AgeDelegate { private var age: Int = 0 operator fun getValue(thisRef: Any?, property: KProperty<*>): Int { return age } operator fun setValue(thisRef: Any?, property: KProperty<*>, value: Int) { age = value } }上边的代码，当获取Person对象的age属性或者为age属性赋值时，kotlin就会自动调用 AgeDelegate对象的 getValue 和 setValue 方法，编译器实际生成的代码如下：
class Person { private var ageDelegate: AgeDelegate = AgeDelegate() var age: Int get() = ageDelegate.getValue(this, ::age) set(value) = ageDelegate.setValue(this, ::age, value) }通过这个例子就可以看出，其实属性委托的原理非常简单，就是用一个委托的对象管理属性。kotlin利用这个特质，给出了属性委托常用的两个场景：惰性初始化 和 属性监听
直接看 lazy函数 的源码：
public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)lazy 函数接收一个函数类型作为参数，他的最终返回值是 SynchronizedLazyImpl 的实例：
private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, Serializable { private var initializer: (() -> T)? = initializer @Volatile private var _value: Any? = UNINITIALIZED_VALUE private val lock = lock ?: this override val value: T get() { val _v1 = _value if (_v1 !== UNINITIALIZED_VALUE) { @Suppress("UNCHECKED_CAST") return _v1 as T } return synchronized(lock) { val _v2 = _value if (_v2 !== UNIN ITIALIZED_VALUE) { @Suppress("UNCHECKED_CAST") (_v2 as T) } else { val typedValue = initializer!!() _value = typedValue initializer = null typedValue } } } } public interface Lazy<out T> { public val value: T public fun isInitialized(): Boolean }SynchronizedLazyImpl 类实现了 Lazy 接口，它内部实现了 value 属性并且重写了 get 方法。get 方法很简单，就是先判断 _value 是否已经初始化，如果初始化了直接返回，如果没有初始化，这里加上了同步锁来保证多线程安全，直接调用外部传进来的 initializer 方法来创建一个实例保存并返回。结束了吗？到这里我们似乎并没有看到被 operator 修饰的 getValue 方法啊？上边不是说属性委托要求委托对象有特定的方法吗？ 其实是这样的：kotlin为Lazy添加了拓展方法，方法直接返回value属性，从而调用了上边的get方法。
public inline operator fun <T> Lazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value属性监听是属性委托的另一大应用，先来看一段代码：
class Person { var age: Int by Delegates.observable( 1, { property, oldValue, newValue -> print("newAge is $newValue") } ) }age的默认值为1，每当 age 改变的时候，lambda表达式就会被执行，打印出 newAge，实现属性监听的效果。直接看Delegates.observable的源码：
public inline fun <T> observable( initialValue: T, crossinline onChange: (property: KProperty<*>, oldValue: T, newValue: T) -> Unit): ReadWriteProperty<Any?, T> = object : ObservableProperty<T>(initialValue) { override fun afterChange(property: KProperty<*>, oldValue: T, newValue: T) = onChange(property, oldValue, newValue) } public abstract class ObservableProperty<T>(initialValue: T) : ReadWriteProperty<Any?, T> { private var value = initialValue protected open fun beforeChange(property: KProperty<*>, oldValue: T, newValue: T): Boolean = true protected open fun afterChange(property: KProperty<*>, oldValue: T, newValue: T): Unit {} public override fun getValue(thisRef: Any?, property: KProperty<*>): T { return value } public override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) { val oldValue = this.value if (!beforeChange(property, oldValue, value)) { return } this.value = value afterChange(property, oldValue, value) } }可以看到 observable 方法实际上是返回了一个继承 ObservableProperty类的匿名对象，ObservableProperty对象中我们看到了 getValue 和 setValue 方法。在 setValue方法中，最后会执行 afterChange 方法，在匿名对象中重写了 afterChange 方法，并且会调用 observable 方法传进来的 onChange 参数，这样每次属性改变，就会回调 onChange 方法，从而达到监听的目的。
ok，关于属性委托就这么多！
