HelloDart-MixIn，土话记录多继承机制

MixIn

MixIn是一种设计模式，旨在一个类中尽可能重用继承多个超类的功能。
在绝大部分面向对象语言中，继承与实现就是MixIn设计模式的实际应用。例如Java，一个子类可以单继承一个超类，实现多个接口。到了JDK1.8之后，接口可以有默认方法和静态方法，更优雅的实现MixIn设计模式。

Dart中的MixIn

在Dart官方文档中，描述Dart是一门面向对象的语言，同时兼备融合了多种面向对象语言的优点。很自然的，MixIn模式也是Dart语言的特性之一。
在Dart中，类和接口是一类东西，但是implements关键字还是保留下来，也带有实现的意思，implements的用法在文章下面再说。
Dart的多继承，是由extends、with和implements来实现的。同时Dart中也保留了抽象类abstract的用法。
首先，抽象出一个实际的模型，用Dart去实现这个模型。

用意念创建一个交通工具抽象类，具有运输方法

//交通工具类，拥有运输功能
abstract class Transportation {
  //运输功能
  void transport();
}

默认创建3个子类去实现这个方法，分别是摩托车，自行车和小轿车，具体实现如下

class Bicycle extends Transportation {
  @override
  void transport() {
    print(
        "Bicycle:\n动力组件: ${twoWheel()} > 安全指数： ${lowSafetyIndex()} > 动力来源：${bodyEnergy()}");
  }

  String lowSafetyIndex() => "low";

  String twoWheel() => "两个轮子";

  String bodyEnergy() => "全靠腿登";
}

class Sedan extends Transportation {
  @override
  void transport() {
    print(
        "Sedan:\n动力组件: ${fourWheel()} > 安全指数： ${middleSafetyIndex()} > 动力来源：${gasolineEnergy()}");
  }

  String middleSafetyIndex() => "middle";

  String fourWheel() => "四个轮子";

  String gasolineEnergy() => "汽油";
}

class Motorcycle extends Transportation {
  @override
  void transport() {
    print(
        "Motorcycle:\n动力组件: ${twoWheel()} > 安全指数： ${lowSafetyIndex()} > 动力来源：${gasolineEnergy()}");
  }

  String lowSafetyIndex() => "low";

  String twoWheel() => "两个个轮子";

  String gasolineEnergy() => "汽油";
}

我们打印出来一下这3种交通工具的运输方式方法

void main() {
  Bicycle().transport();
  Sedan().transport();
  Motorcycle().transport();
}

打印如下

Bicycle:
动力组件: 两个轮子 > 安全指数： low > 动力来源：全靠腿登
Sedan:
动力组件: 四个轮子 > 安全指数： middle > 动力来源：汽油
Motorcycle:
动力组件: 两个轮子 > 安全指数： low > 动力来源：汽油

上面的代码中，Bicycle和Motorcycle的动力组件一样是两个轮子，安全指数都是low。
而Sedan和Motorcycle的动力来源一样是汽油，总结如下表

相同类	相同的实现
Bicycle&Motorcycle	twoWheel()</br>lowSafetyIndex()
Sedan&Motorcycle	gasolineEnergy()

我们可以发现这3个类，3个方法都是可复用的。在一些单继承的语言里，只能利用多实现去复用这部分的代码，
而在Dart中，是可以多继承的，不需要为了实现而多写一些冗余的代码。

extends 与 with

同绝大部分的面向对象语言，在Dart中继承一个超类使用extends关键字。
在上面的交通工具例子中，根据动力组件，安全系数和动力来源可以封装出来以下六个类

//双轮交通工具
class TwoWheelTransportation {
  String powerUnit() => "两个轮子";
}

//汽油能源交通工具
class GasolineEnergyTransportation {
  String energy() => "汽油";
}

//四轮交通工具，一般来说安全性能为中
class FourWheelTransportation {
  String powerUnit() => "四个轮子";

}

//安全指数中等的交通工具儿
class MiddleSafetyIndex{
  String safetyIndex() => "middle";
}

//安全指数低的交通工具儿
class LowSafetyIndex{
  String safetyIndex() => "low";
}

//人力发动机
class BodyEnergyTransportation {
  String energy() => "全靠腿登";
}

然后将Bicycle、Motorcycle、Sedan类的代码改成一下模样

class Bicycle extends Transportation
    with TwoWheelTransportation, BodyEnergyTransportation, LowSafetyIndex {
  @override
  void transport() {
    print(
        "Bicycle:\n动力组件: ${powerUnit()} > 安全指数： ${safetyIndex()} > 动力来源：${energy()}");
  }
}

class Motorcycle extends Transportation
    with TwoWheelTransportation, GasolineEnergyTransportation, LowSafetyIndex {
  @override
  void transport() {
    print(
        "Motorcycle:\n动力组件: ${powerUnit()} > 安全指数： ${safetyIndex()} > 动力来源：${energy()}");
  }
}

class Sedan extends Transportation
    with
        GasolineEnergyTransportation,
        FourWheelTransportation,
        MiddleSafetyIndex {
  @override
  void transport() {
    print(
        "Sedan:\n动力组件: ${powerUnit()} > 安全指数： ${safetyIndex()} > 动力来源：${energy()}");
  }
}

打印结果也是相同

Bicycle:
动力组件: 两个轮子 > 安全指数： low > 动力来源：全靠腿登
Sedan:
动力组件: 四个轮子 > 安全指数： middle > 动力来源：汽油
Motorcycle:
动力组件: 两个轮子 > 安全指数： low > 动力来源：汽油

以上的写法，省略了相同的safetyIndex方法、powerUnit方法和energy方法的重复代码，便于维护。
再举个栗子，例如有个大兴趣发明家发明了一辆四轮的，动力全靠腿蹬的、低安全性的木质汽车。
在抽象这个WoodenSedan的时候，外观最接近的应该是Sedan类，先让WoodenSedan继承Sedan类，打印结果如下

class WoodenSedan extends Sedan {
  @override
  void transport() {
    print(
        "WoodenSedan:\n动力组件: ${powerUnit()} > 安全指数： ${safetyIndex()} > 动力来源：${energy()}");
  }
}
WoodenSedan:
动力组件: 四个轮子 > 安全指数： middle > 动力来源：汽油

这个时候，如果是在Java中就需要以多实现的方式去重写safetyIndex和energy方法了。而Dart中只需要使用with关键字在extends后面添加超类，就可以继承safetyIndex和energy方法了

class WoodenSedan extends Sedan with LowSafetyIndex,BodyEnergyTransportation{
  @override
  void transport() {
    print(
        "WoodenSedan:\n动力组件: ${powerUnit()} > 安全指数： ${safetyIndex()} > 动力来源：${energy()}");
  }
}
WoodenSedan:
动力组件: 四个轮子 > 安全指数： low > 动力来源：全靠腿登

但是，当一个子类所继承的不同超类拥有相同签名的方法的时候，子类实际使用的方法跟超类的位置有关系。

with的顺序问题与implements

with的顺序问题
虽说with的写法很方便，但是还是有一些问题需要注意的。如果2个或多个超类拥有相同签名的A方法，那么子类会以继承的最后一个超类中的A方法为准。当然这是子类没有重写A方法的前提下，如果子类自己重写了A方法则以本身的A方法为准。
可参照上述例子的打印结果
```
class WoodenSedan extends Sedan with LowSafetyIndex,GasolineEnergyTransportation,BodyEnergyTransportation{
  @override
  void transport() {
    print(
        "WoodenSedan:\n动力组件: ${powerUnit()} > 安全指数： ${safetyIndex()} > 动力来源：${energy()}");
  }
}
WoodenSedan:
动力组件: 四个轮子 > 安全指数： low > 动力来源：全靠腿登
```
WoodenSedan类继承了汽油动力类和体力动力类，但是由于BodyEnergyTransportation位置比GasolineEnergyTransportation靠右，所以实际其作用的还是BodyEnergyTransportation的方法。
implements：不同于with的直接继承。implements要求子类必须拥有所继承超类中的所有方法，我们可以将直接认为是Java中的implements关键字。
如果将上述WoodenSedan继承多个类的关键字改为implements打印结果如下
```
class WoodenSedan extends Sedan implements LowSafetyIndex,GasolineEnergyTransportation,BodyEnergyTransportation{
  @override
  void transport() {
    print(
        "WoodenSedan:\n动力组件: ${powerUnit()} > 安全指数： ${safetyIndex()} > 动力来源：${energy()}");
  }
}
WoodenSedan:
动力组件: 四个轮子 > 安全指数： middle > 动力来源：汽油
```
动力来源超类和安全属性超类的方法都不起作用了，取而代之的是Sedan超类中的方法被打印。如果WoodenSedan不继承Sedan超类，则会编译报错

总结

implements多用于强调需要重写的场合，而extends与with则多是为了直接继承。在编码过程中，区分好他们implements和with的关系也能使得代码更加易于阅读与维护

感谢一下文章作者的无私分享，排名不分前后
参考文章
 参考文章
 参考文章