Dart笔记（18）：抽象 继承 多继承mixin

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/hxl517116279/article/details/88563348

抽象类、函数、成员

abstract class Person {
  static const String name = 'abc';
  void printName(){
    print(name);
  }
}

不能直接 new 实例化

var p = Person();//错误
p.printName();

继承方式使用

抽象类中只定义抽象函数，实例化访问会报错

定义

class Teacher extends Person {
}

实例

var user = Teacher();
user.printName();

接口方式使用

定义

abstract class Person {
  static const String name = '';
  void printName();
}

class Student implements Person {
  String name = 'this is student';
  void printName() {
    print(name);
  }
}

实例

var user = Student();
user.printName();

实现多接口

Dart可以履行多接口，Dart中没有interface关键字

void main() {
  var p = AndroidPhone();
  p.startup();
  p.shutdown();
}

class Phone {
  void startup() {
    print('开机');
  }
  void shutdown() {
    print('关机');
  }
}

class Mobile {
  int signal;
}

class AndroidPhone implements Phone, Mobile {
  int signal;
  void startup() {
    print('AndroidPhone 开机');
  }
  void shutdown() {
    print('AndroidPhone 关机');
  }
}

继承

实现集成

void main() {
  var p = AndroidPhone();
  p.startup();
  p.shutdown();
}

class Phone {
  void startup() {
    print('开机');
  }
  void shutdown() {
    print('关机');
  }
}

class AndroidPhone extends Phone {
}

继承抽象类

抽象类中只定义抽象函数，实例化访问抽象函数会报错

void main() {
  var p = AndroidPhone();
  p.startup();
  p.shutdown();
}

abstract class Phone {
  void startup();
  void shutdown();
}

class AndroidPhone extends Phone {
}

调用父类普通方法

super 对象可以访问父类，super.method();

void main() {
  var p = AndroidPhone();
  p.startup();
}

class Phone {
  void startup() {
    print('开机');
  }
  void shutdown() {
    print('关机');
  }
}

class AndroidPhone extends Phone {
  void startup() {
    super.startup();
    print('AndroidPhone 开机');
  }
}

调用父类构造方法

void main() {
  var p = AndroidPhone(12345678);
  p.showNumber();
}

class Mobile {
  int number;
  int signal;
  Mobile(this.number);
  void showNumber() {
    print('010-${number}');
  }
}

class AndroidPhone extends Mobile {
  AndroidPhone(int number) : super(number);
}

class Parent{
    int x;
    int y;

    //父类命名构造函数不会传递
    Parent.aa(x,y)
        :x=x,
        y=y{
        print('父类命名构造函数');
    }
}

class Child extends Parent{
    int x;
    int y;

    //若父类没有默认构造函数，需要手动调用父类其他构造函数
    Child(x,y) :super.aa(x,y){
        print('子类构造函数');
    }
    //在构造函数的初始化列表里使用super(),需要把它放到最后
    Child.fromJson(x,y)
        :x=x,
        y=y,
        super.aa(x,y){
            print('子类命名构造函数');
        }
}

重写父类方法

在重写的函数上加修饰符 @override

void main() {
  dynamic p = AndroidPhone(12345);
  p.showNumber();
}

class Mobile {
  int number;
  int signal;

  Mobile(this.number);

  void showNumber() {
    print('010-${number}');
  }
}

class AndroidPhone extends Mobile {
  AndroidPhone(int number) : super(number);

  @override
  void showNumber() {
    print('sssa');
  }
}

多类继承mixin

'Dart中的Mixins通过创建一个新类来实现，该类将mixin的实现层叠在一个超类之上以创建一个新类 ，它不是“在超类中”，而是在超类的“顶部”，因此如何解决查找问题不会产生歧义。— Lasse R. H. Nielsen on StackOverflow.'

要使用mixin的话，你需要使用with关键字，后跟一个或多个mixin的名称： 

class Phone {
  void startup() {
    print('开机');
  }
  void shutdown() {
    print('关机');
  }
}

class AndroidPhone extends Phone {
  void startup() {
    super.startup();
    print('AndroidPhone 开机');
  }
}

class AndroidSystem {
  void call() {
    print('android call');
  }
}

class Weixin {
  void sms() {
    print('weixin sms');
  }
}

class Xiaomi extends AndroidPhone with AndroidSystem, Weixin {
  void startup() {
    super.startup();
    print('AndroidPhone 开机');
  }
}

函数重名冲突

遇到相同功能的函数，最后载入的会覆盖之前的函数定义

void main() {
  var xm = Xiaomi();
  xm.sms(); // qq sms
}

class Phone {
}

class Weixin {
  void sms() {
    print('weixin sms');
  }
}

class QQ {
  void sms() {
    print('qq sms');
  }
}

class Xiaomi extends Phone with  Weixin, QQ {
}

//顺序问题
//如果2个或多个超类拥有相同签名的A方法，那么子类会以继承的最后一个超类中的A方法为准。
//当然这是子类没有重写A方法的前提下，如果子类自己重写了A方法则以本身的A方法为准
class A {
  String getMessage() => 'A';
}

class B {
  String getMessage() => 'B';
}

class P {
  String getMessage() => 'P';
}

class AB extends P with A, B {}

class BA extends P with B, A {}

class C extends P with B, A {
  String getMessage() => 'C'; //优先级最高的是在具体类中的方法。
}

class CC extends P with B implements A {
} //这里的implement只是表明要实现A的方法，这个时候具体实现是再B中mixin了具体实现


main(List<String> args) {
  print(AB().getMessage());    //B
  print(BA().getMessage());    //A
  print(C().getMessage());     //C
  print(CC().getMessage());    //B
}