Java泛型详解 转载

转载地址：http://blog.csdn.net/jinuxwu/article/details/6771121

比较好的讲解：

http://blog.csdn.net/lonelyroamer/article/details/7868820  

http://blog.csdn.net/lonelyroamer/article/details/7868820        

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();
    } 
}
要当心你类库的客户端。