国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

Java 泛型總結(一):基本用法與類型擦除

Java_oldboy / 1126人閱讀

摘要:然而中的泛型使用了類型擦除,所以只是偽泛型??偨Y本文介紹了泛型的使用,以及類型擦除相關的問題。一般情況下泛型的使用比較簡單,但是某些情況下,尤其是自己編寫使用泛型的類或者方法時要注意類型擦除的問題。

簡介

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

這個系列的另外兩篇文章:

Java 泛型總結(二):泛型與數組

Java 泛型總結(三):通配符的使用

基本用法 泛型類

如果有一個類 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 的泛型版本:

public class Holder2 {

    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 holder2 = new Holder2<>("Generic");
        String s = holder2.get();

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

    }

}

Holder2 中, 變量 a 是一個參數化類型 T,T 只是一個標識,用其它字母也是可以的。創建 Holder2 對象的時候,在尖括號中傳入了參數 T 的類型,那么在這個對象中,所有出現 T 的地方相當于都用 String 替換了。現在的 get 的取出來的不是 Object ,而是 String 對象,因此不需要類型轉換。另外,當調用 set 時,只能傳入 String 類型,否則編譯無法通過。這就保證了 holder2 中的類型安全,避免由于不小心傳入錯誤的類型。

通過上面的例子可以看出泛使得代碼更簡便、安全。引入泛型之后,Java 庫的一些類,比如常用的容器類也被改寫為支持泛型,我們使用的時候都會傳入參數類型,如:ArrayList list = ArrayList<>();

泛型方法

泛型不僅可以針對類,還可以多帶帶使某個方法是泛型的,舉個例子:

public class GenericMethod {
    public  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 是泛型方法。在返回類型之前是它的參數標識 ,注意這里有兩個泛型參數,所以泛型參數可以有多個。

調用泛型方法時可以不顯式傳入泛型參數,上面的調用就沒有。這是因為編譯器會使用參數類型推斷,根據傳入的實參的類型 (這里是 integerString) 推斷出 KV 的類型。

類型擦除 什么是類型擦除

Java 的泛型使用了類型擦除機制,這個引來了很大的爭議,以至于 Java 的泛型功能受到限制,只能說是”偽泛型“。什么叫類型擦除呢?簡單的說就是,類型參數只存在于編譯期,在運行時,Java 的虛擬機 ( JVM ) 并不知道泛型的存在。先看個例子:

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

上面的代碼有兩個不同的 ArrayListArrayListArrayList。在我們看來它們的參數化類型不同,一個保存整性,一個保存字符串。但是通過比較它們的 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 {
    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 manipulator = new Manipulator<>(hasF);
        manipulator.manipulate();

    }

}

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

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

現在 T 的類型是 ,這表示 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 類型的方法,泛型就有用了,因為這樣會返回準確類型。比如下面的例子:

class ReturnGenericType {
    private T obj;
    public ReturnGenericType(T x) { obj = x; }
    public T get() { return obj; }
}

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

類型擦除的補償

類型擦除導致泛型喪失了一些功能,任何在運行期需要知道確切類型的代碼都無法工作。比如下面的例子:

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

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

abstract class GenericWithCreate {
    final T element;
    GenericWithCreate() { element = create(); }
    abstract T create();
}
class X {}
class Creator extends GenericWithCreate {
    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 方法中創建實際的類型并返回。

總結

本文介紹了 Java 泛型的使用,以及類型擦除相關的問題。一般情況下泛型的使用比較簡單,但是某些情況下,尤其是自己編寫使用泛型的類或者方法時要注意類型擦除的問題。接下來會介紹數組與泛型的關系以及通配符的使用,有興趣的讀者可進入下一篇:Java 泛型總結(二):泛型與數組。

參考

Java 編程思想

如果我的文章對您有幫助,不妨點個贊支持一下(^_^)

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/65971.html

相關文章

  • Java泛型總結

    摘要:靜態變量是被泛型類的所有實例所共享的。對于這個類型系統,有如下的一些規則相同類型參數的泛型類的關系取決于泛型類自身的繼承體系結構。在代碼中避免泛型類和原始類型的混用。參考泛型類型擦除 Java泛型總結 Java泛型是JDK5引入的一個新特性,允許在定義類和接口的時候使用類型參數(type parameter)。聲明的類型參數在使用的時候使用具體的類型來替換。泛型最主要的應用是在JDK5...

    CoreDump 評論0 收藏0
  • Java 泛型總結(二):泛型數組

    摘要:總結數組與泛型的關系還是有點復雜的,中不允許直接創建泛型數組。本文分析了其中原因并且總結了一些創建泛型數組的方式。 簡介 上一篇文章介紹了泛型的基本用法以及類型擦除的問題,現在來看看泛型和數組的關系。數組相比于Java 類庫中的容器類是比較特殊的,主要體現在三個方面: 數組創建后大小便固定,但效率更高 數組能追蹤它內部保存的元素的具體類型,插入的元素類型會在編譯期得到檢查 數組可以持...

    Vultr 評論0 收藏0
  • Java系列之泛型

    摘要:總結泛型的類型必須是引用類型,不能是基本類型,泛型的個數可以有多個,可以使用對創建對象時的泛型類型以及方法參數類型進行限制,如使用關鍵字和對泛型的具體類型進行向下限制或向上限制,最后一點,可以聲明泛型數組,但是不能創建泛型數組的實例。 自從 JDK 1.5 提供了泛型概念,泛型使得開發者可以定義較為安全的類型,不至于強制類型轉化時出現類型轉化異常,在沒有反省之前,可以通過 Object...

    MadPecker 評論0 收藏0
  • java編程思想》—— 泛型

    摘要:引用泛型除了方法因不能使用外部實例參數外,其他繼承實現成員變量,成員方法,方法返回值等都可使用。因此,生成的字節碼僅包含普通的類,接口和方法。 為什么要使用泛型程序設計? 一般的類和方法,只能使用具體的類型:要么是基本類型,要么是自定義類的對應類型;如果要編寫可以應用于多種類型的代碼,這種刻板的限制對代碼的束縛就會很大。----摘自原書Ordinary classes and meth...

    CODING 評論0 收藏0
  • Java 泛型總結(三):通配符的使用

    簡介 前兩篇文章介紹了泛型的基本用法、類型擦除以及泛型數組。在泛型的使用中,還有個重要的東西叫通配符,本文介紹通配符的使用。 這個系列的另外兩篇文章: Java 泛型總結(一):基本用法與類型擦除 Java 泛型總結(二):泛型與數組 數組的協變 在了解通配符之前,先來了解一下數組。Java 中的數組是協變的,什么意思?看下面的例子: class Fruit {} class Apple ex...

    itvincent 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<