Dart 类与对象 继承和抽象类

Dart 类与对象 -- 继承

根据类的先后顺序，可以将类分成父类和子类

子类通过 extends 关键字继承父类

  继承后，子类可以使用父类中可见的内容（属性或方法）

子类中，可以通过 @override 元数据来标记 “覆写” 方法

  “覆写”方法：子类中与父类中同名的方法

子类中，可以通过 super 关键字来引用父类中可见的内容，包括：

  属性

  方法（普通构造函数，命名构造函数）

// 父类
class Animal {
  String name;
  num legs;
  // 父类的私有属性
  num _salesPrice = 8000;

  // 父类的构造函数
  Animal(this.name, this.legs);

  // 父类的命名构造函数
  Animal.init() {
    name = '哈士奇';
    legs = 4;
  }

  // 父类的方法
  say() {
    print('My name is $name, I have $legs legs.');
  }

  // 父类的 getter 返回类的私有属性
  num get getPrice {
    return this._salesPrice;
  }
}

import 'Animal.dart';

// 子类
class Dog extends Animal {
  // 子类构造器（通过初始化列表）
  // 通过 super 继承父类的普通构造函数
  Dog(String name, int legs) : super(name, legs);

  // 继承父类的命名构造函数
  Dog.init() : super.init();

  // 子类的同名方法（@override 元数据可用可不用，但是建议使用，语义化更好）
  @override
  say() {
    // 通过 super 关键字访问父类的可见成员
    super.say();

    // super._salesPrice; // 错误：super 不能访问父类的私有成员
    print('我的名字叫 $name');
  }
}

import 'lib/Animal.dart';
import 'lib/Dog.dart';

void main() {
  Animal duck = new Animal('小鸭', 2);
  duck.say(); // My name is 小鸭, I have 2 legs.

  // 不能直接访问类的私有属性，只能通过 getter 访问
  print(duck.getPrice); // 8000

  Dog dog = new Dog('阿奇', 4);
  dog.say();
  // My name is 阿奇, I have 4 legs.
  // 我的名字叫 阿奇

  // 不能直接访问父类的私有属性，只能通过 getter 访问
  print(dog.getPrice); // 8000

  // 通过父类的命名构造函数实例化一个对象
  Dog xiaogou = new Dog.init();
  print(xiaogou.name); // 哈士奇
  print(xiaogou.legs); // 4
}

 Dart 只能单继承，不能同时继承多个父类

// Error: Each class definition can have at most one extends clause
class Student extends Person, Animal {

}

Dart 类与对象 -- 抽象类

抽象类是用 abstract 关键字修饰的类

作用：充当普通类的模板，约定一些必要的属性和方法

抽象方法是指没有方法体的方法：

（1）、抽象类中一般都有抽象方法，也可以没有抽象方法

（2）、普通类中，不能有抽象方法

抽象类不能被实例化（不能被 new）

抽象类可以被普通类继承 （extends）

  如果普通类继承抽象类，必须实现抽象类中的所有抽象方法

抽象类还可以充当接口被实现（implements）

  如果把抽象类当作接口来实现，普通类必须实现抽象类中定义的所有属性和方法

// 1、抽象类，必须通过 abstract 关键字声明
// 2、抽象类中，可以有抽象方法，也可以没有。一般来说，抽象类都还是会有抽象方法的
abstract class Phone {
  // 声明抽象方法
  void processor(); // 手机的处理器

  void camera(); // 手机的摄像头

  // 声明普通方法
  void info() {
    print('来自抽象类中的普通方法');
  }
}

class Xiaomi extends Phone {
  // 普通类继承了抽象类，就必须实现抽象类中的所有抽象方法
  @override
  void processor() {
    print('骁龙888');
  }

  @override
  void camera() {
    print('三星摄像头');
  }

  // 普通类中，不能有抽象方法
  // void info(); // 错误
}

class Huawei extends Phone {
  @override
  void processor() {
    print('麒麟990');
  }

  @override
  void camera() {
    print('徕卡摄像头');
  }
}

void main() {
  // 抽象类，不能被实例化
  // Phone p = new Phone();

  Huawei p30 = new Huawei();
  p30.processor(); // 麒麟990
  p30.camera(); // 徕卡摄像头
  p30.info(); // 来自抽象类中的普通方法
}