Dart--一个类实现多个接口、Mixins用法、泛型方法、泛型类、泛型接口

1.一个类实现多个接口

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

abstract class B {
  printB();
}

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

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

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

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

2.Dart中的mixins

（1）作为mixins的类只能继承自Object,不能继承其他类

（2）作为mixins的类不能有构造函数

（3）一个类可以minxins多个mixins类

（4）mixins绝不是继承，也不是接口，而是一种全新的特性

mixin A {
  String info = 'This is A';

  void printA() {
    print('printA');
  }

  void run() {
    print('run in A');
  }
}

mixin B {
  void printB() {
    print('printB');
  }

  void run() {
    print('run in B');
  }
}

class Person {
  String name = '';

  Person(this.name);

  void printPerson() {
    print('name:${this.name}');
  }
}

class C extends Person with A, B {
  C(super.name);
}

void main() {
  C c = new C('Jack');
  c.printA();
  c.printB();
  //可以反问继承的类的方法
  c.printPerson();
  //如果mixins多个Mixins类有方法重名时，后面的会覆盖前面的，例如调用run打印出来的应该是B的run方法
  c.run();
  print(c.info);

  print(c is A);
  print(c is B);
  print(c is C);
}

上面的例子中简单描述了mixins类的使用。

通俗理解，泛型就是解决类 接口 方法的复用性，以及对不特定数据类型的支持（类型校验）

3.泛型方法

泛型方法的定义格式： T xxx(T value) { return xxxx; }

T getValue<T>(T value) {
  return value;
}
void main() {
  print(getValue<String>('AAA'));
  print(getValue<int>(2233));

}

4.泛型类

class MyList<T> {
  List<T> list = <T>[];
  void add(T value) {
    this.list.add(value);
  }

  List<T> getList() {
    return list;
  }
}

void main() {
  MyList myList = new MyList();
  myList.add(112);
  myList.add(12.56);
  myList.add('wwww');
  print(myList.getList());

  //实现泛型类的时候可以指定数据类型
  MyList<String> mList = new MyList<String>();
  mList.add('123');
  mList.add('333');
  print(mList.getList());

5.泛型接口

实现数据缓存的功能，有文件缓存和内存缓存。内存缓存和文件缓存按照接口约束实现。

(1)定义一个泛型接口 约束实现它的子类必须有getByKey(key)和setByKey(key,value)

(2)要求setByKey的时候的value的类型和实例化子类的时候指定的类型一致

abstract class Cache<T> {
  T? getByKey();
  void setByKey(String key, T value);
}

class MemoryCache<T> implements Cache<T> {
  @override
  void setByKey(String key, T value) {
    print('Memory setByKey');
  }

  @override
  T? getByKey() {
    return null;
  }
}

class FileCache<T> implements Cache<T> {
  @override
  T? getByKey() {
    return null;
  }

  @override
  void setByKey(String key, T value) {
    print('FileCache setByKey');
  }
}
void main() {
  Cache<String> c = new MemoryCache<String>();
  c.setByKey("11", "200");

  Cache<int> cc = new FileCache<int>();
  cc.setByKey("22", 123);