Dart入门面向对象编程二

继承

• 使用关键字extends继承一个类
• 子类会继承父类可见的属性和方法，不会继承构造方法
• 子类能够复写父类的方法、getter和setter
• 单继承，多态性

父类：

class Person {
  String name;
  int age;
  String _gender;
  bool get isAdult => age > 18;
  set aAge(int age) {
    this.age = age;
  }
  void run() {
    print('Person class run');
  }
}

子类：

class Student extends Person {

  ///重写父类getter方法
  @override
  bool get isAdult {
    return this.age > 10;
  }
  ///重写父类setter方法
  @override
  set aAge(int age) {
    this.age = age * 10;
  }
  ///重写父类方法
  @override
  void run() {
    print('Student run...');
  }
  void study() {
    print('Student study...');
  }
}

调用：

void test() {
  var student = Student();
  student.age = 11;
  student.aAge = 10;
  student.name = 'Robin';
  print(student.age); // 100
  print(student.isAdult); // true
  print(student.name); // Robin
  student.run(); // Student run...
  
  Person person = Student(); // 多态
  if (person is Student) {
    person.study(); // Student study...
  }
}

继承中的构造方法

• 子类的构造方法默认会调用父类的无名无参构造方法

  class SupClass {
      SupClass() {
          print('SupClass');
      }
  }
  class SubClass extends SupClass {}
  void test() => SubClass(); // 会打印 SupClass
  

• 如果父类没有无名无参的构造方法，则需要显示调用父类的构造方法

• 在构造方法参数后面使用冒号：显示调用父类构造方法

  class SupClass {
      String name;
      SupClass(this.name);
      SupClass.withName(this.name);
  }
  class SubClass extends SupClass {
      SubClass(String name) : super(name);
      // SubClass(String name) : super.withName(name);
      // SubClass.withName(String name) : super(name);
  }
  
  void test() {
      var sub = SubClass('Robin');
      print(sub.name); // Robin
  }
  

构造方法执行顺序

• 父类的构造方法在子类构造方法体开始执行的位置调用（初始化列表）

• 如果有初始化列表，初始化列表会在父类构造方法之前执行

  class SupClass {
    String name;
    SupClass(this.name);
  }
  class SubClass extends SupClass {
    final String isa;
    /// 初始化列表必须写在父类构造方法之前
    /// 初始化列表和父类构造方法之间用逗号分隔
    SubClass(String name,String isaa) : isa = isaa, super(name); 
  }
  

抽象类

• 抽象类使用 abstract 表示，不能直接被实例化

• 抽象方法不用 abstract 修饰，无实现

  abstract class AbstractClass {
    void abs();
  }
  

• 抽象类可以没有抽象方法

• 有抽象方法的类一定得声明为抽象类

• 通过继承来使用,抽象类更像是接口

  class SubAbstractClass extends AbstractClass {
    @override
    void abs() {
      // print
    }
  }
  

接口

• 类和接口是统一的，类就是接口

• 每个类都隐式的定义了一个包含所有实例成员的接口

• 如果是复用已有的类的实现，使用继承（extends）

• 如果只是使用已有类的外在行为，使用接口（implements）

  class Person {
    String name;
    int get age => 18;
    void run() {
      print('Person run...');
    }
  }
  
  class Student implements Person {
    @override
    String name;
  
    @override
    // TODO: implement age
    int get age => null;
  
    @override
    void run() {
      // TODO: implement run
    }
  }
  
  /// 利用抽象类的方式更像一个接口的用法
  abstract class SupPerson {
    void supRun();
  }
  
  class Runner implements SupPerson {
    @override
    void supRun() {
      // TODO: implement supRun
    }
  }
  
  

Mixins

• Mixins 类似于多继承，是在多类继承中重用一个类代码的方式

  必须先有extends才可以用with Mixin

  main(List args) {
    var d = D();
    d.isa = 'isa';
    d.a(); // 打印结果C.a()...  A、B、C中都有a()方法，最终打印的是C.a()这说明与Mixin的顺序有关，因C在B的后面
  }
  
  class A {
    String isa;
    void a() {
      print('A.a()...');
    }
  }
  
  class B {
    void a() {
      print('B.a()...');
    }
    void b() {
      print('B.b()...');
    }
  }
  
  class C {
    // C() {}
    void a() {
      print('C.a()...');
    }
    void b() {
      print('C.b()...');
    }
    void c() {
      print('C.c()...');
    }
  }
  
  class D extends A with B, C {
    void d() {
      print('D.d()...');
    }
  }
  

• 作为Mixin的类不能有显示声明构造方法（上面代码段中类C中的默认构造方法如果写出来的话，class D mixin就会显示有错误）

• 作为Mixin的类只能继承自Object 即不能有除了Object的其他继承（如果class C 继承在上面所说的Person class D也会报错）

• 使用关键字with连接一个或多个minxin

一个稍复杂的mixin例子：

abstract class Engine {
  void work();
}
class OilEngine implements Engine {
  @override
  void work() {
    print('Work with oil');
  }
}
class ElectricEngine implements Engine {
  @override
  void work() {
    print('Work with electric');
  }
}
class Tyre {
  String name;
  void run(){}
}
// 简写方式 前提是class Car没有其他属性或方法
class Car = Tyre with ElectricEngine; 
// 完整写法 可以添加属性或方法
class TCar extends Type with ElectricEngine {
  String name;
}
class Bus = Tyre with OilEngine;

操作符覆写/重载

• 覆写操作符需要在类中定义

  返回类型 operator 操作符（参数1，参数2，...）{
      实现体...
      return 返回值
  }
  
  

• 如果覆写 ==，还需要覆写对象的hashCode getter方法

可覆写的操作符:

<	+	|	[ ]
>	/	^	[ ]=
<=	~/	&	~
>=	*	<<	==
-	%	>>

main(List args) {
  var person1 = Person(18);
  var person2 = Person(18);
  // person1 > person2; // 未覆写：The operator '>' isn't defined for the class
  bool result = person1 > person2;
  print(result); // false
  person1.age;
  print(person1['age']); // 18
  print(person1 == person2); // 未覆写返回 false 覆写后返回：true
  
}

class Person {
  int age;
  Person(this.age);
  bool operator > (Person person) {
    return this.age > person.age;
  }
  int operator [] (String key) {
    if (key == 'age') {
      return this.age;
    } else {
      return 0;
    }
  }
  @override
  bool operator == (Object other) =>
      identical(this, other) || 
      other is Person &&
      runtimeType == other.runtimeType && 
      age == other.age;
  @override
  int get hashCode => age.hashCode;
}