Dart - 泛型方法、泛型类、泛型接口

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

1.泛型方法

// 只能返回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'));

    print(getData<String>('你好'));

    print(getData<int>(12));

}

2.泛型类

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

class PrintClass{
    List list = <int>[];
    void add(int value){
        this.list.add(value);
    }
    
    void printInfo(){          
        for(var i=0;i<this.list.length;i++){
            print(this.list[i]);
        }
    }
}

PrintClass p = PrintClass();
p.add(1);
p.add(12);
p.add(5);
p.printInfo();


// 自定义泛型数组
class PrintClass<T>{
    List list = <T>[];
    void add(T value){
        this.list.add(value);
    }
    void printInfo(){          
        for(var i=0;i<this.list.length;i++){
            print(this.list[i]);
        }
    }
}

main() {  
    PrintClass p = PrintClass();
    p.add(11);
    p.add('xxx');
    p.add(5);
    p.printInfo();

    PrintClass p = PrintClass<String>();
    p.add('你好');
    p.add('哈哈');
    p.printInfo();
    
    
    PrintClass p = PrintClass<int>();
    p.add(12);
    p.add(23);
    p.printInfo();

 
    List list = List();
    list.add(12);
    list.add("你好");
    print(list);


    List list=new List<String>();
    list.add(12);  // 错误的写法
    list.add('你好');
    list.add('你好1');
    print(list);

    List list = List<int>();
    list.add("你好");  // 错误写法
    list.add(12); 
    print(list);

}

Dart中的泛型接口:

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

1. 定义一个泛型接口，约束实现它的子类必须有getByKey(key) 和 setByKey(key,value)
2. 要求setByKey的时候的value的类型和实例化子类的时候指定的类型一致

abstract class ObjectCache {
    getByKey(String key);
    void setByKey(String key, Object value);
}

abstract class StringCache {
    getByKey(String key);
    void setByKey(String key, String 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 = MemoryCache<String>();
    m.setByKey('index', '首页数据');
    MemoryCache m = MemoryCache<Map>();
    m.setByKey('index', {"name":"张三","age":20});
}