1 本文对Java泛型进行了全面的总结。文章内容包括普通泛型、通配符、受限泛型、泛型接口、泛型方法、返回泛型类型实例等等。2 AD: WOT2014课程推荐:实战MSA:用开源软件搭建微服务系统3 虽然Scala创始人Martin Odersky说当年正是因为Java泛型的丑陋,所以才想到要创建一个新的语言,不过这仍然不妨碍我们学习Java泛型。毕竟即使听说Java泛型不好用,但好不好用还是得会用了才知道。下面是一些有关Java泛型的总结:4
5 普通泛型6
7 class Point< T>{ //此处可以随便写标识符号,T是type的简称
8 private T var ; //var的类型由T指定,即:由外部指定
9 public T getVar(){ //返回值的类型由外部决定
10 returnvar ;11 }12 public void setVar(T var){ //设置的类型也由外部决定
13 this.var =var ;14 }15 };16 public classGenericsDemo06{17 public static voidmain(String args[]){18 Point< String> p = new Point< String>() ; //里面的var类型为String类型
19 p.setVar(“it”) ; //设置字符串
20 System.out.println(p.getVar().length()) ; //取得字符串的长度
21 }22 };23 ———————————————————-
24
25 class Notepad< K,V>{ //此处指定了两个泛型类型
26 private K key ; //此变量的类型由外部决定
27 private V value ; //此变量的类型由外部决定
28 publicK getKey(){29 return this.key ;30 }31 publicV getValue(){32 return this.value ;33 }34 public voidsetKey(K key){35 this.key =key ;36 }37 public voidsetValue(V value){38 this.value =value ;39 }40 };41 public classGenericsDemo09{42 public static voidmain(String args[]){43 Notepad< String,Integer> t = null ; //定义两个泛型类型的对象
44 t = new Notepad< String,Integer>() ; //里面的key为String,value为Integer
45 t.setKey(“汤姆”) ; //设置第一个内容
46 t.setValue(20) ; //设置第二个内容
47 System.out.print(“姓名;” + t.getKey()) ; //取得信息
48 System.out.print(“,年龄;” + t.getValue()) ; //取得信息
49
50 }51 };52
53 通配符54
55 class Info< T>{56 private T var ; //定义泛型变量
57 public voidsetVar(T var){58 this.var =var ;59 }60 publicT getVar(){61 return this.var ;62 }63 public String toString(){ //直接打印
64 return this.var.toString() ;65 }66 };67 public classGenericsDemo14{68 public static voidmain(String args[]){69 Info< String> i = new Info< String>() ; //使用String为泛型类型
70 i.setVar(“it”) ; //设置内容
71 fun(i) ;72 }73 public static void fun(Info< ?> temp){ //可以接收任意的泛型对象
74 System.out.println(“内容:” +temp) ;75 }76 };77
78 受限泛型79
80 class Info< T>{81 private T var ; //定义泛型变量
82 public voidsetVar(T var){83 this.var =var ;84 }85 publicT getVar(){86 return this.var ;87 }88 public String toString(){ //直接打印
89 return this.var.toString() ;90 }91 };92 public classGenericsDemo17{93 public static voidmain(String args[]){94 Info< Integer> i1 = new Info< Integer>() ; //声明Integer的泛型对象
95 Info< Float> i2 = new Info< Float>() ; //声明Float的泛型对象
96 i1.setVar(30) ; //设置整数,自动装箱
97 i2.setVar(30.1f) ; //设置小数,自动装箱
98 fun(i1) ;99 fun(i2) ;100 }101 public static void fun(Info< ? extends Number> temp){ //只能接收Number及其Number的子类
102 System.out.print(temp + “、”) ;103 }104 };105 ———————————————————-
106
107
108 class Info< T>{109 private T var ; //定义泛型变量
110 public voidsetVar(T var){111 this.var =var ;112 }113 publicT getVar(){114 return this.var ;115 }116 public String toString(){ //直接打印
117 return this.var.toString() ;118 }119 };120 public classGenericsDemo21{121 public static voidmain(String args[]){122 Info< String> i1 = new Info< String>() ; //声明String的泛型对象
123 Info< Object> i2 = new Info< Object>() ; //声明Object的泛型对象
124 i1.setVar(“hello”) ;125 i2.setVar(newObject()) ;126 fun(i1) ;127 fun(i2) ;128 }129 public static void fun(Info< ? super String> temp){ //只能接收String或Object类型的泛型
130 System.out.print(temp + “、”) ;131 }132 };133
134 Java泛型无法向上转型135
136 class Info< T>{137 private T var ; //定义泛型变量
138 public voidsetVar(T var){139 this.var =var ;140 }141 publicT getVar(){142 return this.var ;143 }144 public String toString(){ //直接打印
145 return this.var.toString() ;146 }147 };148 public classGenericsDemo23{149 public static voidmain(String args[]){150 Info< String> i1 = new Info< String>() ; //泛型类型为String
151 Info< Object> i2 = null;152 i2 = i1 ; //这句会出错 incompatible types
153 }154 };155
156 Java泛型接口157
158 interface Info< T>{ //在接口上定义泛型
159 public T getVar() ; //定义抽象方法,抽象方法的返回值就是泛型类型
160 }161 class InfoImpl< T> implements Info< T>{ //定义泛型接口的子类
162 private T var ; //定义属性
163 public InfoImpl(T var){ //通过构造方法设置属性内容
164 this.setVar(var) ;165 }166 public voidsetVar(T var){167 this.var =var ;168 }169 publicT getVar(){170 return this.var ;171 }172 };173 public classGenericsDemo24{174 public static voidmain(String arsg[]){175 Info< String> i = null; //声明接口对象
176 i = new InfoImpl< String>(“汤姆”) ; //通过子类实例化对象
177 System.out.println(“内容:” +i.getVar()) ;178 }179 };180 ———————————————————-
181
182
183 interface Info< T>{ //在接口上定义泛型
184 public T getVar() ; //定义抽象方法,抽象方法的返回值就是泛型类型
185 }186 class InfoImpl implements Info< String>{ //定义泛型接口的子类
187 private String var ; //定义属性
188 public InfoImpl(String var){ //通过构造方法设置属性内容
189 this.setVar(var) ;190 }191 public voidsetVar(String var){192 this.var =var ;193 }194 publicString getVar(){195 return this.var ;196 }197 };198 public classGenericsDemo25{199 public static voidmain(String arsg[]){200 Info i = null; //声明接口对象
201 i = new InfoImpl(“汤姆”) ; //通过子类实例化对象
202 System.out.println(“内容:” +i.getVar()) ;203 }204 };205
206 Java泛型方法207
208 classDemo{209 public < T> T fun(T t){ //可以接收任意类型的数据
210 return t ; //直接把参数返回
211 }212 };213 public classGenericsDemo26{214 public static voidmain(String args[]){215 Demo d = new Demo() ; //实例化Demo对象
216 String str = d.fun(“汤姆”) ; //传递字符串
217 int i = d.fun(30) ; //传递数字,自动装箱
218 System.out.println(str) ; //输出内容
219 System.out.println(i) ; //输出内容
220 }221 };222
223 通过泛型方法返回泛型类型实例224
225 class Info< T extends Number>{ //指定上限,只能是数字类型
226 private T var ; //此类型由外部决定
227 publicT getVar(){228 return this.var ;229 }230 public voidsetVar(T var){231 this.var =var ;232 }233 public String toString(){ //覆写Object类中的toString()方法
234 return this.var.toString() ;235 }236 };237 public classGenericsDemo27{238 public static voidmain(String args[]){239 Info< Integer> i = fun(30) ;240 System.out.println(i.getVar()) ;241 }242 public static < T extends Number> Info< T> fun(T param){//方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定
243 Info< T> temp = new Info< T>() ; //根据传入的数据类型实例化Info
244 temp.setVar(param) ; //将传递的内容设置到Info对象的var属性之中
245 return temp ; //返回实例化对象
246 }247 };248
249 使用泛型统一传入的参数类型250
251 class Info< T>{ //指定上限,只能是数字类型
252 private T var ; //此类型由外部决定
253 publicT getVar(){254 return this.var ;255 }256 public voidsetVar(T var){257 this.var =var ;258 }259 public String toString(){ //覆写Object类中的toString()方法
260 return this.var.toString() ;261 }262 };263 public classGenericsDemo28{264 public static voidmain(String args[]){265 Info< String> i1 = new Info< String>() ;266 Info< String> i2 = new Info< String>() ;267 i1.setVar(“HELLO”) ; //设置内容
268 i2.setVar(“汤姆”) ; //设置内容
269 add(i1,i2) ;270 }271 public static < T> void add(Info< T> i1,Info< T>i2){272 System.out.println(i1.getVar() + ” ” +i2.getVar()) ;273 }274 };275
276 Java泛型数组277
278 public classGenericsDemo30{279 public static voidmain(String args[]){280 Integer i[] = fun1(1,2,3,4,5,6) ; //返回泛型数组
281 fun2(i) ;282 }283 public static < T> T[] fun1(T…arg){ //接收可变参数
284 return arg ; //返回泛型数组
285 }286 public static < T> void fun2(T param[]){ //输出
287 System.out.print(“接收泛型数组:”) ;288 for(T t:param){289 System.out.print(t + “、”) ;290 }291 }292 };293
294 Java泛型的嵌套设置295
296 class Info< T,V>{ //接收两个泛型类型
297 privateT var ;298 privateV value ;299 publicInfo(T var,V value){300 this.setVar(var) ;301 this.setValue(value) ;302 }303 public voidsetVar(T var){304 this.var =var ;305 }306 public voidsetValue(V value){307 this.value =value ;308 }309 publicT getVar(){310 return this.var ;311 }312 publicV getValue(){313 return this.value ;314 }315 };316 class Demo< S>{317 privateS info ;318 publicDemo(S info){319 this.setInfo(info) ;320 }321 public voidsetInfo(S info){322 this.info =info ;323 }324 publicS getInfo(){325 return this.info ;326 }327 };328 public classGenericsDemo31{329 public static voidmain(String args[]){330 Demo< Info< String,Integer>> d = null ; //将Info作为Demo的泛型类型
331 Info< String,Integer> i = null ; //Info指定两个泛型类型
332 i = new Info< String,Integer>(“汤姆”,30) ; //实例化Info对象
333 d = new Demo< Info< String,Integer>>(i) ; //在Demo类中设置Info类的对象
334 System.out.println(“内容一:” +d.getInfo().getVar()) ;335 System.out.println(“内容二:” +d.getInfo().getValue()) ;336 }337 };