Java泛型

概述

Java在引入泛型，将数组和类的复杂类型细分成多种类型。

在引入泛型前，要满足类中的方法支持多个数据类型，就需要对方法进行重载；引入泛型后，就可以解决这种问题。举例：

public void calculate(Double double,Double[] doubles);public void calculate(Integer i,Integer[] is);

的泛型化版本：

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

泛型的定义和使用

推荐使用用简练的名字作为形式类型参数的名字(如果可能，单个字符)。最好避免小写字母。

一般使用T代表类型，这经常见于泛型方法。如果有多个类型参数，可以使用字母表中T的临近的字母，比如S。

如果一个泛型函数在一个泛型类里面出现，最好避免在方法的类型参数和类的类型参数中使用同样的名字来避免混 淆。对内部类也是同样。

定义带有类型参数的类

在定义带类型参数的类时，在紧跟类命之后的<>内,指定一个或多个类型参数的名字，同时也可以对类型参数的取值范围进行限定，多个类型参数之间用,号分隔。

定义完类型参数后，可以在定义位置之后的类的几乎任意地方（静态块，静态属性，静态方法除外）使用类型参数， 就像使用普通的类型一样。

同时，父类定义的类型参数不能被子类继承。

public class Test<T,S extends T>{    ...}

定义带有类型参数的方法

在定义带类型参数的方法时，在紧跟可见范围修饰（例如public）之后的<>内,指定一个或多个类型参数的名字， 同时也可以对类型参数的取值范围进行限定，多个类型参数之间用,号分隔。

定义完类型参数后，可以在定义位置之后的方法的任意地方使用类型参数，就像使用普通的类型一样。

public <T,S extends T> T test(T t,S s){    ...}

定义带类型参数的方法，主要目的是为了表达多个参数以及返回值之间的关系。

如果仅仅想实现多态，优先使用通配符解决。

public <T> void test(List<T> list){    ...}

应该改为：

public void test(List<?> list){    ...}

类型参数赋值

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

对带有类型参数的类进行类型参数赋值

第一种声明变量或者实例化时：

List<String> list;list = new ArrayList<String>;

第二种继承类或实现接口时：

public class MyList<E> extends ArrayList<E> implements List<E> {...} 

对带有类型参数的方法进行赋值

当调用范型方法时，编译器自动对类型参数进行赋值，当不能成功赋值时报编译错误。

通配符

在上面介绍中，对是类型参数赋予具体的值，除此，还可以对类型参数赋予不确定值。例如：

List<?> unknownList;List<? extends Number> unknownNumberList;List<? super Integer> unknownBaseLineIntgerList; 

在Java集合框架中，对于参数值是未知类型的容器类，只能读取其中元素，不能像其中添加元素，因为，其类型是未知，所以编译器无法识别添加元素的类型和容器的类型是否兼容，唯一的例外是NULL。

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

数组泛型

可以使用带范型参数值的类声明数组，却不能创建数组。

int[] intValue=new int[6];List[] i = new ArrayList[10];List<?>[] iy = new ArrayList<?>[10];List<Integer>[] iyz = new ArrayList<Integer>[10];//编译报错List<?>[] iyzs = new ArrayList<Integer>[10];//编译报错

实现原理

Java泛型是编译时技术

Java是编译时技术，在运行时不包含泛型信息，仅仅Class的实例中包含了类型参数的定义信息。

泛型是通过java编译器的称为擦除(erasure)的前端处理来实现的。你可以（基本上就是）把它认为是一个从源码到源码的转换，它把泛型版本转换成非泛型版本。

基本上，擦除去掉了所有的泛型类型信息。所有在尖括号之间的类型信息都被扔掉了，因此，比如说一个
List类型被转换为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)，而不管他们的实际类型参数。

作为一个结果，类的静态变量和方法也在所有的实例间共享。这就是为什么在静态方法或静态初始化代码中或者在静态变量的声明和初始化时使用类型参数（类型参数是属于具体实例的）是不合法的原因。

类型参数不能作为静态变量的类型
静态变量是被泛型类所有实例所共享的。对于声明为MyClass的类，访问其中的静态变量的方法仍然是MyClass.myStaticVar。不管是通过new MyClass还是new MyClass创建的对象，都是共享一个静态变量。假设允许类型参数作为静态变量的类型。那么考虑下面一种情况：
MyClass class1 = new MyClass();
MyClass class2 = new MyClass();
class1.myStaticVar = “hello”;
class2.myStaticVar = 5;
由于泛型系统的类型擦除(type erasure)。myStaticVar被还原成Object类型，然后当调用class1.myStaticVar= “hello”; 编译器进行强制类型转换，即myStaticVar = (String)”hello”;接着调用class2.myStaticVar语句时，编译器继续进行强制类型转换，myStaticVar = (Integer)Integer.valueOf(5); 此时myStaticVar是String类型的，当然该语句会在运行时抛出ClassCastException异常，这样一来存在类型安全问题。因此泛型系统不允许类的静态变量用类型参数作为变量类型。
当然，静态泛型方法也不允许。

转型和instanceof

泛型类被所有其实例(instances)共享的另一个暗示是检查一个实例是不是一个特定类型的泛型类是没有意义的。

Collection cs = new ArrayList<String>();if (cs instanceof Collection<String>) { ...} // 非法

类似的，如下的类型转换

Collection<String> cstr = (Collection<String>) cs;

得到一个unchecked warning，因为运行时环境不会为你作这样的检查。

Class的泛型处理

Java 5之后，Class变成范型化了。

JDK1.5中一个变化是类 java.lang.Class是泛型化的。这是把泛型扩展到容器类之外的一个很有意思的例子。

现在，Class有一个类型参数T, 你很可能会问，T 代表什么？它代表Class对象代表的类型。比如说，String.class类型代表 Class，Serializable.class代表 Class。

这可以被用来提高你的反射代码的类型安全。

特别的，因为 Class的 newInstance() 方法现在返回一个T, 你可以在使用反射创建对象时得到更精确的类型。

比如说，假定你要写一个工具方法来进行一个数据库查询，给定一个SQL语句，并返回一个数据库中符合查询条件
的对象集合(collection)。