extends implements Minxin

Abstract

Abstract被用于定义一个抽象类，用Abstract修饰的class是无法被实例化的，可以当做抽象类来 extends 也可以当做接口来 implements，dart 中没有 interface 这个关键字，接口也是抽象类实现的

abstract的类中的方法可以有方法体，也可以没有

用作抽象类 继承

abstract class Animal {
  speak(); // 抽象方法  必须实现
  printInfo() {  // 不需要实现
    print('not abstract method');
  }
}

class Dog extends Animal {
  @override
  speak() {
    print('wang!');
  }
}

class Cat extends Animal {
  @override
  speak() {
    print('miao');
  }
  
}

void main() {
  print('---------抽象类------------');
  Dog d = new Dog();
  Cat c = new Cat();
  d.speak();
  d.printInfo();
  c.speak();
  c.printInfo();
}

用作抽象类 接口 实现

@override 可不写，用作接口 implements，Test类的方法在Mysql类里要全部实现，要不会报错，
包括DB的实例变量也要重写，因为实例变量会自动生成setter getter 方法

abstract class Test {
  String host;
  String port;
  String user;
  String pass;
  test1(String data);
  test2(String data);
  test3(String data);
  test4(String data);
}

class Mysql implements DB {
  @override
  String host;

  @override
  String pass;

  @override
  String port;

  @override
  String user;

  Mysql(this.host, this.user, this.pass, [this.port = '3306']) {
    print(
        '[ok] connect to ${this.host}:${this.port}, use ${this.user}:${this.pass}');
  }

  @override
  test4(String data) {
    print('delete ${data}');
  }

  @override
  test3(String data) {
    print('insert ${data}');
  }

  @override
  test2(String data) {
    print('query ${data}');
  }

  @override
  test1(String data) {
    print('update ${data}');
  }
}

void main() {
  print('---------接口------------');
  Mysql my = new Mysql('127.0.0.1', 'root', '123456', '3307');
  my.test1('121');
  my.test2('121');
  my.test3('121');
  my.test4('121');
}

继承 extends

Flutter中的继承是单继承

• 子类使用extends关键词来继承父类
• 子类会继承父类里面可见的属性和方法 但是不会继承构造函数
• 子类能复写父类的方法 getter和setter
• 子类重写超类的方法，要用@override ,也可不用
• 子类调用超类的方法，要用super
• 子类可以继承父类的非私有变量

class Person {
  //公有变量
  String name; 
  num age; 
  //私有变量
  String _gender;
  //类名构造函数
  Person(this.name,this.age);
  //公有的方法
  void printInfo() {
    print("${this.name}---${this.age}");  
  }

  work(){
    print("${this.name}在工作...");
  }
}

class Web extends Person{
　Web(String name, num age) : super(name, age);
  run(){
    print('run');
    super.work();  //自类调用父类的方法
  }

  //覆写父类的方法
  @override       //可以写也可以不写  建议在覆写父类方法的时候加上 @override 
  void printInfo(){
     print("姓名：${this.name}---年龄：${this.age}"); 
  }
}

main(){ 
  Web w=new Web('李四',20);
  // w.printInfo();
  w.run();
}

接口实现(implements)

Flutter是没有interface的，但是Flutter中的每个类都是一个隐式的接口，这个接口包含类里的所有成员变量，以及定义的方法。如果有一个类 A,你想让类B拥有A的API，但又不想拥有A里的实现，那么你就应该把A当做接口，类B implements 类A

如果你被实现的类不是用abstract 修饰，那么被修饰的类的方法也要写实现，要不然会报错

所以在Flutter中:class 就是 interface

• 当class被当做interface用时，class中的方法就是接口的方法，必须需要在子类里重新实现，在子类实现的时候要加@override(也可不加)

• 当class被当做interface用时，class中的成员变量也需要在子类里重新实现。在成员变量前加@override

如果一个类既有继承又有实现，那么extends要写在 implements前面，要不然会报错

混合 mixins (with)

mixin用于修饰类，和abstract类似，该类可以拥有成员变量、普通方法、抽象方法，但是不可以实例化。mixin一般用于描述一种具有某种功能的组块，而某一对象可以拥有多个不同功能的组块

举个例子，我们有一种能力是 '绘画'，而拥有这种能力的是 ‘教师’，那么实现如下：

mixin DrawFunc {
  
  String content = '..';
  
  String what();
    
  void draw() {
    print('I can draw ${what()}');  
  }
  
}

class Teacher with DrawFunc {
  
  String what() => "car";
  
}

void main() {
  Teacher().draw();
}

我们限定了 '绘画' 这种能力只能够用在 '人类' 上面，示例如下

class Person {}

mixin DrawFunc on Person {
  
  String content = '..';
  
  String what();
    
  void draw() {
    print('I can draw ${what()}');  
  }
  
}

class Teacher extends Person with DrawFunc {
  
  String what() => "car";
  
}

void main() {
  Teacher().draw();
}

当我们在mixin上使用了on关键字，那么mixin只能在那个类的子类上使用，而mixin可以调用那个类的方法

mixin是将一些有共同特性的类抽出来共用，把具体的特性封装成一个mixin供其他类使用。本质上是为了减少代码冗余。而implement也能实现这种功能，但是继承自implement的子类需要完全重写父类的所有属性与方法，这就造成了很多不必要的代码冗余

• mixin在定义时可以使用on关键字指定使用范围

• 当多个mixin函数一样时，后一个mixin会覆盖前面一个（线性特征）

• with关键字能够实现mixin,可以想象成多继承，而且是以类似于栈的形式实现，同一方法调用最外边的

• mixin可以实现蕾丝多重继承的功能，但是多重继承中相同函数执行并不会存在父子关系

• mixin实现了一条继承链，声明的顺序代表了继承的顺序，声明在后面的mixin会最先执行

• 如果with后面跟多个，且有同名方法，则以最后一个为准，如class AB extends P with A, B {}如果A、B有同名方法，则AB使用的是B的方法。如果mixin和extends中有同名方法，最终使用的是mixin中的

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

如果三个一起用

class Extends {
  
  void log() {
    print('extends');
  }
  
}

mixin Mixins {
  
  void log() {
    print('mixin');
  }
  
}

mixin Mixins2 {
  
  void log() {
    print('mixin2');
  }
  
}

class Implements {
  
  void log() {
    print('implements');
  }
  
}

class Log extends Extends with Mixins, Mixins2 implements Implements {}

void main() {
  Log().log();
}

输出结果

mixin2

这里我们发现了一个奇怪的现象：虽然我们加上了implements，但是Dart居然没让我们实现Implements.log()方法也不报错，

这是因为在这种情况下，它识别到我们从with和extends中获得了log()方法的能力，因此调用的是Mixins2.log()。

假如我们对Implements#log方法进行实现：

class Log extends Extends with Mixins, Mixins2 implements Implements {
  
  void log() {
    print("implements log");
  }
}

输出的结果为

implements log

这三种关系可以同时存在，但是有着前后顺序：extends > mixins >implements,必须是extends在最前面 mixins在中间 implements在后面