Java泛型簡明教程

泛型是Java SE 5.0中引入的一個特徵，自從這個語言特徵出現多年來，我相信，幾乎所有的Java程式設計師不僅聽說過，而且使用過它。關於Java泛型的教程，免費的，不免費的，有很多。我遇到的最好的教材有：

• The Java Tutorial

• Java Generics and Collections, by Maurice Naftalin and Philip Wadler

• Java

  Effective Java.

儘管有這麼多豐富的資料，有時我感覺，有很多的程式設計師仍然不太明白Java泛型的功用和意義。這就是為什麼我想用一種最簡單的形式來總結程式設計師需要知道的關於Java泛型的最基本的知識。

Java泛型由來的動機

理解Java泛型最簡單的方法是把它看成一種便捷語法，能節省你某些Java類型轉換(casting)上的操作：

List<Apple> box = ...;
Apple apple = box.get(0);

上面的程式碼本身已表達的很清楚：box是裝有Apple物件的List。 get方法傳回一個Apple物件實例，這個過程不需要進行類型轉換。沒有泛型，上面的程式碼需要寫成這樣：

List box = ...;
Apple apple = (Apple) box.get(0);

很明顯，泛型的主要好處就是讓編譯器保留參數的類型信息，執行類型檢查，執行類型轉換操作：編譯器保證了這些類型轉換的絕對無誤。

相對於依賴程式設計師來記住物件類型、執行類型轉換——這會導致程式運行時的失敗，很難調試和解決，而編譯器能夠幫助程式設計師在編譯時強制進行大量的類型檢查，發現其中的錯誤。

泛型的構成

由泛型的構成引出了一個類型變數的概念。根據Java語言規範，類型變量是一種沒有限制的標誌符，產生於以下幾種情況：

• 泛型類聲明

• 泛型接口聲明

• 泛型方法聲明

• 泛型構造器(constructor)聲明

泛型類別和介面

如果一個類別或介面上有一個或多個類型變量，那麼它就是泛型。類型變數由尖括號界定，放在類別或介面名稱的後面：

public interface List<T> extends Collection<T> {
...
}

簡單的說，類型變數扮演的角色就如同一個參數，它提供給編譯器用來類型檢查的資訊。

Java類庫裡的許多類，例如整個Collection框架都做了泛型化的修改。例如，我們在上面的第一段程式碼裡用到的List介面就是一個泛型類別。在那段程式碼裡，box是一個List對象，它是一個帶有一個Apple類型變數的List介面的類別實作的實例。編譯器使用這個類型變數參數在get方法被呼叫、傳回一個Apple物件時自動對其進行類型轉換。

實際上，這新出現的泛型標記，或者說這個List接口裡的get方法是這樣的：

T get(int index);

get方法實際返回的是一個類型為T的對象，T是在List< T>宣告中的類型變數。

泛型方法和構造器(Constructor)

非常的相似，如果方法和構造器上聲明了一個或多個類型變量，它們也可以泛型化。

public static <t> T getFirst(List<T> list)

這個方法將會接受一個List類型的參數，傳回一個T型別的物件。

範例

你既可以使用Java類庫裡提供的泛型類，也可以使用自己的泛型類。

類型安全的寫入資料…

下面的這段程式碼是個例子，我們建立了一個List實例，然後裝入一些資料：

List<String> str = new ArrayList<String>();
str.add("Hello ");
str.add("World.");

如果我們試圖在List中裝入另一個對象，編譯器就會提示錯誤：

str.add(1); // 不能编译

類型安全的讀取資料…

當我們在使用List物件時，它總能保證我們得到的是一個String物件：

String myString = str.get(0);

遍歷

類庫中的許多類，諸如Iterator，功能都有所增強，被泛型化。 List介面裡的iterator()方法現在回傳的是Iterator，由它的T next()方法傳回的物件不需要再進行型別轉換，你直接得到正確的型別。

for (Iterator<String> iter = str.iterator(); iter.hasNext();) {
String s = iter.next();
System.out.print(s);
}

使用foreach

「for each」語法同樣受益於泛型。前面的程式碼可以寫出這樣：

for (String s: str) {
System.out.print(s);
}

這樣既容易閱讀也容易維護。

自動封裝(Autoboxing)和自動拆封(Autounboxing)

在使用Java泛型時，autoboxing/autounboxing這兩個特徵會被自動的用到，就像下面的這段程式碼：

List<Integer> ints = new ArrayList<Integer>();
ints.add(0);
ints.add(1);
int sum = 0;
for (int i : ints) {
sum += i;
}

然而，你要明白的一點是，封裝和解封會帶來性能上的損失，所有，通用要謹慎的使用。

子類型

在Java中，跟其它具有物件導向類型的語言一樣，類型的層級可以被設計成這樣：

在Java中，类型T的子类型既可以是类型T的一个扩展，也可以是类型T的一个直接或非直接实现(如果T是一个接口的话)。因为“成为某类型的子类型”是一个具有传递性质的关系，如果类型A是B的一个子类型，B是C的子类型，那么A也是C的子类型。在上面的图中：

• FujiApple(富士苹果)是Apple的子类型

• Apple是Fruit(水果)的子类型

• FujiApple(富士苹果)是Fruit(水果)的子类型

所有Java类型都是Object类型的子类型。

B类型的任何一个子类型A都可以被赋给一个类型B的声明：

Apple a = ...;
Fruit f = a;

泛型类型的子类型

如果一个Apple对象的实例可以被赋给一个Fruit对象的声明，就像上面看到的，那么，List 和 a List之间又是个什么关系呢？更通用些，如果类型A是类型B的子类型，那C 和 C之间是什么关系？

答案会出乎你的意料：没有任何关系。用更通俗的话，泛型类型跟其是否子类型没有任何关系。

这意味着下面的这段代码是无效的：

List<Apple> apples = ...;
List<Fruit> fruits = apples;

下面的同样也不允许：

List<Apple> apples;
List<Fruit> fruits = ...;
apples = fruits;

为什么？一个苹果是一个水果，为什么一箱苹果不能是一箱水果？

在某些事情上，这种说法可以成立，但在类型(类)封装的状态和操作上不成立。如果把一箱苹果当成一箱水果会发生什么情况？

List<Apple> apples = ...;
List<Fruit> fruits = apples;
fruits.add(new Strawberry());

如果可以这样的话，我们就可以在list里装入各种不同的水果子类型，这是绝对不允许的。

另外一种方式会让你有更直观的理解：一箱水果不是一箱苹果，因为它有可能是一箱另外一种水果，比如草莓(子类型)。

这是一个需要注意的问题吗？

应该不是个大问题。而程序员对此感到意外的最大原因是数组和泛型类型上用法的不一致。对于泛型类型，它们和类型的子类型之间是没什么关系的。而对于数组，它们和子类型是相关的：如果类型A是类型B的子类型，那么A[]是B[]的子类型：

Apple[] apples = ...;
Fruit[] fruits = apples;

可是稍等一下！如果我们把前面的那个议论中暴露出的问题放在这里，我们仍然能够在一个apple类型的数组中加入strawberrie(草莓)对象：

Apple[] apples = new Apple[1];
Fruit[] fruits = apples;
fruits[0] = new Strawberry();

这样写真的可以编译，但是在运行时抛出ArrayStoreException异常。因为数组的这特点，在存储数据的操作上，Java运行时需要检查类型的兼容性。这种检查，很显然，会带来一定的性能问题，你需要明白这一点。

重申一下，泛型使用起来更安全，能“纠正”Java数组中这种类型上的缺陷。

现在估计你会感到很奇怪，为什么在数组上会有这种类型和子类型的关系，我来给你一个《Java Generics and Collections》这本书上给出的答案：如果它们不相关，你就没有办法把一个未知类型的对象数组传入一个方法里(不经过每次都封装成Object[])，就像下面的：

void sort(Object[] o);

泛型出现后，数组的这个个性已经不再有使用上的必要了(下面一部分我们会谈到这个)，实际上是应该避免使用。

通配符

在本文的前面的部分里已经说过了泛型类型的子类型的不相关性。但有些时候，我们希望能够像使用普通类型那样使用泛型类型：

• 向上造型一个泛型对象的引用

• 向下造型一个泛型对象的引用

向上造型一个泛型对象的引用

例如，假设我们有很多箱子，每个箱子里都装有不同的水果，我们需要找到一种方法能够通用的处理任何一箱水果。更通俗的说法，A是B的子类型，我们需要找到一种方法能够将C类型的实例赋给一个C类型的声明。

为了完成这种操作，我们需要使用带有通配符的扩展声明，就像下面的例子里那样：

List<Apple> apples = new ArrayList<Apple>();
List<? extends Fruit> fruits = apples;

“? extends”是泛型类型的子类型相关性成为现实：Apple是Fruit的子类型，List 是 List 的子类型。

向下造型一个泛型对象的引用

现在我来介绍另外一种通配符：? super。如果类型B是类型A的超类型(父类型)，那么C 是 C 的子类型：

List<Fruit> fruits = new ArrayList<Fruit>();
List<? super Apple> = fruits;

为什么使用通配符标记能行得通？

原理现在已经很明白：我们如何利用这种新的语法结构？

? extends

让我们重新看看这第二部分使用的一个例子，其中谈到了Java数组的子类型相关性：

Apple[] apples = new Apple[1];
Fruit[] fruits = apples;
fruits[0] = new Strawberry();

就像我们看到的，当你往一个声明为Fruit数组的Apple对象数组里加入Strawberry对象后，代码可以编译，但在运行时抛出异常。

现在我们可以使用通配符把相关的代码转换成泛型：因为Apple是Fruit的一个子类，我们使用? extends 通配符，这样就能将一个List对象的定义赋到一个List的声明上：

List<Apple> apples = new ArrayList<Apple>();
List<? extends Fruit> fruits = apples;
fruits.add(new Strawberry());

这次，代码就编译不过去了！Java编译器会阻止你往一个Fruit list里加入strawberry。在编译时我们就能检测到错误，在运行时就不需要进行检查来确保往列表里加入不兼容的类型了。即使你往list里加入Fruit对象也不行：

fruits.add(new Fruit());

你没有办法做到这些。事实上你不能够往一个使用了? extends的数据结构里写入任何的值。

原因非常的简单，你可以这样想：这个? extends T 通配符告诉编译器我们在处理一个类型T的子类型，但我们不知道这个子类型究竟是什么。因为没法确定，为了保证类型安全，我们就不允许往里面加入任何这种类型的数据。另一方面，因为我们知道，不论它是什么类型，它总是类型T的子类型，当我们在读取数据时，能确保得到的数据是一个T类型的实例：

Fruit get = fruits.get(0);

? super

使用 ? super 通配符一般是什么情况？让我们先看看这个：

List<Fruit> fruits = new ArrayList<Fruit>();
List<? super Apple> = fruits;

我们看到fruits指向的是一个装有Apple的某种超类(supertype)的List。同样的，我们不知道究竟是什么超类，但我们知道Apple和任何Apple的子类都跟它的类型兼容。既然这个未知的类型即是Apple，也是GreenApple的超类，我们就可以写入：

fruits.add(new Apple());
fruits.add(new GreenApple());

如果我们想往里面加入Apple的超类，编译器就会警告你：

fruits.add(new Fruit());
fruits.add(new Object());

因为我们不知道它是怎样的超类，所有这样的实例就不允许加入。