你真的懂 Kotlin 中的 by 关键字吗？3分钟搞懂精髓

引言

在Kotlin中，by 关键字主要用于实现委托模式。委托模式是一种设计模式，它允许一个对象将部分职责委托给另一个对象。在Kotlin中，by 关键字提供了一种简洁的语法，使得委托的实现变得更加轻松。

委托模式概述

在委托模式中，有两个主要角色：

委托类（Delegated Class）： 持有实际的工作对象，负责将部分职责委托给这个对象。
委托属性（Delegated Property）： 在委托类中声明的属性，使用 by 关键字将其委托给其他类。

by关键字的工作原理

当使用 by 关键字将属性委托给其他类时，编译器会在后台生成一些额外的代码，实际上是将属性的 getter 和 setter 方法委托给特定的委托类。下面是一个简单的例子来说明 by 关键字的工作原理：

interface Printer {
    fun print(message: String)
}

class DefaultPrinter : Printer {
    override fun print(message: String) {
        println("Default: $message")
    }
}

class CustomPrinter(private val delegate: Printer) : Printer by delegate

fun main() {
    val customPrinter = CustomPrinter(DefaultPrinter())
    customPrinter.print("Hello, Kotlin!")
}

在这个例子中，CustomPrinter 类通过 by 关键字将 Printer 接口的实现委托给了 DefaultPrinter 类。编译器会生成类似下面的代码：

class CustomPrinter(private val delegate: Printer) : Printer {
    override fun print(message: String) {
        delegate.print(message)
    }
}

实际上，CustomPrinter 中的 print 方法被委托给了 DefaultPrinter 的 print 方法。

自定义委托类

除了使用接口作为委托的对象外，我们还可以自定义委托类。自定义委托类需要实现属性委托的接口，即具备 getValue 和 setValue 方法。以下是一个简单的自定义委托类的例子：

import kotlin.reflect.KProperty

class CustomDelegate {
    private var value: String = ""

    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        println("Getting value: $value")
        return value
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, newValue: String) {
        println("Setting value: $newValue")
        value = newValue
    }
}

class Example {
    var customProperty: String by CustomDelegate()
}

fun main() {
    val example = Example()
    example.customProperty = "Hello, Kotlin!"
    println(example.customProperty)
}

在上面的例子中，CustomDelegate 类实现了属性委托的接口，通过重写 getValue 和 setValue 方法实现了属性的读取和设置。Example 类中的 customProperty 属性通过 by 关键字委托给了 CustomDelegate 类。

lazy原理

有了上面的基础，再来看lazy的实现就非常简单。

lazy 是 Kotlin 标准库中的一个函数，用于实现延迟初始化。它的主要作用是将一个 lambda 表达式作为参数传递给 lazy 函数，该 lambda 表达式将在首次访问属性时执行，并且只会执行一次。lazy 返回一个 Lazy 类型的实例，该实例包含一个被委托的属性，以及相应的初始化逻辑。

以下是 lazy 的简化实现原理，为了更好地理解，我们将采用伪代码的形式：

class Lazy<T>(private val initializer: () -> T) {
    private var value: T? = null
    private var isInitialized: Boolean = false

    operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
        if (!isInitialized) {
            value = initializer()
            isInitialized = true
        }
        return value!!
    }
}

fun <T> lazy(initializer: () -> T): Lazy<T> = Lazy(initializer)

上述代码中，我们定义了一个 Lazy 类，它接受一个 lambda 表达式 initializer，这个 lambda 表达式包含了属性首次访问时的初始化逻辑。Lazy 类包含一个泛型参数 T，表示被委托的属性的类型。

value 存储被委托属性的值，初始值为 null。
isInitialized 用于追踪属性是否已经被初始化。

Lazy 类还实现了 getValue 操作符函数，这是属性委托的关键。当被委托的属性首次被访问时，getValue 函数会执行 initializer lambda 表达式，初始化属性的值，并将 isInitialized 设置为 true。之后，再次访问该属性时，直接返回已经初始化过的值。

最后，我们通过 lazy 函数创建了一个 Lazy 类的实例，用于实际的属性委托。在实际使用中，lazy 函数可以直接作为属性的委托，如下所示：

val myProperty: String by lazy {
    println("Initializing myProperty")
    "Hello, Kotlin!"
}

fun main() {
    println(myProperty) // 第一次访问，会执行初始化逻辑
    println(myProperty) // 后续访问，直接返回已初始化的值
}

在上述例子中，myProperty 的初始化逻辑只在首次访问时执行，之后的访问直接返回已经初始化的值。

总结

通过 by 关键字，Kotlin 提供了一种优雅而强大的委托模式实现方式。无论是通过接口还是自定义委托类，都能够轻松地实现代码的重用和解耦。了解 by 关键字的实现原理有助于更深入地理解 Kotlin 的委托模式，并在实际开发中更加灵活地运用。

引言

委托模式概述

by关键字的工作原理

自定义委托类

lazy原理

总结

推荐