简单易懂的Dart基础语法，抽象类和接口。

抽象类

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

abstractDemo() {
  AbstractClass cls = AbstractClass();
}
abstract class AbstractClass{
}

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

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

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

class SubClass extends AbstractClass{
  @override
  int sum(int a, int b) {
    print('a + b = ${a + b}');
    return a + b;
  }
}

abstractDemo() {
  SubClass cls = SubClass();
  cls.sum(10, 20);
}

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

抽象类的实现

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

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

abstract class AbstractClass1 {
  // 这就是抽象方法
  int sum1(int a, int b);
}

abstract class AbstractClass2 {
  // 这就是抽象方法
  int sum2(int a, int b);
}

/// implements类似于接口
class SubClass implements AbstractClass, AbstractClass1, AbstractClass2 {
  @override
  int sum(int a, int b) {
    print('a + b = ${a + b}');
    return a + b;
  }
  
  @override
  int sum1(int a, int b) {
    print('a + b + 1 = ${a + b + 1}');
    return a + b + 1;
  }

  @override
  int sum2(int a, int b) {
    print('a + b + 2 = ${a + b + 2}');
    return a + b + 2;
  }
}

abstractDemo() {
  SubClass cls = SubClass();
  cls.sum(10, 20);
  cls.sum1(10, 20);
  cls.sum2(10, 20);
}

Mixins混入

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

class A {
  a() => print('a...');
}

class B {
  b() => print('b...');
}

class C {
  c() => print('c...');
}

class D extends A with B, C {}

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

mixinDemo(){
  D d = D();
  d.a();
  d.b();
  d.c();
}

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

class A {
  a() => print('a...');
}

class B {
  a() => print('b...');
}

class C {
  a() => print('c...');
}

mixinDemo(){
  D d = D();
  d.a(); ///此时调用的a是哪一个
}

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

class C {
  C();
  a() => print('c...');
}

作为混入的类是不能实现构造方法的!!!

作为混入的类也不能继承除了Object之外其他的类!!!

class C extends TestClass {
  a() => print('c...');
}

class TestClass {
}

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

// class D extends A with B, C {
// }
class D = A with B,C;

operator操作符

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

operatorDemo(){
  OperatorClass ope1 = OperatorClass(10);
  OperatorClass ope2 = OperatorClass(20);
  print(ope1 > ope2); /// false
}

class OperatorClass{
  int age;
  OperatorClass(this.age); /// 构造函数
  bool operator >(OperatorClass other) => this.age > other.age; /// 重载“>”操作符
}

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