2. 程式人生 > >轉：Java 泛型，你瞭解型別擦除嗎？

轉：Java 泛型，你瞭解型別擦除嗎？

阿新 • • 發佈：2019-01-26

泛型，一個孤獨的守門者。

大家可能會有疑問，我為什麼叫做泛型是一個守門者。這其實是我個人的看法而已，我的意思是說泛型沒有其看起來那麼深不可測，它並不神祕與神奇。泛型是 Java 中一個很小巧的概念，但同時也是一個很容易讓人迷惑的知識點，它讓人迷惑的地方在於它的許多表現有點違反直覺。

文章開始的地方，先給大家奉上一道經典的測試題。

List<String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();

System.out.println(l1.getClass() == l2.getClass());

請問，上面程式碼最終結果輸出的是什麼？不瞭解泛型的和很熟悉泛型的同學應該能夠答出來，而對泛型有所瞭解，但是瞭解不深入的同學可能會答錯。
正確答案是 true。

上面的程式碼中涉及到了泛型，而輸出的結果緣由是型別擦除。先好好說說泛型。

泛型是什麼？

泛型的英文是 generics，generic 的意思是通用,而翻譯成中文，泛應該意為廣泛，型是型別。所以泛型就是能廣泛適用的型別。

但泛型還有一種較為準確的說法就是為了引數化型別，或者說可以將型別當作引數傳遞給一個類或者是方法。

那麼，如何解釋型別引數化呢？

public class Cache {
    Object value;

    public
 
 Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }
}

假設 Cache 能夠存取任何型別的值，於是，我們可以這樣使用它。

Cache cache = new Cache();
cache.setValue(134);
int value = (int) cache.getValue();
cache.setValue("hello");
String value1 = (String) cache.getValue();

使用的方法也很簡單，只要我們做正確的強制轉換就好了。

但是，泛型卻給我們帶來了不一樣的程式設計體驗。

public class Cache<T> {
    T value;

    public Object getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

}

這就是泛型，它將 value 這個屬性的型別也引數化了，這就是所謂的引數化型別。再看它的使用方法。

Cache<String> cache1 = new Cache<String>();
cache1.setValue("123");
String value2 = cache1.getValue();

Cache<Integer> cache2 = new Cache<Integer>();
cache2.setValue(456);
int value3 = cache2.getValue();

最顯而易見的好處就是它不再需要對取出來的結果進行強制轉換了。但，還有另外一點不同。

泛型不再需要對取出來的結果進行強制轉換

泛型除了可以將型別引數化外，而引數一旦確定好，如果類似不匹配，編譯器就不通過。
上面程式碼顯示，無法將一個 String 物件設定到 cache2 中，因為泛型讓它只接受 Integer 的型別。

所以，綜合上面資訊，我們可以得到下面的結論。

  1. 與普通的 Object 代替一切型別這樣簡單粗暴而言，泛型使得資料的類別可以像引數一樣由外部傳遞進來。它提供了一種擴充套件能力。它更符合面向抽象開發的軟體程式設計宗旨。
  2. 當具體的型別確定後，泛型又提供了一種型別檢測的機制，只有相匹配的資料才能正常的賦值，否則編譯器就不通過。所以說，它是一種型別安全檢測機制，一定程度上提高了軟體的安全性防止出現低階的失誤。
  3. 泛型提高了程式程式碼的可讀性，不必要等到執行的時候才去強制轉換，在定義或者例項化階段，因為 Cache< String > 這個型別顯化的效果，程式設計師能夠一目瞭然猜測出程式碼要操作的資料型別。
    下面的文章，我們正常介紹泛型的相關知識。

泛型的定義和使用

泛型按照使用情況可以分為 3 種。
1. 泛型類。
2. 泛型方法。
3. 泛型介面。

泛型類

我們可以這樣定義一個泛型類。

public class Test<T> {
    T field1;
}

尖括號 < > 中的 T 被稱作是型別引數，用於指代任何型別。事實上，T 只是一種習慣性寫法，如果你願意。你可以這樣寫。

public class Test<Hello> {
    Hello field1;
}

但出於規範的目的，Java 還是建議我們用單個大寫字母來代表型別引數。常見的如：

  1. T 代表一般的任何類。
  2. E 代表 Element 的意思，或者 Exception 異常的意思。
  3. K 代表 Key 的意思。
  4. V 代表 Value 的意思，通常與 K 一起配合使用。
  5. S 代表 Subtype 的意思，文章後面部分會講解示意。

如果一個類被 的形式定義，那麼它就被稱為是泛型類。

那麼對於泛型類怎麼樣使用呢？

Test<String> test1 = new Test<>();
Test<Integer> test2 = new Test<>();

只要在對泛型類建立例項的時候，在尖括號中賦值相應的型別便是。T 就會被替換成對應的型別，如 String 或者是 Integer。你可以相像一下，當一個泛型類被建立時，內部自動擴充套件成下面的程式碼。

public class Test<String> {
    String field1;
}

當然，泛型類不至接受一個型別引數，它還可以這樣接受多個型別引數。

public class MultiType <E,T>{
    E value1;
    T value2;

    public E getValue1(){
        return value1;
    }

    public T getValue2(){
        return value2;
    }
}

泛型方法

public class Test1 {

    public <T> void testMethod(T t){

    }
}

泛型方法與泛型類稍有不同的地方是，型別引數也就是尖括號那一部分是寫在返回值前面的。 中的 T 被稱為型別引數，而方法中的 T 被稱為引數化型別，它不是執行時真正的引數。

當然，宣告的型別引數，其實也是可以當作返回值的型別的。

public  <T> T testMethod1(T t){
        return null;
}

泛型類與泛型方法的共存現象

public class Test1<T>{

    public  void testMethod(T t){
        System.out.println(t.getClass().getName());
    }
    public  <T> T testMethod1(T t){
        return t;
    }
}

上面程式碼中，Test1< T > 是泛型類，testMethod 是泛型類中的普通方法，而 testMethod1 是一個泛型方法。而泛型類中的型別引數與泛型方法中的型別引數是沒有相應的聯絡的，泛型方法始終以自己定義的型別引數為準。

所以，針對上面的程式碼，我們可以這樣編寫測試程式碼。

Test1<String> t = new Test1();
t.testMethod("generic");
Integer i = t.testMethod1(new Integer(1));

泛型類的實際型別引數是 String，而傳遞給泛型方法的型別引數是 Integer，兩者不想幹。

但是，為了避免混淆，如果在一個泛型類中存在泛型方法，那麼兩者的型別引數最好不要同名。比如，Test1< T > 程式碼可以更改為這樣：

public class Test1<T>{

    public  void testMethod(T t){
        System.out.println(t.getClass().getName());
    }
    public  <E> E testMethod1(E e){
        return e;
    }
}

泛型介面

泛型介面和泛型類差不多，所以一筆帶過。

public interface Iterable<T> {
}

萬用字元 ？

除了用 < T > 表示泛型外，還有 < ? > 這種形式。？ 被稱為萬用字元。

可能有同學會想，已經有了 < T > 的形式了，為什麼還要引進 < ? > 這樣的概念呢？

class Base{}

class Sub extends Base{}

Sub sub = new Sub();
Base base = sub;

上面程式碼顯示，Base 是 Sub 的父類，它們之間是繼承關係，所以 Sub 的例項可以給一個 Base 引用賦值，那麼

List<Sub> lsub = new ArrayList<>();
List<Base> lbase = lsub;

最後一行程式碼成立嗎？編譯會通過嗎？

答案是否定的。

編譯器不會讓它通過的。Sub 是 Base 的子類，不代表 List 和 List 有繼承關係。

但是，在現實編碼中，確實有這樣的需求，希望泛型能夠處理某一範圍內的資料型別，比如某個類和它的子類，對此 Java 引入了萬用字元這個概念。

所以，萬用字元的出現是為了指定泛型中的類型範圍。

萬用字元有 3 種形式。

  1. < ?> 被稱作無限定的萬用字元。
  2. < ? extends T> 被稱作有上限的萬用字元。
  3. < ? super T> 被稱作有下限的萬用字元。

無限定萬用字元

public void testWildCards(Collection<?> collection){
}

上面的程式碼中，方法內的引數是被無限定萬用字元修飾的 Collection 物件，它隱略地表達了一個意圖或者可以說是限定，那就是 testWidlCards() 這個方法內部無需關注 Collection 中的真實型別，因為它是未知的。所以，你只能呼叫 Collection 中與型別無關的方法。

呼叫 Collection 中與型別無關的方法

我們可以看到，當 < ? > 存在時，Collection 物件喪失了 add() 方法的功能，編譯器不通過。
我們再看程式碼。

List<?> wildlist = new ArrayList<String>();
wildlist.add(123);// 編譯不通過

有人說，< ? > 提供了只讀的功能，也就是它刪減了增加具體型別元素的能力，只保留與具體型別無關的功能。它不管裝載在這個容器內的元素是什麼型別，它只關心元素的數量、容器是否為空？我想這種需求還是很常見的吧。

有同學可能會想，< ? > 既然作用這麼渺小，那麼為什麼還要引用它呢？ 

個人認為，提高了程式碼的可讀性，程式設計師看到這段程式碼時，就能夠迅速對此建立極簡潔的印象，能夠快速推斷原始碼作者的意圖。

< ? extends T>

< ? > 代表著型別未知，但是我們的確需要對於型別的描述再精確一點，我們希望在一個範圍內確定類別，比如型別 A 及 型別 A 的子類都可以。

public void testSub(Collection<? extends Base> para){

}

上面程式碼中，para 這個 Collection 接受 Base 及 Base 的子類的型別。

但是，它仍然喪失了寫操作的能力。也就是說

para.add(new Sub());
para.add(new Base());

仍然編譯不通過。

沒有關係，我們不知道具體型別，但是我們至少清楚了型別的範圍。

public void testSuper(Collection<? super Sub> para){
}

< ? super T> 神奇的地方在於，它擁有一定程度的寫操作的能力。

public void testSuper(Collection<? super Sub> para){
    para.add(new Sub());//編譯通過
    para.add(new Base());//編譯不通過
}

萬用字元與型別引數的區別

一般而言，萬用字元能幹的事情都可以用型別引數替換。
比如：

public void testWildCards(Collection<?> collection){}

可以被

public <T> void test(Collection<T> collection){}

取代。

值得注意的是，如果用泛型方法來取代萬用字元，那麼上面程式碼中 collection 是能夠進行寫操作的。只不過要進行強制轉換。

public <T> void test(Collection<T> collection){
    collection.add((T)new Integer(12));
    collection.add((T)"123");
}

需要特別注意的是，型別引數適用於引數之間的類別依賴關係，舉例說明。

public class Test2 <T,E extends T>{
    T value1;
    E value2;
}
public <D,S extends D> void test(D d,S s){

    }

E 型別是 T 型別的子類，顯然這種情況型別引數更適合。
有一種情況是，萬用字元和型別引數一起使用。

public <T> void test(T t,Collection<? extends T> collection){

}

如果一個方法的返回型別依賴於引數的型別，那麼萬用字元也無能為力。

public T test1(T t){
    return value1;
}

型別擦除

泛型是 Java 1.5 版本才引進的概念，在這之前是沒有泛型的概念的，但顯然，泛型程式碼能夠很好地和之前版本的程式碼很好地相容。

這是因為，泛型資訊只存在於程式碼編譯階段，在進入 JVM 之前，與泛型相關的資訊會被擦除掉，專業術語叫做型別擦除。

通俗地講，泛型類和普通類在 java 虛擬機器內是沒有什麼特別的地方。回顧文章開始時的那段程式碼

List<String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();

System.out.println(l1.getClass() == l2.getClass());

列印的結果為 true 是因為 List< String > 和 List< Integer > 在 jvm 中的 Class 都是 List.class。

泛型資訊被擦除了。

可能同學會問，那麼型別 String 和 Integer 怎麼辦？

答案是泛型轉譯。

public class Erasure <T>{
    T object;

    public Erasure(T object) {
        this.object = object;
    }

}

Erasure 是一個泛型類，我們檢視它在執行時的狀態資訊可以通過反射。

Erasure<String> erasure = new Erasure<String>("hello");
Class eclz = erasure.getClass();
System.out.println("erasure class is:"+eclz.getName());

列印的結果是

erasure class is:com.frank.test.Erasure

Class 的型別仍然是 Erasure 並不是 Erasure 這種形式，那我們再看看泛型類中 T 的型別在 jvm 中是什麼具體型別。

Field[] fs = eclz.getDeclaredFields();
for ( Field f:fs) {
    System.out.println("Field name "+f.getName()+" type:"+f.getType().getName());
}

列印結果是

Field name object type:java.lang.Object

那我們可不可以說，泛型類被型別擦除後，相應的型別就被替換成 Object 型別呢？

這種說法，不完全正確。

我們更改一下程式碼。

public class Erasure <T extends String>{
//  public class Erasure <T>{
    T object;

    public Erasure(T object) {
        this.object = object;
    }

}

現在再看測試結果：

Field name object type:java.lang.String

我們現在可以下結論了，在泛型類被型別擦除的時候，之前泛型類中的型別引數部分如果沒有指定上限，如 < T > 則會被轉譯成普通的 Object 型別，如果指定了上限如 < T extends String> 則型別引數就被替換成型別上限。

所以，在反射中。

public class Erasure <T>{
    T object;

    public Erasure(T object) {
        this.object = object;
    }

    public void add(T object){

    }

}

add() 這個方法對應的 Method 的簽名應該是 Object.class。

Erasure<String> erasure = new Erasure<String>("hello");
Class eclz = erasure.getClass();
System.out.println("erasure class is:"+eclz.getName());

Method[] methods = eclz.getDeclaredMethods();
for ( Method m:methods ){
    System.out.println(" method:"+m.toString());
}

列印結果是

method:public void com.frank.test.Erasure.add(java.lang.Object)

也就是說，如果你要在反射中找到 add 對應的 Method，你應該呼叫 getDeclaredMethod(“add”,Object.class) 否則程式會報錯，提示沒有這麼一個方法，原因就是型別擦除的時候，T 被替換成 Object 型別了。

型別擦除帶來的侷限性

型別擦除，是泛型能夠與之前的 java 版本程式碼相容共存的原因。但也因為型別擦除，它會抹掉很多繼承相關的特性，這是它帶來的侷限性。

理解型別擦除有利於我們繞過開發當中可能遇到的雷區，同樣理解型別擦除也能讓我們繞過泛型本身的一些限制。比如：

型別擦除帶來的侷限性

正常情況下，因為泛型的限制，編譯器不讓最後一行程式碼編譯通過，因為類似不匹配，但是，基於對型別擦除的瞭解，利用反射，我們可以繞過這個限制。

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

     boolean add(E e);
}

上面是 List 和其中的 add() 方法的原始碼定義。

因為 E 代表任意的型別，所以型別擦除時，add 方法其實等同於

boolean add(Object obj);

那麼，利用反射，我們繞過編譯器去呼叫 add 方法。

public class ToolTest {


    public static void main(String[] args) {
        List<Integer> ls = new ArrayList<>();
        ls.add(23);
//      ls.add("text");
        try {
            Method method = ls.getClass().getDeclaredMethod("add",Object.class);


            method.invoke(ls,"test");
            method.invoke(ls,42.9f);
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        for ( Object o: ls){
            System.out.println(o);
        }

    }

}

列印結果是：

23
test
42.9

可以看到，利用型別擦除的原理，用反射的手段就繞過了正常開發中編譯器不允許的操作限制。

泛型中值得注意的地方

泛型類或者泛型方法中，不接受 8 種基本資料型別。

所以，你沒有辦法進行這樣的編碼。

List<int> li = new ArrayList<>();
List<boolean> li = new ArrayList<>();

需要使用它們對應的包裝類。

List<Integer> li = new ArrayList<>();
List<Boolean> li1 = new ArrayList<>();

對泛型方法的困惑

public <T> T test(T t){
    return null;
}

有的同學可能對於連續的兩個 T 感到困惑，其實 < T > 是為了說明型別引數，是宣告,而後面的不帶尖括號的 T 是方法的返回值型別。
你可以相像一下，如果 test() 這樣被呼叫

test("123");

那麼實際上相當於

public String test(String t);

Java 不能建立具體型別的泛型陣列

這句話可能難以理解，程式碼說明。

List<Integer>[] li2 = new ArrayList<Integer>[];
List<Boolean> li3 = new ArrayList<Boolean>[];

這兩行程式碼是無法在編譯器中編譯通過的。原因還是型別擦除帶來的影響。

List< Integer> 和 List< Boolean> 在 jvm 中等同於List< Object> ，所有的型別資訊都被擦除，程式也無法分辨一個數組中的元素型別具體是 List< Integer>型別還是 List< Boolean> 型別。

但是，

List<?>[] li3 = new ArrayList<?>[10];
li3[1] = new ArrayList<String>();
List<?> v = li3[1];

藉助於無限定萬用字元卻可以，前面講過 ？ 代表未知型別，所以它涉及的操作都基本上與型別無關，因此 jvm 不需要針對它對型別作判斷，因此它能編譯通過，但是，只提供了陣列中的元素因為萬用字元原因，它只能讀，不能寫。比如，上面的 v 這個區域性變數，它只能進行 get() 操作，不能進行 add() 操作，這個在前面萬用字元的內容小節中已經講過。

泛型，並不神奇

我們可以看到，泛型其實並沒有什麼神奇的地方，泛型程式碼能做的非泛型程式碼也能做。

而型別擦除，是泛型能夠與之前的 java 版本程式碼相容共存的原因。

可量也正因為型別擦除導致了一些隱患與侷限。

但，我還是要建議大家使用泛型，如官方文件所說的，如果可以使用泛型的地方，儘量使用泛型。

畢竟它抽離了資料型別與程式碼邏輯，本意是提高程式程式碼的簡潔性和可讀性，並提供可能的編譯時型別轉換安全檢測功能。

型別擦除不是泛型的全部，但是它卻能很好地檢測我們對於泛型這個概念的理解程度。

我在文章開頭將泛型比作是一個守門人，原因就是他本意是好的，守護我們的程式碼安全，然後在門牌上寫著出入的各項規定，及“xxx 禁止出入”的提醒。但是同我們日常所遇到的那些門衛一般，他們古怪偏執，死板守舊，我們可以利用反射基於型別擦除的認識，來繞過泛型中某些限制，現實生活中，也總會有調皮搗蛋者能夠基於對門衛們生活作息的規律，選擇性地繞開他們的監視，另闢蹊徑溜進或者溜出大門，然後揚長而去，剩下守衛者一個孤獨的身影。

所以，我說泛型，並不神祕，也不神奇。

相關推薦

轉：Java 泛型，你瞭解型別擦除嗎？

泛型，一個孤獨的守門者。 大家可能會有疑問，我為什麼叫做泛型是一個守門者。這其實是我個人的看法而已，我的意思是說泛型沒有其看起來那麼深不可測，它並不神祕與神奇。泛型是 Java 中一個很小巧的概念，但同時也是一個很容易讓人迷惑的知識點，它讓人迷惑的地方

Java 泛型，你瞭解型別擦除嗎？

大家可能會有疑問，我為什麼叫做泛型是一個守門者。這其實是我個人的看法而已，我的意思是說泛型沒有其看起來那麼深不可測，它並不神祕與神奇。泛型是 Java 中一個很小巧的概念，但同時也是一個很容易讓人迷惑的知識點，它讓人迷惑的地方在於它的許多表現有點違反直覺。

用了這麼多年的 Java 泛型，你對它到底有多瞭解？

> 本篇文章 idea 來自[用了這麼多年的泛型，你對它到底有多瞭解？](https://www.cnblogs.com/huangxincheng/p/12764925.html),恰好當時看了「深入 Java 虛擬機器的第三版」瞭解泛型的一些歷史，感覺挺有意思的，就寫了寫 Java 版的泛型。 作為一個

用了這麼多年的泛型，你對它到底有多瞭解？

現代程式設計師寫程式碼沒有人敢說自己沒用過泛型，這個泛型模板T可以被任何你想要的型別替代，確實很魔法很神奇，很多人也習以為常了，但就是這麼有趣的泛型T底層到底是怎麼幫你實現的，不知道有多少人清楚底層玩法，這篇我就試著來分享一下，不一定全對哈。。。 一：沒有泛型前 現在的netcore 3.1和最新的.netf

面試官：十問泛型，你能扛住嗎？

問題一：為什麼需要泛型？ 答： 使用泛型機制編寫的程式碼要比那些雜亂的使用Object變數，然後再進行強制型別轉換的程式碼具有更好的安全性和可讀性，也就是說使用泛型機制編寫的程式碼可以被很多不同型別的物件所重用。 問題二：從ArrayList的角度說一下為什麼要用泛型？ 答： 在Java增加泛型機制之前就已

重溫Java泛型，帶你更深入地理解它，更好的使用它！

## **1. 引言** jdk5.0中引入了Java泛型，目的是減少錯誤，並在型別上新增額外的抽象層。 本文將簡要介紹Java中的泛型、泛型背後的目標以及如何使用泛型來提高程式碼的質量。 ## **2. 為什麼要用泛型？** 設想一個場景，我們希望用Java建立一個列表來儲存*Integer*；程式碼

java泛型的一些知識點：Java泛型--泛型應用--泛型接口、泛型方法、泛型數組、泛型嵌套

泛型數組 light inf 返回值 通過 類實例化 this str set 感謝這位大神： http://blog.csdn.net/waldmer/article/details/12773021 1、泛型接口 1.1泛型接口的基本概念 1.2泛型接口實現的兩

Java總結篇系列：Java泛型

ech internal clone 傳遞 sta 是什麽 dom bar 依然 一. 泛型概念的提出（為什麽需要泛型）？ 首先，我們看下下面這段簡短的代碼: 1 public class GenericTest { 2 3 public static

java泛型，內部類，列舉型別

（1）泛型 JDK1.5之後增加的新功能，泛型可以解決資料型別的安全性問題，他主要的原理，是在類宣告的時候通過一個標識表示類中某個屬性的型別或者是某個方法的返回值及引數型別。 格式：訪問許可權 class 類名稱<泛型，泛型...>{ 屬性 方法} 泛型方法：訪問許

你知道在java泛型中KTVE等的代表含義嗎？我來告訴你

K ： Key（健，常在集合中使用） V ： Value（值，常在集合中使用） E ： Element（元素，常在集合中使用） T ： Type（型別，常代表 java 類） ? ： 表示不確定的 java 型別（無限制萬用字元型別） N ： Number（數值

Java基礎篇系列：Java泛型

一. 泛型概念的提出（為什麼需要泛型）？ 首先，我們看下下面這段簡短的程式碼: public class GenericTest { public static void main(String[] args) { Lis

轉：Java學習路線圖，專為新手定製的Java學習計劃建議

從網上發現這篇文章，發現和我寫的一篇關於《知識體系》的文章互相呼應，就轉過來了。 怎麼學習Java，這是很多新手經常會問我的問題，現在我簡單描述下一個Java初學者到就業要學到的一些東西：     首先要明白Java體系設計到得三個方面：J2SE,J2EE,J2M

JAVA 泛型，集合使用方法

工作內容： 1.集合學習 2.泛型學習 學習分享： 1.典型泛型集合List<T>，HashMap<K,V> 常用定義泛型集合： List<T> list = new ArrayList<T>(); 【儲存型別必須是T型別，可

java泛型，怎麼這麼難

泛型，就是引數化型別。好吧，這是我抄的定義，自己都覺得難以理解。還是舉個簡單例子吧。 public class SimpleJava<T> { T t; public static void main(String[] args

Java泛型，結合JSONObject動態生成指定的物件

private <T> T getTargetClass(String resultString, T t) { System.out.println(resultString); JSONObject result = JSONObject.from

Java基礎：Java泛型程式設計快速入門

1、Java泛型 其實Java的泛型就是建立一個用型別作為引數的類。就象我們寫類的方法一樣，方法是這樣的method(String str1,String str2 ),方法中引數str1、str2的值是可變的。而泛型也是一樣的，這樣寫class Java_Generics＜

Java 泛型（引數化型別）

Java 泛型 Java 泛型（generics）是 JDK 5 中引入的一個新特性, 泛型提供了編譯時型別安全檢測機制，該機制允許程式設計師在編譯時檢測到非法的型別。  泛型的本質是引數化型別，也就是說所操作的資料型別被指定為一個引數。 一. 泛型概念的提出（為什麼需要泛型）？ 首先，我們

第十一章：Java多型中的引用型別轉換以及抽象類

引用型別轉換 1.向上型別轉換（隱式/自動型別轉換），是小型別到大型別的轉換。 2.向下型別轉換（強制型別轉換），是大型別到小型別 3.instanceof運算子，來解決引用物件的型別，避免型別轉換的安全性問題 抽象類 1.抽象類前使用abstract關鍵字修飾，

Java絕對基礎知識你還記得多少：浮點型，字元型，布林型

浮點型別 java語音包含兩種浮點型別，分別為單精度浮點型別和雙精度浮點型別，各種自用float和double關機鍵字進行標識，計算機通過這兩種資料型別來儲存小數。 小數都被看做double型，佔64位，要想使用float型小數，需要在小數後加字母F或f，如1.23F，佔32位記憶體。

JAVA泛型（轉）

強制 off 實例 emp 思想 void 成了 意義 依然 一. 泛型概念的提出（為什麽需要泛型）？ 首先，我們看下下面這段簡短的代碼: 1 public class GenericTest { 2 3 public static void