泛型是Java SE 5.0中引入的一項特征，自從這項語言特征出現多年來，我相信，幾乎所有的Java程序員不僅聽說過，而且使用過它。關於Java泛型的教程，免費的，不免費的，有很多。我遇到的最好的教材有：
The Java Tutorial
Java Generics and Collections, by Maurice Naftalin and Philip Wadler
Effective Java中文版(第2版), by Joshua Bloch.
盡管有這麼多豐富的資料，有時我感覺，有很多的程序員仍然不太明白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>對象，它是一個帶有一個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>類型的參數，返回一個T類型的對象。
例子
你既可以使用Java類庫裡提供的泛型類，也可以使用自己的泛型類。
類型安全的寫入數據…
下面的這段代碼是個例子，我們創建瞭一個List<String>實例，然後裝入一些數據：
List<String> str = new ArrayList<String>();
str.add(“Hello “);
str.add(“World.”);
如果我們試圖在List<String>裝入另外一種對象，編譯器就會提示錯誤：
str.add(1); //不能編譯
類型安全的讀取數據…
當我們在使用List<String>對象時，它總能保證我們得到的是一個String對象：
String myString = str.get(0);
遍歷
類庫中的很多類，諸如Iterator<T>，功能都有所增強，被泛型化。List<T>接口裡的 iterator()方法現在返回的是Iterator<T>，由它的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<Apple> 和 a List<Fruit>之間又是個什麼關系呢？更通用些，如果類型A是類型B的子類型，那C<A> 和 C<B>之間是什麼關系？
答案會出乎你的意料：沒有任何關系。用更通俗的話，泛型類型跟其是否子類型沒有任何關系。
這意味著下面的這段代碼是無效的：
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[]的子類型：
1 Apple[] apples = …;
2 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的子類型，我們需要找到一
