第8章 Dart面向对象 -- 类的继承与混入(Mixin)
继承(extends)是面向对象开发方法中非常重要的一个特征，继承体现着现实世界中“一般”与“特殊”的关系。对于拥有“一般”性质的类我们称之为“父类”或者“超类”，拥有“特殊”性质的类我们称之为“子类”。比如“动物”和“鸟”，动物是一般的概念，鸟是特殊的概念，可以通过“鸟是一种特殊的动物”这句话逻辑是否成立来判断继承关系是否成立。
1. Dart中的继承
与Java语言类似，Dart语言标榜自己为“单继承”，也就是一个类只能有一个直接的父类。如果一个类没有显式地声明父类，那么它会默认继承Object类。此外Dart语言又提供了混入（Mixin）的语法，允许子类在继承父类时混入其他类。关于混入（Mixin）的理解，请参照本章第7节的内容理解。
Dart语言中使用extends作为继承关键字，子类会继承父类的数据和函数。
示例代码：猫类继承动物类
main() {
var a = new Animal();
var b = new Cat();
a.name = "动物";
b.name = "猫";
b.color = "黑色";
a.eat();
b.eat();
b..climb();
}
class Animal{
String name;
void eat(){
print("${name}:进食");
}
}
class Cat extends Animal{
String color;
void climb(){
print("${color}的${name}:爬树");
}
}
运行结果
运行结果
2. 函数重写
重写在面向对象中体现的现实意义是“子类与父类在同一行为上有不同的表现形式”。同Java语言类似，Dart语言也支持函数的重写，子类重写父类的函数后，对象调用的即为子类的同名函数。
演示示例：在第1节的例子的Cat类中重写Animal类的eat函数。
main() {
var a = new Animal();
var b = new Cat();
a.name = "动物";
b.name = "猫";
b.color = "黑色";
a.eat();
b.eat();
b..climb();
}
class Animal{
String name;
void eat(){
print("${name}:进食");
}
}
class Cat extends Animal{
String color;
@override
void eat(){//子类重写父类的eat方法
print("${color}的${name}:吃鱼");
}
void climb(){
print("${color}的${name}:爬树");
}
}
运行结果
运行结果
3. 操作符重写
同C++语言类似，Dart语言支持操作符的重写，常规的四则运算和比较运算符都可以进行重写，其中只有!=不可重写，a!=b相当于!(a==b)的语法糖。
示例代码：
重写了==和+的Rectangle类，当两个对象的width和height一致认为它们是“相等”的，两个Rectangle相加则将两者的width和height进行相加后得到新的Rectangle对象
main() {
var a = new Rectangle(10,10);
var b = new Rectangle(5, 5);
var c = new Rectangle(10, 10);
print(a == b);
print(a == c);
var d = a + b;
print("${a.width}:${a.height}");
print("${d.width}:${d.height}");
print(a == d);
}
class Rectangle{
int width;
int height;
Rectangle(this.width,this.height){}
@override
bool operator ==(dynamic other) {
if(other is! Rectangle){
return false;
}
Rectangle temp = other;
return (temp.width == width && temp.height == height);
}
@override
Rectangle operator +(dynamic other){
if(other is! Rectangle){
return this;
}
Rectangle temp = other;
return new Rectangle( this.width + temp.width, this.height + temp.height);
}
}
运行结果
运行结果
4. 抽象类
抽象abstract是面向对象中的一个非常重要的概念，通常用于描述父类拥有一种行为但无法给出细节实现，而需要通过子类来实现抽象的细节。这种情况下父类被定义为抽象类，子类继承父类后实现其中的抽象方法。
同Java语言类似，Dart中的抽象类也使用abstract来实现，不过抽象函数无需使用abstract，直接给出定义不给出方法体实现即可
抽象类中可以有数据，可以有常规函数，可以有抽象函数，但抽象类不能实例化。子类继承抽象类后必须实现其中的抽象函数。
演示示例：Dog类继承Animal抽象类
main(){
var d = new Dog();
d.name = "dog";
d.eat();
d.display();
}
abstract class Animal{
String name; //数据
void display(){ //普通函数
print("名字是:${name}");
}
void eat(); //抽象函数
}
class Dog extends Animal{
@override
void eat() { //实现抽象函数
print("eat");
}
}
运行结果
运行结果
5. 接口
Dart语言中没有接口（interface）的关键字，但是有实现（implements）关键字，Dart中可以将类（是否为抽象无关）当做隐式接口直接使用，当需要使用接口时，可以声明类来代替。（个人认为抽象类更适合对接口的理解）
演示示例：
在第4节的示例基础上，添加swimable类和walkable类作为接口使用，Dog类继承Animal类并实现swimable和walkable接口
main(){
var d = new Dog();
d.name = "dog";
d.eat();
d.display();
d.swim();
d.walk();
}
abstract class Animal{
String name;
void display(){
print("名字是:${name}");
}
void eat(); //抽象方法
}
abstract class swimable{ //抽象类作为接口
void swim();
}
class walkable{ //普通类作为接口
void walk(){}
}
class Dog extends Animal implements swimable, walkable{
@override
void eat() {
print("eat");
}
@override
void swim() {
print("swim");
}
@override
void walk() {
print("walk");
}
}
运行结果
运行结果
6. 泛型继承
上一章中，提到了泛型编程中的继承问题，在使用泛型编程时也可以使用extends关键字约束输入泛型的类型。
演示示例
被泛型约束的函数，当传入泛型int时，只能计算整数加法，且在声明对象x时泛型只能传入num类型及其子类
main(){
var a = 3;
var b = 3.14;
var c = 4;
var x = DataUtil<int>();
var f = x.addition(a, c);
print(f);
}
class DataUtil<T extends num>{
T addition(T a, T b){
return a+b;
}
}
运行结果：7
7. 混入(mixin)
本章节内容借鉴了简书用户Vadaski的文章【译】Dart | 什么是Mixin，在此对其表示感谢。
问题
我们来看下面这张关于动物（Animal），哺乳动物（Mammal），鸟（Bird）和鱼（Fish）的继承关系图
继承关系图
这里有一个名为Animal的超类，它有三个子类（Mammal，Bird和Fish）。在底部，我们有具体的一些子类。
小方块代表行为。例如，
- 黄色方块表示具有此行为的类的实例可以步行（walk）。
- 蓝色方块表示具有此行为的类的实例可以游泳（swim）。
- 灰色方块表示具有此行为的类的实例可以飞行（fly）。
有些动物有共同的行为：猫(Cat)和鸽子(Dove)都可以行走，但是猫不能飞。
这些行为与此分类正交，因此我们无法在超类中实现这些行为。
在Java语言中我们可以借助接口（Interface）来实现相关的设计，Dart中也可以利用隐式接口来完成相应的设计。
如果不同的子类在某种行为上表现的都不相同，那么使用接口来实现设计是一种良好的设计。
但如果不同的子类在实现某种行为上有着同样的表现，那么使用接口来实现设计可能会造成代码的冗余。（接口实现强制重写函数）
所以除了上述两种方式，我们也可以利用混入方式（Mixin）来完成相应的设计
实现
对三种行为分别定义三个类描述它们，分别是Walker，Swimmer和Flyer
class Walker {
void walk() {
print("I'm walking");
}
}
class Swimmer {
void swim() {
print("I'm swimming");
}
}
class Flyer{
void fly() {
print("I'm flying");
}
}
如果不想这三个类被实例化，可以使用抽象类+工厂方式定义
abstract class Walker {
factory Walker._() => null;
void walk() {
print("I'm walking");
}
}
使用混入的关键字是with，它的后面可以跟随一个或多个类名
class Cat extends Mammal with Walker {}
class Dove extends Bird with Walker, Flyer {}
使用时允许Cat和Dove调用Mixin的walk函数，不允许Cat调用未Mixin的Fly函数
main(){
Cat cat = Cat();
Dove dove = Dove();
cat.walk();
dove.walk();
dove.fly();
}
理解
如果Mixin的类和继承类，或者混入的类之间有相同的方法，在调用时会产生什么样的情况，看下面的例子。
演示示例
AB和BA类都使用A和B Mixin继承至P类，但顺序不同。A，B和P类都有一个名为getMessage的方法。
class A {
String getMessage() => 'A';
}
class B {
String getMessage() => 'B';
}
class P {
String getMessage() => 'P';
}
class AB extends P with A, B {}
class BA extends P with B, A {}
void main() {
String result = '';
AB ab = AB();
result += ab.getMessage();
BA ba = BA();
result += ba.getMessage();
print(result);
}
运行结果： BA
为什么会产生这个结果？
Dart中的Mixins通过创建一个新类来实现，该类将mixin的实现层叠在一个超类之上以创建一个新类 ，它不是“在超类中”，而是在超类的“顶部”，因此如何解决查找问题不会产生歧义。
— Lasse R. H. Nielsen on StackOverflow.'
实际上，这段代码
class AB extends P with A, B {}
class BA extends P with B, A {}
在语义上等同于
class PA = P with A;
class PAB = PA with B;
class AB extends PAB {}
class PB = P with B;
class PBA = PB with A;
class BA extends PBA {}
最终的继承关系如下图所示
继承关系
很显然，最后被继承的类重写了上面所有的getMessage方法，可以理解为处于Mixin结尾的类将前面的getMessage方法都覆盖（override）掉了
mixin应用程序实例的类型是什么？
通常，它是其超类的子类型，也是mixin名称本身表示的类的子类型，即原始类的类型。
— dartlang.org
所以这意味着这个程序的运行结果全部为true
class A {
String getMessage() => 'A';
}
class B {
String getMessage() => 'B';
}
class P {
String getMessage() => 'P';
}
class AB extends P with A, B {}
class BA extends P with B, A {}
void main() {
AB ab = AB();
print(ab is P); //true
print(ab is A); //true
print(ab is B); //true
BA ba = BA();
print(ba is P); //true
print(ba is A); //true
print(ba is B); //true
}
最后
完整的实现示例
abstract class Animal {}
abstract class Mammal extends Animal {}
abstract class Bird extends Animal {}
abstract class Fish extends Animal {}
abstract class Walker {
factory Walker._() => null;
void walk() {
print("I'm walking");
}
}
abstract class Swimmer {
factory Swimmer._() => null;
void swim() {
print("I'm swimming");
}
}
abstract class Flyer {
factory Flyer._() => null;
void fly() {
print("I'm flying");
}
}
class Dolphin extends Mammal with Swimmer {}
class Bat extends Mammal with Walker, Flyer {}
class Cat extends Mammal with Walker {}
class Dove extends Bird with Walker, Flyer {}
class Duck extends Bird with Walker, Swimmer, Flyer {}
class Shark extends Fish with Swimmer {}
class FlyingFish extends Fish with Swimmer, Flyer {}
Mixin类图
Mixin类图
