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>，破坏了数据类型的完整性。

在引入范型之前，要在类中的方法支持多个数据类型，就需要对方法进行重载，在引入范型后，可以解决此问题（多态），更进一步可以定义多个参数以及返回值之间的关系。

    e.g.

public void write(Integer i, Integer[] ia);
public void write(Double  d, Double[] da);

的范型版本为

public <T> void write(T t, T[] ta);

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
       }

类型参数在运行时并不存在。这意味着它们不会添加任何的时间或者空间上的负担，这很好。不幸的是，这也意味着你不能依靠他们进行类型转换。
     下面的代码打印的结果是什么？

List<String> l1 = new ArrayList<String>();
       List<Integer> l2 = new ArrayList<Integer>();
       System.out.println(l1.getClass() == l2.getClass());

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

原文请见http://blog.csdn.net/jinuxwu/article/details/6771121