Dart语言零基础学习笔记（二十二）

Dart泛型

泛型:就是对类型的约束，解决类的接口, 方法, 复用性, 以及对不特定数据类型的支持(类型校验)

引入泛型之前，定义一个方法，传入什么类型的数据就会返回什么类型的数据。如果传入不同的数据，就需要调用不同的方法，代码量比较大。

void main(List<String> args) {
  String get1(String value) {
    return value;
  }

  int get2(int value) {
    return value;

  }
}

如果不限制方法的类型，可以用一个方法来代替，但是这样就不会进行类型检查
而且在现实开发中，有时候传入的数据和返回的数据不是一个类型，不会进行类型检查。类如

  void main(List<String> args) {
    get1(age) {
      return "是个中年人";
    }

    var man =get1(35);
    print(man);  

    }
  

泛型的定义

使用 < > 来声明泛型
通常情况下，使用一个字母来代表类型参数

Dart泛型方法的定义

T getData< T >(T value){ }

void main(List<String> args) {

//对传入、传出数据都进行校验
  T getData<T>(T value) {
    return value;
  }

// 没有类型校验
  print(getData(111)); //111
  print(getData("man")); //man
//实现类型校验
  print(getData<int>(100)); //100  其中将int传给T，这样方法就会检查你传入数据必须是int，返回的数据也必须是int
  print(getData<String>('women'));//women


//只对传入参数进行校验，不对传出参数进行校验
  getinfo<T>(T value) {
    return value;
  }
 print(getinfo<String>('women.....'));//women.....

}

Dart泛型类的定义

Dart里面的List，本身就是一个泛型类
List 定义的泛型*(或者 参数化) 类型，定义为List。

void main(List<String> args) {
  /**创建一个长度为3 的集合 */
  List l = List.filled(3, 1);
  l[0] = 1;
  l[1] = 2;
  l[2] = 3;
  print(l);
//加上new  在调用list.filled 就是在实例化List类
  List li = new List.filled(2,'  ');
  l[0] = 'haha';
  l[1] = 'lala';
  print(li);
  //指定类型
 List l2 = new List<String >.filled(2,'  ');
  l[0] = 'haha';
  l[1] = 'lala';
  print(l2);

}

自定义泛型类 ，给mylist类里面增加任意类型的数据 ，在定义类时使用泛型, 类中的方法,包括属性都可以使用泛型

/**自定义泛型类 ，给mylist类里面增加任意类型的数据 */
class mylist<T> {
  List list = <T>[];
  void add(T  value) {
    this.list.add(value);
  }

  List getList() {
    return list;
  }
}


void main(List<String> args) {
  var ml = mylist(); //实例化mylist  ，可以省略掉new 关键词
  ml.add('huahua');
  ml.add(100);
  ml.add(1.1);
  print(ml.getList());
}
// [huahua, 100, 1.1]

Dart泛型接口的定义

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

/** 1、定义一个泛型接口 约束实现它的子类必须有getByKey(key) 和 setByKey(key,value)
    2、要求setByKey的时候的value的类型和实例化子类的时候指定的类型一致*/
/**定义一个泛型接口 */
abstract class Cache<T> {
  get(String key);
  set(String key, T value);
}

class FileCache<T> implements Cache<T> {
  @override
  get(String key) {}

  @override
  set(String key, T value) {
    print("filecache key=$key,value=$value ->cache");
  }
}

class MemoryCache<T> implements Cache<T> {
  @override
  get(String key) {}

  @override
  set(String key, T value) {
    print("memotycache key=$key,value=$value ->cache");
  }
}

void main() {
  var m = new MemoryCache<String>();
  m.set("XXX", "YYY"); //memotycache key=XXX,value=YYY ->cache
  var n = new MemoryCache<Map>();
  n.set("xxx", {'name': 'huahua'});//memotycache key=xxx,value={name: huahua} ->cache
}