我們可以在定義集合時設置泛型這樣的約束，也可以在定義類和方法時加上泛型，這樣能提升類和方法的靈活性。此外我們還可以在定義泛型時加上繼承和通配符。在平時的培訓中，我曾發現初學者對一些復雜的泛型（其實也不復雜，只不過是較少用）感到困惑。這里就通過一些案例展示泛型在項目里的常見用法。
1 泛型可以作用在類和接口上
泛型作用在類上的案例，比如在項目里，我們需要定義一個倉庫類（WareHouse），會用一個列表來表示倉庫里存放的東西。在定義倉庫類時，我們可以通過泛型來指定列表里能容納的數據類型。請看如下的GenericClass.java例子。
1 //省略import集合包的代碼
2 //請注意在定義類時，直接加上了泛型T
3 class WareHouse<T>{
4 private List<T> productList;//請注意這里的泛型是T，和第3行一致
5 public List<T> getProductList()
6 {return productList; }
7 public void setProductList(List<T> productList)
8 {this.productList = productList;}
9 //構造函數
10 public WareHouse()
11 {productList = new ArrayList<T>();}
12 //添加元素的方法，請注意參數類型是T
13 void addItem(T item)
14 {productList.add(item); }
15 //打印所有的對象
16 public void printAllItems() {
17 //T作用到了迭代器上
18 Iterator<T> it = productList.iterator();
19 while(it.hasNext())
20 {System.out.println(it.next().toString());}
21 }
22 }
在第3行定義WareHourse這個類時，我們加上了泛型約束T，而在這個類的屬性和方法里，我們又多處用到了這個泛型T。比如，在第4行里通過T來創建一個含泛型約束的List，在第13行添加元素的方法里，參數是T，在第16行打印所有對象的printAllItems方法里，我們在第18行創建迭代器時，也用到了泛型T。
我們也可以把T修改成E等字符，但一旦定義成T，那么在使用時，就需要和這個字符”T”相匹配。
23 class Item{
24 //貨物名稱
25 private String itemName;
26 //構造函數
27 public Item(String name)
28 {this.itemName = name;}
29 //針對屬性的get方法
30 public String getItemName()
31 {return itemName; }
32 //針對屬性的set方法
33 public void setItemName(String itemName)
34 {this.itemName = itemName; }
35 //重寫了toString方法
36 public String toString()
37 {return this.itemName; }
38 }
隨后我們在第23到38行定義了一個用於描述倉庫貨物的Item類，在其中的第25行，我們通過itemName這個屬性來定義該貨物的名字。
39 public class GenericClass {
40 public static void main(String[] args) {
41 //這里傳入的泛型種類是String
42 WareHouse<String> wh = new WareHouse<String>();
43 wh.addItem("Java");
44 wh.addItem("C#");
45 wh.printAllItems();//能輸出Java和C#
46 //接下來我們創建兩個Item對象
47 Item bookItem = new Item("Book");
48 Item carItem = new Item("Car");
49 //這里的泛型種類是Item
50 WareHouse<Item> itemWh = new WareHouse<Item>();
51 itemWh.addItem(bookItem);
52 itemWh.addItem(carItem);
53 itemWh.printAllItems(); //輸出是Book和Car
54 }
55 }
我們在main函數里用到了這個帶泛型的WareHouse類。在第42行里，我們實例化wh對象時，指定了該對象的泛型類型是String，也就是說，在WareHouse這個類里，所有帶“T”的地方都可以用String來替代。比如private List<T> productList;可以被替代成private List<String> productList。之后在第43和44行里，我們調用了addItem方法添加對象，並在第45行通過了printAllItems方法輸出了存儲在wh里的所有商品。
在第50行里，我們指定了泛型類型是自定義的Item；如是，在第51和52行調用addItem方法時，傳入的參數就需要是Item類型了。
在這個例子中，我們把泛型作用到類上。如此，我們就可以用比較靈活的方式來定義類里的數據類型，從而這個類也有比較高的通用性。
泛型也可以作用到接口上，這個語法點和作用到類上的很相似，就不示例了。
此外，在上述代碼里，我們也見到了泛型作用到方法上的基本用法，比如我們讓泛型作用到類的返回類型上。代碼如下：
public List<T> getProductList()
也可以讓泛型作用到方法的參數類型上，代碼如下：
void addItem(T item)
2 泛型的繼承和通配符
在定義泛型時，我們可以通過extends來限定泛型類型的上限，也可以通過super來限定下限，這兩個限定字一般會和?等關鍵字搭配使用。
比如有這樣的代碼List<? super Father> dest，這里，super包含“高於”的意思，? Super Father就表示dest存放的對象應當“以Father為子類”；換句話說，在dest里，可以存放任何子類是Father類的對象。
再來看個extends的用法。比如有這樣的代碼，List<? extends Father> src，extends用來表示繼承，這里的src可以存放以”Father”為父類的對象；也就是說，src可以存放任何Father對象的子類。
在實際的項目里，我們一般從List<? extends Father> src這類的集合里讀元素，而從List<? super Father> dest這樣的集合里寫元素。通過下面的GenericExtends.java例子，再來了解extends，super和?的用法。
1 import java.util.ArrayList;
2 import java.util.List;
3 //定義一個空的父類和空的子類
4 class Father{ }
5 class Son extends Father{}
6 //這是個包含main方法的主類
7 public class GenericExtends {
8 //這個方法里，將把src里的對象復制到dest里
9 static void copy(List<? super Father> dest,
10 List<? extends Father> src) {
11 for (int i=0; i<src.size(); i++)
12 { dest.add(src.get(i)); }
13 }
在第9行copy方法的兩個參數里，我們看到了兩個包含extends和super泛型的參數。在方法體的for循環里，我們的做法符合剛才講到的原則：從帶extends泛型的集合里讀，往帶super泛型的集合里寫。
14 public static void main(String[] args) {
15 Father f = new Father();
16 Son s = new Son();
17 //創建了一個帶Father泛型的集合，並向其中放了一個元素
18 List<Father> srcFatherList = new ArrayList<Father>();
19 srcFatherList.add(f);
20 List<Father> destFatherList = new ArrayList<Father>();
21 //通過copy方法，把元素復制進了destFatherList里
22 copy(destFatherList,srcFatherList);
23 //這里的輸出是1，說明copy方法成功地往destFatherList里寫了元素
24 System.out.println(destFatherList.size());
25 }
26 }
在定義方法的參數時，我們可以用帶extends和super的泛型來確保輸入參數類型的准確性。除此之外，這兩種泛型的用處不大，比如在main函數的第22行里，調用copy方法時，我們傳入的參數都是List<Father>類型。
下面我們來展示些錯誤的用法：
錯誤用法一：用帶問號的類型實例化集合對象。
1 List<?> list = new ArrayList<String>(); //正確
2 //List<?> list = new ArrayList<?>(); //錯誤
第1行里，雖然在等號的左邊我們用到了問號，但在右邊，我們確立了泛型類型是String，這個是正確的。與之相比，在等號的左邊和右邊我們都用了問號，這是錯誤的，因為編譯器不知道list集合該采用哪種泛型類型。
錯誤用法二：向包含<? extends Father>泛型的集合里寫。
1 List<? extends Father> list = new ArrayList<Father>();
2 //list.add(f); //error
第2行會報語法錯，原因是編譯器不知道這個基於Father的子類型究竟是什么；因為沒法確定，為了保證類型安全，所以就不允許往里面加數據。”
錯誤用法三：從包含<? super Father>泛型的集合里讀。
1 List<? super Father> list1 = new ArrayList<Father>();
2 list.add(f); //正確
3 //list.get(0);//錯誤
第3行會報語法錯，原因是編譯器不知道該用哪種Father的父類來接收get的返回值；於是，同樣為了保證類型安全，所以就不允許讀。
從上述的第二和第三種錯誤的用法里，我們能感受到，extends和super這兩種定義泛型的用法除了在定義方法參數之外，還真沒其他合適的用途。