typescript泛型类 泛型方法

  1 /*
  2 
  3 泛型：软件工程中，我们不仅要创建一致的定义良好的API，同时也要考虑可重用性。 组件不仅能够支持当前的数据类型，同时也能支持未来的数据类型，这在创建大型系统时为你提供了十分灵活的功能。
  4 
  5 在像C#和Java这样的语言中，可以使用泛型来创建可重用的组件，一个组件可以支持多种类型的数据。 这样用户就可以以自己的数据类型来使用组件。
  6 
  7 
  8 通俗理解：泛型就是解决 类 接口 方法的复用性、以及对不特定数据类型的支持(类型校验)
  9 
 10 */
 11 
 12 
 13 //只能返回string类型的数据
 14 
 15     // function getData(value:string):string{
 16     //     return value;
 17     // }
 18 
 19 //同时返回 string类型 和number类型  （代码冗余）
 20 
 21 
 22     // function getData1(value:string):string{
 23     //     return value;
 24     // }
 25 
 26 
 27     // function getData2(value:number):number{
 28     //     return value;
 29     // }
 30 
 31 
 32 
 33 
 34 //同时返回 string类型 和number类型       any可以解决这个问题
 35 
 36 
 37     //  function getData(value:any):any{
 38     //     return '哈哈哈';
 39     // }
 40 
 41 
 42     // getData(123);
 43 
 44     // getData('str');
 45 
 46 
 47     
 48 
 49 //any放弃了类型检查,传入什么 返回什么。比如:传入number 类型必须返回number类型  传入 string类型必须返回string类型
 50 
 51 
 52     //传入的参数类型和返回的参数类型可以不一致
 53     //    function getData(value:any):any{
 54     //         return '哈哈哈';
 55     //     }
 56 
 57 
 58 
 59 
 60 // 泛型：可以支持不特定的数据类型   要求：传入的参数和返回的参数一直
 61 
 62 
 63 
 64 // T表示泛型，具体什么类型是调用这个方法的时候决定的
 65 
 66     //    function getData<T>(value:T):T{
 67     //        return value;
 68     //    }
 69     //     getData<number>(123);
 70 
 71         // getData<string>('1214231');
 72 
 73 
 74        // getData<number>('2112');       /*错误的写法*/  
 75 
 76 
 77 
 78 
 79 
 80     //    function getData<T>(value:T):any{
 81     //        return '2145214214';
 82     //    }
 83 
 84     //    getData<number>(123);  //参数必须是number
 85 
 86     //    getData<string>('这是一个泛型');
 87 
 88 
 89 
 90 
 91 
 92 
 93 
 94 
 95 // 泛型类：比如有个最小堆算法，需要同时支持返回数字和字符串 a  -  z两种类型。  通过类的泛型来实现
 96 
 97 
 98     /*
 99 
100             class MinClass{
101                 public list:number[]=[];
102                 add(num:number){
103                     this.list.push(num)
104                 }
105                 min():number{
106                     var minNum=this.list[0];
107                     for(var i=0;i<this.list.length;i++){
108                         if(minNum>this.list[i]){
109                             minNum=this.list[i];
110                         }
111                     }
112                     return minNum;
113                 }
114 
115             }
116 
117             var m=new MinClass();
118 
119             m.add(3);
120             m.add(22);
121             m.add(23);
122             m.add(6);
123 
124             m.add(7);
125             alert(m.min());
126 
127     */
128 
129 
130 
131 
132 //类的泛型
133 
134 class MinClas<T>{
135 
136     public list:T[]=[];
137 
138     add(value:T):void{
139 
140         this.list.push(value);
141     }
142 
143     min():T{        
144         var minNum=this.list[0];
145         for(var i=0;i<this.list.length;i++){
146             if(minNum>this.list[i]){
147                 minNum=this.list[i];
148             }
149         }
150         return minNum;
151     }
152 }
153 
154 var m1=new MinClas<number>();   /*实例化类 并且制定了类的T代表的类型是number*/
155 m1.add(11);
156 m1.add(3);
157 m1.add(2);
158 alert(m1.min())
159 
160 
161 var m2=new MinClas<string>();   /*实例化类 并且制定了类的T代表的类型是string*/
162 
163 m2.add('c');
164 m2.add('a');
165 m2.add('v');
166 alert(m2.min())