Flutter学习-dart(7):继承与多态

1. Dart中的类的继承

1. 子类使用extends关键词来继承父类
2. 子类会继承父类里面可见的属性和方法 但是不会继承构造函数
3. 子类能复写父类的方法 getter和setter

1.2. super关键词给父类构造函数传参

class Person {
  String name;
  num age; 
  Person(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");  
  }
}


class Web extends Person {
  String sex;
  Web(String name, num age, String sex) : super(name, age){
    this.sex=sex;
  }
  run(){
   print("${this.name}---${this.age}--${this.sex}");  
  }
}

1.3. 覆盖父类的方法

class Person {
  String name;
  num age;
  Person(this.name, this.age);
  void printInfo() {
    print("${this.name}---${this.age}");
  }

  work() {
    print("${this.name}在工作...");
  }
}

class Web extends Person {
  Web(String name, num age) : super(name, age);

  run() {
    print('run');
  }

  //覆写父类的方法
  @override //可以写也可以不写  建议在覆写父类方法的时候加上 @override
  void printInfo() {
    print("姓名：${this.name}---年龄：${this.age}");
  }

  @override
  work() {
    print("${this.name}的工作是写代码");
  }
}

1.4 子类调用父类的方法:

• super.xxx()实现调用

class Web extends Person {
  Web(String name, num age) : super(name, age);

  run() {
    print('run');
    super.work(); //自类调用父类的方法
  }

  //覆写父类的方法
  @override //可以写也可以不写  建议在覆写父类方法的时候加上 @override
  void printInfo() {
    print("姓名：${this.name}---年龄：${this.age}");
  }
}

2. 抽象类和接口

1. 抽象类通过abstract 关键字来定义
2. Dart中的抽象方法不能用abstract声明，Dart中没有方法体的方法我们称为抽象方法
3. 如果子类继承抽象类必须得实现里面的抽象方法
4. 如果把抽象类当做接口实现的话必须得实现抽象类里面定义的所有属性和方法。
5. 抽象类不能被实例化，只有继承它的子类可以

2.1 案例：定义一个Animal类, 要求它的子类必须包含eat方法

abstract class Animal {
  eat(); //抽象方法
  run(); //抽象方法
  printInfo() {
    print('我是一个抽象类里面的普通方法');
  }
}

class Dog extends Animal {
  @override
  eat() {
    print('小狗在吃骨头');
  }

  @override
  run() {
    // TODO: implement run
    print('小狗在跑');
  }
}

class Cat extends Animal {
  @override
  eat() {
    // TODO: implement eat
    print('小猫在吃老鼠');
  }

  @override
  run() {
    // TODO: implement run
    print('小猫在跑');
  }
}

2.2 接口

• 和Java一样，dart也有接口，但是和Java还是有区别的:

  1. 首先，dart的接口没有interface关键字定义接口，而是普通类或抽象类都可以作为接口被实现; 同样使用implements关键字进行实现
  2. dart的接口有点奇怪，如果实现的类是普通类，会将普通类和抽象中的属性的方法全部需要覆写一遍;
  3. 而因为抽象类可以定义抽象方法，普通类不可以，所以一般如果要实现像Java接口那样的方式，一般会使用抽象类
  4. 建议使用抽象类定义接口

• extends抽象类 和 implements的区别:

  1. 如果要复用抽象类里面的方法，并且要用抽象方法约束自类的话我们就用extends继承抽象类;
  2. 如果只是把抽象类当做标准的话我们就用implements实现抽象类

2.3 示例:定义一个DB库 支持 mysql mssql mongodb

abstract class Db {
  //当做接口   接口：就是约定 、规范
  String url; //数据库的链接地址
  add(String data);
  save();
  delete();
}

class Mysql implements Db {
  @override
  String uri;

  Mysql(this.uri);

  @override
  add(data) {
    // TODO: implement add
    print('这是mysql的add方法' + data);
  }

  @override
  delete() {
    // TODO: implement delete
    return null;
  }

  @override
  save() {
    // TODO: implement save
    return null;
  }

  remove() {}
}

class MsSql implements Db {
  @override
  String uri;
  @override
  add(String data) {
    print('这是mssql的add方法' + data);
  }

  @override
  delete() {
    // TODO: implement delete
    return null;
  }

  @override
  save() {
    // TODO: implement save
    return null;
  }
}

3. dart实现多态

1. 允许将子类类型的指针赋值给父类类型的指针, 同一个函数调用会有不同的执行效果 ;
2. 子类的实例赋值给父类的引用
3. 多态就是父类定义一个方法不去实现，让继承他的子类去实现，每个子类有不同的表现

example

abstract class USB {
  late String deviceName;

  void transferData();
}

//手机类, 实现传输数据功能
class Phone implements USB {
  @override
  String deviceName;

  Phone(this.deviceName);

  @override
  void transferData() {
    print('${this.deviceName} is transfer');
  }
}

//相机类,实现传输数据功能
class Camera implements USB {
  @override
  String deviceName;

  Camera.name(this.deviceName);

  @override
  void transferData() {
    print('${this.deviceName} is transfer');
  }
}

class Computer {
  //电脑, 能给具备传输数据的设备进行数据传输
  void transfer(USB device) {
    device.transferData();
  }
}

void main() {
  Phone phone = new Phone("iphone");
  Camera camera = new Camera.name("sony");
  Computer computer = new Computer();

  computer.transfer(phone); //iphone is transfer
  computer.transfer(camera); //sony is transfer
}

3.2 Dart中一个类实现多个接口

abstract class A {
  String name;
  printA();
}

abstract class B {
  printB();
}

class C implements A, B {
  @override
  String name;
  @override
  printA() {
    print('printA');
  }

  @override
  printB() {
    // TODO: implement printB
    return null;
  }
}

void main() {
  C c = new C();
  c.printA();
}