本文已同步发表于我的微信公众号，搜索 代码说 即可关注，欢迎与我沟通交流。

类委托

委托机制是一种非常灵活的语言特性，它可以让我们将对象的某些属性或方法委托给其他对象来处理。示例：

interface ISay {    fun sayHello()}class DelegateImp : ISay {    override fun sayHello() {        println("sayHello from DelegateImp")    }}//delegate传入DelegateImp()class RealImp (val delegate : ISay) : ISay {    override fun sayHello() {        delegate.sayHello()    }}

RealImp 类将 sayHello() 方法的实现委托给了 DelegateImp 对象，从而实现了代码复用和模块化。当调用 RealImp 的 sayHello() 方法时，实际上是调用了 DelegateImp 对象的 sayHello()方法。

Kotlin 中通过使用 by 关键字进行委托，上述 RealImp 的实现方式可以直接通过下面的方式来替代：

class RealImp2 : ISay by DelegateImp()  //方式1class RealImp3(delegate: ISay) : ISay by delegate //方式2

上述两种方式的结果是一样的，可以看到 by 关键字后面的表达式是为了得到 ISay 接口的实例对象。最后执行：

RealImp(DelegateImp()).sayHello() //方式1RealImp2().sayHello() //方式2RealImp3(DelegateImp()).sayHello() //方式3

上述执行结果都是一样的:

sayHello from DelegateImp

属性委托

除了上一节中的接口类委托，Kotlin 还支持属性委托，语法模板如下：

val/var <属性名>: <类型> by <表达式>

接口是把接口方法委托出去，那属性要委托什么呢？很简单，对于一个属性，无非有两个操作：获取属性以及修改属性，也就是对应的 get()/set() 。

属性委托即是将对应的 get()/set() 操作分发给指定委托对象的 getValue()/setValue() 方法执行；当然，如果是 val 修饰的属性，只需要提供 getValue() 即可。示例：

class Delegate {    //对应属性中的get()，表示获取数据    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {        return "$thisRef，${property.name}"    }    //对应属性中的set()，表示设置数据，只有var的属性会有    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {        println("$thisRef , ${property.name} , $value")    }}

thisRef： 请求其值的对象，即被委托对象的实例property： 被委托对象属性的元数据。包含了被委托对象属性的名称、类型、可见性等信息。value： setValue() 中要设置的值。

使用示例：

class DelegateProperty {    var p1: String by Delegate()}fun main() {   val property = DelegateProperty()   println(property.p1) //getValue()   property.p1 = "小马快跑" //setValue()}执行结果：DelegateProperty@6d5380c2, p1  //getValue()DelegateProperty@6d5380c2 , p1 , 小马快跑 //setValue()

上述 Delegate中的 getValue()/setValue()方法需要我们手动编写，有点麻烦，Kotlin为我们提供了ReadOnlyProperty、ReadWriteProperty接口：

//只读public fun interface ReadOnlyProperty<in T, out V> {    public operator fun getValue(thisRef: T, property: KProperty<*>): V}//读写都支持public interface ReadWriteProperty<in T, V> : ReadOnlyProperty<T, V> {    public override operator fun getValue(thisRef: T, property: KProperty<*>): V    public operator fun setValue(thisRef: T, property: KProperty<*>, value: V)}

使用示例：

class DelegateR : ReadOnlyProperty<Any, String> {    override fun getValue(thisRef: Any, property: KProperty<*>): String {        return "getValue：$thisRef，${property.name}"    }}class DelegateRW : ReadWriteProperty<Any, String> {    override fun getValue(thisRef: Any, property: KProperty<*>): String {        return "getValue：$thisRef，${property.name}"    }    override fun setValue(thisRef: Any, property: KProperty<*>, value: String) {        println("setValue：$thisRef，${property.name}，$value")    }}class DelegateProperty {    val p2: String by DelegateR()    var p3: String by DelegateRW()}fun main() {   val property = DelegateProperty()   println(property.p2) //p2取值   println(property.p3) //p3取值   property.p3 = "小马快跑" //p3设值}执行结果：getValue：DelegateProperty@77a567e1，p2getValue：DelegateProperty@77a567e1，p3setValue：DelegateProperty@77a567e1，p3，小马快跑

可以看到利用ReadOnlyProperty、ReadWriteProperty实现的结果跟手动实现的结果是一致的，但是对比手动编写更方便、更快捷。

延迟委托 （by lazy）

//1public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)//2public actual fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T> =    when (mode) {        LazyThreadSafetyMode.SYNCHRONIZED -> SynchronizedLazyImpl(initializer)        LazyThreadSafetyMode.PUBLICATION -> SafePublicationLazyImpl(initializer)        LazyThreadSafetyMode.NONE -> UnsafeLazyImpl(initializer)    }

lazy() 是接受一个 lambda 表达式， 并返回一个 Lazy <T> 实例的函数，返回的实例可以作为实现延迟属性的委托： 第一次调用属性的 get() 会执行已传递给 lazy() 的 lambda 表达式并记录结果； 后续调用直接返回已经记录的结果。示例：

val lazyView by lazy {  println("我只有第一次初始化的时候才执行哟~")  "Come on"}//调用:println("第1次：${property.lazyView}")println("第2次：${property.lazyView}")//执行结果：我只有第一次初始化的时候才执行哟~第1次：Come on第2次：Come on

从结果可以看出只有第一次执行时走到了 lambda 表达式中的逻辑，第二次执行时直接返回第一次生成的结果。 另外再调用 lazy() 函数时可以传入一个 LazyThreadSafetyMode 参数，有下面三个值，分别代表不同的意思：

LazyThreadSafetyMode.SYNCHRONIZED：该值只在一个线程中计算，并且所有线程会看到相同的值。LazyThreadSafetyMode.PUBLICATION：可以在并发访问未初始化的Lazy实例值时调用多次，但只有第一次返回的值将被用作Lazy实例的值。LazyThreadSafetyMode.NONE：不会有任何线程安全的保证以及相关的开销，当初始化与使用总是位于相同线程中时使用。

如果lazy 属性的求值时不传 LazyThreadSafetyMode 参数，那么默认情况下走的是是LazyThreadSafetyMode.SYNCHRONIZED模式。

使用案例

先编写一个顶级扩展函数，注意其内部使用 lazy 包裹：

fun <T : View> Activity.id(id: Int) = lazy {    findViewById<T>(id)}

接下来就可以使用了：

//Activityclass ViewPager2DispatchActivity : AppCompatActivity() {    //注意看是在这里使用的    private val mTvTxNews: TextView by id(R.id.tv_tx_news)    override fun onCreate(savedInstanceState: Bundle?) {        super.onCreate(savedInstanceState)        setContentView(R.layout.activity_view_pager2_dispatch)        mTvTxNews.text = "我已经初始化好了，可以使用了"    }}//XML中(activity_view_pager2_dispatch.xml)<androidx.constraintlayout.widget.ConstraintLayout xmlns:android=";    xmlns:app=";    xmlns:tools=";    android:layout_width="match_parent"    android:layout_height="match_parent">    <TextView        android:id="@+id/tv_tx_news"        app:layout_constraintLeft_toLeftOf="parent"        app:layout_constraintRight_toRightOf="parent"/></androidx.constraintlayout.widget.ConstraintLayout>

可以看到通过private val mTvTxNews: TextView by id(R.id.tv_tx_news) 声明后，下面就可以正常使用该TextView了，其原理本质上就是通过 by lazy 延迟初始化了该属性，这种写法不需要每次去调用findViewById()了，跟我们使用ButterKnife 库的效果是一样的。同理，如果在Fragment中或其他场景中使用，继续写类似的扩展函数即可。 嗯，Kotlin 的语法糖真甜！

可观察属性（observable properties）

Delegates.observable()可以认为是一个属性监听器，当监听的属性变更时会收到通知。其接受两个参数：初始值initialValue与onChange()函数，当属性被赋值后就会触发onChange()，内部有三个参数：被赋值的属性、旧值与新值。

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

Delegates.observable() 可以帮助我们在属性值发生变化时自动执行一些操作，例如更新UI、保存数据、防抖动等。它适用于需要对属性值进行监听和处理的场景。

使用案例

这里以实现一个防抖动功能为例：

class ExampleActivity : AppCompatActivity()  {    private var lastClickTime by Delegates.observable(0L) { _, old, new ->        // 在lastClickTime属性值发生变化时执行点击事件        if (new - old > 1000) {            onClick()        }    }    override fun onClick(view: View) {        //每次点击都会触发Delegates.observable()        lastClickTime = System.currentTimeMillis()    }    private fun onClick() {        // 点击事件代码    }}

上述代码中，在 lastClickTime 属性值发生变化时，判断两次点击时间的间隔是否大于 1 秒：如果是，则执行点击事件；如果不是，什么都不做。如此通过 Delegates.observable 便实现了防抖动能力。

注：在属性被赋新值生效之前想截获赋值，可以使用 vetoable() 取代 observable()，onChange()中会返回一个Boolean值来决定是否生效本次赋值。

属性之间的委托

从 Kotlin 1.4 开始，一个属性可以把它的 getter 与 setter 委托给另一个属性，被委托的属性属于顶层或普通类属性都可。

为将一个属性委托给另一个属性，可以使用 :: 限定符，例如，this::delegate 或 MyClass::delegate。

使用案例

class DelegateProperty {    @Deprecated("Use [newName] instead", ReplaceWith("newName"))    var oldName by this::newName //this可以省略    var newName = ""}fun main() {    val property = DelegateProperty()    property.oldName = "2023"    println("oldName: ${property.oldName}")    println("newName: ${property.newName}")}//执行结果：oldName: 2023newName: 2023

当想要以一种向后兼容的方式重命名一个属性的时候：引入一个新的属性、 使用 @Deprecated 注解来注解旧的属性、并委托其实现。