多继承问题在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的能力，愈加直观，其背面是经过托付目标来履行详细的办法。