一、Java泛型的由来
在泛型的概念提出来之前，一般的类和方法只能使用具体的类型：要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码（泛化），这种刻板的限制对代码的束缚就会很大。对于经常使用未经泛型改造的集合类的程序员来说，可以深深体会到这种痛苦。在泛型之前，多态可以算是一种泛化机制，不过由于类继承的限制，比如final类型不能扩展，java的单根继承等，也使多态这种泛化手法受到很多限制。于是在JDK 5中引入了Java泛型（generics）。
Java泛型实现了参数化类型的概念，通过解耦类或方法与所使用的类型之间的约束，来使代码支持多种类型。泛型最主要的应用是在JDK5中的新集合框架中，下面是引入泛型前后对集合的使用：
不使用泛型：
// Removes 4-letter words from c. Elements must be strings
static void expurgate(Collection c) {
for (Iterator i = c.iterator(); i.hasNext(); )
if (((String) i.next()).length() == 4)
i.remove();
}// Removes the 4-letter words from c
static void expurgate(Collection<String> c) {
for (Iterator<String> i = c.iterator(); i.hasNext(); )
if (i.next().length() == 4)
i.remove();
}当然为了保证与旧有版本的兼容性，Java泛型在实现上存在一些不够优雅的地方。与C++的模板相比，Java泛型给人一种投机取巧的感觉。 JVM是不支持泛型的，只是编译器“做了手脚”。
二、泛型的实现
1、类型信息让狗吃了
package study.java.core.generic;
import java.util.ArrayList;
public class ErasedTypeEquivalence {
public static void main(String[] args) {
Class c1 = new ArrayList<Integer>().getClass();
Class c2 = new ArrayList<String>().getClass();
System.out.println("c1:"+c1);
System.out.println("c2:"+c2);
System.out.println("c1 == c2 : " +(c1==c2));
}
}c1:class java.util.ArrayList
c2:class java.util.ArrayList
c1 == c2 : true
Java泛型中，类型信息不是让狗吃了，而是被编译器吃了。
2、类型擦除的过程
类型擦除的基本过程是：先找出用来替换类型参数的具体类，如果没有指定则为Object，如果指定类型参数的上界，则使用这个上界。然后把代码中的类型参数都替换成具体的类，同时去掉出现的类型声明，即去掉<>的内容。比如T get()方法声明就变成了Object get()；List<String>就变成了List。
以下是对类Pair的类型擦除的分析过程：
package study.java.core.generic;
public class Pair<T> {
private T first;
private T sencond;
public Pair(T first,T sencond){
this.first = first;
this.sencond = sencond;
}
public T getFirst() {
return first;
}
public void setFirst(T first) {
this.first = first;
}
public T getSencond() {
return sencond;
}
public void setSencond(T sencond) {
this.sencond = sencond;
}
}
没有指定具体类型：
public class study.java.core.generic.Pair extends java.lang.Object{
//域
private java.lang.Object first;
private java.lang.Object sencond;
//构造器
public Pair(java.lang.Object, java.lang.Object);
//方法
public void setFirst(java.lang.Object);
public java.lang.Object getSencond( );
public void setSencond(java.lang.Object);
public java.lang.Object getFirst( );
}将Pair的类型参数加上限定，比如 Pair<T extends List>：
public class study.java.core.generic.Pair extends java.lang.Object{
//域
private java.util.List first;
private java.util.List sencond;
//构造器
public Pair(java.util.List, java.util.List);
//方法
public void setFirst(java.util.List);
public java.util.List getSencond( );
public void setSencond(java.util.List);
public java.util.List getFirst( );
}
注意： 某些情况下，由于存在类型擦除，T被替换为类型参数的上限，所以会存在强制类型转换的情况，只不过编译器会帮我们处理罢了。比如在调用泛型方法，返回值被擦除的情况：
public static void main(String[] args) {
Pair<String> p = new Pair<String>("1", "2");
String f = p.getFirst();//编译器会先调用getFirst()方法，然后将返回的Object结果强制转换为String。由于在编译期间已经确保传入参数的正确性，所以此处强制转换不为出现异常。
}3、类型擦除的问题
由于类型擦除的存在，导致使用Java泛型出现如下问题：
一个类不能实现同一个泛型接口的两种变体。
interface Payable<T>{}
class Employee implements Payable<Employee>{}
class Hourly extends Employee implements Payable<Hourly>{}//编译不通过，Payable接口不能实现两次.class UserList<W,T>{
void f(List<W> v){}
void f(List<T> v){}//两个方法签名一样，编译不通过！
}类型擦除与多态冲突，这个在桥方法中说明。
4、桥方法
泛型方法的类型擦除会带来两个问题，1、类型擦除与多态的冲突。2、方法签名的冲突。Java泛型是如何解决这两个问题的？那就是通过引入桥方法。
package study.java.core.generic;
import java.util.Date;
public class DateInterval extends Pair<Date> {
public DateInterval(Date first, Date sencond) {
super(first, sencond);
}
@Override
public Date getFirst() {
return super.getFirst();
}
@Override
public void setFirst(Date first) {
super.setFirst(first);
}
public static void main(String[] args) {
DateInterval di = new DateInterval(new Date(), new Date());
Pair<Date> pr = di;//父类引用指向子类对象，典型的多态
Date date = new Date(2013, 10, 12);
System.out.println("原来的日期："+pr.getFirst());
pr.setFirst(date);//貌似重写了，其实这都是假象！
System.out.println("新设置的日期："+date);
System.out.println("通过父类引用修改后的日期（pr.setFirst(date)）："+pr.getFirst());
}
}
原来的日期：Sat Mar 29 09:00:13 CST 2014
新设置的日期：Wed Nov 12 00:00:00 CST 3913
通过父类引用修改后的日期（pr.setFirst(date)）：Wed Nov 12 00:00:00 CST 3913
public void setFirst(Object first)public void setFirst(Date first)public class study.java.core.generic.DateInterval extends study.java.core.generic.Pair{
//构造器
public DateInterval(java.util.Date, java.util.Date);
//方法
public void setFirst(java.util.Date);//方法4
public volatile void setFirst(java.lang.Object); //方法1，注意签名
public java.util.Date getFirst( );//方法2
public volatile java.lang.Object getFirst( );//方法3，注意签名！方法2和方法3存在方法签名冲突吗？
public static void main(java.lang.String[]);
}由类分析器得出的结果可以看出，编译器为我们添加了方法1和方法3两个方法，这两个方法就是桥方法。真正覆写超类的就是它。语句
pr.setFirst(date);
public volatile void setFirst(java.lang.Object);
public volatile void setFirst(Object first){
this.setFirst((java.util.Date) first);
}对于方法2和方法3，从方法签名的角度来看，两个方法完全相同，那它们是如何共存的？如果是我们自己编写Java代码，这样的代码是无法通过编译器的检查的，但是虚拟机却是允许这样做的，因为 虚拟机通过参数类型和返回类型来确定一个方法，所以编译器为了实现泛型的多态允许自己做这个看起来“不合法”的事情。从JDK1.5开始，在一个方法覆盖另一个方法时可以指定一个更严格的返回类型，它的机制也是同样使用的桥方法，示例如下：
父类：getList返回的类型为List。
package study.java.core.generic;
import java.util.ArrayList;
import java.util.List;
public class Bridge {
public <T> List<T> getList(){
return new ArrayList<T>();
}
}
package study.java.core.generic;
import java.util.ArrayList;
public class ArrayBridge extends Bridge{
@Override
public <T> ArrayList<T> getList() {
return new ArrayList<T>();
}
}
public class study.java.core.generic.ArrayBridge extends study.java.core.generic.Bridge{
//构造器
public ArrayBridge( );
//方法
public java.util.ArrayList getList( );
public volatile java.util.List getList( );//桥方法
}在Java中，我们比较熟悉的是通过继承机制而产生的类型体系结构。比如String继承自Object。根据Liskov替换原则，子类是可以替换父类的。当需要Object类的引用的时候，如果传入一个String对象是没有任何问题的。但是反过来的话，即用父类的引用替换子类引用的时候，就需要进行强制类型转换。编译器并不能保证运行时刻这种转换一定是合法的。这种自动的子类替换父类的类型转换机制，对于数组也是适用的。 String[]可以替换Object[]。但是泛型的引入，对于这个类型系统产生了一定的影响。
1、一箱苹果是一箱水果吗？
在基于继承机制的类型体系结构中，一个苹果是一个水果，一箱苹果是一箱水果（从数组的角度看），但在泛型系统中一箱苹果却不是一箱水果。
数组角度：
Apple[] apples = new Apple[1];
Fruit[] fruits = apples;//将Apple[]赋值给Fruit[]是合法的，因为前者是后者的子类型。
fruits[0] = new Pear();//编译可以通过，但运行时会抛出ArrayStoreException异常。泛型角度：
List<Apple> apples = new ArrayList<Apple>();
List<Fruit> fruits = apples;//将水果篮赋值为苹果篮，指明该水果篮是放苹果的
fruits.add(new Pear());//由于Pear(梨)也是一种水果，所以也可以放到该水果篮中。这样苹果篮就可以放任何水果了，不符合实际。2、泛型类型系统的两个维度
引入泛型之后的类型系统增加了两个维度：一个是类型参数自身的继承体系结构，另外一个是泛型类或接口自身的继承体系结构。第一个指的是对于 List<String>和List<Object>这样的情况，类型参数String是继承自Object的。而第二种指的是 List接口继承自Collection接口。
对于这个类型系统，有如下的一些规则：
1、相同类型参数的泛型类的关系取决于泛型类自身的继承体系结构。即List<String>是Collection<String> 的子类型，List<String>可以替换Collection<String>。这种情况也适用于带有上下界的类型声明。
2、当泛型类的类型声明中使用了通配符的时候， 其子类型可以在两个维度上分别展开。如对Collection<? extends Number>来说，其子类型可以在Collection这个维度上展开，即List<? extends Number>和Set<? extends Number>等；也可以在Number这个层次上展开，即Collection<Double>和 Collection<Integer>等。如此循环下去，ArrayList<Long>和 HashSet<Double>等也都算是Collection<? extends Number>的子类型。
3、如果泛型类中包含多个类型参数，则对于每个类型参数分别应用上面的规则。
4、由于存在类型擦除，类型参数自身的继承体系结构对泛型类型系统的影响就很小了，毕竟这个维度的信息会被擦除（使用通配符的时候除外）。比如，List<String>和List<Object>两个泛型类型就不存在父子关系，那就不能使用List<String>替换掉List<Object>，但可以使用List<String>替换List<?>。
通过分析泛型类型系统的维度就很容易明白一箱水果和一箱苹果的关系了。
四、通配符
1、通配符？
Java泛型使用通配符？来表示未知类型。通配符所代表的其实是一组类型，但具体的类型是未知的。List<?>所声明的就是所有类型都是可以的。但是List<?>并不等同于List<Object>。List<Object>实际上确定了List中包含的是Object及其子类，在使用的时候都可以通过Object来进行引用。而List<?>则其中所包含的元素类型是不确定。其中可能包含的是String，也可能是 Integer。如果它包含了String的话，往里面添加Integer类型的元素就是错误的。正因为类型未知，就不能通过new ArrayList<?>()的方法来创建一个新的ArrayList对象。因为编译器无法知道具体的类型是什么。但是对于 List<?>中的元素却总是可以用Object来引用的，因为虽然类型未知，但肯定是Object及其子类。考虑下面的代码：
public void wildcard(List<?> list) {
list.add(1);//编译错误
} 2、上下界
因为对于List<?>中的元素只能用Object来引用，在有些情况下不是很方便。在这些情况下，可以使用上下界来限制未知类型的范围。
？extends
子类型通配符，如List<? extends Number>说明List中可能包含的元素类型是Number及其子类。
？super
超类型通配符，如List<? super Number>说明List中包含的是Number及其父类。
当引入了上界之后，在使用类型的时候就可以使用上界类中定义的方法。比如访问 List<? extends Number>的时候，就可以使用Number类的intValue等方法。
3、存取原则和PECS法则
总结 ? extends 和 ? super 通配符的特征，我们可以得出以下结论：
如果你想从一个数据类型里获取数据，使用 ? extends 通配符；
如果你想把对象写入一个数据结构里，使用 ? super 通配符；
如果你既想存，又想取，那就别用通配符。
这就是Maurice Naftalin在他的《Java Generics and Collections》中所说的存取原则，以及Joshua Bloch在他的《Effective Java》中所说PECS法则，“Producer Extends, Consumer Super”，这个更容易记忆和运用。
五、最佳实践
在使用泛型的时候可以遵循一些基本的原则，从而避免一些常见的问题。
1、在代码中避免泛型类和原始类型的混用。比如List<String>和List不应该共同使用。这样会产生一些编译器警告和潜在的运行时异常。当需要利用JDK 5之前开发的遗留代码，而不得不这么做时，也尽可能的隔离相关的代码。
2、在使用带通配符的泛型类的时候，需要明确通配符所代表的一组类型的概念。由于具体的类型是未知的，很多操作是不允许的。
3、泛型类最好不要同数组一块使用。你只能创建new List<?>[10]这样的数组，无法创建new List<String>[10]这样的。这限制了数组的使用能力，而且会带来很多费解的问题。因此，当需要类似数组的功能时候，使用集合类即可。
4、不要忽视编译器给出的警告信息。
参考资料：
652
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
