對于java的泛型我一直屬于一知半解的，平常真心用的不多。直到閱讀《Effect Java》,看到很多平常不了解的用法，才下定決心，需要系統的學習，并且記錄下來。

[[275234]]

1、泛型的概述：

1.1 泛型的由來

根據《Java編程思想》中的描述，泛型出現的動機：

有很多原因促成了泛型的出現，而最引人注意的一個原因，就是為了創建容器類。

泛型的思想很早就存在，如C++中的模板(Templates)。模板的精神：參數化類型

1.2 基本概述

• 泛型的本質就是"參數化類型"。一提到參數，最熟悉的就是定義方法的時候需要形參，調用方法的時候，需要傳遞實參。那"參數化類型"就是將原來具體的類型參數化
• 泛型的出現避免了強轉的操作，在編譯器完成類型轉化，也就避免了運行的錯誤。

1.3 泛型的目的

Java泛型也是一種語法糖，在編譯階段完成類型的轉換的工作，避免在運行時強制類型轉換而出現ClassCastException,類型轉化異常。

1.4 實例

JDK 1.5時增加了泛型，在很大的程度上方便在集合上的使用。

不使用泛型：

public static void main(String[] args) { 
 List list = new ArrayList(); 
 list.add(11); 
 list.add("ssss"); 
 for (int i = 0; i < list.size(); i++) { 
 System.out.println((String)list.get(i)); 
 } 
 } 

因為list類型是Object。所以int,String類型的數據都是可以放入的，也是都可以取出的。但是上述的代碼，運行的時候就會拋出類型轉化異常，這個相信大家都能明白。

使用泛型：

public static void main(String[] args) { 
 List<String> list = new ArrayList(); 
 list.add("hahah"); 
 list.add("ssss"); 
 for (int i = 0; i < list.size(); i++) { 
 System.out.println((String)list.get(i)); 
 } 
 } 

在上述的實例中，我們只能添加String類型的數據，否則編譯器會報錯。

2、泛型的使用

泛型的三種使用方式：泛型類，泛型方法，泛型接口

2.1 泛型類

泛型類概述：把泛型定義在類上

定義格式：

public class 類名 <泛型類型1,...> { 
  
} 

注意事項：泛型類型必須是引用類型(非基本數據類型)

2.2 泛型方法

泛型方法概述：把泛型定義在方法上

定義格式：

public <泛型類型> 返回類型 方法名(泛型類型 變量名) { }

注意要點：

方法聲明中定義的形參只能在該方法里使用，而接口、類聲明中定義的類型形參則可以在整個接口、類中使用。當調用fun()方法時，根據傳入的實際對象，編譯器就會判斷出類型形參T所代表的實際類型。

class Demo{  
 public <T> T fun(T t){ // 可以接收任意類型的數據  
 return t ; // 直接把參數返回  
 }  
};  
public class GenericsDemo26{  
 public static void main(String args[]){  
 Demo d = new Demo() ; // 實例化Demo對象  
 String str = d.fun("湯姆") ; // 傳遞字符串  
 int i = d.fun(30) ; // 傳遞數字，自動裝箱  
 System.out.println(str) ; // 輸出內容  
 System.out.println(i) ; // 輸出內容  
 }  
}; 

2.3 泛型接口

泛型接口概述：把泛型定義在接口

定義格式：

public interface 接口名<泛型類型> { 
  
} 

實例：

/** 
 * 泛型接口的定義格式: 修飾符 interface 接口名<數據類型> {} 
 */ 
public interface Inter<T> { 
 public abstract void show(T t) ; 
} 
/** 
 * 子類是泛型類 
 */ 
public class InterImpl<E> implements Inter<E> { 
 @Override 
 public void show(E t) { 
 System.out.println(t); 
 } 
} 
Inter<String> inter = new InterImpl<String>() ; 
inter.show("hello") ; 

2.4 源碼中泛型的使用，下面是List接口和ArrayList類的代碼片段。

//定義接口時指定了一個類型形參，該形參名為E 
public interface List<E> extends Collection<E> { 
 //在該接口里，E可以作為類型使用 
 public E get(int index) {} 
 public void add(E e) {}  
} 
//定義類時指定了一個類型形參，該形參名為E 
public class ArrayList<E> extends AbstractList<E> implements List<E> { 
 //在該類里，E可以作為類型使用 
 public void set(E e) { 
 ....................... 
 } 
} 

2.5 泛型類派生子類

父類派生子類的時候不能在包含類型形參，需要傳入具體的類型

錯誤的方式：

public class A extends Container {} 

正確的方式：

public class A extends Container {} 

也可以不指定具體的類型，系統就會把K,V形參當成Object類型處理

public class A extends Container {} 

2.6 泛型構造器

構造器也是一種方法，所以也就產生了所謂的泛型構造器。

和使用普通方法一樣沒有區別，一種是顯示指定泛型參數，另一種是隱式推斷

public class Person { 
 public <T> Person(T t) { 
 System.out.println(t); 
 } 
  
} 

使用：

public static void main(String[] args) { 
 new Person(22);// 隱式 
 new <String> Person("hello");//顯示 
} 

特殊說明：

如果構造器是泛型構造器，同時該類也是一個泛型類的情況下應該如何使用泛型構造器：因為泛型構造器可以顯式指定自己的類型參數(需要用到菱形，放在構造器之前)，而泛型類自己的類型實參也需要指定(菱形放在構造器之后)，這就同時出現了兩個菱形了，這就會有一些小問題，具體用法再這里總結一下。 以下面這個例子為代表

public class Person<E> { 
 public <T> Person(T t) { 
 System.out.println(t); 
 } 
} 

正確用法：

public static void main(String[] args) { 
 Person<String> person = new Person("sss"); 
} 

PS：編譯器會提醒你怎么做的

2.7 高級通配符

2.7.1背景：

2.7.2 上界通配符

上界通配符顧名思義，表示的是類型的上界【包含自身】，因此通配的參數化類型可能是T或T的子類。

正因為無法確定具體的類型是什么，add方法受限(可以添加null，因為null表示任何類型)，但可以從列表中獲取元素后賦值給父類型。如上圖中的第一個例子，第三個add()操作會受限，原因在于List和List是List的子類型。

它表示集合中的所有元素都是Animal類型或者其子類 List

這就是所謂的上限通配符，使用關鍵字extends來實現，實例化時，指定類型實參只能是extends后類型的子類或其本身。

例如：

這樣就確定集合中元素的類型，雖然不確定具體的類型，但最起碼知道其父類。然后進行其他操作。

它表示集合中的所有元素都是Animal類型或者其子類 
 List<? extends Animal> 

2.7.3 下界通配符

下界通配符表示的是參數化類型是T的超類型(包含自身)，層層至上，直至Object

編譯器無從判斷get()返回的對象的類型是什么，因此get()方法受限。但是可以進行add()方法，add()方法可以添加T類型和T類型的子類型，如第二個例子中首先添加了一個Cat類型對象，然后添加了兩個Cat子類類型的對象，這種方法是可行的，但是如果添加一個Animal類型的對象，顯然將繼承的關系弄反了，是不可行的。

它表示集合中的所有元素都是Cat類型或者其父類 List

這就是所謂的下限通配符，使用關鍵字super來實現，實例化時，指定類型實參只能是extends后類型的子類或其本身

例如

//Animal是其父類 
List<? super Cat> list = new ArrayList<Animal>(); 

2.7.4 無界通配符

任意類型，如果沒有明確，那么就是Object以及任意的Java類了

無界通配符用表示，?代表了任何的一種類型，能代表任何一種類型的只有null(Object本身也算是一種類型，但卻不能代表任何一種類型，所以List和List的含義是不同的，前者類型是Object，也就是繼承樹的最上層，而后者的類型完全是未知的)

3、泛型擦除

3.1 概念

編譯器編譯帶類型說明的集合時會去掉類型信息

3.2 驗證實例：

public class GenericTest { 
 public static void main(String[] args) { 
 new GenericTest().testType(); 
 } 
 public void testType(){ 
 ArrayList<Integer> collection1 = new ArrayList<Integer>(); 
 ArrayList<String> collection2= new ArrayList<String>(); 
  
 System.out.println(collection1.getClass()==collection2.getClass()); 
 //兩者class類型一樣,即字節碼一致 
  
 System.out.println(collection2.getClass().getName()); 
 //class均為java.util.ArrayList,并無實際類型參數信息 
 } 
} 

輸出結果：

true 
java.util.ArrayList 

分析：

這是因為不管為泛型的類型形參傳入哪一種類型實參，對于Java來說，它們依然被當成同一類處理，在內存中也只占用一塊內存空間。從Java泛型這一概念提出的目的來看，其只是作用于代碼編譯階段，在編譯過程中，對于正確檢驗泛型結果后，會將泛型的相關信息擦出，也就是說，成功編譯過后的class文件中是不包含任何泛型信息的。泛型信息不會進入到運行時階段。

在靜態方法、靜態初始化塊或者靜態變量的聲明和初始化中不允許使用類型形參。由于系統中并不會真正生成泛型類，所以instanceof運算符后不能使用泛型類

4、泛型與反射

把泛型變量當成方法的參數，利用Method類的getGenericParameterTypes方法來獲取泛型的實際類型參數

例子：

public class GenericTest { 
 public static void main(String[] args) throws Exception { 
 getParamType(); 
 } 
  
 /*利用反射獲取方法參數的實際參數類型*/ 
 public static void getParamType() throws NoSuchMethodException{ 
 Method method = GenericTest.class.getMethod("applyMap",Map.class); 
 //獲取方法的泛型參數的類型 
 Type[] types = method.getGenericParameterTypes(); 
 System.out.println(types[0]); 
 //參數化的類型 
 ParameterizedType pType = (ParameterizedType)types[0]; 
 //原始類型 
 System.out.println(pType.getRawType()); 
 //實際類型參數 
 System.out.println(pType.getActualTypeArguments()[0]); 
 System.out.println(pType.getActualTypeArguments()[1]); 
 } 
 /*供測試參數類型的方法*/ 
 public static void applyMap(Map<Integer,String> map){ 
 } 
} 

輸出結果：

java.util.Map<java.lang.Integer, java.lang.String> 
interface java.util.Map 
class java.lang.Integer 
class java.lang.String 

通過反射繞開編譯器對泛型的類型限制

public static void main(String[] args) throws Exception { 
        //定義一個包含int的鏈表 
        ArrayList<Integer> al = new ArrayList<Integer>(); 
        al.add(1); 
        al.add(2); 
        //獲取鏈表的add方法，注意這里是Object.class，如果寫int.class會拋出NoSuchMethodException異常 
        Method m = al.getClass().getMethod("add", Object.class); 
        //調用反射中的add方法加入一個string類型的元素，因為add方法的實際參數是Object 
        m.invoke(al, "hello"); 
        System.out.println(al.get(2)); 
    } 

5 泛型的限制

5.1 模糊性錯誤

對于泛型類User

public class User<K, V> { 
  
 public void show(K k) { // 報錯信息：'show(K)' clashes with 'show(V)'; both methods have same erasure 
  
 } 
 public void show(V t) { 
 } 
} 

由于泛型擦除，二者本質上都是Obejct類型。方法是一樣的，所以編譯器會報錯。

換一個方式：

public class User<K, V> { 
 public void show(String k) { 
 } 
 public void show(V t) { 
 } 
} 

使用結果：

 

 

可以正常的使用5.2 不能實例化類型參數

編譯器也不知道該創建那種類型的對象

public class User<K, V> { 
 private K key = new K(); // 報錯：Type parameter 'K' cannot be instantiated directly 
} 

5.3 對靜態成員的限制

靜態方法無法訪問類上定義的泛型;如果靜態方法操作的類型不確定，必須要將泛型定義在方法上。

如果靜態方法要使用泛型的話，必須將靜態方法定義成泛型方法。

public class User<T> { 
 //錯誤 
 private static T t; 
 //錯誤 
 public static T getT() { 
 return t; 
 } 
 //正確 
 public static <K> void test(K k) { 
 } 
} 

5.4 對泛型數組的限制

不能實例化元素類型為類型參數的數組，但是可以將數組指向類型兼容的數組的引用

public class User<T> { 
 private T[] values; 
 public User(T[] values) { 
 //錯誤，不能實例化元素類型為類型參數的數組 
 this.values = new T[5]; 
 //正確，可以將values 指向類型兼容的數組的引用 
 this.values = values; 
 } 
} 

5.5 對泛型異常的限制

泛型類不能擴展 Throwable，意味著不能創建泛型異常類