abstract

abstract修饰的类可以被用于extended、with和implemented，abstract的类中的方法可以有方法体，也可以没有，还可以有构造函数。当abstract修饰的类可以被用于extended的时候就可以使用到abstract类中有方法体的方法。用于with的时候不能有构造函数。

abstract class AbstractDemo {
  final String str;
  AbstractDemo(this.str);
  void printStr(){
    print(str);
    print('abstract');
  }
}

class TestClass extends AbstractDemo{
  TestClass(String str) : super(str);
}

TestClass('hello').printStr();
打印出以下结果
#flutter: hello
#flutter: abstract

abstract class AbstractDemo {
  void printStr(){
    print('abstract');
  }
}

class TestClass with AbstractDemo{
}

TestClass().printStr();
打印出以下结果
#flutter: abstract

class

class修饰的类可以被用于extended、with和implemented。用于with的时候不能有构造函数。

mixin

mixin在dart 2中的定义：https://github.com/dart-lang/language/blob/master/accepted/2.1/super-mixins/feature-specification.md#dart-2-mixin-declarations
mixin修饰的类只能被用于with，且不能有构造函数。

Mixin定义方法
mixin A on B, C implements D, E { body }

on给使用mixin的类添加了父类约束，使用该mixin的类必须extends on指定的类。如果mixin定义中使用了on，则怎mixin中可以使用super。如下例子，如果Mixin定义没有使用on ViewBase，则不能使用super.attach(s);
class Base {
void attach(String s) {
print("Base attach $s");
}
}

class ViewBase {
 void attach(String s) {
   print("Viewbase attach $s");
 }
}

mixin Mixin on ViewBase implements Base {
 @override
 void attach(String s) {
   super.attach(s);
  print("Mixin attach $s");
 }
}
接口B和C必须兼容。该on子句引入了一个综合接口，将B和组合在一起C，称为A$super，它等效于以下形式的类声明的接口：
abstract class A$super implements B, C {}。如果A$super类声明无效，则上面的mixin声明编译时错误。

上面A的mixin声明定义了一个接口（interface），此接口等效于下面的接口定义
abstract class A extends A$super implements D, E { body' }其中body'包含与A mixin 的body相对应的实例成员的抽象声明。
因此mixin也可被用于implements。且mixin定义的body中可以存在没有实体的方法（如void aa();）,如果存在，使用该mixin的类必须实现该方法。

如果on缺省，则等效于on Object

mixin和class一样允许有实例和静态成员，但当前不能有构造函数

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

class AAA {
  String a = 'aaa';
  prt(){
    print('aaa print');
  }
}

class BBB extends AAA {
  String b = 'bbb';
  prt(){
//可以使用super
    super.prt();
    print('bbb print');
  }
}

//AAA可以用abstract而不是class
class CCC implements AAA {
  //a和prt都必须实现
  String a = 'ccc';
  prt(){
//不能使用super
//     super.prt();
    print('ccc print');
  }
}

//AAA可以用mixin而不是class
class DDD with AAA {
  prt(){
//可以使用super
    super.prt();
    print('ddd print');
  }
}

实现原理举例：

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

继承层级如下图：

1_sayzomK1biB7iy5W8hrUSQ.png

Demo

class Base {
  int num = 0;
  void attach(String s) {
    print("Base attach $s");
  }
}

class ViewBase extends Base {
  void attach(String s) {
    print("Viewbase attach $s");
    super.attach(s);
  }
}

mixin Mixin on ViewBase {
  void attach(String s) {
    
    print("Mixin attach");
    super.attach(s);
  }
}

mixin Mixin2 on ViewBase {
  void attach(String s) {
    print("Mixin2 attach $s");
    super.attach(s);
  }
}

class View extends ViewBase with Mixin,Mixin2 {
  void attach(String str) {
    print("View attach $str");
    super.attach(str);
  }
}

void main() {
  new View().attach("me");
  // print(View().num);
}
//打印结果如下
View attach me
Mixin2 attach me
Mixin attach
Viewbase attach me
Base attach me

extends

继承，不需要实现父类的方法。如果子类不实现构造函数，在创建子类的时候，实际调用的是父类的构造函数

implements

实现接口，dart中每个类都是一个隐式接口。需要实现接口的所有方法

flutter extends implements mixin