多继承问题在Kotlin中该如何解决

前言

面向对象编程语言有两个重要特性：继承和实现。熟悉 Java 编程的都知道它是不支持类的多继承，Kotlin也是如此。那为什么要这样设计呢？ 平常开发场景中多继承的需求常常会出现，但类的多继承往往会导致关系上混淆。

回顾菱形继承问题

如果了解C++，应该知道它是支持多重继承机制的。有一个经典的钻石问题-骡子的多继承困惑。如果用Java语言来描述

abstract class Animal {
    abstract public void run();
}
class Horse extends Animal {
    @Override
    public void run() {
        System.out.println("I am run fast");
    }
}
class Donkey extends Animal {
    @Override
    public void run() {
        System.out.println("I am run slow");
    }
}
class Mule extends Horse, Donkey {
    // 骡子
    ...
    @Override
    public void run() {
        ...
    }
}

这段伪代码含义：

• Horse和Donkey都继承Animal类，并实现了Animal中的抽象方法 run
• Mule 继承了Horse和Donkey，拥有两者的特性

那要调用Mule中的run方法，问题就来了：Mule是继承Horse的run方法，还是Donkey的run方法？这个就是经典的菱形继承问题。

类的多继承如果使用不当，就会在继承关系上产生歧义。会给代码维护带来困扰：

• 代码的耦合度会提高
• 各种类之间的关系混乱

因此Java 和 Kotlin都只支持单继承。

Kotlin中解决多重继承

使用内部类

在Java中将一个类定义在另一个类的内部，这个就是内部类。内部类可继承一个与外部无关的类，所以保证了内部类的独立性，可以用这个特性来解决多继承问题

open class Horse {
    fun runFast() {
        println("I can run fast")
    }
}
open class Donkey {
    fun doLongTimeThing() {
        println("I can do some thing long time")
    }
}
class Mule {
    fun runFast() {
        HorseC().runFast()
    }
    fun doLongTimeThing() {
        DonkeyC().doLongTimeThing()
    }
    // 内部类使用 inner 修饰
    private inner class HorseC : Horse()
    private inner class DonkeyC : Donkey()
}

以上示例代码可看出:

• 可在一个类的内部定义多个内部类，每个内部类的实例都有自己的独立状态，与外部对象的信息相互独立
• 让内部类HorseC、DonkeyC分别继承Horse和Donkey这两个外部类，可以在Mule类中定义它们的实例对象，而获得Horse和Donkey两者不同的状态和行为
• 利用private修饰内部类，使得其他类都不能访问内部类，这样具有非常良好的封闭性

用接口实现多继承

一个类可以实现多个接口，Kotlin同样可以利用接口的这个特性，如以下示例代码:

interface Flyer {
    fun fly()
    fun kind() = "flying animals"
}
interface Animal {
    val name: String 
    fun eat()
    fun kind() = "flying animals"
}

class Bird(override val name: String) : Flyer, Animal {
    override fun eat() {
        println("I can eat")
    }
    override fun fly() {
        println("I can fly")
    }
    override fun kind() = super<Flyer>.kind()
}

fun main(args: Array<String) {
    val bird = Bird("sparrow")
    println(bird.kind())
}// 运行结果：flying animals

Bird类实现了 Flyer 和 Animal 两个接口，但都拥有默认的kind方法，同样会引起著名的钻石问题。Kotlin中提供了对应的解决方式，就是super关键字，利用它来指定继承哪个父类接口的方法，上面代码中: super.kind()

通过以上示例，可看出:

• 在Kotlin中同时实现多个接口，若多个接口又有相同方法名的默认实现时，需要主动指定使用哪个接口的方法或者重写自己的逻辑实现
• 对于默认的接口方法，可在实现类中通过super关键字调用它，T为拥有该方法的接口名

使用委托代替多继承

委托是一种特殊的类型，用于方法事件委托，比如调用A类的methodA()，其实是B类的methodA()去执行

Kotlin中简化了语法，只需通过by关键字就可以实现委托。如by lazy语法，利用委托实现延迟初始化语法

val laziness: String by lazy {
    println("I will hava a value")
    "I am a lazy initialized string"
}

用委托来替代多继承:

//定义了两个接口
interface CanFly {
    fun fly()
}
interface CanEat {
    fun eat()
}

// 实现接口
open class Flyer : CanFly {
    override fun fly() {
        println("I can fly")
    }
}
open class Animal : CanEat {
    override fun eat() {
        println("I can eat")
    }
}

class Bird(flyer: Flyer, animal: Animal) : CanFly by flyer, CanEat by animal {}

fun main() {
    val flyer = Flyer()
    val animal = Animal()
    val b = Bird(flyer, animal)
    b.fly()
    b.eat()
}

由以上示例：若需要继承的类是A，委托对象是B、C，在具体调用的时候并不是像组合A.B.method，而是可直接调用A.method，更能表达A拥有该method的能力，更加直观，其背后是通过委托对象来执行具体的方法。