java泛型与没有使用泛型的区别
介绍　　在Java SE
1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。
　　泛型的好处是在编译的时候检查，并且所有的都是自动和隐式的，提高代码的重用率。
规则和限制
　　1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
　　2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的实例是不兼容的。
　　3、泛型的类型参数可以有多个。
　　4、泛型的参数类型可以使用extends语句，例如&T extends
superclass&。习惯上称为“有界类型”。
　　5、泛型的参数类型还可以是通配符类型。例如Class&?&
classType = Class.forName("java.lang.String");
　　泛型还有接口、方法等等，内容很多，需要花费一番功夫才能理解掌握并熟练应用。在此给出我曾经了解泛型时候写出的两个例子（根据看的印象写的），实现同样的功能，一个使用了泛型，一个没有使用，通过对比，可以很快学会泛型的应用，学会这个基本上学会了泛型70%的内容。
　　例子一：使用了泛型
　　public class Gen&T& {
　　private T //定义泛型成员变量
　　public Gen(T ob) {
　　this.ob =
　　public T getOb() {
　　public void setOb(T ob) {
　　this.ob =
　　public void showType() {
　　System.out.println("T的实际类型是: " + ob.getClass().getName());
　　public class GenDemo {
　　public static void main(String[] args){
　　//定义泛型类Gen的一个Integer版本
　　Gen&Integer& intOb=new
Gen&Integer&(88);
　　intOb.showType();
　　int i= intOb.getOb();
　　System.out.println("value= " + i);
　　System.out.println("----------------------------------");
　　//定义泛型类Gen的一个String版本
　　Gen&String& strOb=new
Gen&String&("Hello Gen!");
　　strOb.showType();
　　String s=strOb.getOb();
　　System.out.println("value= " + s);
　　例子二：没有使用泛型
　　public class Gen2 {
　　private O //定义一个通用类型成员
　　public Gen2(Object ob) {
　　this.ob =
　　public Object getOb() {
　　public void setOb(Object ob) {
　　this.ob =
　　public void showTyep() {
　　System.out.println("T的实际类型是: " + ob.getClass().getName());
　　public class GenDemo2 {
　　public static void main(String[] args) {
　　//定义类Gen2的一个Integer版本
　　Gen2 intOb = new Gen2(new Integer(88));
　　intOb.showTyep();
　　int i = (Integer) intOb.getOb();
　　System.out.println("value= " + i);
　　System.out.println("---------------------------------");
　　//定义类Gen2的一个String版本
　　Gen2 strOb = new Gen2("Hello Gen!");
　　strOb.showTyep();
　　String s = (String) strOb.getOb();
　　System.out.println("value= " + s);
　　运行结果：
　　两个例子运行Demo结果是相同的,控制台输出结果如下：
　　T的实际类型是:
　　java.lang.Integer
　　value= 88
　　----------------------------------
　　T的实际类型是: java.lang.String
　　value= Hello Gen!
　　Process finished with exit code 0
　　看明白这个，以后基本的泛型应用和代码阅读就不成问题了。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。Java 泛型中super T和extends T的区别_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
Java 泛型中super T和extends T的区别
|0|0|文档简介
北大青鸟IT培训|
总评分0.0|
&&Java知识记录
阅读已结束，如果下载本文需要使用0下载券
想免费下载更多文档？
定制HR最喜欢的简历
下载文档到电脑，查找使用更方便
还剩1页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢中国领先的IT技术网站
51CTO旗下网站
Java 泛型中super T和extends T的区别
经常发现有List、Set的声明，是什么意思呢？表示包括T在内的任何T的父类，表示包括T在内的任何T的子类，下面我们详细分析一下两种通配符具体的区别。
作者：来源：| 09:36
经常发现有List& super T&、Set&extends T&的声明，是什么意思呢？&
super T&表示包括T在内的任何T的父类，& extends
T&表示包括T在内的任何T的子类，下面我们详细分析一下两种通配符具体的区别。
List&&extends&Number&&foo3的通配符声明，意味着以下的赋值是合法的：&&&&List&&extends&Number&&foo3&=&new&ArrayList&&extends&Number&();&&&&List&&extends&Number&&foo3&=&new&ArrayList&&extends&Integer&();&&&&List&&extends&Number&&foo3&=&new&ArrayList&&extends&Double&();&
读取操作通过以上给定的赋值语句，你一定能从foo3列表中读取到的元素的类型是什么呢？你可以读取到Number，因为以上的列表要么包含 Number元素，要么包含Number的类元素。你不能保证读取到Integer，因为foo3可能指向的是List&Double&。你 不能保证读取到Double，因为foo3可能指向的是List&Integer&。
写入操作过以上给定的赋值语句，你能把一个什么类型的元素合法地插入到foo3中呢？你不能插入一个Integer元素，因为foo3可能指向 List&Double&。你不能插入一个Double元素，因为foo3可能指向List&Integer&。你不能插入一个 Number元素，因为foo3可能指向List&Integer&。你不能往List& extends
T&中插入任何类型的对象，因为你不能保证列表实际指向的类型是什么，你并不能保证列表中实际存储什么类型的对象。唯一可以保证的是，你可以从中读 取到T或者T的子类。
现在考虑一下List& super T&。
List&&super&Integer&&foo3的通配符声明，意味着以下赋值是合法的：&&&&List&&super&Integer&&foo3&=&new&ArrayList&Integer&();&&&&List&&super&Integer&&foo3&=&new&ArrayList&Number&();&&&&List&&super&Integer&&foo3&=&new&ArrayList&Object&();&
读取操作通过以上给定的赋值语句，你一定能从foo3列表中读取到的元素的类型是什么呢？你不能保证读取到Integer，因为foo3可能指向 List&Number&或者List&Object&。你不能保证读取到Number，因为foo3可能指向 List&Object&。唯一可以保证的是，你可以读取到Object或者Object子类的对象（你并不知道具体的子类是什么）。
写入操作通过以上给定的赋值语句，你能把一个什么类型的元素合法地插入到foo3中呢？你可以插入Integer对象，因为上述声明的列表都支持 Integer。你可以插入Integer的子类的对象，因为Integer的子类同时也是Integer，原因同上。你不能插入Double对象，因为 foo3可能指向ArrayList&Integer&。你不能插入Number对象，因为foo3可能指向 ArrayList&Integer&。你不能插入Object对象，因为foo3可能指向 ArrayList&Integer&。
请记住PECS原则：生产者（Producer）使用extends，消费者（Consumer）使用super。
生产者使用extends
如果你需要一个列表提供T类型的元素（即你想从列表中读取T类型的元素），你需要把这个列表声明成& extends T&，比如List& extends Integer&，因此你不能往该列表中添加任何元素。
消费者使用super
如果需要一个列表使用T类型的元素（即你想把T类型的元素加入到列表中），你需要把这个列表声明成& super T&，比如List& super Integer&，因此你不能保证从中读取到的元素的类型。
即是生产者，也是消费者
如果一个列表即要生产，又要消费，你不能使用泛型通配符声明列表，比如List&Integer&。
请参考java.util.Collections里的copy方法(JDK1.7)：
我们可以从Java开发团队的代码中获得到一些启发，copy方法中使用到了PECS原则，实现了对参数的保护。
【责任编辑： TEL：（010）】
大家都在看猜你喜欢
外电头条头条外电头条
24H热文一周话题本月最赞
讲师：1人学习过
讲师：28人学习过
讲师：0人学习过
精选博文论坛热帖下载排行
本书全面深入地介绍网络安全的配置与实现技术，包括系统管理、用户账户、病毒防御、灾难恢复、文件备份、安全策略、注册表等服务器安全，用...
订阅51CTO邮刊让天下没有难学的技术}