抽象类

抽象类有点像我们iOS中的协议，抽象类是不能被实例化的类，使用abstract修饰

  1. abstractDemo() {
  2.   AbstractClass cls = AbstractClass();
  3. }
  4. abstract class AbstractClass{
  5. }

image.png
在抽象类里面可以定义抽象方法，这里的抽象方法没有实现。

  1. abstract class AbstractClass{
  2.   // 这就是抽象方法
  3.   int sum(int a, int b);
  4. }

但是继承抽象类的子类就需要实现这个抽象方法。

  1. class SubClass extends AbstractClass{
  2.   @override
  3.   int sum(int a, int b) {
  4.     print('a + b = ${a + b}');
  5.     return a + b;
  6.   }
  7. }
  9. abstractDemo() {
  10.   SubClass cls = SubClass();
  11.   cls.sum(10, 20);
  12. }

image.png
因为Dart是单继承，所以我们没有办法继承多个抽象类，那这个时候怎么处理呢？Dart中有个专门的功能叫做实现，此时叫做实现抽象类而不是继承抽象类。

抽象类的实现

一个类如果实现了多个抽象类，那么就需要实现抽闲类里面所有的抽象方法，感觉是不是有点拗口，我们上代码看一下：

  1. abstract class AbstractClass {
  2.   // 这就是抽象方法
  3.   int sum(int a, int b);
  4. }
  6. abstract class AbstractClass1 {
  7.   // 这就是抽象方法
  8.   int sum1(int a, int b);
  9. }
  11. abstract class AbstractClass2 {
  12.   // 这就是抽象方法
  13.   int sum2(int a, int b);
  14. }
  16. /// implements类似于接口
  17. class SubClass implements AbstractClass, AbstractClass1, AbstractClass2 {
  18.   @override
  19.   int sum(int a, int b) {
  20.     print('a + b = ${a + b}');
  21.     return a + b;
  22.   }
  24.   @override
  25.   int sum1(int a, int b) {
  26.     print('a + b + 1 = ${a + b + 1}');
  27.     return a + b + 1;
  28.   }
  30.   @override
  31.   int sum2(int a, int b) {
  32.     print('a + b + 2 = ${a + b + 2}');
  33.     return a + b + 2;
  34.   }
  35. }
  37. abstractDemo() {
  38.   SubClass cls = SubClass();
  39.   cls.sum(10, 20);
  40.   cls.sum1(10, 20);
  41.   cls.sum2(10, 20);
  42. }

image.png

Mixins混入

Mixins说爱了就是多继承，D要多继承的话加一个with, D继承于A，BC是D的混入类。

  1. class A {
  2.   a() => print('a...');
  3. }
  5. class B {
  6.   b() => print('b...');
  7. }
  9. class C {
  10.   c() => print('c...');
  11. }
  13. class D extends A with B, C {}

此时D可以调用ABC中的方法

  1. mixinDemo(){
  2.   D d = D();
  3.   d.a();
  4.   d.b();
  5.   d.c();
  6. }

image.png
但是如果把abc都换成同名的方法，那么此时调用谁？

  1. class A {
  2.   a() => print('a...');
  3. }
  5. class B {
  6.   a() => print('b...');
  7. }
  9. class C {
  10.   a() => print('c...');
  11. }
  13. mixinDemo(){
  14.   D d = D();
  15.   d.a(); ///此时调用的a是哪一个
  16. }

我们看下控制台输出；发现调用的是C中的a方法，因为C覆盖了前面的两个方法。
image.png
但是这个mixin混入有一个局限性，一旦某一个类实现了构造方法，就不可以这么使用了。如果我让C实现它的构造方法，此时会报错：

  1. class C {
  2.   C();
  3.   a() => print('c...');
  4. }

image.png
作为混入的类是不能实现构造方法的!!!
作为混入的类也不能继承除了Object之外其他的类!!!

  1. class C extends TestClass {
  2.   a() => print('c...');
  3. }
  5. class TestClass {
  6. }

image.png
此时换成class C extends Object就没有问题了。
D类没有自己的成员和方法的时，在混入的时候可以这么写：

  1. // class D extends A with B, C {
  2. // }
  3. class D = A with B,C;

operator操作符

如果说想要比较两个类的大小，而操作符是比较数据的大小，在对象里面不能直接用来比较，此时我们可以重载操作符：

  1. operatorDemo(){
  2.   OperatorClass ope1 = OperatorClass(10);
  3.   OperatorClass ope2 = OperatorClass(20);
  4.   print(ope1 > ope2); /// false
  5. }
  7. class OperatorClass{
  8.   int age;
  9.   OperatorClass(this.age); /// 构造函数
  10.   bool operator >(OperatorClass other) => this.age > other.age; /// 重载“>”操作符
  11. }

好了，Dart的基础语法到了这里就要结束了~