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 return var ;
11 }
12 public void setVar(T var){ // 设置的类型也由外部决定
13 this.var = var ;
14 }
15 };
16 public class GenericsDemo06{
17 public static void main(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 public K getKey(){
29 return this.key ;
30 }
31 public V getValue(){
32 return this.value ;
33 }
34 public void setKey(K key){
35 this.key = key ;
36 }
37 public void setValue(V value){
38 this.value = value ;
39 }
40 };
41 public class GenericsDemo09{
42 public static void main(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 void setVar(T var){
58 this.var = var ;
59 }
60 public T getVar(){
61 return this.var ;
62 }
63 public String toString(){ // 直接打印
64 return this.var.toString() ;
65 }
66 };
67 public class GenericsDemo14{
68 public static void main(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 void setVar(T var){
83 this.var = var ;
84 }
85 public T getVar(){
86 return this.var ;
87 }
88 public String toString(){ // 直接打印
89 return this.var.toString() ;
90 }
91 };
92 public class GenericsDemo17{
93 public static void main(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 void setVar(T var){
111 this.var = var ;
112 }
113 public T getVar(){
114 return this.var ;
115 }
116 public String toString(){ // 直接打印
117 return this.var.toString() ;
118 }
119 };
120 public class GenericsDemo21{
121 public static void main(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(new Object()) ;
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 void setVar(T var){
139 this.var = var ;
140 }
141 public T getVar(){
142 return this.var ;
143 }
144 public String toString(){ // 直接打印
145 return this.var.toString() ;
146 }
147 };
148 public class GenericsDemo23{
149 public static void main(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 void setVar(T var){
167 this.var = var ;
168 }
169 public T getVar(){
170 return this.var ;
171 }
172 };
173 public class GenericsDemo24{
174 public static void main(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 void setVar(String var){
192 this.var = var ;
193 }
194 public String getVar(){
195 return this.var ;
196 }
197 };
198 public class GenericsDemo25{
199 public static void main(String arsg[]){
200 Info i = null; // 声明接口对象
201 i = new InfoImpl("汤姆") ; // 通过子类实例化对象
202 System.out.println("内容：" + i.getVar()) ;
203 }
204 };
205
206 Java泛型方法
207
208 class Demo{
209 public < T> T fun(T t){ // 可以接收任意类型的数据
210 return t ; // 直接把参数返回
211 }
212 };
213 public class GenericsDemo26{
214 public static void main(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 public T getVar(){
228 return this.var ;
229 }
230 public void setVar(T var){
231 this.var = var ;
232 }
233 public String toString(){ // 覆写Object类中的toString()方法
234 return this.var.toString() ;
235 }
236 };
237 public class GenericsDemo27{
238 public static void main(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 public T getVar(){
254 return this.var ;
255 }
256 public void setVar(T var){
257 this.var = var ;
258 }
259 public String toString(){ // 覆写Object类中的toString()方法
260 return this.var.toString() ;
261 }
262 };
263 public class GenericsDemo28{
264 public static void main(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 class GenericsDemo30{
279 public static void main(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 private T var ;
298 private V value ;
299 public Info(T var,V value){
300 this.setVar(var) ;
301 this.setValue(value) ;
302 }
303 public void setVar(T var){
304 this.var = var ;
305 }
306 public void setValue(V value){
307 this.value = value ;
308 }
309 public T getVar(){
310 return this.var ;
311 }
312 public V getValue(){
313 return this.value ;
314 }
315 };
316 class Demo< S>{
317 private S info ;
318 public Demo(S info){
319 this.setInfo(info) ;
320 }
321 public void setInfo(S info){
322 this.info = info ;
323 }
324 public S getInfo(){
325 return this.info ;
326 }
327 };
328 public class GenericsDemo31{
329 public static void main(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 };
转载于http://www.cnblogs.com/dk18stone/p/3738228.html