Flutter 知识梳理 (Dart) - implements, extends, mixin 的理解

1、前言

在使用Java语言设计类之间关系的时候，咱们会接触到 组成单元 和 关系链接 这两类概念：

• 组成单元：普通类、abstract抽象类，interface接口。
• 关系链接：implements实现，extends继承。

而在Dart当中，对于这两类概念进行了增减：

• 组成单元：普通类，abstract抽象类、mixin。
• 关系链接：implements实现、extends继承、with混入。

最大的不一样有两点：

• 去掉了interface。
• 增长了混入的概念。

下面咱们就来看一下其中涉及到的知识点，前面两节对比一下Java和Dart的区别，最后着重介绍混入的概念。

推荐给你们一个网站：dartpad.dartlang.org/ 能够在线运行。

2、组成单元

2.1 普通类

Java和Dart的普通类有区别，可是不影响咱们设计类之间的关系，所以再也不赘述。

2.2 abstract 抽象类

Java和Dart的抽象类定义时大致是同样的，咱们能够在其中定义变量、普通方法、抽象方法，它和普通类最大的区别就是 抽象类不能实例化。

Java和Dart在使用抽象类时有一点不一样：Dart在定义抽象方法时，不须要用abstract修饰。

abstract class DartAbs {
  
  void absMethod();
  
}
复制代码

2.3 interface 接口

在Dart中，没有 interface 关键字。

顺带咱们复习一下Java中abstract和interface的一些要点：

• 抽象类和接口都不能被实例化。
• 抽象类要被子类继承，接口要被类实现。
• 接口只能作方法的声明，抽象类能够作方法的声明，也能够作方法的实现。
• 接口里定义的变量只能是公共的静态常量，抽象类中的变量能够是普通变量。
• 抽象类里的抽象方法必须所有被子类实现；接口的接口方法必须所有被子类实现，不然只能为抽象类。
• 抽象类里能够没有抽象方法。
• 若是一个类里有抽象方法，那么这个类只能是抽象类。
• 抽象方法要被实现，因此不能是静态的，也不能是私有的。
• 接口可继承接口，并可多继承接口，但类只能单继承。

3、关系链接

3.1 extends

Java和Dart中extends是一致的，只能够单继承，要注意的点是：

• 子类能够继承父类里面 可见的属性和方法。
  • 对于Java来讲，可见指的是非private修饰，
  • 对Dart来讲，指的是非下划线_开头。
• 子类调用父类的方法，使用super关键字。
• 子类不会 继承 父类的构造函数。

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
复制代码

3.2 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
复制代码

4、混入

前面咱们介绍的都是Java中接触过的概念，下面咱们来介绍Dart中特有的概念 - 混入。

4.1 mixin

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

(1) 最简单

最简单的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();
}
复制代码

(2) 限定类型

咱们限定了 '绘画' 这种能力只可以用在 '人类' 上面，示例以下：

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能够调用那个类的方法。

(3) 多个类型

在 '绘画' 的基础上，咱们增长一种新的能力 '唱歌'，示例以下：

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();
}
复制代码

(4) 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 {}
复制代码

(5) 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();
}
复制代码

4.2 冲突

若是同时存在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
复制代码

5、小结

梳理下来，有几点感想：

• 以前咱们设计中用到了interface的部分，能够采用只带有抽象方法的abstract class替换，并继续使用implements关键字。
• 理解mixin的概念，我是将它理解为一个个的功能组块：哪些宿主须要哪些功能，我就with到上去。
• on关键字一方面是为了限制组块的应用场景，也能够为多个组块提供公共的基础功能。

参考资料

• 【Dart学习】-- Dart 之 extends && implements && with的用法与区别
• Flutter 基础：理解 Dart 的 Mixin 继承机制
• Flutter mixin 用法详解