了解泛型
泛型不是协变的
协变:
Java 语言中的数组是协变的（covariant），也就是说，
如果
Integer 扩展了
Number （事 实也是如此），那么不仅
Integer 是
Number ，而且
Integer[] 也是
Number[] ，在要求
Number[] 的地方完全可以传递或者赋予
Integer[] 。
（更 正式地说，如果
Number 是
Integer 的超类型，那么
Number[] 也是
Integer[] 的超类型）
但是，
泛型并不是协变的。 如果，List<Number> 是List<Integer> 的超类型，但是，如果需要List<Integer>的时候， 并不容许传递List<Number>，它们并不等价。
不允许的理由很简单，这样会破坏要提供的类型安全泛型. 如下代码:
|
public static void main(String[] args) {
List<Integer> list=new ArrayList<Integer>();
List<Number> list2=list;
//编译错误.
list2.add(new Float(19.0f));
}
|
其他协变问题
数组能够协变而泛型不能协变的另外一个问题是：不能实例化泛型类型的数组： (new List<String>[3]是不合法的 ),除非类型参数是一个未绑定类型的通配符(new List<?>[3]是合法的 ).
延迟构造
因为可以擦除功能，所以List<Integer>和List<String>是同一个类，编译器在编译List<V>的时候，只生成一个类。
所以，运行时，不能区分List<Integer>和List<String>(实际上，运行时都是List,类型被擦除了),用泛型类型参数标识类型的变量的构造就成了问题。运行时缺乏类型信息，这给泛型容器类和希望创建保护性副本的泛型类提出了难题。
比如泛型类Foo:
|
class Foo<T>{
public void dosomething(T param){
T copy=new T(param);//语法错误.
}
}
|
因为编译的时候，还不知道要构造T的具体类型，所以也无法调用T的构造函数。
那么，我们是否可以使用克隆来构建呢？
|
class Foo<T extends Cloneable>{
}
|
所以，不能复制在编译时根本不知道是什么类的类型引用。
构造通配符引用
那么使用通配符类型怎么样呢？ 假设要创建类型为Set<?>的参数的保护性副本。 我们来看看：
|
class Foo{
}
|
但是下面的方法可以实现：
|
class Foo{
}
|
构造数组
对于我们常用的ArrayList<V> ，我们需要来探讨一下它的内部实现机制：
假设它内部管理着一个V数组，那么我们希望能在ArrayList<V>的构造函数中来初始化这个数组：
|
class ArrayList<V>{
}
|
Java库中的 Collections提供了一种思路，用于实现，但是非常别扭（设置连Collections的作者都这样说过.） 在Collections类编译时，会产生警告：
|
class ArrayList<V> {
private V[] backingArray;
public ArrayList() {
backingArray = (V[]) new Object[DEFAULT_SIZE];
}
}
|
因为泛型是通过擦除实现的， backingArray 的类型实际上就是 Object[] ，因为 Object 代替了 V 。
这意味着：实际上这个类期望 backingArray 是一个 Object 数组，但是编译器要进行额外的类型检查，以确保它包含 V 类型的对象。所以这种方法很奏效，但是非常别扭，因此不值得效仿
另外有一种方法是：
声明backingArray为Object数组，并在使用它的各个地方，强转成V[]
其他方法
最好的方法是： 向构造方法中，传入类对象，这样，在运行时，就可以知道T的值了。不采用这种方法的原因是，它无法与之前版本的Collections框架相兼容。
比如：
|
public class ArrayList<V> implements List<V> {
}
|
但是，这里还是有地方不是很妥当:
调用 Array.newInstance() 时会引起未经检查的类型转换。为什么呢？同样是由于向后兼容性。 Array.newInstance() 的签名是：
| public static Object newInstance(Class<?> componentType, int length) |
而不是类型安全的：
| public static<T> T[] newInstance(Class<T> componentType, int length) |
为何 Array 用这种方式进行泛化呢？同样是为了保持向后兼容。要创建基本类型的数组，如 int[] ， 可以使用适当的包装器类中的 TYPE 字段调用 Array.newInstance() （对于 int ，可以传递 Integer.TYPE 作为类文字）。用 Class<T> 参数而不是 Class<?> 泛化 Array.newInstance() ，对 于引用类型有更好的类型安全，但是就不能使用 Array.newInstance() 创建基本类型数组的实例了。也许将来会为引用类型提供新的 newInstance() 版本，这样就两者兼顾了。
在这里可以看到一种模式 —— 与泛型有关的很多问题或者折衷并非来自泛型本身，而是保持和已有代码兼容的要求带来的副作用。
擦除的实现
因为泛型基本上都是在JAVA编译器中而不是运行库中实现的，所以在生成字节码的时候，差不多所有关于泛型类型的类型信息都被“擦除”了， 换句话说，编译器生成的代码与手工编写的不用泛型、检查程序类型安全后进行强制类型转换所得到的代码基本相同。与C++不同，List<Integer>和List<Number>是同一个类（虽然是不同的类型，但是都是List<?>的子类型。）
擦除意味着，一个类不能同时实现 Comparable<String>和Comparable<Number>,因为事实上，两者都在同一个接口中，指定同一个compareTo()方法。
擦除也造成了上述问题，即不能创建泛型类型的对象，因为编译器不知道要调用什么构造函数。 如果泛型类需要构造用泛型类型参数来指定类型的对象，那么构造函数应该传入类对象，并将它们保存起来，以便通过反射来创建实例。