java泛型学习

 ##.可以这样理解，类名和类型参数一起组成了一个新的类型: 比如List<String> 和 List<Object>是两个不同的类型。

##其实泛型也没那么可怕，它就是一个个简简单单的类型参数代表一个类型，在定义时先用一个暂位符代表了，占位符可以是任意字符比如T，那么当我们需要用到这个类做声明时就指出类型参数具体代表什么类型就可以了。java集合框架类已帮我定义了对应的泛型类，所以我们使用时需要指出类型参数的具体代表类型。比如List<String> 也就是说我要放入的是String对象而不是其他.===>比较好的一个总结:http://blog.csdn.net/jinuxwu/article/details/6771121

 ##本文主要是在类中讲述泛型，实际上，泛型还可以用在类方法、接口

 public class TestClassDefine<T, S extends T> {
....
} ====>S extends T表示对S类型的进一步限定，具体继承是什么类现在还没知道，但在具体指明时间类型参数时，S类型应该是T类型的子类。

###个人理解: 在泛型之前，在操作集合类时转换类型的确也是一个小小的问题，因为有时忘了转换并会提示出错，现在泛型的一个好处是把运行时的转型错误在编译期就搞定了，另外由于泛型已经指定了参数的类型，所以只要允许这些类型放进去，那么在拿出来的时候就不需要转型了。

什么时候写泛型？有什么好处？

最简单的体现，只要使用到了带有<>的类和接口，就指定具体对象类型。====>这些类一大部分是jdk带的比如集合框架下的类，另一部分是自己按需要些的泛型方法和泛型类，当这些方法或者类需要使用时，我需要具体指出类型。比如List<String> 那么在我们声明和赋值时指出之后，但需要重这个list拿东西出来的时候我们就不需要强制转换成String的代码了

 

泛型的好处：

1， 将运行时出现的ClassCastException问题，再编译时期给解决了。运行就安全了。

2， 避免了强制转换的麻烦。

 

所以泛型就是JDK1.5后出现的一个安全机制。

==>个人觉得还有一个好处就是可以通过泛型来实现多态，具体是说节省重载方法的代码。比如有一个方法 void f(int a){}; 假如业务还需要另一个传入String 的方法，那么就需要重载一个方法void f(String a) {}; 但使用多态后只需写一个 void f(T a){}, 那么在调用这个方法时再具体事例化这个类型，这个有点像实参和行参的关系，不过实参形参是传值（值传递），而这个只是给类型参数确定下具体类型. 

##2.
什么时候使用泛型类？

当类中要操作的引用数据类型不确定的时候，以前使用的是共性类型Object，

现在可以使用泛型来解决。

====>比如说有个变量，现在还没确定是什么类型，但在该类的方法需要用到，那么以前的做法是把它定义成Object型，那么在找这个对象出来的时候也是需要转换的，有泛型后，只需再类使用使用一个占位符比如T，那么在需要使用到这个参数的地方都是使用类型T的参数，那么在具体使用这个类作为类型声明变量时，可以连通类型参数T一起初始化，指出T是什么类型.( 记住有点类似形参和实参的关系，只不过它只是在使用类来声明时, 具体指出类型参数的当前具体类型应该是什么)

什么时候使用泛型方法？

当方法操作的引用数据类型不确定的时候，就使用泛型方法。

====>道理同上，在自己定义泛型方法时如果当前不能确定数据类型 比如参数的数据类型有很多种比如int，string等，那么就可以使用泛型，这样就不用重载很多方法也可以实现多态，其实把该参数的类型定义成Object也可以达到目的，但那样需要做类型转换.

 

##3.泛型类中数据类型的约束
程序员在编写泛型类时，总是会对通用数据类型T进行有意或无意地有假想，也就是说这个T一般来说是不能适应所有类型，但怎样限制调用者传入的数据类型呢？===>其实我之前真的有这方面的顾虑，总感觉这个T代表所有的类型不踏实，那怎么办呢，其实我们可以对这个T占位符所代表的类型做进一步的限定以缩小范围，那就是继承一个父类,(这就需要对传入的数据类型进行约束，约束的方式是指定T的祖先，即继承的接口或类。)

##2.========以下这个是用c#写的。。不过可以参考=================

泛型是什么，为什么要使用泛型，泛型的出现是解决什么问题的

我们在编写程序时，经常遇到两个模块的功能非常相似，只是一个是处理int数据，另一个是处理string数据，或者其他自定义的数据类型，但我们没有办法，只能分别写多个方法处理每个数据类型，因为方法的参数类型不同。有没有一种办法，在方法中传入通用的数据类型，这样不就可以合并代码了吗？泛型的出现就是专门解决这个问题的。读完本篇文章，你会对泛型有更深的了解。

为什么要使用泛型
为了了解这个问题，我们先看下面的代码，代码省略了一些内容，但功能是实现一个栈，这个栈只能处理int数据类型：

public class Stack

{

private int[] m_item;

public int Pop(){...}

public void Push(int item){...}

public Stack(int i)

{

this.m_item = new int[i];

}

}

上面代码运行的很好，但是，当我们需要一个栈来保存string类型时，该怎么办呢？很多人都会想到把上面的代码复制一份，把int改成string不就行了。当然，这样做本身是没有任何问题的，但一个优秀的程序是不会这样做的，因为他想到若以后再需要long、Node类型的栈该怎样做呢？还要再复制吗？优秀的程序员会想到用一个通用的数据类型object来实现这个栈：

public class Stack

{

private object[] m_item;

public object Pop(){...}

public void Push(object item){...}

public Stack(int i)

{

this.m_item = new[i];

}

 

}

这个栈写的不错，他非常灵活，可以接收任何数据类型，可以说是一劳永逸。但全面地讲，也不是没有缺陷的，主要表现在：

当Stack处理值类型时，会出现装箱、折箱操作，这将在托管堆上分配和回收大量的变量，若数据量大，则性能损失非常严重。
在处理引用类型时，虽然没有装箱和折箱操作，但将用到数据类型的强制转换操作，增加处理器的负担。
在数据类型的强制转换上还有更严重的问题（假设stack是Stack的一个实例）：
Node1 x = new Node1();

stack.Push(x);

Node2 y = (Node2)stack.Pop();

上面的代码在编译时是完全没问题的，但由于Push了一个Node1类型的数据，但在Pop时却要求转换为Node2类型，这将出现程序运行时的类型转换异常，但却逃离了编译器的检查。

 

针对object类型栈的问题，我们引入泛型，他可以优雅地解决这些问题。泛型用用一个通过的数据类型T来代替object，在类实例化时指定T的类型，运行时（Runtime）自动编译为本地代码，运行效率和代码质量都有很大提高，并且保证数据类型安全。

 

使用泛型
下面是用泛型来重写上面的栈，用一个通用的数据类型T来作为一个占位符，等待在实例化时用一个实际的类型来代替。让我们来看看泛型的威力：

public class Stack<T>

{

private T[] m_item;

public T Pop(){...}

public void Push(T item){...}

public Stack(int i)

{

this.m_item = new T[i];

}

}

类的写法不变，只是引入了通用数据类型T就可以适用于任何数据类型，并且类型安全的。这个类的调用方法：

//实例化只能保存int类型的类

Stack<int> a = new Stack<int>(100);

a.Push(10);

a.Push("8888"); //这一行编译不通过，因为类a只接收int类型的数据

int x = a.Pop();

 

//实例化只能保存string类型的类

Stack<string> b = new Stack<string>(100);

b.Push(10); //这一行编译不通过，因为类b只接收string类型的数据

b.Push("8888");

string y = b.Pop();

 

这个类和object实现的类有截然不同的区别：

1. 他是类型安全的。实例化了int类型的栈，就不能处理string类型的数据，其他数据类型也一样。

2. 无需装箱和折箱。这个类在实例化时，按照所传入的数据类型生成本地代码，本地代码数据类型已确定，所以无需装箱和折箱。

3. 无需类型转换。

 

泛型类实例化的理论
C#泛型类在编译时，先生成中间代码IL，通用类型T只是一个占位符。在实例化类时，根据用户指定的数据类型代替T并由即时编译器（JIT）生成本地代码，这个本地代码中已经使用了实际的数据类型，等同于用实际类型写的类，所以不同的封闭类的本地代码是不一样的。按照这个原理，我们可以这样认为：

泛型类的不同的封闭类是分别不同的数据类型。

例：Stack<int>和Stack<string>是两个完全没有任何关系的类，你可以把他看成类A和类B，这个解释对泛型类的静态成员的理解有很大帮助。

 

泛型类中数据类型的约束
程序员在编写泛型类时，总是会对通用数据类型T进行有意或无意地有假想，也就是说这个T一般来说是不能适应所有类型，但怎样限制调用者传入的数据类型呢？这就需要对传入的数据类型进行约束，约束的方式是指定T的祖先，即继承的接口或类。因为C#的单根继承性，所以约束可以有多个接口，但最多只能有一个类，并且类必须在接口之前。这时就用到了C#2.0的新增关键字：

public class Node<T, V> where T : Stack, IComparable

where V: Stack

{...}

以上的泛型类的约束表明，T必须是从Stack和IComparable继承，V必须是Stack或从Stack继承，否则将无法通过编译器的类型检查，编译失败。

通用类型T没有特指，但因为C#中所有的类都是从object继承来，所以他在类Node的编写中只能调用object类的方法，这给程序的编写造成了困难。比如你的类设计只需要支持两种数据类型int和string，并且在类中需要对T类型的变量比较大小，但这些却无法实现，因为object是没有比较大小的方法的。 了解决这个问题，只需对T进行IComparable约束，这时在类Node里就可以对T的实例执行CompareTo方法了。这个问题可以扩展到其他用户自定义的数据类型。

如果在类Node里需要对T重新进行实例化该怎么办呢？因为类Node中不知道类T到底有哪些构造函数。为了解决这个问题，需要用到new约束：

public class Node<T, V> where T : Stack, new()

where V: IComparable

需要注意的是，new约束只能是无参数的，所以也要求相应的类Stack必须有一个无参构造函数，否则编译失败。

C#中数据类型有两大类：引用类型和值类型。引用类型如所有的类，值类型一般是语言的最基本类型，如int, long, struct等，在泛型的约束中，我们也可以大范围地限制类型T必须是引用类型或必须是值类型，分别对应的关键字是class和struct:

public class Node<T, V> where T : class

where V: struct

 

泛型方法
泛型不仅能作用在类上，也可单独用在类的方法上，他可根据方法参数的类型自动适应各种参数，这样的方法叫泛型方法。看下面的类：

public class Stack2

{

public void Push<T>(Stack<T> s, params T[] p)

{

foreach (T t in p)

{

s.Push(t);

}

}

}

原来的类Stack一次只能Push一个数据，这个类Stack2扩展了Stack的功能（当然也可以直接写在Stack中），他可以一次把多个数据压入Stack中。其中Push是一个泛型方法，这个方法的调用示例如下：

Stack<int> x = new Stack<int>(100);

Stack2 x2 = new Stack2();

x2.Push(x, 1, 2, 3, 4, 6);

string s = "";

for (int i = 0; i < 5; i++)

{

s += x.Pop().ToString();

} //至此，s的值为64321

 

 

泛型中的静态成员变量
在C#1.x中，我们知道类的静态成员变量在不同的类实例间是共享的，并且他是通过类名访问的。C#2.0中由于引进了泛型，导致静态成员变量的机制出现了一些变化：静态成员变量在相同封闭类间共享，不同的封闭类间不共享。

这也非常容易理解，因为不同的封闭类虽然有相同的类名称，但由于分别传入了不同的数据类型，他们是完全不同的类，比如：

Stack<int> a = new Stack<int>();

Stack<int> b = new Stack<int>();

Stack<long> c = new Stack<long>();

类实例a和b是同一类型，他们之间共享静态成员变量，但类实例c却是和a、b完全不同的类型，所以不能和a、b共享静态成员变量。

泛型中的静态构造函数
静态构造函数的规则：只能有一个，且不能有参数，他只能被.NET运行时自动调用，而不能人工调用。

泛型中的静态构造函数的原理和非泛型类是一样的，只需把泛型中的不同的封闭类理解为不同的类即可。以下两种情况可激发静态的构造函数：

1. 特定的封闭类第一次被实例化。

2. 特定封闭类中任一静态成员变量被调用。

 

泛型类中的方法重载
方法的重载在.Net Framework中被大量应用，他要求重载具有不同的签名。在泛型类中，由于通用类型T在类编写时并不确定，所以在重载时有些注意事项，这些事项我们通过以下的例子说明：

public class Node<T, V>

{

public T add(T a, V b) //第一个add

{

return a;

}

public T add(V a, T b) //第二个add

{

return b;

}

public int add(int a, int b) //第三个add

{

return a + b;

}

}

上面的类很明显，如果T和V都传入int的话，三个add方法将具有同样的签名，但这个类仍然能通过编译，是否会引起调用混淆将在这个类实例化和调用add方法时判断。请看下面调用代码：

Node<int, int> node = new Node<int, int>();

object x = node.add(2, 11);

这个Node的实例化引起了三个add具有同样的签名，但却能调用成功，因为他优先匹配了第三个add。但如果删除了第三个add，上面的调用代码则无法编译通过，提示方法产生的混淆，因为运行时无法在第一个add和第二个add之间选择。

Node<string, int> node = new Node<string, int>();

object x = node.add(2, "11");

这两行调用代码可正确编译，因为传入的string和int，使三个add具有不同的签名，当然能找到唯一匹配的add方法。

由以上示例可知，C#的泛型是在实例的方法被调用时检查重载是否产生混淆，而不是在泛型类本身编译时检查。同时还得出一个重要原则：

当一般方法与泛型方法具有相同的签名时，会覆盖泛型方法。

 

泛型类的方法重写
方法重写（override）的主要问题是方法签名的识别规则，在这一点上他与方法重载一样，请参考泛型类的方法重载。

 

泛型的使用范围
本文主要是在类中讲述泛型，实际上，泛型还可以用在类方法、接口、结构（struct）、委托等上面使用，使用方法大致相同，就不再讲述。

小结
C# 泛型是开发工具库中的一个无价之宝。它们可以提高性能、类型安全和质量，减少重复性的编程任务，简化总体编程模型，而这一切都是通过优雅的、可读性强的语法完成的。尽管 C# 泛型的根基是 C++ 模板，但 C# 通过提供编译时安全和支持将泛型提高到了一个新水平。C# 利用了两阶段编译、元数据以及诸如约束和一般方法之类的创新性的概念。毫无疑问，C# 的将来版本将继续发展泛型，以便添加新的功能，并且将泛型扩展到诸如数据访问或本地化之类的其他 .NET Framework 领域。

======================end======c#+++++++++++++++++++++++++============

 

 

 

 ###3.http://blog.csdn.net/jinuxwu/article/details/6771121

Java泛型详解

 

1. 概述
在引入范型之前，Java类型分为原始类型、复杂类型，其中复杂类型分为数组和类。引入范型后，一个复杂类型
就可以在细分成更多的类型。
例如原先的类型List，现在在细分成List<Object>, List<String>等更多的类型。
注意，现在List<Object>, List<String>是两种不同的类型，
他们之间没有继承关系，即使String继承了Object。下面的代码是非法的
List<String> ls = new ArrayList<String>();
List<Object> lo = ls;
这样设计的原因在于，根据lo的声明，编译器允许你向lo中添加任意对象（例如Integer），但是此对象是
List<String>，破坏了数据类型的完整性。
在引入范型之前，要在类中的方法支持多个数据类型，就需要对方法进行重载，在引入范型后，可以解决此问题
（多态），更进一步可以定义多个参数以及返回值之间的关系。
例如
public void write(Integer i, Integer[] ia);
public void write(Double d, Double[] da);
的范型版本为
public <T> void write(T t, T[] ta);

2. 定义&使用
类型参数的命名风格为：
推荐你用简练的名字作为形式类型参数的名字(如果可能，单个字符)。最好避免小写字母，这使它和其他的普通
的形式参数很容易被区分开来。
使用T代表类型，无论何时都没有比这更具体的类型来区分它。这经常见于泛型方法。如果有多个类型参数，我们
可能使用字母表中T的临近的字母，比如S。
如果一个泛型函数在一个泛型类里面出现，最好避免在方法的类型参数和类的类型参数中使用同样的名字来避免混
淆。对内部类也是同样。

2.1 定义带类型参数的类
在定义带类型参数的类时，在紧跟类命之后的<>内,指定一个或多个类型参数的名字，同时也可以对类型参数的取
值范围进行限定，多个类型参数之间用,号分隔。
定义完类型参数后，可以在定义位置之后的类的几乎任意地方（静态块，静态属性，静态方法除外）使用类型参数，
就像使用普通的类型一样。
注意，父类定义的类型参数不能被子类继承。
public class TestClassDefine<T, S extends T> {
....
}

2.2 定义待类型参数方法
在定义带类型参数的方法时，在紧跟可见范围修饰（例如public）之后的<>内,指定一个或多个类型参数的名字，
同时也可以对类型参数的取值范围进行限定，多个类型参数之间用,号分隔。
定义完类型参数后，可以在定义位置之后的方法的任意地方使用类型参数，就像使用普通的类型一样。
例如：
public <T, S extends T> T testGenericMethodDefine(T t, S s){
...
}
注意：定义带类型参数的方法，骑主要目的是为了表达多个参数以及返回值之间的关系。例如本例子中T和S的继
承关系， 返回值的类型和第一个类型参数的值相同。
如果仅仅是想实现多态，请优先使用通配符解决。通配符的内容见下面章节。
public <T> void testGenericMethodDefine2(List<T> s){
...
}
应改为
public void testGenericMethodDefine2(List<？> s){
...
}

3. 类型参数赋值
当对类或方法的类型参数进行赋值时，要求对所有的类型参数进行赋值。否则，将得到一个编译错误。

3.1 对带类型参数的类进行类型参数赋值
对带类型参数的类进行类型参数赋值有两种方式
第一声明类变量或者实例化时。例如
List<String> list;
list = new ArrayList<String>;
第二继承类或者实现接口时。例如
public class MyList<E> extends ArrayList<E> implements List<E> {...}

3.2 对带类型参数方法进行赋值
当调用范型方法时，编译器自动对类型参数进行赋值，当不能成功赋值时报编译错误。例如
public <T> T testGenericMethodDefine3(T t, List<T> list){
...
}
public <T> T testGenericMethodDefine4(List<T> list1, List<T> list2){
...
}

Number n = null;
Integer i = null;
Object o = null;
testGenericMethodDefine(n, i);//此时T为Number, S为Integer
testGenericMethodDefine(o, i);//T为Object, S为Integer

List<Number> list1 = null;
testGenericMethodDefine3(i, list1)//此时T为Number

List<Integer> list2 = null;
testGenericMethodDefine4(list1, list2)//编译报错

3.3 通配符
在上面两小节中，对是类型参数赋予具体的值，除此，还可以对类型参数赋予不确定值。例如
List<?> unknownList;
List<? extends Number> unknownNumberList;
List<? super Integer> unknownBaseLineIntgerList;
注意： 在Java集合框架中，对于参数值是未知类型的容器类，只能读取其中元素，不能像其中添加元素，
因为，其类型是未知，所以编译器无法识别添加元素的类型和容器的类型是否兼容，唯一的例外是NULL

List<String> listString;
List<?> unknownList2 = listString;
unknownList = unknownList2;
listString = unknownList;//编译错误

4. 数组范型
可以使用带范型参数值的类声明数组，却不可有创建数组
List<Integer>[] iListArray;
new ArrayList<Integer>[10];//编译时错误

5. 实现原理

5.1. Java范型时编译时技术，在运行时不包含范型信息，仅仅Class的实例中包含了类型参数的定义信息。
泛型是通过java编译器的称为擦除(erasure)的前端处理来实现的。你可以（基本上就是）把它认为是一个从源
码到源码的转换，它把泛型版本转换成非泛型版本。
基本上，擦除去掉了所有的泛型类型信息。所有在尖括号之间的类型信息都被扔掉了，因此，比如说一个
List<String>类型被转换为List。所有对类型变量的引用被替换成类型变量的上限(通常是Object)。而且，
无论何时结果代码类型不正确，会插入一个到合适类型的转换。
<T> T badCast(T t, Object o) {
return (T) o; // unchecked warning
}
类型参数在运行时并不存在。这意味着它们不会添加任何的时间或者空间上的负担，这很好。不幸的是，这也意味
着你不能依靠他们进行类型转换。

5.2.一个泛型类被其所有调用共享
下面的代码打印的结果是什么？
List<String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();
System.out.println(l1.getClass() == l2.getClass());
或许你会说false，但是你想错了。它打印出true。因为一个泛型类的所有实例在运行时具有相同的运行时类(class)，
而不管他们的实际类型参数。
事实上，泛型之所以叫泛型，就是因为它对所有其可能的类型参数，有同样的行为；同样的类可以被当作许多不同
的类型。作为一个结果，类的静态变量和方法也在所有的实例间共享。这就是为什么在静态方法或静态初始化代码
中或者在静态变量的声明和初始化时使用类型参数（类型参数是属于具体实例的）是不合法的原因。

5.3. 转型和instanceof
泛型类被所有其实例(instances)共享的另一个暗示是检查一个实例是不是一个特定类型的泛型类是没有意义的。
Collection cs = new ArrayList<String>();
if (cs instanceof Collection<String>) { ...} // 非法
类似的，如下的类型转换
Collection<String> cstr = (Collection<String>) cs;
得到一个unchecked warning，因为运行时环境不会为你作这样的检查。

6. Class的范型处理
Java 5之后，Class变成范型化了。
JDK1.5中一个变化是类 java.lang.Class是泛型化的。这是把泛型扩展到容器类之外的一个很有意思的例子。
现在，Class有一个类型参数T, 你很可能会问，T 代表什么？它代表Class对象代表的类型。比如说，
String.class类型代表 Class<String>，Serializable.class代表 Class<Serializable>。
这可以被用来提高你的反射代码的类型安全。
特别的，因为 Class的 newInstance() 方法现在返回一个T, 你可以在使用反射创建对象时得到更精确的类型。
比如说，假定你要写一个工具方法来进行一个数据库查询，给定一个SQL语句，并返回一个数据库中符合查询条件
的对象集合(collection)。
一个方法是显式的传递一个工厂对象，像下面的代码：
interface Factory<T> {
public T[] make();
}
public <T> Collection<T> select(Factory<T> factory, String statement) {
Collection<T> result = new ArrayList<T>();
/* run sql query using jdbc */
for ( int i=0; i<10; i++ ) { /* iterate over jdbc results */
T item = factory.make();
/* use reflection and set all of item’s fields from sql results */
result.add( item );
}
return result;
}
你可以这样调用：
select(new Factory<EmpInfo>(){
public EmpInfo make() {
return new EmpInfo();
}
} , ”selection string”);
也可以声明一个类 EmpInfoFactory 来支持接口 Factory：
class EmpInfoFactory implements Factory<EmpInfo> { ...
public EmpInfo make() { return new EmpInfo();}
}
然后调用：
select(getMyEmpInfoFactory(), "selection string");
这个解决方案的缺点是它需要下面的二者之一：
调用处那冗长的匿名工厂类，或为每个要使用的类型声明一个工厂类并传递其对象给调用的地方
这很不自然。
使用class类型参数值是非常自然的，它可以被反射使用。没有泛型的代码可能是：
Collection emps = sqlUtility.select(EmpInfo.class, ”select * from emps”); ...
public static Collection select(Class c, String sqlStatement) {
Collection result = new ArrayList();
/* run sql query using jdbc */
for ( /* iterate over jdbc results */ ) {
Object item = c.newInstance();
/* use reflection and set all of item’s fields from sql results */
result.add(item);
}
return result;
}
但是这不能给我们返回一个我们要的精确类型的集合。现在Class是泛型的，我们可以写：
Collection<EmpInfo> emps=sqlUtility.select(EmpInfo.class, ”select * from emps”); ...
public static <T> Collection<T> select(Class<T>c, String sqlStatement) {
Collection<T> result = new ArrayList<T>();
/* run sql query using jdbc */
for ( /* iterate over jdbc results */ ) {
T item = c.newInstance();
/* use reflection and set all of item’s fields from sql results */
result.add(item);
}
return result;
}
来通过一种类型安全的方式得到我们要的集合。
这项技术是一个非常有用的技巧，它已成为一个在处理注释(annotations)的新API中被广泛使用的习惯用法。

7. 新老代码兼容

7.1. 为了保证代码的兼容性，下面的代码编译器（javac）允许，类型安全有你自己保证
List l = new ArrayList<String>();
List<String> l = new ArrayList();

7.2. 在将你的类库升级为范型版本时，慎用协变式返回值。
例如，将代码
public class Foo {
public Foo create(){
return new Foo();
}
}

public class Bar extends Foo {
public Foo create(){
return new Bar();
}
}
采用协变式返回值风格，将Bar修改为
public class Bar extends Foo {
public Bar create(){
return new Bar();
}
}
要小心你类库的客户端。

 

 

 

##1.转自:

http://blog.csdn.net/zsm653983/article/details/8127537

Java 泛型详解

分类： java笔记2012-10-30 11:56675人阅读评论(1)收藏举报

首先在没有泛型之前，一旦把一个对象丢进java集合中，集合就会忘记对象的类型，把所有对象当成Object类型来处理。当程序从集合中取出对象时，就需要进行强制类型转换，这种强制类型转换不仅代码臃肿，而且容易引起ClassCastException异常。

 

publicclass ListErr
{
 publicstaticvoid main(String[] args)
 {
 //创建一个只想保存字符串的List集合
 List strList = new ArrayList();
 strList.add("Struts2权威指南");
 strList.add("基于J2EE的Ajax宝典");
 strList.add("轻量级J2EE企业应用实战");
 //”不小心“把一个Integer对象”丢进"了集合
 strList.add(5);
 for (int i = 0; i < strList.size() ; i++ )
 {
 //因为List里取出的全部是Object，所以必须强制类型转换
 //最后一个元素将出现ClassCastException异常
 String str = (String)strList.get(i);
 }
 }
}

    public class ListErr
    {
        public static void main(String[] args) 
        {
            //创建一个只想保存字符串的List集合
            List strList = new ArrayList();
            strList.add("Struts2权威指南");
            strList.add("基于J2EE的Ajax宝典");
            strList.add("轻量级J2EE企业应用实战");
            //”不小心“把一个Integer对象”丢进"了集合
            strList.add(5);
            for (int i = 0; i < strList.size() ; i++ )
            {
                //因为List里取出的全部是Object，所以必须强制类型转换
                //最后一个元素将出现ClassCastException异常
                String str = (String)strList.get(i);
            }
        }
    }

为了解决这个问题，在1.5前都采用，创建个List对象的方法，但每遇到个集合都要建个对象，eg
 class StrList
 {
 private List strList = new ArrayList();
 //定义StrList的add方法
 publicboolean add(String ele)
 {
 return strList.add(ele);
 }
 //重写get方法，将get方法的返回值类型改为String类型
 public String get(int index)
 {
 return (String)strList.get(index);
 }
 publicint size()
 {
 return strList.size();
 }
 }

为了解决这个问题，在1.5前都采用，创建个List对象的方法，但每遇到个集合都要建个对象，eg

    class StrList
    {
        private List strList = new ArrayList();
        //定义StrList的add方法
        public boolean add(String ele)
        {
            return strList.add(ele);
        }
        //重写get方法，将get方法的返回值类型改为String类型
        public String get(int index)
        {
            return (String)strList.get(index);
        }
        public int size()
        {
            return strList.size();
        }
    }

publicclass CheckType
{
 publicstaticvoid main(String[] args)
 {
 //创建一个只想保存字符串的List集合
 StrList strList = new StrList();
 strList.add("Struts2权威指南");
 strList.add("基于J2EE的Ajax宝典");
 strList.add("轻量级J2EE企业应用实战");
 //下面语句不能把Integer对象“丢进”集合中,将引起编译异常
 strList.add(5);
 System.out.println(strList);
 for (int i = 0; i < strList.size() ; i++ )
 {
 //因为StrList里元素的类型就是String类型，所以无需强制类型转换
 String str = strList.get(i);
 }
 }
}

public class CheckType
{
    public static void main(String[] args) 
    {
        //创建一个只想保存字符串的List集合
        StrList strList = new StrList();
        strList.add("Struts2权威指南");
        strList.add("基于J2EE的Ajax宝典");
        strList.add("轻量级J2EE企业应用实战");
        //下面语句不能把Integer对象“丢进”集合中,将引起编译异常
        strList.add(5);
        System.out.println(strList);
        for (int i = 0; i < strList.size() ; i++ )
        {
            //因为StrList里元素的类型就是String类型，所以无需强制类型转换
            String str = strList.get(i);
        }
    }
}

有了泛型就方便了，eg
 publicclass GenericList
 {
 publicstaticvoid main(String[] args)
 {
 //创建一个只想保存字符串的List集合
 List<String> strList = new ArrayList<String>();
 strList.add("Struts2权威指南");
 strList.add("基于J2EE的Ajax宝典");
 strList.add("轻量级J2EE企业应用实战");
 //下面代码将引起编译错误
 strList.add(5);
 for (int i = 0; i < strList.size() ; i++ )
 {
 //下面代码无需强制类型转换
 String str = strList.get(i);
 }
 }
 }

有了泛型就方便了，eg

    public class GenericList
    {
        public static void main(String[] args) 
        {
            //创建一个只想保存字符串的List集合
            List<String> strList = new ArrayList<String>();
            strList.add("Struts2权威指南");
            strList.add("基于J2EE的Ajax宝典");
            strList.add("轻量级J2EE企业应用实战");
            //下面代码将引起编译错误
            strList.add(5);
            for (int i = 0; i < strList.size() ; i++ )
            {
                //下面代码无需强制类型转换
                String str = strList.get(i);
            }
        }
    }

当创建带泛型的自定义类时，在定义该类构造器时，构造器名还是和类名一样，不要增加泛型声明。

从泛型类派生子类，接口，父类不能包含类型形参。

下面例子就是错误的。

public class A extends B<T>{},

使用类型通配符“？’”， 它可以匹配任何类型，

public void test(List <?>){}

 

使用时注意：List<String>不是List<Object>子类
特殊的泛型（带类型通配符和类型上限），eg
 public class Apple<T extends Number>
 {
 T col;
 public static void main(String[] args)
 {
 Apple<Integer>ai = new Apple<Integer>();
 Apple<Double>ad = new Apple<Double>();
 //下面代码将引起编译异常
 //因为String类型传给T形参，但String不是Number的子类型。
 Apple<String>as = new Apple<String>();
 }
 }
java泛型不支持泛型数组（List<String>aa=new ArrayList<String>[10];），因为java泛型的设计原则是没有unchecked警告就没有ClassCastExcepiton. 我建议大家遇到集合数组等的时候，自己来检验数据的类型，eg
 public class test {
 public static void main(String[] args) {
 ArrayList[] aa = new ArrayList[10];
 List<Integer>li = new ArrayList<Integer>();
 li.add(3);
 ((Object[]) aa)[1] = li;
 Object target = aa[1].get(0);
 if (target instanceof Integer) {
 Integer s = (Integer) target;
 System.out.println(s);
 }
 }
 }
由于java的泛型只是编译时做下检验，大家不要想的过于强大，他的最大作用只是增强代码的可读性，别的方面也没见多大的作用。

使用时注意：List<String>不是List<Object>子类

特殊的泛型（带类型通配符和类型上限），eg

    public class Apple<T extends Number>
    {
        T col;
        
        public static void main(String[] args)
        {
            Apple<Integer> ai = new Apple<Integer>();
            Apple<Double> ad = new Apple<Double>();
            //下面代码将引起编译异常
            //因为String类型传给T形参，但String不是Number的子类型。
            Apple<String> as = new Apple<String>();
            
        }
    }

java泛型不支持泛型数组（List<String> aa=new ArrayList<String>[10];），因为java泛型的设计原则是没有unchecked警告就没有ClassCastExcepiton. 我建议大家遇到集合数组等的时候，自己来检验数据的类型，eg

    public class test {
        public static void main(String[] args) {
            ArrayList[] aa = new ArrayList[10];
            List<Integer> li = new ArrayList<Integer>();
            li.add(3);
            ((Object[]) aa)[1] = li;
            Object target = aa[1].get(0);
            if (target instanceof Integer) {
                Integer s = (Integer) target;
                System.out.println(s);
            }
        }
    }

由于java的泛型只是编译时做下检验，大家不要想的过于强大，他的最大作用只是增强代码的可读性，别的方面也没见多大的作用。

 

什么时候写泛型？有什么好处？

最简单的体现，只要使用到了带有<>的类和接口，就指定具体对象类型。

 

泛型的好处：

1， 将运行时出现的ClassCastException问题，再编译时期给解决了。运行就安全了。

2， 避免了强制转换的麻烦。

 

所以泛型就是JDK1.5后出现的一个安全机制。

泛型的理解？

首先在没有泛型之前，一旦把一个对象丢进java集合中，集合就会忘记对象的类型，把所有对象当成Object类型来处理。

当程序从集合中取出对象时，就需要进行强制类型转换，这种强制类型转换不仅代码臃肿，而且容易引起ClassCastException异常。

1，泛型就是传参数。

2，泛型替代了Object。

什么是泛型的擦除和补偿？

泛型是编译时期的安全机制。

编译时，通过泛型机制，编译器多了多元素类型进行检查的步骤。

如果检查通过，产生的class文件时不带有泛型的：也就是泛型的擦除。

 

泛型的补偿：在对元素存储的时候，可以完成类型的判断。

可是在对元素取出的时候，怎么用指定的类型来接收呢？

JVM运行时，会获取元素的类型，并用该类型对元素进行转换即可。

什么时候使用泛型类？

当类中要操作的引用数据类型不确定的时候，以前使用的是共性类型Object，

现在可以使用泛型来解决。

什么时候使用泛型方法？

当方法操作的引用数据类型不确定的时候，就使用泛型方法。

 

如果方法是静态的，是无法访问类上定义的泛型的。

如果该方法还需要泛型。

必须将泛型定义在方法上。

泛型的限定。

如果要对操作的类型进行限定，只操作一部分类型时，可以使用泛型的高级功能。

？extends E:可以接收E类型和E的子类型。这叫泛型的上限。

？super E:可以接收E类型或E的父类型。这叫泛型的下限。

什么时候会用？ extends E 呢？（往集合中添加集合的时候经常使用）

一般在存储具体引用类型时，使用这种情况。

因为存储E类型或者E类型的子类型，在取出的时候都可以用E类型来操作这些元素。

这时可以保证类型是安全的。

下限什么时候用？

从集合中取出对象进行操作时，可以使用下限。

例如：比较器。无论集合中的元素对象的类型是什么，只要比较器的指定的类型可以接收这些对象完成比较，就可以了。

所以比较器的类型，可以是集合中当前元素的类型，也可以是该元素类型的父类型。

泛型使用的误区：

1， 凡是安全的都特别严格。一定要保证座左右两边一致。

2， 不能操作特有对象。

参数定义的集合类型是一个范围，而接受的实际参数是以一个实体，该实体肯定会指定该范围中的某一个具体类型。而该类型是创建容器时指定的，到底是哪种类型该方法是不确定的，那么就不可以在该方法内，进行具体类型对象的定义和操作。

建议定义泛型时，左右两边一定要一致。如果不一致要保证一点，左边在声明时可以声明一个类型范围，右边在实例化时指定的具体类型必须是左边类型范围中的一种。