泛型

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

2. 泛型方法

   // 只能返回String类型的数据
    String getData(String value) {
      return value;
    }
   
    // 同时支持返回String类型和int类型  不指定类型放弃了类型检查
    getData(value) {
      return value;
    }
   
    // 同时支持返回String类型和int类型  传入什么类型返回什么类型
    T getData<T>(T value) {
      return value;
    }
   
    void main() {
      print(getData(21));
      print(getData('xxx'));
    }
   

   Dart中的泛型类

3. 泛型类就是在类中使用泛型

   class PrintClass<T> {
     List list = <T>[]; // 这里的<T>表示泛型，告诉编译器，这是一个泛型类
   
     void add(T value) {
       this.list.add(value);
     }
   
     void printInfo() {
       print(this.list);
       for (var i = 0; i < this.list.length; i++) {
         print(this.list[i]);
       }
     }
   }
   
   void main() {
     PrintClass p = new PrintClass();
     p.add(1);
     p.add(2);
     p.add(3);
     p.add(4);
     p.add('xxx');
     p.printInfo();
   }
   

4. 泛型类的继承

       class PrintClass<T> {
         List list = <T>[]; // 这里的<T>表示泛型，告诉编译器，这是一个泛型类
   
         void add(T value) {
            this.list.add(value);
         }
   
         void printInfo() {
            print(this.list);
            for (var i = 0; i < this.list.length; i++) {
               print(this.list[i]);
            }
         }
       }
   
       class PrintSubClass<T> extends PrintClass<T> {
   
       }
   
       void main() {
         PrintSubClass p = new PrintSubClass();
         p.add(1);
         p.add(2);
         p.add(3);
         p.add(4);
         p.add('xxx');
         p.printInfo();
       }
   

5. 泛型接口

       // 泛型接口
       abstract class Cache<T> {
         getByKey(String key);
         void setByKey(String key, T value);
       }
        // 
       class FileCache<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<Map>();
          m.setByKey('index', {'name': '张三', 'age': 20});
   
          MemoryCache m1 = new MemoryCache<String>();
          m1.setByKey('index', '张三');
   
          MemoryCache m2 = new MemoryCache<int>();
          m2.setByKey('index', 123);
   
          FileCache f = new FileCache<Map>();
          f.setByKey('index', {'name': '张三', 'age': 20});
   
          FileCache f1 = new FileCache<String>();
          f1.setByKey('index', '张三');
   
          FileCache f2 = new FileCache<int>();
          f2.setByKey('index', 123);
        }