1．為什麽需要泛型

泛型在Java中有很重要的地位，網上很多文章羅列各種理論，不便於理解，本篇將立足於代碼介紹、總結了關於泛型的知識。希望能給你帶來一些幫助。

先看下面的代碼：

1. List list = new ArrayList();
2. list.add("CSDN_SEU_Cavin");
3. list.add(100);
4. for (int i = 0; i < list.size(); i++) {
5. String name = (String) list.get(i); //取出Integer時，運行時出現異常
6. System.out.println("name:" + name);
7. }

本例向list類型集合中加入了一個字符串類型的值和一個Integer類型的值。（這樣合法，因為此時list默認的類型為Object類型）。在之後的循環中，由於忘記了之前在list中也加入了Integer類型的值或其他原因，運行時會出現java.lang.ClassCastException異常。為了解決這個問題，泛型應運而生。

2．泛型的使用

Java泛型編程是JDK1.5版本後引入的。泛型讓編程人員能夠使用類型抽象，通常用於集合裏面。

只要在上例中將第1行代碼改成如下形式，那麽就會在編譯list.add(100)時報錯。

1. List<String> list = new ArrayList<String>();

通過List<String>，直接限定了list集合中只能含有String類型的元素，從而在上例中的第6行中，無須進行強制類型轉換，因為集合能夠記住其中元素的類型信息，編譯器已經能夠確認它是String類型了。

3．泛型只在編譯階段有效

看下面的代碼：

1. AyyayList<String> a = new ArrayList<String>();
2. ArrayList b = new ArrayList();
3. Class c1 = a.getClass();
4. Class c2 = b.getClass();
5. System.out.println(a == b); //true

上面程序的輸出結果為true。所有反射的操作都是在運行時的，既然為true，就證明了編譯之後，程序會采取去泛型化的措施，也就是說Java中的泛型，只在編譯階段有效。在編譯過程中，正確檢驗泛型結果後，會將泛型的相關信息擦出，並且在對象進入和離開方法的邊界處添加類型檢查和類型轉換的方法。也就是說，成功編譯過後的class文件中是不包含任何泛型信息的。泛型信息不會進入到運行時階段。

上述結論可通過下面反射的例子來印證：

1. ArrayList<String> a = new ArrayList<String>();
2. a.add("CSDN_SEU_Cavin");
3. Class c = a.getClass();
4. try{
5. Method method = c.getMethod("add",Object.class);
6. method.invoke(a,100);
7. System.out.println(a);
8. }catch(Exception e){
9. e.printStackTrace();
10. }

因為繞過了編譯階段也就繞過了泛型，輸出結果為：

1. [CSDN_SEU_Cavin, 100]

4．泛型類和泛型方法

如下，我們看一個泛型類和方法的使用例子，和未使用泛型的使用方法進行了對比，兩者輸出結果相同，在這裏貼出來方便讀者體會兩者的差異。泛型接口的例子有興趣可以去找一些資料，這裏就不贅述了。

（1）使用泛型的情況

1. public static class FX<T> {
2. private T ob; // 定義泛型成員變量
4. public FX(T ob) {
5. this.ob = ob;
6. }
8. public T getOb() {
9. return ob;
10. }
12. public void showTyep() {
13. System.out.println("T的實際類型是: " + ob.getClass().getName());
14. }
15. }
16. public static void main(String[] args) {
17. FX<Integer> intOb = new FX<Integer>(100);
18. intOb.showTyep();
19. System.out.println("value= " + intOb.getOb());
20. System.out.println("----------------------------------");
22. FX<String> strOb = new FX<String>("CSDN_SEU_Calvin");
23. strOb.showTyep();
24. System.out.println("value= " + strOb.getOb());
25. }

（2）不使用泛型的情況

1. public static class FX {
2. private Object ob; // 定義泛型成員變量
4. public FX(Object ob) {
5. this.ob = ob;
6. }
8. public Object getOb() {
9. return ob;
10. }
12. public void showTyep() {
13. System.out.println("T的實際類型是: " + ob.getClass().getName());
14. }
15. }
17. public static void main(String[] args) {
18. FX intOb = new FX(new Integer(100));
19. intOb.showTyep();
20. System.out.println("value= " + intOb.getOb());
21. System.out.println("----------------------------------");
23. FX strOb = new FX("CSDN_SEU_Calvin");
24. strOb.showTyep();
25. System.out.println("value= " + strOb.getOb());
26. }

輸出結果均為：

1. T的實際類型是: java.lang.Integer
2. value= 100
3. ----------------------------------
4. T的實際類型是: java.lang.String
5. value= CSDN_SEU_Calvin

5．通配符

為了引出通配符的概念，先看如下代碼：

1. List<Integer> ex_int= new ArrayList<Integer>();
2. List<Number> ex_num = ex_int; //非法的

上述第2行會出現編譯錯誤，因為Integer雖然是Number的子類，但List<Integer>不是List<Number>的子類型。

假定第2行代碼沒有問題，那麽我們可以使用語句ex_num.add(newDouble())在一個List中裝入了各種不同類型的子類，這顯然是不可以的，因為我們在取出List中的對象時，就分不清楚到底該轉型為Integer還是Double了。

因此，我們需要一個在邏輯上可以用來同時表示為List<Integer>和List<Number>的父類的一個引用類型，類型通配符應運而生。在本例中表示為List<?>即可。下面這個例子也說明了這一點，註釋已經寫的很清楚了。

1. public static void main(String[] args) {
2. FX<Number> ex_num = new FX<Number>(100);
3. FX<Integer> ex_int = new FX<Integer>(200);
4. getData(ex_num);
5. getData(ex_int);//編譯錯誤
6. }
8. public static void getData(FX<Number> temp) { //此行若把Number換為“？”編譯通過
9. //do something...
10. }
12. public static class FX<T> {
13. private T ob;
14. public FX(T ob) {
15. this.ob = ob;
16. }
17. }

what are you 弄啥嘞！！！！！！！！！！！！！！！！泛型