本文实例讲述了java 泛型 定义与用法。分享给大家供大家参考，具体如下：
1. 泛型的由来
先看如下代码：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import java.util.list; import java.util.arraylist; public class testgeneric { @suppresswarnings ({ "rawtypes" , "unchecked" }) public static void main(string[] args) { list list = new arraylist(); list.add( 1 ); list.add( "1" ); list.add( new object()); system.out.println(list); // 取值 integer var1 = (integer) list.get( 0 ); string var2 = (string) list.get( 1 ); object var3 = list.get( 2 ); system.out.println(var1 + " " + var2 + " " + var3); } } |
运行结果：
[1, 1, java.lang.object@1db9742]
1 1 java.lang.object@1db9742
这段代码很简单，将整形、字符串、对象放进list集合中，然后逐一取出。可以看出，由于list接口在定义时并不知道元素的类型，因此默认为object,即任意类型元素进入list集合后都会自动装箱。而取值的过程更为复杂，所有取得的值都是装箱后的object对象，必须得知道每一个元素的初始类型才能拆箱。一般使用集合的时候，集合的元素往往都是具有共同特征的，比如同属于一类的----那么，如果一开始限定了list集合元素的类型，那么就可避免上述不规范操作。代码如下，
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import java.util.list; import java.util.arraylist; public class testgeneric { @suppresswarnings ( "unused" ) public static void main(string[] args) { list<string> list = new arraylist<string>(); // list.add(1);//报错 // list.add(new object());//报错 list.add( "1" ); // 取值 string var1 = list.get( 0 ); // 无需转换 } } |
如此一来，便有了泛型集合的说法。实际上，查阅list接口的api会发现，list接口正是泛型接口，它可以接受一个类型参数e，若不传递参数，则默认是object类型。
2. 泛型类型的继承关系
有如下功能的代码，实现打印任意集合的元素：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import java.util.list; import java.util.arraylist; import java.util.collection; public class testgeneric{ //打印任意集合元素 public void print(collection<object> c){ system.out.println(c); } public static void main(string[] args){ list<string> list= new arraylist<string>(); new testgeneric().print(list); } } |
输出：
testgeneric.java:11: 无法将 testgeneric 中的 print(java.util.collection<java.lang.object>) 应用于 (java.util.list<java.lang.string>)
new testgeneric().print(list);
^
1 错误
很明显，意思就是传递的参数类型不匹配。难道string不是继承自object的吗？没错，string是继承自object的，但是 list<string> 与 list<object> 是截然不同的两个类型，两者之间没有任何继承关系。那如果真的要实现上面的功能，该如何呢？
2.1 类型通配符
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import java.util.list; import java.util.arraylist; import java.util.collection; public class testgeneric { // 打印任意集合元素 public void print(collection<?> c) { system.out.println(c); } public static void main(string[] args) { list<string> list = new arraylist<string>(); new testgeneric().print(list); } } |
程序正常执行，这里的？表示一个未知类型，这个未知类型与object不同，list<?>代表了所有的list<类型>的父类。
2.2 泛型方法
不只有通配符可以解决泛型继承的问题，若将上面的方法定义为泛型方法也具有同样的效果：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import java.util.list; import java.util.arraylist; import java.util.collection; public class testgeneric { // 打印任意集合元素 public <t> void print(collection<t> c) { system.out.println(c); } public static void main(string[] args) { list<string> list = new arraylist<string>(); new testgeneric().print(list); } } |
泛型方法的定义形式如下，
修饰符 <t,e> 返回值 方法名(形参)
其中<t,e>在修饰符的后面做为类型定义，为方法指明形参中需要用到的t，e类型是来自哪里。既然泛型方法和类型通配符都可以实现泛型中的继承，那么有什么区别？
2.3 泛型方法和通配符的区别
看如下代码：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
import java.util.list; import java.util.arraylist; import java.util.collection; public class testgeneric { // 打印任意集合元素 public <e, t extends e> void print(collection<t> c1, collection<e> c2) { system.out.println(c1); system.out.println(c2); } public static void main(string[] args) { list<father> list1 = new arraylist<father>(); list<father> list2 = new arraylist<father>(); new testgeneric().print(list1, list2); // 传2个father类型 list<child> list3 = new arraylist<child>(); list<father> list4 = new arraylist<father>(); new testgeneric().print(list3, list4); // t为child，e为father list<father> list5 = new arraylist<father>(); list<child> list6 = new arraylist<child>(); new testgeneric().print(list5, list6); // t为father,e为child,报错 } } class father { } class child extends father { } class other { } |
上述泛型方法在定义t,e时已经指明了关系：t是e的子类，所以在传递参数的时候，t要么是e的子类，要么就是e本身，所以在传递关系不小心变为e exends t时，在第三次调用方法时报错了。而如果把上述代码换成？通配符的话，则不具有如此强的限定关系。
总之，泛型方法和？通配符都可以实现未知类型的继承，但是泛型方法主要强调多个未知类型之间的依赖关系。如果只是单纯用作成为一个通用类型的父类这一功能的话，两者都可以实现，反而？通配符较为简洁明了。
2.4 泛型参数上、下限的注意
看如下代码：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import java.util.list; import java.util.arraylist; import java.util.collection; public class testgeneric { // 复制集合并返回原始集合的最后一个元素 public <t> t copy(collection<t> des, collection<? extends t> src) { t lastelement = null ; for (t t : src) { lastelement = t; des.add(t); } return lastelement; } public static void main(string[] args) { list<number> des = new arraylist<number>(); list<integer> src = new arraylist<integer>(); src.add( new integer( 1 )); integer lastelement = new testgeneric().copy(des, src); // system.out.println(lastelement.getclass()); } } |
输出：
testgeneric.java:18: 不兼容的类型
找到： java.lang.number
需要： java.lang.integer
integer lastelement= new testgeneric().copy(des,src);//
^
1 错误
当调用完copy方法后，系统比对发现t类型为number,?类型为integer。所以函数返回的t类型是number了，所以根本不兼容integer。要修改上面的代码，有俩个办法，
方法1：
改为
|
1 |
number lastelement= new testgeneric().copy(des,src); |
分析代码可以得出，？为t的子类，在方法中 t=lastelement 这句表现为多态，虽然返回的是t类型，但是多态的表现为？类型，即interger类型，调用 lastelement.getclass() 也可发现返回的是 java.lang.integer 类型，说明此处编译类型为t类型，实际运行类型为？类型。这就好比如下多态转换，
|
1 2 |
father f= new child(); child c=f; //此处一定报错，类型不兼容 |
虽然f的多态表现为子类child,但是上面一句连语法检测都过不了。这也就是为什么上面integer不能兼容number的原因了。
方法2：
改为
|
1 |
public <t> t copy(collection<? super t> des,collection<t> src) |
这样一来，？类型变为了父类，t类型变为了子类，于是在方法中返回的t类型对象，即lastelement就不具有多态性了。泛型中的上下限是很有学问的，每次看源码时都会琢磨很久，但还是会在浩瀚的接口+泛型的设计中昏迷，这种设计真的完全是为了突出面向对象的特性，以后慢慢琢磨吧。
从这也再次可以看出？通配符在处理具有依赖关系的泛型方法中，显得过于灵活而会导致一些潜在的隐患。
希望本文所述对大家java程序设计有所帮助。
原文链接：https://blog.csdn.net/kkkkkxiaofei/article/details/18262049