泛型不是协变的，数组与集合类之间的区别##
虽然将集合看作是数组的抽象会有所帮助，但是数组还有一些集合不具备的特殊性质。Java 语言中的数组是协变的（covariant），也就是说，如果 Integer扩展了 Number（事实也是如此），那么不仅 Integer是 Number，而且 Integer[]也是 Number[]，在要求 Number[]的地方完全可以传递或者赋予 Integer[]。（更正式地说，如果 Number是 Integer的超类型，那么 Number[]也是 Integer[]的超类型）。
Integer [] intArray = new Integer[10];
intArray[0] = 10;
Number[] numArray = intArray;
numArray[2] = 3;
numArray[1] = 2.5f; // java.lang.ArrayStoreException: java.lang.Float 编译不通过，因为intArray类型为Integer
System.out.println("numArray[2] = " + numArray[2]);
System.out.println("numArray[0] = " + numArray[0] + "; numArray[1] = " + numArray[1]);
您也许认为这一原理同样适用于泛型类型 —— List<Number>是 List<Integer>的超类型，那么可以在需要 List<Number>的地方传递 List<Integer>。不幸的是，情况并非如此。
不允许这样做有一个很充分的理由：这样做将破坏要提供的类型安全泛型。如果能够将 List<Integer>赋给 List<Number>。那么下面的代码就允许将非 Integer的内容放入 List<Integer>：
List<Integer> li = new ArrayList<Integer>();
List<Number> ln = li; // illegal
ln.add(new Float(3.1415));
因为 ln是 List<Number>，所以向其添加 Float似乎是完全合法的。但是如果 ln是 li的别名，那么这就破坏了蕴含在 li定义中的类型安全承诺 —— 它是一个整数列表，这就是泛型类型不能协变的原因。
一个常见错误##
import java.util.ArrayList;
/**
* Created by shun on 2017/8/31.
*/
public class ErasureProblem {
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String>();
al.add("a");
al.add("b");
// accept(al); //编译不过
}
public static void accept(ArrayList<Object> al) {
for (Object o : al)
System.out.println(o);
}
}
以上代码看起来是没问题的，因为String是Object的子类。然而，这并不会工作，编译不会通过
原因在于类型擦除。记住：Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。
在编译之后，List<Object>和List<String>将变成List，Object和String类型信息对于JVM来说是不可见的。在编译阶段，编译器发现它们不一致，因此给出了一个编译错误。
通配符和有界通配符##
List<? >表示List能包含任何类型的元素
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String>();
al.add("a");
al.add("b");
// accept(al); //编译不过
test(al);
ArrayList<Object> a = new ArrayList<>();
a.add("abc");
a.add(1);
test(a);
}
public static void test(ArrayList<?> al) {
for (Object e : al) {// no matter what type, it will be Object
System.out.println(e);
// in this method, because we don’t know what type ? is, we can not
// add anything to al.
}
}
擦除的实现##
因为泛型基本上都是在 Java 编译器中而不是运行库中实现的，所以在生成字节码的时候，差不多所有关于泛型类型的类型信息都被“擦掉”了。换句话说，编译器生成的代码与您手工编写的不用泛型、检查程序的类型安全后进行强制类型转换所得到的代码基本相同。与 C++ 不同，List<Integer>和 List<String>是同一个类（虽然是不同的类型但都是 List<?>的子类型，与以前的版本相比，在 JDK 5.0 中这是一个更重要的区别）。
擦除意味着一个类不能同时实现 Comparable<String>和 Comparable<Number>，因为事实上两者都在同一个接口中，指定同一个 compareTo()方法。声明 DecimalString类以便与 String与 Number比较似乎是明智的，但对于 Java 编译器来说，这相当于对同一个方法进行了两次声明：
public class DecimalString implements Comparable<Number>, Comparable<String>
{
@Override
public int compareTo(Number o) {
return 0;
}
} // nope
擦除的另一个后果是，对泛型类型参数是用强制类型转换或者 instanceof毫无意义。下面的代码完全不会改善代码的类型安全性：
public <T> T naiveCast(T t, Object o) {
return (T) o;
}
编译器仅仅发出一个类型未检查转换警告，因为它不知道这种转换是否安全。naiveCast()方法实际上根本不作任何转换，T直接被替换为 Object，与期望的相反，传入的对象被强制转换为 Object。
擦除也是造成上述构造问题的原因，即不能创建泛型类型的对象，因为编译器不知道要调用什么构造函数。如果泛型类需要构造用泛型类型参数来指定类型的对象，那么构造函数应该接受类文字（Foo.class）并将它们保存起来，以便通过反射创建实例。
public static <T> T getTypeInstance() {
return new T(); // 编译不通过
}
网友评论