java泛型詳細介紹

一. 泛型概念的提出（為什麼需要泛型）？ （推薦：java影片教學）

首先，我們看下面這段簡短的程式碼:

public class GenericTest {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("qqyumidi");
        list.add("corn");
        list.add(100);

        for (int i = 0; i < list.size(); i++) {
            String name = (String) list.get(i); // 1
            System.out.println("name:" + name);
        }
    }
}

定義了一個List類型的集合，先在其中加入了兩個字串類型的值，隨後加入一個Integer類型的值。這是完全允許的，因為此時list預設的類型為Object類型。

在之後的循環中，由於忘記了先前在list中也加入了Integer類型的值或其他編碼原因，很容易出現類似//1中的錯誤。因為編譯階段正常，而執行時會出現「java.lang.ClassCastException」異常。因此，導致此類錯誤編碼過程中不易發現。

 在如上的編碼過程中，我們發現主要存在兩個問題：

1.當我們將一個物件放入集合中，集合不會記住此物件的類型，當當再次從集合中取出此物件時，改物件的編譯類型變成了Object類型，但其執行時間類型任然為其本身類型。

2.因此，//1處取出集合元素時需要人為的強制類型轉換到特定的目標類型，且容易出現「java.lang.ClassCastException」異常。

那麼有沒有辦法可以讓集合能夠記住集合內元素各型，且能夠達到只要編譯時不出現問題，執行時就不會出現「java.lang.ClassCastException」異常呢？答案就是使用泛型。

二.什麼是泛型？

泛型，即「參數化類型」。 一提到參數，最熟悉的就是定義方法時有形參，然後呼叫此方法時傳遞實參。

那麼參數化型別怎麼理解呢？顧名思義，就是將類型由原來的具體的類型參數化，類似於方法中的變數參數，此時類型也定義成參數形式（可以稱之為類型形參），然後在使用/呼叫時傳入具體的類型（類型實參）。

 看起來好像有點複雜，首先我們看下上面那個例子採用泛型的寫法。

public class GenericTest {

    public static void main(String[] args) {
        /*
        List list = new ArrayList();
        list.add("qqyumidi");
        list.add("corn");
        list.add(100);
        */

        List<String> list = new ArrayList<String>();
        list.add("qqyumidi");
        list.add("corn");
        //list.add(100);   // 1  提示编译错误

        for (int i = 0; i < list.size(); i++) {
            String name = list.get(i); // 2
            System.out.println("name:" + name);
        }
    }
}

採用泛型寫法後，在//1處想加入一個Integer類型的物件時會出現編譯錯誤，透過Listf7e83be87db5cd2d9a8a0b8117b38cd4，直接限定了list集合中只能含有String類型的元素，從而在//2處無須進行強制類型轉換，因為此時，集合能夠記住元素的類型信息，編譯器已經能夠確認它是String類型了。

結合上面的泛型定義，我們知道在Listf7e83be87db5cd2d9a8a0b8117b38cd4中，String是類型實參，也就是說，對應的List介面中肯定含有類型形參。且get()方法的回傳結果也直接是此形參類型（也就是對應的傳入的型別實參）。下面就來看看List介面的的具體定義：

public interface List<E> extends Collection<E> {

    int size();

    boolean isEmpty();

    boolean contains(Object o);

    Iterator<E> iterator();

    Object[] toArray();

    <T> T[] toArray(T[] a);

    boolean add(E e);

    boolean remove(Object o);

    boolean containsAll(Collection<?> c);

    boolean addAll(Collection<? extends E> c);

    boolean addAll(int index, Collection<? extends E> c);

    boolean removeAll(Collection<?> c);

    boolean retainAll(Collection<?> c);

    void clear();

    boolean equals(Object o);

    int hashCode();

    E get(int index);

    E set(int index, E element);

    void add(int index, E element);

    E remove(int index);

    int indexOf(Object o);

    int lastIndexOf(Object o);

    ListIterator<E> listIterator();

    ListIterator<E> listIterator(int index);

    List<E> subList(int fromIndex, int toIndex);
}

我們可以看到，在List介面中採用泛型化定義之後，1a4db2c2c2313771e5742b6debf617a1中的E表示類型形參，可以接收具體的類型實參，且此介面定義中，凡是出現E的地方均表示相同的接受自外部的類型實參。

自然的，ArrayList作為List介面的實作類，其定義形式是：

public class ArrayList<E> extends AbstractList<E> 
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    
    public E get(int index) {
        rangeCheck(index);
        checkForComodification();
        return ArrayList.this.elementData(offset + index);
    }
    
    //...省略掉其他具体的定义过程

}

由此，我們從原始碼角度明白了為什麼//1處加入Integer類型物件編譯錯誤，且//2處get()到的類型直接就是String類型了。

三.自訂泛型介面、泛型類別和泛型方法

#從上面的內容中，大家已經明白了泛型的具體運作過程。也知道了介面、類別和方法也都可以使用泛型去定義，以及對應的使用。是的，在具體使用時，可以分為泛型介面、泛型類別和泛型方法。

自訂泛型介面、泛型類別和泛型方法與上述Java原始碼中的List、ArrayList類似。如下，我們來看一個最簡單的泛型類別和方法定義：

public class GenericTest {

    public static void main(String[] args) {

        Box<String> name = new Box<String>("corn");
        System.out.println("name:" + name.getData());
    }

}

class Box<T> {

    private T data;

    public Box() {

    }

    public Box(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

}

在泛型介面、泛型類別和泛型方法的定義過程中，我們常見的如T、E、K、V等形式的參數常用於表示泛型形參，由於接收來自外部使用時候傳入的類型實參。那麼對於不同傳入的型別實參，所產生的對應物件實例的型別是不是一樣的呢？

public class GenericTest {

    public static void main(String[] args) {

        Box<String> name = new Box<String>("corn");
        Box<Integer> age = new Box<Integer>(712);

        System.out.println("name class:" + name.getClass());      // com.qqyumidi.Box
        System.out.println("age class:" + age.getClass());        // com.qqyumidi.Box
        System.out.println(name.getClass() == age.getClass());    // true

    }

}

由此，我們發現，在使用泛型類別時，雖然傳入了不同的泛型實參，但並沒有真正意義上生成不同的類型，傳入不同泛型實參的泛型類別在記憶體上只有一個，即還是原來的最基本的類型（本實例中為Box），當然，在邏輯上我們可以理解成多個不同的泛型類型。

究其原因，在於Java中的泛型這一概念提出的目的，導致其只是作用於程式碼編譯階段，在編譯過程中，對於正確檢驗泛型結果後，會將泛型的相關資訊擦出，也就是說，成功編譯過後的class檔案中是不包含任何泛型資訊的。泛型資訊不會進入到運行時階段。

对此总结成一句话：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。 

四.类型通配符

接着上面的结论，我们知道，Boxc8f01a3f8889dcf657849dd45bc0fc4c和Boxc0f559cc8d56b43654fcbe4aa9df7b4a实际上都是Box类型，现在需要继续探讨一个问题，那么在逻辑上，类似于Boxc8f01a3f8889dcf657849dd45bc0fc4c和Boxc0f559cc8d56b43654fcbe4aa9df7b4a是否可以看成具有父子关系的泛型类型呢？

为了弄清这个问题，我们继续看下下面这个例子:

public class GenericTest {

    public static void main(String[] args) {

        Box<Number> name = new Box<Number>(99);
        Box<Integer> age = new Box<Integer>(712);

        getData(name);
        
        //The method getData(Box<Number>) in the type GenericTest is 
        //not applicable for the arguments (Box<Integer>)
        getData(age);   // 1

    }
    
    public static void getData(Box<Number> data){
        System.out.println("data :" + data.getData());
    }

}

我们发现，在代码//1处出现了错误提示信息：The method getData(Boxc8f01a3f8889dcf657849dd45bc0fc4c) in the t ype GenericTest is not applicable for the arguments (Boxc0f559cc8d56b43654fcbe4aa9df7b4a)。显然，通过提示信息，我们知道Boxc8f01a3f8889dcf657849dd45bc0fc4c在逻辑上不能视为Boxc0f559cc8d56b43654fcbe4aa9df7b4a的父类。那么，原因何在呢？

public class GenericTest {

    public static void main(String[] args) {

        Box<Integer> a = new Box<Integer>(712);
        Box<Number> b = a;  // 1
        Box<Float> f = new Box<Float>(3.14f);
        b.setData(f);        // 2

    }

    public static void getData(Box<Number> data) {
        System.out.println("data :" + data.getData());
    }

}

class Box<T> {

    private T data;

    public Box() {

    }

    public Box(T data) {
        setData(data);
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

}

这个例子中，显然//1和//2处肯定会出现错误提示的。在此我们可以使用反证法来进行说明。

假设Boxc8f01a3f8889dcf657849dd45bc0fc4c在逻辑上可以视为Boxc0f559cc8d56b43654fcbe4aa9df7b4a的父类，那么//1和//2处将不会有错误提示了，那么问题就出来了，通过getData()方法取出数据时到底是什么类型呢？Integer? Float? 还是Number？且由于在编程过程中的顺序不可控性，导致在必要的时候必须要进行类型判断，且进行强制类型转换。显然，这与泛型的理念矛盾，因此，在逻辑上Boxc8f01a3f8889dcf657849dd45bc0fc4c不能视为Boxc0f559cc8d56b43654fcbe4aa9df7b4a的父类。

好，那我们回过头来继续看“类型通配符”中的第一个例子，我们知道其具体的错误提示的深层次原因了。那么如何解决呢？总部能再定义一个新的函数吧。

这和Java中的多态理念显然是违背的，因此，我们需要一个在逻辑上可以用来表示同时是Boxc0f559cc8d56b43654fcbe4aa9df7b4a和Boxc8f01a3f8889dcf657849dd45bc0fc4c的父类的一个引用类型，由此，类型通配符应运而生。

类型通配符一般是使用 ? 代替具体的类型实参。注意了，此处是类型实参，而不是类型形参！且Box6b3d0130bba23ae47fe2b8e8cddf0195在逻辑上是Boxc0f559cc8d56b43654fcbe4aa9df7b4a、Boxc8f01a3f8889dcf657849dd45bc0fc4c...等所有Boxf4669da5dd7ec4cbc793dba728d85fa1的父类。由此，我们依然可以定义泛型方法，来完成此类需求。

public class GenericTest {

    public static void main(String[] args) {

        Box<String> name = new Box<String>("corn");
        Box<Integer> age = new Box<Integer>(712);
        Box<Number> number = new Box<Number>(314);

        getData(name);
        getData(age);
        getData(number);
    }

    public static void getData(Box<?> data) {
        System.out.println("data :" + data.getData());
    }

}

有时候，我们还可能听到类型通配符上限和类型通配符下限。具体有是怎么样的呢？

在上面的例子中，如果需要定义一个功能类似于getData()的方法，但对类型实参又有进一步的限制：只能是Number类及其子类。此时，需要用到类型通配符上限。

public class GenericTest {

    public static void main(String[] args) {

        Box<String> name = new Box<String>("corn");
        Box<Integer> age = new Box<Integer>(712);
        Box<Number> number = new Box<Number>(314);

        getData(name);
        getData(age);
        getData(number);
        
        //getUpperNumberData(name); // 1
        getUpperNumberData(age);    // 2
        getUpperNumberData(number); // 3
    }

    public static void getData(Box<?> data) {
        System.out.println("data :" + data.getData());
    }
    
    public static void getUpperNumberData(Box<? extends Number> data){
        System.out.println("data :" + data.getData());
    }

}

此时，显然，在代码//1处调用将出现错误提示，而//2 //3处调用正常。

类型通配符上限通过形如Boxa2b037db85f4e1df0e812b9647ac55a8形式定义，相对应的，类型通配符下限为Boxda50108ad159903fabe211f1543600e8形式，其含义与类型通配符上限正好相反，在此不作过多阐述了。

更多java知识请关注java基础教程栏目。

以上是java泛型詳細介紹的詳細內容。更多資訊請關注PHP中文網其他相關文章！