導讀	Java 泛型（generics）是 JDK 5 中引入的一個新特性, 泛型提供了編譯時型別安全檢測機制，該機制允許程式設計師在編譯時檢測到非法的型別。

一、什麼是泛型

Java 泛型(generics)是 JDK 5 中引入的一個新特性, 泛型提供了編譯時型別安全檢測機制，該機制允許程式設計師在編譯時檢測到非法的型別。

簡單理解就是：泛型指定編譯時的型別，減少執行時由於物件型別不匹配引發的異常。其主要用途是提高我們的程式碼的複用率。

我們Java標準庫中的ArrayList就是泛型使用的典型應用：

public class ArrayListextends AbstractListimplements List, RandomAccess, Cloneable, java.io.Serializable { 
        
      ...... 
 
    public ArrayList(Collection c) { 
        elementData = c.toArray(); 
        if ((size = elementData.length) != 0) { 
            // c.toArray might (incorrectly) not return Object[] (see 6260652) 
            if (elementData.getClass() != Object[].class) 
                elementData = Arrays.copyOf(elementData, size, Object[].class); 
        } else { 
            // replace with empty array. 
            this.elementData = EMPTY_ELEMENTDATA; 
        } 
    } 
 
    public void sort(Comparator c) { 
        final int expectedModCount = modCount; 
        Arrays.sort((E[]) elementData, 0, size, c); 
        if (modCount != expectedModCount) { 
            throw new ConcurrentModificationException(); 
        } 
        modCount++; 
    } 
    
  ..... 
 
    public E get(int index) { 
        rangeCheck(index); 
 
        return elementData(index); 
    } 
 
    public boolean add(E e) { 
        ensureCapacityInternal(size + 1);  // Increments modCount!! 
        elementData[size++] = e; 
        return true; 
    } 
 
}

原始碼中，ArrayList中的E稱為型別引數變數，而整個ArrayList我們稱為泛型型別。我們可以指定除基本型別之外的任何型別，如：ArrayList。

原始碼中Collection 中? 萬用字元型別表示型別的上界，表示引數化型別的可能是T 或是 T的子類。

原始碼中Comparator 表示型別下界(Java Core中叫超型別限定)，表示引數化型別是此型別的超型別(父型別)，直至Object。

二、extends和super萬用字元

在定義泛型型別Generic的時候，也可以使用extends萬用字元來限定T的型別：

public class Generic{ ... }

現在，我們只能定義：

Genericp1 = null; 
Genericp2 = new Generic<>(1, 2); 
Genericp3 = null;

因為Number、Integer和Double都符合。

非Number型別將無法透過編譯：

Genericp1 = null; // compile error! 
Generic p2 = null; // compile error!

因為String、Object都不符合，因為它們不是Number型別或Number的子類。

我們看一個例子：

public class Test { 
 
    static class Food { 
 
    } 
 
    static class Fruit extends Food { 
    } 
 
    static class Apple extends Fruit { 
    } 
 
    static class Orange extends Fruit { 
    } 
 
    public void testExtend() { 
        List list = new ArrayList(); 
 
        //無法安全新增任何具有實際意義的元素,報錯,extends為上界萬用字元,只能取值,不能放. 
        //因為Fruit的子類不只有Apple還有Orange,這裡不能確定具體的泛型到底是Apple還是Orange，所以放入任何一種型別都會報錯 
 
        //list.add(new Apple()); 
        //list.add(new Orange()); 
 
        //可以新增null，因為null可以表示任何型別 
        list.add(null); 
 
        //可以正常獲取，用java多型 
        Food foot = list.get(0); 
        Apple apple = (Apple) list.get(0); 
    } 
 
    public void testSuper() { 
        List list = new ArrayList(); 
 
        //super為下界萬用字元，可以存放元素，但是也只能存放當前類或者子類的例項，以當前的例子來講， 
        list.add(new Fruit()); 
        list.add(new Apple()); 
 
        //無法確定Fruit的父類是否只有Food一個(Object是超級父類) 
        //因此放入Food的例項編譯不透過，只能放自己的例項 或者根據java多型的特性放子類例項 
        //list.add(new Food()); 
        //List list2 = new ArrayList(); 
        //Fruit fruit = list.get(0); //不能確定返回型別 
 
    } 
 
}

在testExtend方法中，因為泛型中用的是extends，在向list中存放元素的時候，我們並不能確定List中的元素的具體型別，即可能是Apple也可能是Orange。因此呼叫add方法時，不論傳入new Apple()還是new Orange()，都會出現編譯錯誤。

理解了extends之後，再看super就很容易理解了，即我們不能確定testSuper方法的引數中的泛型是Fruit的哪個父類，因此在呼叫get方法時只能返回Object型別。結合extends可見，在獲取泛型元素時，使用extends獲取到的是泛型中的上邊界的型別(本例子中為Fruit),範圍更小。

總結：

在使用泛型時，存取元素時用super。

獲取元素時，用extends。

有了上面的結論我們看下Java標準庫的Collections類定義的copy()方法，這個copy()方法的定義就完美地展示了extends和super的意圖：

copy()方法內部不會讀取dest，因為不能呼叫dest.get()來獲取T的引用;

copy()方法內部也不會修改src，因為不能呼叫src.add(T)。

public class Collections { 
    // 把src的每個元素複製到dest中: 
    public staticvoid copy(List dest, List src) { 
        for (int i=0; i<1src.size(); i++)="" {="" t="" dest.add(t);="" }=""

三、泛型擦除

Java的泛型是偽泛型，這是因為Java在編譯期間，所有的泛型資訊都會被擦掉，正確理解泛型概念的首要前提是理解型別擦除。Java的泛型基本上都是在編譯器這個層次上實現的，在生成的位元組碼中是不包含泛型中的型別資訊的，使用泛型的時候加上型別引數，在編譯器編譯的時候會去掉，這個過程成為型別擦除

我們看一個示例：

public class Test2 { 
 
    public static void main(String[] args) { 
        Mapmap = new HashMap<>(); 
        Animal animal = new Animal(); 
        animal.setVegetarian(true); 
        animal.setEats("fish"); 
        map.put("cat", animal); 
 
        String json = new Gson().toJson(map); 
        System.out.println(json); 
 
        MapjsonToMap = fromJson(json); 
        System.out.println(jsonToMap); 
 
        Animal animal1 = jsonToMap.get("cat"); 
        System.out.println(animal1.getEats()); 
    } 
 
    public staticT fromJson(String str) { 
        return new Gson().fromJson(str, new TypeToken() { 
        }.getType()); 
    } 
 
}

上的程式碼執行會提示如下異常：

Exception in thread "main" java.lang.ClassCastException: com.google.gson.internal.LinkedTreeMap cannot be cast to com.uaf.rabbitmq.producer.Animal 
    at com.uaf.rabbitmq.producer.Test2.main(Test2.java:30)

異常原因主要是這句：new Gson().fromJson(str, new TypeToken() {}.getType());

這句在實際執行的時候，List中的T並未傳入實際的泛型引數，導致Gson按照LinkedTreeMap來解析JSON，以致發生了錯誤;這就是一個在編譯期泛型型別擦除所導致的問題;

解決這個問題我們需要修改fromJson方法

public class Test2 { 
 
    public static void main(String[] args) { 
        Mapmap = new HashMap<>(); 
        Animal animal = new Animal(); 
        animal.setVegetarian(true); 
        animal.setEats("fish"); 
        map.put("cat", animal); 
 
        String json = new Gson().toJson(map); 
        System.out.println(json); 
 
        MapjsonToMap = fromJson(json,  
        new TypeToken<1map>() {}.getType()); 
        System.out.println(jsonToMap); 
 
        Animal animal1 = jsonToMap.get("cat"); 
        System.out.println(animal1.getEats()); 
 
    } 
 
    public staticT fromJson(String str, Type type) { 
        return new Gson().fromJson(str, type); 
    } 
 
}

在Gson中提供了TypeToken解決泛型執行時型別擦除問題，TypeToken 這個類來幫助我們捕獲像Map這樣的泛型資訊。上文建立了一個匿名內部類，這樣Java編譯器就會把泛型資訊編譯到這個匿名內部類裡，然後在執行時就可以被getType()方法用反射API提取到。

Java泛型知識

相關文章