【Java】泛型詳解（一篇就夠了）

泛型的理解

泛型的概念

所謂泛型，就是允許在定義類、接口時通過一個標識表示類中某個屬性的類型 或者是 某個方法的返回值類型及參數類型。這個類型參數將在使用時（例如，繼承或實現這個接口，用這個類型聲明變量、創建對象時）確定（即傳入實際的類型參數，也稱為類型實參）。

泛型的本質是為了參數化類型（在不創建新的類型的情況下，通過泛型指定的不同類型來控制形參具體限制的類型）。也就是說在泛型使用過程中，操作的數據類型被指定為一個參數，這種參數類型可以用在類、接口和方法中，分別被稱為泛型類、泛型接口、泛型方法

泛型的引入背景

集合容器類在設計階段/聲明階段不能確定這個容器到底實際存的是什么類型的對象，所以在JDK1.5之前只能把元素類型設計為Object，JDK1.5之后使用泛型來解決。因為這個時候除了元素的類型不確定，其他的部分是確定的，例如關於這個元素如何保存，如何管理等是確定的，因此此時把元素的類型設計成一個參數，這個類型參數叫做泛型。Collection ，List ，ArrayList 這個 就是類型參數，即泛型。

為什么要有泛型(Generic)

為什么要有泛型呢，直接Object不是也可以存儲數據嗎？

先來看一個栗子

List arrayList = new ArrayList();
arrayList.add("aaaa");
arrayList.add(100);

for(int i = 0; i< arrayList.size();i++){
    String item = (String)arrayList.get(i);
    Log.d("泛型測試","item = " + item);
}

毫無疑問，程序的運行結果會以崩潰結束：

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

ArrayList可以存放任意類型，例子中添加了一個String類型，添加了一個Integer類型，使用時都以String接收，Integer被強轉成String，因此報錯。為了解決類似這樣的類型轉換問題，在編譯階段就規定只能存放某種類型的數據，泛型應運而生。

泛型的特點

泛型只在編譯階段有效。

看下面的代碼：

List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();

Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();

if(classStringArrayList.equals(classIntegerArrayList)){
    Log.d("泛型測試","類型相同");
}
//輸出結果：D/泛型測試: 類型相同。

通過上面的例子可以證明，在編譯之后程序會采取去泛型化的措施。也就是說Java中的泛型，只在編譯階段有效。在編譯過程中，正確檢驗泛型結果后，會將泛型的相關信息擦出，並且在對象進入和離開方法的邊界處添加類型檢查和類型轉換的方法。也就是說，泛型信息不會進入到運行時階段。

泛型的使用

泛型有三種使用方式，分別為：泛型類、泛型接口、泛型方法

泛型的聲明

例如interface List<T> 和class GenTest<K,V>

其中T,K,V表示泛指，代表類型。這里使用任意字母都可以。常用T表示，是Type的縮寫

要在類名后面指定泛型

List<String> strList = new ArrayList<String>();
Iterator<Customer> iterator = customers.iterator();

• T只能是類，不能用基本數據類型。可以使用包裝類
• 使用泛型的主要優點是能夠在編譯時而不是在運行時檢測錯誤

ArrayList<Integer> list = new ArrayList<>();//類型推斷
list.add(78);
list.add(88);
list.add(77);
list.add(66);
//遍歷方式一：
//for(Integer i : list){
//不需要強轉
//System.out.println(i);
//}
//遍歷方式二：
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()){
	System.out.println(iterator.next());
}

Map<String,Integer> map = new HashMap<String,Integer>();
map.put("Tom1",34);
map.put("Tom2",44);
map.put("Tom3",33);
map.put("Tom4",32);
//添加失敗
//map.put(33, "Tom");
Set<Entry<String,Integer>> entrySet = map.entrySet();
Iterator<Entry<String,Integer>> iterator = entrySet.iterator();
while(iterator.hasNext()){
	Entry<String,Integer> entry = iterator.next();
	System.out.println(entry.getKey() + "--->" + entry.getValue());
}

自定義泛型結構

一些注意事項

1. 泛型類可能有多個參數，此時應將多個參數一起放在尖括號內。比如：<E1,E2,E3>
2. 實例化后，操作原來泛型位置的結構必須與指定的泛型類型一致。
3. 泛型不同的引用不能相互賦值。盡管在編譯時ArrayList<String>和ArrayList<Integer>是兩種類型，但是，在運行時只有一個ArrayList被加載到JVM中。
4. 泛型如果不指定，將被擦除，泛型對應的類型均按照Object處理，但不等價於Object。泛型要使用一路都用，如果不用，一路都不要用。
5. jdk1.7，泛型的簡化操作：ArrayList<Fruit> flist = new ArrayList<>();
6. 泛型的指定中不能使用基本數據類型，可以使用包裝類替換
7. 在類/接口上聲明的泛型，在本類或本接口中即代表某種類型，可以作為非靜態屬性的類型、非靜態方法的參數類型、非靜態方法的返回值類型。但在靜態方法中不能使用類的泛型。
8. 異常類不能是泛型的
9. 不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];參考：ArrayList源碼中聲明：Object[] elementData，而非泛型參數類型數組。
10. 父類有泛型，子類可以選擇保留泛型也可以選擇指定泛型類型

class GenericTest {
    public static void main(String[] args) {
        // 1、使用時：類似於Object，不等同於Object
        ArrayList list = new ArrayList();
        // list.add(new Date());//有風險
        list.add("hello");
        test(list);// 泛型擦除，編譯不會類型檢查
        // ArrayList<Object> list2 = new ArrayList<Object>();
        // test(list2);//一旦指定Object，編譯會類型檢查，必須按照Object處理
    }
    public static void test(ArrayList<String> list) {
        String str = "";
        for (String s : list) {
        str += s + ","; }
        System.out.println("元素:" + str);
    }
}

泛型類

泛型用於類的定義中，被稱為泛型類。通過泛型可以完成對一組類的操作對外開放相同的接口。最典型的就是各種容器類，如：List、Set、Map。

泛型類的最基本寫法（這么看可能會有點暈，會在下面的例子中詳解）：

class 類名稱 <泛型標識：可以隨便寫任意標識號，標識指定的泛型的類型>{
  private 泛型標識 /*（成員變量類型）*/ var; 
  .....

  }
}

示例：

//此處T可以隨便寫為任意標識，常見的如T、E、K、V等形式的參數常用於表示泛型
//在實例化泛型類時，必須指定T的具體類型
class Person<T> {
    // 使用T類型定義變量
    private T info;
    // 使用T類型定義一般方法
    public T getInfo() {
    return info; }
    public void setInfo(T info) {
    this.info = info; }
    // 使用T類型定義構造器
    public Person() {
    }
    public Person(T info) {
    this.info = info; }
    
    //下面兩個方法編譯報錯
    // static的方法中不能聲明泛型
  public static void show(T t) {
      
  }
	// 不能在try-catch中使用泛型定義
  public void test() {
      try {

      } catch (MyException<T> ex) {

      }
  }
}

泛型接口

泛型接口與泛型類的定義及使用基本相同。泛型接口常被用在各種類的生產器中，可以看一個例子：

//定義一個泛型接口
public interface Generator<T> {
    public T next();
}

當實現泛型接口的類，未傳入泛型實參時：

/**
 * 未傳入泛型實參時，與泛型類的定義相同，在聲明類的時候，需將泛型的聲明也一起加到類中
 * 即：class FruitGenerator<T> implements Generator<T>{
 * 如果不聲明泛型，如：class FruitGenerator implements Generator<T>，編譯器會報錯："Unknown class"
 */
class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}

泛型方法

基本使用

格式：[權限修飾符] <泛型> 返回類型 方法名([泛型標識 參數名稱]) 拋出異常

/**
 * 泛型方法的基本介紹
 * @param tClass 傳入的泛型實參
 * @return T 返回值為T類型
 */
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}

說明：

• public 與 返回值中間`<T>`非常重要，**表示此方法為泛型方法**。
  

• 只有聲明了`<T>`的方法才是泛型方法，泛型類中的使用了泛型的成員方法並不是泛型方法。
  

• 與泛型類的定義一樣，此處T可以隨便寫為任意標識，常見的如T、E、K、V等形式的參數常用於表示泛型。
  

類中的泛型方法

//這個類是個泛型類，在上面已經介紹過
public class Generic<T>{     
    private T key;

    public Generic(T key) {
        this.key = key;
    }

    //雖然在方法中使用了泛型，但是這並不是一個泛型方法。
    //這只是類中一個普通的成員方法，只不過他的返回值是在聲明泛型類已經聲明過的泛型。
    //所以在這個方法中才可以繼續使用 T 這個泛型。
    public T getKey(){
        return key;
    }

    /**
         * 這個方法是有問題的，在編譯器會給我們提示這樣的錯誤信息"cannot reslove symbol E"
         * 因為在類的聲明中並未聲明泛型E，所以在使用E做形參和返回值類型時，編譯器會無法識別。
        public E setKey(E key){
             this.key = keu
        }
        */
}

/** 
     * 這才是一個真正的泛型方法。
     * 首先在public與返回值之間的<T>必不可少，這表明這是一個泛型方法，並且聲明了一個泛型T
     * 這個T可以出現在這個泛型方法的任意位置.
     * 泛型的數量也可以為任意多個 
     *    如：public <T,K> K showKeyName(Generic<T> container){
     *        ...
     *        }
     */
public <T> T showKeyName(Generic<T> container){
    System.out.println("container key :" + container.getKey());
    //當然這個例子舉的不太合適，只是為了說明泛型方法的特性。
    T test = container.getKey();
    return test;
}

//這也不是一個泛型方法，這就是一個普通的方法，只是使用了Generic<Number>這個泛型類做形參而已。
public void showKeyValue1(Generic<Number> obj){
    Log.d("泛型測試","key value is " + obj.getKey());
}

//這也不是一個泛型方法，這也是一個普通的方法，只不過使用了泛型通配符?
//同時這也印證了泛型通配符章節所描述的，?是一種類型實參，可以看做為Number等所有類的父類
public void showKeyValue2(Generic<?> obj){
    Log.d("泛型測試","key value is " + obj.getKey());
}

/**
     * 這個方法是有問題的，編譯器會為我們提示錯誤信息："UnKnown class 'E' "
     * 雖然我們聲明了<T>,也表明了這是一個可以處理泛型的類型的泛型方法。
     * 但是只聲明了泛型類型T，並未聲明泛型類型E，因此編譯器並不知道該如何處理E這個類型。
    public <T> T showKeyName(Generic<E> container){
        ...
    }  
    */

/**
     * 這個方法也是有問題的，編譯器會為我們提示錯誤信息："UnKnown class 'T' "
     * 對於編譯器來說T這個類型並未項目中聲明過，因此編譯也不知道該如何編譯這個類。
     * 所以這也不是一個正確的泛型方法聲明。
    public void showkey(T genericObj){

    }

泛型通配符

我們在定義泛型類，泛型方法，泛型接口的時候經常會碰見很多不同的通配符，比如 T，E，K，V 等等，這些通配符又都是什么意思呢？

常用的 T，E，K，V，？

本質上這些個都是通配符，沒啥區別，只不過是編碼時的一種約定俗成的東西。比如上述代碼中的 T ，我們可以換成 A-Z 之間的任何一個 字母都可以，並不會影響程序的正常運行，但是如果換成其他的字母代替 T ，在可讀性上可能會弱一些。通常情況下，T，E，K，V，？是這樣約定的：

• ？表示不確定的 java 類型
• T (type) 表示具體的一個java類型
• K V (key value) 分別代表java鍵值中的Key Value
• E (element) 代表Element

無界通配符?

我們知道Ingeter是Number的一個子類，Generic<Ingeter>與Generic<Number>實際上是相同的一種基本類型。那么問題來了，在使用Generic<Number>作為形參的方法中，能否使用Generic<Ingeter>的實例傳入呢？在邏輯上類似於Generic<Number>和Generic<Ingeter>是否可以看成具有父子關系的泛型類型呢？

為了弄清楚這個問題，我們使用Generic<T>這個泛型類繼續看下面的例子：

public void showKeyValue1(Generic<Number> obj){
    Log.d("泛型測試","key value is " + obj.getKey());
}
...
Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);

showKeyValue(gInteger);

// showKeyValue這個方法編譯器會為我們報錯：Generic<java.lang.Integer> 
// cannot be applied to Generic<java.lang.Number>

通過提示信息我們可以看到Generic<Integer>不能被看作為``Generic `的子類。由此可以看出: 同一種泛型可以對應多個版本（因為參數類型是不確定的），不同版本的泛型類實例是不兼容的。

回到上面的例子，如何解決上面的問題？總不能為了定義一個新的方法來處理Generic<Integer>類型的類，這顯然與java中的多態理念相違背。因此我們需要一個在邏輯上可以同時表示Generic<Integer>和Generic<Number>父類的引用類型。類型通配符應運而生。

我們可以將上面的方法改一下：

public void showKeyValue1(Generic<?> obj){
    Log.d("泛型測試","key value is " + obj.getKey());
}

類型通配符一般是使用？代替具體的類型實參，注意了，此處?是類型實參，而不是類型形參 。再直白點的，此處的？和Number、String、Integer一樣都是一種實際的類型，看成所有類型的父類。是一種真實的類型。

上界通配符 < ? extends E>

先從一個小例子看起

我有一個父類 Animal 和幾個子類，如狗、貓等，現在我需要一個動物的列表，我的第一個想法是像這樣的：

List<Animal> listAnimals

但是大佬的想法確是這樣的：

List<? extends Animal> listAnimals

為什么要使用通配符而不是簡單的泛型呢？其實通配符在聲明局部變量時是沒有什么意義的，但是當你為一個方法聲明一個參數時，它是非常重要的。

static int countLegs (List<? extends Animal > animals ) {
    int retVal = 0;
    for ( Animal animal : animals ) {
        retVal += animal.countLegs();
    }
    return retVal;
}

static int countLegs1 (List<Animal> animals ){
    int retVal = 0;
    for ( Animal animal : animals )
    {
        retVal += animal.countLegs();
    }
    return retVal;
}

public static void main(String[] args) {
    List<Dog> dogs = new ArrayList<>();
    
    countLegs(dogs); // 不會報錯

    countLegs1(dogs);    // 報錯
}

用 <? extends E 關鍵字聲明，表示參數類型可能是所指定的類型或者是此類型的子類。

在類型參數中使用 extends 表示這個泛型中的參數必須是 E 或者 E 的子類，這樣有兩個好處：

• 如果傳入的類型不是 E 或者 E 的子類，編譯不成功，在編譯期間就能指出
• 可以使用 E 的方法，要不然還得強轉成 E 才能使用

private <K extends A, E extends B> E test(K arg1, E arg2){
    arg2.compareTo(arg1);
     E result = arg2;
    //.....
    return result;
}

泛型可以設置多個，用逗號分開

下界通配符 < ? super E>

用 super 進行聲明，表示參數化的類型可能是所指定的類型，或者是此類型的父類型，直至 Object

在類型參數中使用 super 表示這個泛型中的參數必須是 E 或者 E 的父類。

private <T> void test(List<? super T> dst, List<T> src){
    for (T t : src) {
        dst.add(t);
    }
}

public static void main(String[] args) {
    List<Dog> dogs = new ArrayList<>();
    List<Animal> animals = new ArrayList<>();
    test(animals,dogs);
}
// Dog 是 Animal 的子類
class Dog extends Animal {

}

dst 類型 “大於等於” src 的類型，這里的“大於等於”是指 dst 表示的范圍比 src 要大，因此裝得下 dst 的容器也就能裝 src 。

上界通配符主要用於讀數據，下界通配符主要用於寫數據。

？和 T 的區別

//集合元素只能是 T 類型
List<T> list = new ArrayList<T>();

//集合元素可以是任意類型，用於不確定參數類型的情況
public void test(List<?> list) {
    
}

注意：List<?> 不能改成 List<T>，除非方法所在類已經定義過泛型T

參考文檔1

參考文檔2