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
    }
  }