Java 5 之后加入了「泛型(generic)」,允许将对象的型态以参数的形式来定义。「?」是泛型的通配符,表示任意的对象型态,「?」还可以与「extends」和「super」两个关键字合用,至于它们的用法和差别在哪,将是本篇文章要探讨的部份。
泛型的通配符「?」
先来说明一下泛型的通配符「?」是要来做什么用的。先看一下以下的程序:
class A {
}
class B extends A {
}
class C extends B {
}
class Q {
}
和
ArrayList<B> list1 = new ArrayList<B>();
ArrayList<B> list2 = new ArrayList();
ArrayList<B> list3 = new ArrayList<>();
ArrayList<Object> list4 = new ArrayList<Object>();
ArrayList<Object> list5 = new ArrayList();
ArrayList<Object> list6 = new ArrayList<>();
ArrayList list7 = new ArrayList<B>();
ArrayList list8 = new ArrayList<Object>();
ArrayList list9 = new ArrayList();
ArrayList list10 = new ArrayList<>();
ArrayList<?> list11 = new ArrayList<B>();
ArrayList<?> list12 = new ArrayList<Object>();
ArrayList<?> list13 = new ArrayList();
ArrayList<?> list14 = new ArrayList<>();
试问,以上的 14 个 list 对象,各自可否进行以下几样的操作呢?
- 保存 A 类别的对象。
- 保存 B 类别的对象。
- 保存 C 类别的对象。
- 保存 Q 类别的对象。
- 取得 A 类别的对象。
- 取得 B 类别的对象。
- 取得 C 类别的对象。
- 取得 Q 类别的对象。
先来看看 list1:
//list1.add(new A()); // 编译错误
((ArrayList) list1).add(new A());
list1.add(new B());
list1.add(new C());
//list1.add(new Q()); // 编译错误
((ArrayList) list1).add(new Q()); // 要对list1变量强制转型
A a = list1.get(0);
B b = list1.get(1);
C c = (C) list1.get(2);
//Q q = (Q) list1.get(3); // 会编译错误,无法直接对取得的元素强制转型
Q q = (Q) ((ArrayList) list1).get(3); // 要对list1变量强制转型
list1 不可直接但可以间接保存 A 类别和 Q 类别的对象,也不可以直接但可以间接取得 Q 类别的对象。
再来看看 list2:
//list2.add(new A()); // 编译错误
((ArrayList) list2).add(new A());
list2.add(new B());
list2.add(new C());
//list2.add(new Q()); // 编译错误
((ArrayList) list2).add(new Q()); // 要对list2变量强制转型
A a = list2.get(0);
B b = list2.get(1);
C c = (C) list2.get(2);
//Q q = (Q) list2.get(3); // 会编译错误,无法直接对取得的元素强制转型
Q q = (Q) ((ArrayList) list2).get(3); // 要对list2变量强制转型
list2 和 list1 一样,皆不可直接但可以间接保存 A 类别和 Q 类别的对象,也不可以直接但可以间接取得 Q 类别的对象。
再来看看 list3:
//list3.add(new A()); // 编译错误
((ArrayList) list3).add(new A());
list3.add(new B());
list3.add(new C());
//list3.add(new Q()); // 编译错误
((ArrayList) list3).add(new Q()); // 要对list3变量强制转型
A a = list3.get(0);
B b = list3.get(1);
C c = (C) list3.get(2);
//Q q = (Q) list3.get(3); // 会编译错误,无法直接对取得的元素强制转型
Q q = (Q) ((ArrayList) list3).get(3); // 要对list3变量强制转型
list3 和 list2 与 list1 一样,皆不可直接但可以间接保存 A 类别和 Q 类别的对象,也不可以直接但可以间接取得 Q 类别的对象。至此我们可以知道,使用 new 操作符实体化对象时所传入的泛型型态,实际上并不能真的对传入的对象型态有所限制,主要还是看变量的型态。
同理,list4、list5、list6、list7、list8、list9、list10 想必可以直接保存和取得所有的对象型态。程序如下:
list4.add(new A());
list4.add(new B());
list4.add(new C());
list4.add(new Q());
A a4 = (A) list4.get(0);
B b4 = (B) list4.get(1);
C c4 = (C) list4.get(2);
Q q4 = (Q) list4.get(3);
list5.add(new A());
list5.add(new B());
list5.add(new C());
list5.add(new Q());
A a5 = (A) list5.get(0);
B b5 = (B) list5.get(1);
C c5 = (C) list5.get(2);
Q q5 = (Q) list5.get(3);
list6.add(new A());
list6.add(new B());
list6.add(new C());
list6.add(new Q());
A a6 = (A) list6.get(0);
B b6 = (B) list6.get(1);
C c6 = (C) list6.get(2);
Q q6 = (Q) list6.get(3);
list7.add(new A());
list7.add(new B());
list7.add(new C());
list7.add(new Q());
A a7 = (A) list7.get(0);
B b7 = (B) list7.get(1);
C c7 = (C) list7.get(2);
Q q7 = (Q) list7.get(3);
list8.add(new A());
list8.add(new B());
list8.add(new C());
list8.add(new Q());
A a8 = (A) list8.get(0);
B b8 = (B) list8.get(1);
C c8 = (C) list8.get(2);
Q q8 = (Q) list8.get(3);
list9.add(new A());
list9.add(new B());
list9.add(new C());
list9.add(new Q());
A a9 = (A) list9.get(0);
B b9 = (B) list9.get(1);
C c9 = (C) list9.get(2);
Q q9 = (Q) list9.get(3);
list10.add(new A());
list10.add(new B());
list10.add(new C());
list10.add(new Q());
A a10 = (A) list10.get(0);
B b10 = (B) list10.get(1);
C c10 = (C) list10.get(2);
Q q10 = (Q) list10.get(3);
接着来看看使用通配符「?」的泛型型态,list11、list12、list13、list14 变量都是一样的型态,只看 list11 即可,其他的和 list11 都是一样的。测试程序如下:
//list11.add(new A()); // 编译错误
((ArrayList) list11).add(new A()); // 要对list11变量强制转型
//list11.add(new B()); // 编译错误
((ArrayList) list11).add(new B()); // 要对list11变量强制转型
//list11.add(new C()); // 编译错误
((ArrayList) list11).add(new C()); // 要对list11变量强制转型
//list11.add(new Q()); // 编译错误
((ArrayList) list11).add(new Q()); // 要对list11变量强制转型
A a4 = (A) list11.get(0);
B b4 = (B) list11.get(1);
C c4 = (C) list11.get(2);
Q q4 = (Q) list11.get(3);
list11 不可直接但可以间接保存所有类别的对象,却可以直接取得所有类型的对象,这究竟是为什么呢?「?」所代表的到底是什么?是「Object」吗?撰写以下程序来判断「?」到底是不是「Object」:
Object o = new Object();
list11.add(o); // 编译失败
o = list11.get(0);
从以上程序可知,「?」并不是「Object」。「?」代表着未知,不知道会传入怎样的对象,所以无法保证传入对象的型态(与之后提到的泛型转换有关)。但是回传的状况就不同了,未知的对象,一定是一个「Object」对象,所以回传的对象元素参考,可以使用 Object 型态的变量来保存。
那如果同样传入「?」型态的对象而不是「Object」型态的对象,可行吗?程序如下:
list11.add(list11.get(0)); // 编译失败
即便是从自己本身取出的「?」型态之元素,也无法直接作为参数传回自己本身。
通配符「?」与 extends 和 super 关键字
extends 和 super 皆与继承关系有关,如果写成「? extends B」,表示为 B 类别或是 B 的任意子类别;如果写成「? super B」,表示为 B 类别或是 B 的任意父类别。在上一节所介绍的通配符「?」,其实就等同于「? extends Object」,表示为 Object 或是 Object 的子类别,即为所有任意的类别。
承上一节的程序,若再加上以下这段代码:
ArrayList<? extends B> list15 = new ArrayList();
ArrayList<? super B> list16 = new ArrayList();
再来看看 list15 和 list16,能不能访问 A、B、C、Q 的类别所实体化出来的对象。测试程序如下:
//list15.add(new A()); // 编译错误
((ArrayList) list15).add(new A()); // 要对list15变量强制转型
//list15.add(new B()); // 编译错误
((ArrayList) list15).add(new B()); // 要对list15变量强制转型
//list15.add(new C()); // 编译错误
((ArrayList) list15).add(new C()); // 要对list15变量强制转型
//list15.add(new Q()); // 编译错误
((ArrayList) list15).add(new Q()); // 要对list15变量强制转型
A a15 = list15.get(0);
B b15 = list15.get(1);
C c15 = (C) list15.get(2);
// Q q15 = (Q) list15.get(3); // 会编译错误,无法直接对取得的元素强制转型
Q q = (Q) ((ArrayList) list15).get(3); // 要对list15变量强制转型
//list16.add(new A()); // 编译错误
((ArrayList) list16).add(new A()); // 要对list16变量强制转型
list16.add(new B());
list16.add(new C());
//list16.add(new Q()); // 编译错误
((ArrayList) list16).add(new Q()); // 要对list16变量强制转型
A a16 = (A) list16.get(0);
B b16 = (B) list16.get(1);
C c16 = (C) list16.get(2);
Q q16 = (Q) list16.get(3);
list15 不可直接但可以间接保存所有类别的对象,也可以直接取得所有有继承关系类别的对象,但没有继承关系类别的对象需要间接访问。这是因为 list15 以对象变量型态的方式确保了其元素只能有 B 类别的对象实体或是 B 之子类别的对象实体,所以回传的对象元素可以确定一定是 B 类别型态,但是传入的对象型态并无法保证(与之后提到的泛型转换有关)。
list16 不可直接但可以间接保存 A 类别和 Q 类别的对象(与之后提到的泛型转换有关),却可以直接取得所有类型的对象。可以直接取得所有类型的对象是因为 Object 类别为其他所有类别的父类别,所以 list16 回传的对象型态可当作是 Object 型态。
泛型的转换
拥有泛型的类别型态也可以转型,以 ArrayList 为例,任何形式的泛型类别型态,都可以转换成以下三种型态:
- ArrayList
- ArrayList<?>
- ArrayList<? extends Object>
若已知 B 类别继承自 A 类别,C 类别继承自 B 类别,则 ArrayList<B> 可以转换成:
- ArrayList
- ArrayList<?>
- ArrayList<? extends Object>
- ArrayList<? extends B>
- ArrayList<? extends A>
- ArrayList<? super B>
- ArrayList<? super C>
注意,ArrayList<B> 不能转换为 ArrayList<A>!
当 ArrayList<B> 转换成 ArrayList<? extends A> 时,我们预期原先的 ArrayList<B> 只会拥有 B 类别或是 B 类别的子类别所实体化的对象元素,因此我们可以保证这个 ArrayList 对象转成 ArrayList<? extends A> 之型态后,所取得的元素必定是 A 类别或是其子类别对象,因为 B 类别继承自 A 类别。但是我们却无法保证传入 ArrayList<? extends A> 的对象之型态为 B 类别或是 B 类别的子类别,也有可能会有个 D 类别继承自 A 类别,若将 D 类别实体化的对象存进去了,就无法保证这个 ArrayList 内的元素一定是 B 类别或是 B 类别的子类别,因为编译器并不知道这个 ArrayList<? extends A> 型态所指到的 ArrayList 对象,原先只能够接受 B 类别或是 B 类别的子类别。为了保护这个 ArrayList 对象型态的一致性,在泛型使用到 extends 时,会避免允许泛型参数的传入,只允许传出,传出的对象参考型态为 A 类别。
当 ArrayList<B> 转换成 ArrayList<? super C> 时,我们预期原先的 ArrayList<B> 只会拥有 B 类别或是 B 类别的子类别所实体化的对象元素,我们可以保证这个 ArrayList 对象转成 ArrayList<? super C> 之型态后,一定可以继续保存 C 类别或是其子类别所实体化出来的对象,因为 C 类别继承自 B 类别,是 B 类别的子类别。但是我们却无法保证从 ArrayList<? super C> 对象型态所参考到的实际对象,所存放的元素都是 C 类别或是其子类别实体化出来的对象,也许有个 E 类别继承自 B 类别,而 E 类别实体化出来的对象就存在这个 ArrayList 对象中。为了保护这个 ArrayList 对象型态的正确性,在泛型使用到 super 时,回传的对象型态一律为 Object,且只能传入 C 类别或是其子类别所实体化出来的对象。
若已知 B 类别继承自 A 类别,C 类别继承自 B 类别,则 ArrayList<? extends B> 可以转换成:
- ArrayList
- ArrayList<?>
- ArrayList<? extends Object>
- ArrayList<? extends A>
使用 extends 关键字的泛型只出不进,确保 ArrayList 对象内取出的元素为 B 类别或是 B 类别的子类别所实体化的对象,而此种对象当然也算是 B 类别的父类别(A 类别)或其子类别所实体化的对象。
若已知 B 类别继承自 A 类别,C 类别继承自 B 类别,则 ArrayList<? super B> 可以转换成:
- ArrayList
- ArrayList<?>
- ArrayList<? extends Object>
- ArrayList<? super C>
原先的 ArrayList<? super B> 允许保存 B 类别或是 B 类别的子类别所实体化的对象元素。转换成 ArrayList<? super C> 之后,只能存入 C 类别或是 C 类别的子类别所实体化的对象,而此种对象当然也算是 B 类别的子类别所实体化的对象,所以原先的 ArrayList 对象一定能够接受。
结语
泛型是 Java 编程语言非常方便的语法,可以让程序在编译阶段的时候变得更为严谨,能避免许多态态上的错误,也可以减少型态转换的次数,增加一些程序的性能。但泛型的观念有点复杂,又很容易混淆,是学习 Java 必须要跨越的障碍之一,通常也是各类 Java 考试的必考项目。
