Flutter学习-06-dart语法学习之继承

「这是我参与11月更文应战的第4天，活动概况查看：2021最后一次更文应战」。

1. dart中的承继

咱们在dart中类是单承继，子类承继父类的非私有办法和特点

class person{
  String? name;
  int? _height;
  bool get isHigh => (_height??=0) >180;
  void sayHello() => print('hello');
}
class student extends person{
}
void extendDemo(){
  student s = student();
  s.sayHello();
  s.name = 'jack';
  print(s.isHigh);
}

咱们子类能够重写父类的办法,能够不写@override，可是一般也写便利阅览，咱们也能够调用父类该办法。

class student extends person{
  int? height;
 @override
  void sayHello() {
    // TODO: implement sayHello
    super.sayHello();
    print('student say hello');
  }
  @override
  // TODO: implement isHigh
  bool get isHigh => (height??=0 )>120;
}

父类中如果有一个或多个自界说结构办法，子类必须至少完成其间的一个，否则会报错

子类重写父类办法：

student.withName(String? name) : super.withName(name);
student.init() : super.init();

2. dart中的笼统类

Dart笼统类主要用于界说标准，子类能够承继笼统类，也能够完成笼统类接口。笼统类不能实例化的类 一起 笼统类通过abstract关键字类界说

abstract class addAbstractClass{
 int add(int a,int b);
}
void testDemo(){
 addAbstractClass cls =  addAbstractClass();
}

2.1 笼统办法

abstract class helloFlutterAPI{
  void sayYes();//笼统办法
  void sayHello() =>print('hello flutter,today is new day');//办法
}

在abstract中咱们把没有办法体的办法称为笼统办法一起Dart中的笼统办法不能用abstract声明,

在非笼统类中界说笼统办法会报错

abstract class addAbstractClass {
   void printA() => print('object');
  int add(int a,int b);
}
class addSubClass extends addAbstractClass
{
  @override
  int add(int a, int b) {
    // TODO: implement add
    return a+b -1;
  }
}

子类能够承继笼统类，笼统类的笼统办法要完成，非笼统办法能够直接调用因为它现已完成了。 这其实也是多态，多态便是父类界说一个办法不去完成,让承继他的子类去完成, 每个子类有不同的表现

3.dart中的接口

咱们想要完成多个笼统类办法的承继完成对应的办法怎么做呢咱们能够完成implements来完成一个或许多个接口

class childClass implements helloFlutterAPI,sumAbstractClasss,addAbstractClass{
@override
String name;
childClass(this.name);//复写特点
 @override
  sayYes() {
    // TODO: implement sayYes
    print('yes');
  }
  @override
  void sayHello() {
    // TODO: implement sayHello
  }
  @override
  int sum(int a, int b) {
    // TODO: implement sum
    var sum =  a+b+20;
    print('sum is $sum');
    return sum;
  }
  @override
  void printA() {
    // TODO: implement printA
  }
  @override
  int add(int a, int b) {
    // TODO: implement add
    var sum =  a+b;
    print('add is $sum');
    return sum;
  }
}

咱们运用implements完成多接口的完成，子类要完成父类的办法，和特点。它们的关系不是承继关系，而是父类便是界说接口,完成接口的子类要覆写接口中的所有特点和办法.

3.1 笼统类作为接口完成

abstract class redClaas {
  String color;
  redClaas(this.color);
  void changeColor(String changeColor);
  void printCunrrentColor();
}
class colorClass implements redClaas{
  @override 
  String color;
  colorClass(this.color);
  @override
  void changeColor(String changeColor) {
    // TODO: implement changeColor
    print(changeColor);
  }
  @override
  void printCunrrentColor() {
    // TODO: implement printCunrrentColor
    print(this.color);
  }
}

将笼统类作为接口运用(类便是接口)，让子类来完成（关键字implements来完成)

4. Mixin

官方界说:

Mixin是复用类代码的一种途径， 复用的类能够在不同层级，之间能够不存在承继关系。

简单说便是在类中混入其他的功用,完成相似多承继的功用

4.1 普通类

class a {
  String name = 'a'
  void printA()=>print('this is a class');
}
class b{
  String name = 'b'
  void printB()=>print('this is b class');
}
class c{
  String name = 'c'
  void printC()=>print('this is c class');
}
class mixClass with a,b,c{
}

完成

void main(List<String> arguments) {
  print('Hello world!');
  mixinDemo();
}
void mixinDemo(){
  mixClass class1 = mixClass();
  print(class1.name);//打印成果为c
  class1.printA();
  class1.printB();
  class1.printC();
}

在混入多个类是,类中有相同 的特点或办法,后混入的会将先混入的覆盖掉

6.2 mixin界说

咱们运用mixin修饰类的时分不能初始化否则会报错

mixin a {
  String name = 'a';
  void printA()=>print('this is a class');
}
 mixin b{
  String name = 'b';
  void printB()=>print('this is b class');
}
mixin c{
  String name = 'c';
  void printC()=>print('this is c class');
}
class mixClass with a,b,c{
}

6.3 混入类的承继问题

混入类不能承继除了Object之外的类,咱们换成Object即可

6.4 混入不影响承继

class a {
  String name = 'a';
  void printA()=>print('this is a class');
}
 mixin b{
  String name = 'b';
  void printB()=>print('this is b class');
}
class c{
  String name = 'c';
  void printC()=>print('this is c class');
}
class mixClass extends a with b,c{
}