委托模型可以很好的去替换继承的方式。接下来就借助kotlin中文站，进行学习一下委托模型，以下方的代码为例：Derived类可以通过将其他所有共有成员都委托给指定对象来实现一个接口Base(Base的名称随便修改，基础类不一定就只能叫做Base)

interface Base {
    fun print()
}

class BaseImpl(val x: Int) : Base {
    override fun print() { print(x) }
}

class Derived(b: Base) : Base by b

fun main() {
    val b = BaseImpl(10)
    Derived(b).print()
}

//输出的结果为10

注意：Derived的超类型列表中的by意思表示b将会在Derived中内部存储，并且编译器将生成转发给b的所有Base的方法。
by b 中的b只能用b，不行去修改为其他字母

覆盖由委托实现的接口成员

覆盖符合预期：编译器会使用 override 覆盖的实现而不是委托对象中的。如果将 override fun printMessage() { print("abc") } 添加到 Derived，那么当调用 printMessage 时程序会输出“abc”而不是“10”：

interface Base {
    fun printMessage()
    fun printMessageLine()
}

class BaseImpl(val x: Int) : Base {
    override fun printMessage() { print(x) }
    override fun printMessageLine() { println(x) }
}

class Derived(b: Base) : Base by b {
    override fun printMessage() { print("abc") }
}

fun main() {
    val b = BaseImpl(10)
    Derived(b).printMessage()
    Derived(b).printMessageLine()
}
//输出的结果为：abc10

但请注意，以这种方式重写的成员不会在委托对象的成员中调用 ，委托对象的成员只能访问其自身对接口成员实现：

interface Base {
    val message: String
    fun print()
}

class BaseImpl(val x: Int) : Base {
    override val message = "BaseImpl: x = $x"
    override fun print() { println(message) }
}

class BaseImpl2(val xx :Int):Base{
    override val message = "第二部分实现message ：$xx"
    override fun print(){
        println("第二个实现 :$xx")
    }
}

class Derived(b: Base) : Base by b {
    // 在 b 的 `print` 实现中不会访问到这个属性
    override val message = "Message of Derived"
}

fun main() {
       val b = BaseImpl(10)
      val derived = Derived(b)
      derived.print()
      println(derived.message)
      val bb = BaseImpl2(12)
      Derived(bb).print()
      println(Derived(bb).message)
}
//输出结果为：
//BaseImpl: x = 10
//Message of Derived
//第二个实现 :12
//Message of Derived