08Dart 抽象类和接口

本篇从大地老师《Dart 入门实战教程》学习整理而来。

抽象类

Dart中抽象类: Dart抽象类主要用于定义标准，子类可以继承抽象类，也可以实现抽象类接口。

抽象类通过 abstract 关键字来定义。
Dart中的抽象方法不能用 abstract 声明，Dart中没有方法体的方法我们称为抽象方法。
如果子类继承抽象类必须得实现里面的抽象方法。
如果把抽象类当做接口实现的话必须得实现抽象类里面定义的所有属性和方法。
抽象类不能被实例化，只有继承它的子类可以。

extends 抽象类和 implements 的区别：

如果要复用抽象类里面的方法，并且要用抽象方法约束自类的话我们就用extends继承抽象类
如果只是把抽象类当做标准的话我们就用implements实现抽象类

abstract class Animal {
  eat(); //抽象方法
  run(); //抽象方法
  printInfo() {
    print('我是一个抽象类里面的普通方法');
  }
}
class Dog extends Animal {
  @override
  eat() {
    print('小狗在吃骨头');
  }

  @override
  run() {
    // TODO: implement run
    print('小狗在跑');
  }
}

main() {
  Dog d = new Dog();
  d.eat(); // 小狗在吃骨头
  d.printInfo(); // 我是一个抽象类里面的普通方法

  // Animal a=new Animal();   // 抽象类没法直接被实例化
}

多态

允许将子类类型的指针赋值给父类类型的指针, 同一个函数调用会有不同的执行效果。
子类的实例赋值给父类的引用。
多态就是父类定义一个方法不去实现，让继承他的子类去实现，每个子类有不同的表现。

abstract class Animal{
  eat();   //抽象方法 
}

class Dog extends Animal{
  @override
  eat() {
     print('小狗在吃骨头');
  }
  run(){
    print('run');
  }
}
class Cat extends Animal{
  @override
  eat() {   
    print('小猫在吃老鼠');
  }
  run(){
    print('run');
  }
}

main(){
  Animal d=new Dog();
  d.eat(); // 小狗在吃骨头

  Animal c=new Cat();
  c.eat(); // 小猫在吃老鼠
}

接口

首先，dart的接口没有interface关键字定义接口，而是普通类或抽象类都可以作为接口被实现。
同样使用implements关键字进行实现。

但是dart的接口有点奇怪，如果实现的类是普通类，会将普通类和抽象中的属性的方法全部需要覆写一遍。
而因为抽象类可以定义抽象方法，普通类不可以，建议使用抽象类定义接口。

/* 
案例 定义一个DB库 支持 mysql  mssql
mysql  mssql 类里面都有同样的方法
*/ 
abstract class Db{   //当做接口   接口：就是约定 、规范
    late String uri;      //数据库的链接地址
    add(String data);
    save();
    delete();
}
// Mysql
class Mysql implements Db{
  @override
  String uri;

  Mysql(this.uri);

  @override
  add(data) {
    print('这是mysql的add方法'+data);
  }

  @override
  delete() {
    return null;
  }

  @override
  save() {
    return null;
  }
  // 子类自己的方法
  remove(){}
}
// MsSql 
class MsSql implements Db{
  @override
  late String uri;
  @override
  add(String data) {
    print('这是mssql的add方法'+data);
  }

  @override
  delete() {
    return null;
  }

  @override
  save() {
    return null;
  }
}

main() {
  Mysql mysql = new Mysql('xxxxxx');
  mysql.add('mysql'); // 这是mysql的add方法mysql

  MsSql myssl = new MsSql();
  myssl.add('myssl'); // 这是mssql的add方法myssl
}

实现多个接口

使用 implements 一个类实现多个接口

abstract class A {
  late String name;
  printA();
}

abstract class B {
  printB();
}

class C implements A, B {
  @override
  late String name;
  @override
  printA() {
    print('printA');
  }

  @override
  printB() {
    print('printB');
  }
}

void main() {
  C c = new C();
  c.printA(); // printA
  c.printB(); // printB
}

mixins

在 Dart 中本不可以实现多继承，利用 mixins 可实现类似多继承的功能。

因为mixins使用的条件，随着Dart版本一直在变，这里讲的是Dart2.x中使用mixins的条件：

作为mixins的类只能继承自Object，不能继承其他类。
作为mixins的类不能有构造函数。
一个类可以mixins多个mixins类。
mixins绝不是继承，也不是接口，而是一种全新的特性。

mixins 的实现

class A {
  String info="this is A";
  void printA(){
    print("A");
  }
}

class B {
  void printB(){
    print("B");
  }
}

class Person {
  String name;
  num age;
  Person(this.name, this.age);
  printInfo() {
    print('${this.name}----${this.age}');
  }

  void run() {
    print("Person Run");
  }
}

// 使用 with 关键字实现 mixins
class C with A,B{}

// 既继承自 Person 又 mixins A 和 B，with 后跟的类有顺序之分，后类的方法会覆盖前类的方法
class D extends Person with A, B {
  C(String name, num age) : super(name, age);
}

void main(){
  var c=new C();  
  c.printA(); // A
  c.printB(); // B
  print(c.info); // this is A

  var D = new C('张三', 20);
  D.printInfo(); // 张三----20
  D.run(); // B Run
}

mixins 的类型

mixins的类型就是其超类的子类型。

class A {
  String info="this is A";
  void printA(){
    print("A");
  }
}

class B {
  void printB(){
    print("B");
  }
}

class C with A,B{}

void main(){  
   var c=new C();  
   
  print(c is C);    //true
  print(c is A);    //true
  print(c is B);    //true

  var a=new A();
  print(a is Object); //true
}