Java 泛型總結（一）：基本用法與類型擦除

時間 2019-11-06

標籤 java 總結基本用法類型擦除欄目 Java 简体版

原文原文鏈接

簡介

Java 在 1.5 引入了泛型機制，泛型本質是參數化類型，也就是說變量的類型是一個參數，在使用時再指定爲具體類型。泛型能夠用於類、接口、方法，經過使用泛型可使代碼更簡單、安全。然而 Java 中的泛型使用了類型擦除，因此只是僞泛型。這篇文章對泛型的使用以及存在的問題作個總結，主要參考自《Java 編程思想》。編程

這個系列的另外兩篇文章：segmentfault

基本用法

泛型類

若是有一個類 Holder 用於包裝一個變量，這個變量的類型多是任意的，怎麼編寫 Holder 呢？在沒有泛型以前能夠這樣：設計模式

public class Holder1 {
    private Object a;

    public Holder1(Object a) {
        this.a = a;
    }

    public void set(Object a) {
        this.a = a;
    }
    public Object get(){
        return a;
    }

    public static void main(String[] args) {
        Holder1 holder1 = new Holder1("not Generic");
        String s = (String) holder1.get();
        holder1.set(1);
        Integer x = (Integer) holder1.get();
    }

}數組

在 Holder1 中，有一個用 Object 引用的變量。由於任何類型均可以向上轉型爲 Object，因此這個 Holder 能夠接受任何類型。在取出的時候 Holder 只知道它保存的是一個 Object 對象，因此要強制轉換爲對應的類型。在 main 方法中， holder1 先是保存了一個字符串，也就是 String 對象，接着又變爲保存一個 Integer 對象(參數 1 會自動裝箱)。從 Holder 中取出變量時強制轉換已經比較麻煩，這裏還要記住不一樣的類型，要是轉錯了就會出現運行時異常。安全

下面看看 Holder 的泛型版本：ui

public class Holder2<T> {

    private T a;
    public Holder2(T a) {
        this.a = a;
    }

    public T get() {
        return a;
    }

    public void set(T a) {
        this.a = a;
    }

    public static void main(String[] args) {
        Holder2<String> holder2 = new Holder2<>("Generic");
        String s = holder2.get();

        holder2.set("test");
        holder2.set(1);//沒法編譯   參數 1 不是 String 類型

    }

}this

在 Holder2 中，變量 a 是一個參數化類型 T，T 只是一個標識，用其它字母也是能夠的。建立 Holder2 對象的時候，在尖括號中傳入了參數 T 的類型，那麼在這個對象中，全部出現 T 的地方至關於都用 String 替換了。如今的 get 的取出來的不是 Object ，而是 String 對象，所以不須要類型轉換。另外，當調用 set 時，只能傳入 String 類型，不然編譯沒法經過。這就保證了 holder2 中的類型安全，避免因爲不當心傳入錯誤的類型。設計

經過上面的例子能夠看出泛使得代碼更簡便、安全。引入泛型以後，Java 庫的一些類，好比經常使用的容器類也被改寫爲支持泛型，咱們使用的時候都會傳入參數類型，如：ArrayList<Integer> list = ArrayList<>();。code

泛型方法

泛型不只能夠針對類，還能夠單獨使某個方法是泛型的，舉個例子：對象

public class GenericMethod {
    public <K,V> void f(K k,V v) {
        System.out.println(k.getClass().getSimpleName());
        System.out.println(v.getClass().getSimpleName());
    }

    public static void main(String[] args) {
        GenericMethod gm = new GenericMethod();
        gm.f(new Integer(0),new String("generic"));
    }
}

代碼輸出：
    Integer
    String

GenericMethod 類自己不是泛型的，建立它的對象的時候不須要傳入泛型參數，可是它的方法 f 是泛型方法。在返回類型以前是它的參數標識 <K,V>，注意這裏有兩個泛型參數，因此泛型參數能夠有多個。

調用泛型方法時能夠不顯式傳入泛型參數，上面的調用就沒有。這是由於編譯器會使用參數類型推斷，根據傳入的實參的類型 (這裏是 integer 和 String) 推斷出 K 和 V 的類型。

類型擦除

什麼是類型擦除

Java 的泛型使用了類型擦除機制，這個引來了很大的爭議，以致於 Java 的泛型功能受到限制，只能說是」僞泛型「。什麼叫類型擦除呢？簡單的說就是，類型參數只存在於編譯期，在運行時，Java 的虛擬機 ( JVM ) 並不知道泛型的存在。先看個例子：

public class ErasedTypeEquivalence {
    public static void main(String[] args) {
        Class c1 = new ArrayList<String>().getClass();
        Class c2 = new ArrayList<Integer>().getClass();
        System.out.println(c1 == c2);
    }
}

上面的代碼有兩個不一樣的 ArrayList：ArrayList<Integer> 和 ArrayList<String>。在咱們看來它們的參數化類型不一樣，一個保存整性，一個保存字符串。可是經過比較它們的 Class 對象，上面的代碼輸出是 true。這說明在 JVM 看來它們是同一個類。而在 C++、C# 這些支持真泛型的語言中，它們就是不一樣的類。

泛型參數會擦除到它的第一個邊界，好比說上面的 Holder2 類，參數類型是一個單獨的 T，那麼就擦除到 Object,至關於全部出現 T 的地方都用 Object 替換。因此在 JVM 看來，保存的變量 a 仍是 Object 類型。之因此取出來自動就是咱們傳入的參數類型，這是由於編譯器在編譯生成的字節碼文件中插入了類型轉換的代碼，不須要咱們手動轉型了。若是參數類型有邊界那麼就擦除到它的第一個邊界，這個下一節再說。

擦除帶來的問題

擦除會出現一些問題，下面是一個例子：

class HasF {
    public void f() {
        System.out.println("HasF.f()");
    }
}
public class Manipulator<T> {
    private T obj;

    public Manipulator(T obj) {
        this.obj = obj;
    }

    public void manipulate() {
        obj.f(); //沒法編譯 找不到符號 f()
    }

    public static void main(String[] args) {
        HasF hasF  = new HasF();
        Manipulator<HasF> manipulator = new Manipulator<>(hasF);
        manipulator.manipulate();

    }

}

上面的 Manipulator 是一個泛型類，內部用一個泛型化的變量 obj，在 manipulate 方法中，調用了 obj 的方法 f()，可是這行代碼沒法編譯。由於類型擦除，編譯器不肯定 obj 是否有 f() 方法。解決這個問題的方法是給 T 一個邊界:

class Manipulator2<T extends HasF> {
    private T obj;
    public Manipulator2(T x) { obj = x; }
    public void manipulate() { obj.f(); }
}

如今 T 的類型是 <T extends HasF>，這表示 T 必須是 HasF 或者 HasF 的導出類型。這樣，調用 f() 方法才安全。HasF 就是 T 的邊界，所以經過類型擦除後，全部出現 T 的
地方都用 HasF 替換。這樣編譯器就知道 obj 是有方法 f() 的。

可是這樣就抵消了泛型帶來的好處，上面的類徹底能夠改爲這樣：

class Manipulator3 {
    private HasF obj;
    public Manipulator3(HasF x) { obj = x; }
    public void manipulate() { obj.f(); }
}

因此泛型只有在比較複雜的類中才體現出做用。可是像 <T extends HasF> 這種形式的東西不是徹底沒有意義的。若是類中有一個返回 T 類型的方法，泛型就有用了，由於這樣會返回準確類型。好比下面的例子：

class ReturnGenericType<T extends HasF> {
    private T obj;
    public ReturnGenericType(T x) { obj = x; }
    public T get() { return obj; }
}

這裏的 get() 方法返回的是泛型參數的準確類型，而不是 HasF。

類型擦除的補償

類型擦除致使泛型喪失了一些功能，任何在運行期須要知道確切類型的代碼都沒法工做。好比下面的例子：

public class Erased<T> {
    private final int SIZE = 100;
    public static void f(Object arg) {
    if(arg instanceof T) {} // Error
    T var = new T(); // Error
    T[] array = new T[SIZE]; // Error
    T[] array = (T)new Object[SIZE]; // Unchecked warning
    }
}

經過 new T() 建立對象是不行的，一是因爲類型擦除，二是因爲編譯器不知道 T 是否有默認的構造器。一種解決的辦法是傳遞一個工廠對象而且經過它建立新的實例。

interface FactoryI<T> {
    T create();
}
class Foo2<T> {
    private T x;
    public <F extends FactoryI<T>> Foo2(F factory) {
    x = factory.create();
    }
    // ...
}
class IntegerFactory implements FactoryI<Integer> {
    public Integer create() {
    return new Integer(0);
    }
}
class Widget {
    public static class Factory implements FactoryI<Widget> {
        public Widget create() {
            return new Widget();
        }
    }
}
public class FactoryConstraint {
    public static void main(String[] args) {
        new Foo2<Integer>(new IntegerFactory());
        new Foo2<Widget>(new Widget.Factory());
    }
}

另外一種解決的方法是利用模板設計模式：

abstract class GenericWithCreate<T> {
    final T element;
    GenericWithCreate() { element = create(); }
    abstract T create();
}
class X {}
class Creator extends GenericWithCreate<X> {
    X create() { return new X(); }
    void f() {
    System.out.println(element.getClass().getSimpleName());
    }
}
public class CreatorGeneric {
    public static void main(String[] args) {
        Creator c = new Creator();
        c.f();
    }
}

具體類型的建立放到了子類繼承父類時，在 create 方法中建立實際的類型並返回。