第8章 Dart面向对象 -- 类的继承与混入(Mixin)

作者: yangsg | 来源:发表于2019-05-19 09:27 被阅读16次

继承(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类图

第8章 Dart面向对象 -- 类的继承与混入(Mixin)

1. Dart中的继承

2. 函数重写

3. 操作符重写

4. 抽象类

5. 接口

6. 泛型继承

7. 混入(mixin)

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

IT@程序员猿媛