这是一篇初学者对 Java 泛型的理解,如果不对欢迎指出。
Java 中的泛型,在编译时期提供类型检查。在运行时期,为了让泛型零开销,泛型都被擦除。擦除的方式:
- 用 bound 替换泛型参数,如果泛型参数是 unbound 的,直接用 Object 类型替换。所以生成的字节码中,只包含原始的类,接口,和方法;
- 在必要的情况下生成类型的强制转换,来做到类型安全;
- Generate bridge methods to preserve polymorphism in extended generic types. (这句没看懂)
这种类型擦除的方式保证了没有新的 class 生成,使用泛型不会增加程序的开销。
在读了很多资料之后,我发现自己对泛型的误解主要是基于从 Python 来的印象。比如在 Animals
的一个 list 中,里面即可以有 Dog
又可以有 Cat
,所以就以为在 Java 中 ArrayList<? extends Animal>
即可以有 Dog
又可以有 Cat
,认为这样声明即表示这个 ArrayList
可以放任何 Animal
的子类。其实不是的,<? extends Animal>
是一个类型声明,最终只会表示一种类型。即这个 ArrayList
即可以是一个 Dog
的 ArrayList
,也可以是一个 Cat
的 ArrayList
,但不能有 Cat
又有 Dog
。
基于此,Bound 其实是比较好理解的。
Upper Bound
顾名思义,就是类型的上界被确定了。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
class Dog extends Animal {}; class Cat extends Animal {}; class PersianCat extends Cat {}; public class Main { public void upperBound() { ArrayList<Dog> dogs = new ArrayList<>(); ArrayList<? extends Animal> dogAnimals = dogs; Animal animal = dogAnimals.get(0); System.out.println(animal); } } |
在这个例子中,上界是 Animal,所以 ArrayList<? extends Animal>
这个 ArrayList
就表示一种 Animal
的 List
。可能是 Cat,也可能是 Dog。 ArrayList<? extends Animal>
是 ArrayList<Dog>
的子类,所以这个赋值可以成功。
对于写,因为 ArrayList
里面可以是任何 Animal
的子类,所以无法写入。不能 .add(new Dog())
也不能 .add(new Animal())
.
对于读,读出来的都是 bound 的类型,即 Animal
。
Lower Bound
确定的是类型的下界,即允许这个类型的任何父类。
1 2 3 4 5 6 7 8 9 |
public void lowerbound() { ArrayList<Animal> animals = new ArrayList<>(); ArrayList<? super Cat> catSuper = animals; catSuper.add(new Cat()); catSuper.add(new PersianCat()); Object object = catSuper.get(0); System.out.println(object); } |
下界是 Cat
,即这个 ArrayList
允许任何 Cat
的父类。所以这个 ArrayList
可以是 Animal
的 ArrayList
,也可以是 Cat
的,也可以是 Object
的。
对于写,是允许的,因为下界是 Cat
了,那么任何 Cat
或者 Cat
的子类,都可以被转换成 <? super Cat>
,所以允许写入 Cat
或 Cat
的子类。
对于读,因为不知道 ArrayList
的类型可能是什么,所以读出来的都是 Object
,即最上面的 Bound。
这段代码实际被编译器抹去泛型的字节码反编译如下:
1 2 3 4 5 6 7 |
public void lowerbound() { ArrayList var1 = new ArrayList(); var1.add(new Cat()); var1.add(new PersianCat()); Object var3 = var1.get(0); System.out.println(var3); } |
本质上,Java 的泛型是通过编译器来实现的,编译器将我们写的有泛型的代码转换成没有泛型的代码。但是这个转换只是推导,增加类型转换,而不会生成新的类,也不会生成新的代码。在运行时不会有泛型的信息,没有额外的开销。
泛型是类型未确定,实际运行的时候,还是会确定到某一种类型上,时刻记住这是一门静态的语言。是否允许写入,读出来是什么类型这些问题,基于“保证”类型安全这个角度理解,就比较简单了。
更多阅读:
- Generics in the Java Programming Language
- Can’t add a ModuleInfo object to ArrayList<? extends ModuleInfo>
- Java generics type erasure: when and what happens?
感谢 messense 发我的资料和耐心解答。以上是个人理解,如果有误那肯定是我理解不到位。理解没有问题的话就是老师教得好。
https://stackoverflow.com/questions/8481301/covariance-invariance-and-contravariance-explained-in-plain-english/8482091#8482091