委托

// 定义接口
interface Printer {
    fun print(message: String)
}

// 实现接口的具体类
class ConsolePrinter : Printer {
    override fun print(message: String) {
        println("Printing message: $message")
    }
}

// 委托类
class Delegate(private val printer: Printer) : Printer by printer {
    // 可以添加自己的额外逻辑或方法
    fun doAdditionalTask() {
        println("Performing additional task")
    }
}

// 测试代码
fun main() {
    // 创建委托类的实例，并传入具体的打印机对象
    val printer = ConsolePrinter()
    val delegate = Delegate(printer)

    // 调用委托类的方法，实际上会委托给打印机对象执行打印任务
    delegate.print("Hello, World!")

    // 委托类可以调用自己的方法
    delegate.doAdditionalTask()
}

拆解

// 第一步
class Delegate(private val printer: Printer) {
   // do sth
}

//第二步，实现接口
class Delegate(private val printer: Printer) : Printer {
   // do sth
}

//第三步，对象委托
class Delegate(private val printer: Printer) : Printer by printer {
   // do sth
}

从效果上看，kotlin中的委托就是去实现接口，但是具体的实现方法交给其他对象。好处：继承的一个很好的替代方式，较少样板代码的书写

属性委托

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

在 by 后面的表达式是该 委托， 因为属性对应的 get()（与 set()）会被委托给它的 getValue() 与 setValue() 方法。 属性的委托不必实现接口，但是需要提供一个 getValue() 函数（对于 var 属性还有 setValue()）

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

标准委托 - lazy

构造方法

// 默认线程安全，内部的原理是synchronize实现的懒汉模式
public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)

// 也可以指定模式
public actual fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T> =
    when (mode) {
        LazyThreadSafetyMode.SYNCHRONIZED -> SynchronizedLazyImpl(initializer)
        LazyThreadSafetyMode.PUBLICATION -> SafePublicationLazyImpl(initializer)
        LazyThreadSafetyMode.NONE -> UnsafeLazyImpl(initializer)
    }