关键词
-
class：类，可以新建实例，可以被extends、implements、mixin； -
abstract：抽象类，在Java，C++中都是接口抽象类，可以定义属性和虚函数，等着实现类去实现定义的方法。相当于Swift和OC的protocol,Swift里可以使用extension实现默认方法，但是在Dart里抽象类可以直接默认实现方法和属性，只是不能新建实例类。 -
mixin：通过创建一个继承自 Object 且没有构造函数的类，来 实现 一个 Mixin 。 如果 Mixin 不希望作为常规类被使用，使用关键字 mixin 替换 class 。
关系
- 继承：通过关键字
extends； - 接口实现：通过关键字
implements； - 混入
mixins：通过关键字with；
这三种关系可以同时存在，但是有前后顺序：
extends -> mixins(with) -> implements
extens在前，mixins在中间，implements最后；
继承（extends）
Dart中的继承是单继承，具体继承规则：
- 子类使用
extends关键词来继承父类； - 子类会继承父类里面可见的属性和方法 但是不会继承构造函数；
- 子类能复写父类的方法
getter和setter； - 子类重写超类的方法，要用
@override； - 子类调用超类的方法，要用
super； - 子类可以继承父类的非私有变量（对Dart来说，指的是非下划线
_开头） ；
举个简单的栗子：
class Extends {
void base() {
print('base');
}
void log() {
print('extends');
}
}
class Log extends Extends {
log() {
print('log');
}
}
void main() {
Log().base();
Log().log();
}
输出结果：
base
log
接口实现（implements）
implements与extends最大的不同就是允许后面接上多个普通或者抽象类，当我们使用B implement A修饰时，那么A中的所有的属性和方法都要在A中实现，无论它原来是抽象方法还是普通方法。
也就是说如果我们只想要A中的接口定义，而不想要它的实现，那么就试用implements。
class Implements {
void base() {
print('base');
}
void log() {
print('extends');
}
}
class Log implements Implements {
base() {
print('log#base');
}
log() {
print('log');
}
}
void main() {
Log().base();
Log().log();
}
输出结果：
log#base
log
混入（mixin）
mixin用于修饰类，和abstract类似，该类可以拥有成员变量、普通方法、抽象方法，但是不可以实例化。mixin一般用于描述一种具有某种功能的组块，而某一对象可以拥有多个不同功能的组块。
简单应用
最简单的mixin由mixin & with关键字组成。
举个例子，我们有一种能力是 '绘画'，而拥有这种能力的是 ‘教师’，那么实现如下：
mixin DrawFunc {
String content = '..';
String what();
void draw() {
print('I can draw ${what()}');
}
}
class Teacher with DrawFunc {
String what() => "car";
}
void main() {
Teacher().draw();
}
限定类型（mixin ... on）
我们限定了 '绘画' 这种能力只能够用在 '人类' 上面，示例如下：
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可以调用那个类的方法。
多个类型
在 '绘画' 的基础上，我们增加一种新的能力 '唱歌'，示例如下：
class Person {}
mixin DrawFunc on Person {
String content = '..';
String what();
void draw() {
print('I can draw ${what()}');
}
}
mixin SingFunc on Person {
void sing() {
print('I can sing');
}
}
class Teacher extends Person with DrawFunc, SingFunc {
String what() => "car";
}
void main() {
Teacher().draw();
Teacher().sing();
}
on的一种复杂变形
关于on还有一种复杂的变形，我们在 '唱歌' 上增加一条约束，要求它必须是在DrawFunc之上：
mixin SingFunc on Person, DrawFunc {
void sing() {
print('I can sing');
}
}
那么这时候，虽然Teacher没有extends DrawFunc，但是如下的代码仍然可以编译通过：
class Teacher extends Person with DrawFunc, SingFunc {
String what() => "car";
}
而我们交换一下DrawFunc和SingFunc的顺序就不行了：
class Teacher extends Person with SingFunc, DrawFunc {
String what() => "car";
}
提示信息是：
Error compiling to JavaScript:
main.dart:22:7:
Error: 'Person' doesn't implement 'DrawFunc' so it can't be used with 'SingFunc'.
- 'Person' is from 'main.dart'.
- 'DrawFunc' is from 'main.dart'.
- 'SingFunc' is from 'main.dart'.
class Teacher extends Person with SingFunc, DrawFunc {
^
Error: Compilation failed.
结论：要满足
on的要求，除了使用extends之外，还可以在with列表中，在它之前进行声明。在Flutter的WidgetsFlutterBinding中，就涉及到了这一点的运用。
abstract class BindingBase {}
mixin ServicesBinding on BindingBase {}
mixin SchedulerBinding on BindingBase, ServicesBinding {}
mixin RendererBinding on BindingBase, ServicesBinding {}
class WidgetsFlutterBinding extends BindingBase with ServicesBinding, SchedulerBinding, RendererBinding {}
Tips
在这上面，我们接触了几个新的概念mixin, on, with：
mixin：定义了组块。
on：限定了使用mixin组块的宿主必须要继承于某个特定的类；在mixin中可以访问到该特定类的成员和方法。
with：负责组合组块，而with后面跟的类并不一定需要是mixin的，abstract class和普通类都是可以的，这一点需要注意，例如下面这样：
class Person {}
mixin DrawFunc on Person {
String content = '..';
String what();
void draw() {
print('I can draw ${what()}');
}
}
mixin SingFunc on Person {
void sing() {
print('I can sing');
}
}
abstract class DanceFunc {
void dance() {
print('I can dance');
}
}
class Teacher extends Person with DrawFunc, SingFunc, DanceFunc {
String what() => "car";
}
void main() {
Teacher().draw();
Teacher().sing();
Teacher().dance();
}
冲突
如果同时存在extends, with，并且它们都定义了相同的方法名，那么结果如何呢？我们来看下面的例子：
class Extends {
void log() {
print('extends');
}
}
mixin Mixins {
void log() {
print('mixin');
}
}
mixin Mixins2 {
void log() {
print('mixin2');
}
}
class Log extends Extends with Mixins, Mixins2 {}
void main() {
Log().log();
}
输出结果：
mixin2
结论：
with修饰的会覆盖extends中修饰的同名方法。with列表中后一个的会覆盖之前的。
再来看一下加上了implements的情况：
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
以上，希望能让我们都有所收获～
喜欢我的可以关注收藏我的个人博客：Ro.bber