Flutter学习笔记1.7 Dart基础（抽象类多态接口

作者: 艾伦oy | 来源:发表于2022-04-23 01:41 被阅读0次

抽象类

Dart中抽象类: Dart抽象类主要用于定义标准，子类可以继承抽象类，也可以实现抽象类接口。

1、抽象类通过abstract关键字来定义

2、Dart中的抽象方法不能用abstract声明，Dart中没有方法体的方法我们称为抽象方法。

3、如果子类继承抽象类必须得实现里面的抽象方法

4、如果把抽象类当做接口实现的话必须得实现抽象类里面定义的所有属性和方法。

5、抽象类不能被实例化，只有继承它的子类可以

extends抽象类和 implements的区别：

1、如果要复用抽象类里面的方法，并且要用抽象方法约束自类的话我们就用extends继承抽象类

2、如果只是把抽象类当做标准的话我们就用implements实现抽象类

案例：
定义一个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('小猫在跑');
  }
}

main() {
  Dog d = new Dog();
  d.eat();
  d.printInfo();

  Cat c = new Cat();
  c.eat();

  c.printInfo();
//注意
  // Animal a=new Animal();   //抽象类没法直接被实例化
}

多态

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

abstract class Animal {
  eat(); //抽象方法
}

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

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

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

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

main() {
  // Dog d=new Dog();
  // d.eat();
  // d.run();

  // Cat c=new Cat();
  // c.eat();

  Animal d = new Dog();

  d.eat();

  Animal c = new Cat();

  c.eat();
}

接口

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

实用案例
定义一个DB库支持 mysql mssql mongodb，
mysql mssql mongodb三个类里面都有同样的方法

1.定义接口

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

2.实现接口1

import 'Db.dart';


class MsSql implements Db{
  @override
  late 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.实现接口3

import 'Db.dart';


class Mysql implements Db{
  
  @override
  String uri;

  Mysql(this.uri);

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

  @override
  delete() {   
    return null;
  }

  @override
  save() {   
    return null;
  }

  
}

4.调用

// import 'lib/Mysql.dart';
import 'lib/MsSql.dart';

main() {

  Mysql mysql=new Mysql('xxxxxx');

  mysql.add('1243214');

  MsSql mssql=new MsSql();
  mssql.uri='127.0.0.1';

  mssql.add('增加的数据');

  
}

进阶用法：一个类实现多个接口：

class C implements A, B {}

abstract class A {
  late String name;

  printA();
}

abstract class B {
  printB();
}

class C implements A, B {
  @override
  late String name;

  @override
  printA() {
    print('printA');
  }

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

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

Mixins多重继承

Dart2.x版本的新特性，mixins的中文意思是混入，就是在类中混入其他功能。
在Dart中可以使用mixins实现类似多继承的功能
特点：
1、作为mixins的类只能继承自Object，不能继承其他类
2、作为mixins的类不能有构造函数
3、一个类可以mixins多个mixins类
4、mixins绝不是继承，也不是接口，而是一种全新的特性

示例1

class Person {
  String name;
  num age;

  Person(this.name, this.age);

  printInfo() {
    print('${this.name}----${this.age}');
  }

  void run() {
    print("Person Run");
  }
}

class A {
  String info = "this is A";

  void printA() {
    print("A");
  }

  void run() {
    print("A Run");
  }
}

class B {
  void printB() {
    print("B");
  }

  void run() {
    print("B Run");
  }
}

class C extends Person with B, A {
  C(String name, num age) : super(name, age);
}

void main() {
  var c = new C('张三', 20);
  c.printInfo();
  // c.printB();
  // print(c.info);

  c.run();
}

mixins的实例类型是什么？
：mixins的类型就是其超类的子类型。

示例2

class A {
  String info = "this is A";

  void printA() {
    print("A");
  }
}

class B {
  void printB() {
    print("B");
  }
}

class C with A, B {}

void main() {
  var c = new C();

  print(c is C); //true
  print(c is A); //true
  print(c is B); //true

  // var a=new A();

  // print(a is Object);
}

泛型

通俗理解：泛型就是解决类接口方法的复用性、以及对不特定数据类型的支持(类型校验)》

泛型类

案例
把下面类转换成泛型类，要求MyList里面可以增加int类型的数据，也可以增加String类型的数据。但是每次调用增加的类型要统一

class MyList<T> {
  List list = <T>[];

  void add(T value) {
    this.list.add(value);
  }

  List getList() {
    return list;
  }
}

main() {
  MyList l2 = new MyList<String>();
  l2.add("张三1");
  // l2.add(11);  //错误的写法
  print(l2.getList());

  MyList l3 = new MyList<int>();
  l3.add(11);
  l3.add(12);
  l3.add("aaaa");
  print(l3.getList());

  // List list = List.filled(2, "");
  // list[0] = "张三";
  // list[1] = "李四";
  // print(list);

  List list = new List.filled(2, "");
  list[0] = "张三1";
  list[1] = "李四";
  print(list);

  List list2 = new List<String>.filled(2, "");
  list2[0] = "张三1";
  list2[1] = "李四";
  print(list2);

  List list3 = new List<int>.filled(2, 0);
  list3[0] = 12;
  list3[1] = 13;
  print(list3);
}

泛型方法


//痛点
//--------------------------------------------------------------------------------------------------------
//只能返回string类型的数据

String getData(String value){
    return value;
}

//同时支持返回 string类型 和int类型  （代码冗余）

String getData1(String value){
    return value;
}

int getData2(int value){
    return value;
}

//同时返回 string类型 和number类型       不指定类型可以解决这个问题

getData(value){
    return value;
}
//--------------------------------------------------------------------------------------------------------
//不指定类型放弃了类型检查。我们现在想实现的是传入什么 返回什么。比如:传入number 类型必须返回number类型  传入 string类型必须返回string类型

T getData<T>(T value){
    return value;
}

getData<T>(T value) {
  return value;
}

void main() {
  print(getData(21));

  print(getData('xxx'));

  getData<String>('你好');

  print(getData<int>(12));
}

泛型接口

案例
实现数据缓存的功能：有文件缓存、和内存缓存。内存缓存和文件缓存按照接口约束实现。
1、定义一个泛型接口约束实现它的子类必须有getByKey(key) 和 setByKey(key,value)
2、要求setByKey的时候的value的类型和实例化子类的时候指定的类型一致

abstract class Cache<T> {
  getByKey(String key);

  void setByKey(String key, T value);
}

class FlieCache<T> implements Cache<T> {
  @override
  getByKey(String key) {
    return null;
  }

  @override
  void setByKey(String key, T value) {
    print("我是文件缓存 把key=${key}  value=${value}的数据写入到了文件中");
  }
}

class MemoryCache<T> implements Cache<T> {
  @override
  getByKey(String key) {
    return null;
  }

  @override
  void setByKey(String key, T value) {
    print("我是内存缓存 把key=${key}  value=${value} -写入到了内存中");
  }
}

void main() {
  // MemoryCache m=new MemoryCache<String>();

  //  m.setByKey('index', '首页数据');

  MemoryCache m = new MemoryCache<Map>();

  m.setByKey('index', {"name": "张三", "age": 20});
}

网友评论

本文标题：Flutter学习笔记1.7 Dart基础（抽象类多态接口

本文链接：https://www.haomeiwen.com/subject/bnobertx.html

延伸阅读

深度阅读

您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

Flutter学习笔记1.7 Dart基础（抽象类多态接口

抽象类

多态

接口

进阶用法：一个类实现多个接口：

Mixins多重继承

泛型

泛型类

泛型方法

泛型接口

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Flutter学习笔记1.7 Dart基础（抽象类 多态 接口

抽象类

多态

接口

进阶用法：一个类实现多个接口：

Mixins多重继承

泛型

泛型类

泛型方法

泛型接口

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Flutter学习笔记1.7 Dart基础（抽象类多态接口