前言
面向对象编程语言有两个重要特性：继承和实现。熟悉 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的能力，更加直观，其背后是通过委托对象来执行具体的方法。
网友评论