java泛型总结之二

代码github地址

泛型不是协变的,数组与集合类之间的区别##

虽然将集合看作是数组的抽象会有所帮助,但是数组还有一些集合不具备的特殊性质。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是 List的超类型,那么可以在需要 List的地方传递 List。不幸的是,情况并非如此。
不允许这样做有一个很充分的理由:这样做将破坏要提供的类型安全泛型。如果能够将 List赋给 List。那么下面的代码就允许将非 Integer的内容放入 List

List li = new ArrayList(); 
List ln = li; // illegal 
ln.add(new Float(3.1415));

因为 ln是 List,所以向其添加 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 al = new ArrayList();
        al.add("a");
        al.add("b");
        // accept(al); //编译不过
    }

    public static void accept(ArrayList al) {
        for (Object o : al)
            System.out.println(o);
    }

}
 
 

以上代码看起来是没问题的,因为String是Object的子类。然而,这并不会工作,编译不会通过
原因在于类型擦除。记住:Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。

在编译之后,List和List将变成List,Object和String类型信息对于JVM来说是不可见的。在编译阶段,编译器发现它们不一致,因此给出了一个编译错误。

通配符和有界通配符##

List表示List能包含任何类型的元素

public static void main(String[] args) {
    ArrayList al = new ArrayList();
    al.add("a");
    al.add("b");
    // accept(al); //编译不过

    test(al);
    ArrayList 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和 List是同一个类(虽然是不同的类型但都是 List的子类型,与以前的版本相比,在 JDK 5.0 中这是一个更重要的区别)。
擦除意味着一个类不能同时实现 Comparable和 Comparable,因为事实上两者都在同一个接口中,指定同一个 compareTo()方法。声明 DecimalString类以便与 String与 Number比较似乎是明智的,但对于 Java 编译器来说,这相当于对同一个方法进行了两次声明:

public class DecimalString implements Comparable, Comparable
{

    @Override
    public int compareTo(Number o) {
        return 0;
    }
} // nope

擦除的另一个后果是,对泛型类型参数是用强制类型转换或者 instanceof毫无意义。下面的代码完全不会改善代码的类型安全性:

public  T naiveCast(T t, Object o) { 
    return (T) o; 
}

编译器仅仅发出一个类型未检查转换警告,因为它不知道这种转换是否安全。naiveCast()方法实际上根本不作任何转换,T直接被替换为 Object,与期望的相反,传入的对象被强制转换为 Object。
擦除也是造成上述构造问题的原因,即不能创建泛型类型的对象,因为编译器不知道要调用什么构造函数。如果泛型类需要构造用泛型类型参数来指定类型的对象,那么构造函数应该接受类文字(Foo.class)并将它们保存起来,以便通过反射创建实例。

public static  T getTypeInstance() {
    return new T(); // 编译不通过
}

引用:

了解泛型
Java类型擦除机制

你可能感兴趣的:(java泛型总结之二)