Java隨筆-Java泛型的一點學習

時間  2019-11-08
標籤 java 隨筆 一點 1點 學習 欄目 Java 简体版
原文   原文鏈接

Java泛型

Java泛型（generics）是JDK 5中引入的一個新特性，容許在定義類和接口的時候使用類型參數（type parameter）。聲明的類型參數在使用時用具體的類型來替換。泛型最主要的應用是在JDK 5中的新集合類框架中。泛型的引入能夠解決JDK5以前的集合類框架在使用過程當中較爲容出現的運行時類型轉換異常，由於編譯器能夠在編譯時經過類型檢查，規避掉一些潛在的風險。java

在JDK5以前，使用集合框架時，是沒有類型信息的，統一使用Object,我找了一段JDK4 List接口的方法簽名
clipboard.png
以下是JDK5開始引入泛型，List接口的改動，新的方法簽名，引入了類型參數。編程

boolean add(E e);

在JDK5以前，使用集合類時，能夠往其中添加任意元素，由於其中的類型是Object，在取出的階段作強制轉換，由此可能引起不少意向不到的運行時強制轉換錯誤,好比如下代碼。框架

public class Test1 {
    public static void main(String[] args) {
        List a = new ArrayList();
        a.add("123");
        a.add(1);             
        // 以上代碼能夠正常經過編譯，其中同時含有了Integer類型和String類型
        for (int i = 0 ; i < a.size(); i++) {
            int result = (Integer)a.get(i);    // 在取出時須要對Object進行強制轉型
            System.out.println(result);
        }
    }
}

如上代碼就會在運行時階段帶來強轉異常，在編譯時間不可以排查出潛在風險。
clipboard.png
若是使用泛型機制，能夠在編譯期間就檢查出List的類型插入的有問題，進行規避，以下代碼。編程語言

public class Test1 {
    public static void main(String[] args) {
        List<Integer> a = new ArrayList();
        a.add("123");          // 編譯不經過
        a.add(1);
    }
}

引入泛型後，編譯器會在編譯時先根據類型參數進行類型檢查，杜絕掉一些潛在風險。
爲什麼說是在編譯時檢查，由於在運行時仍然是能夠經過反射，將不符合類型參數的數據插入至list中，以下代碼所示。ide

public class Test1 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        List<Integer> a = new ArrayList();
        List b = new ArrayList();
        a.getClass().getMethod("add",Object.class).invoke(a,"abc");    
        // 以上代碼編譯經過，運行經過
    }
}

引入泛型的同時，也爲了兼容JDK5以前的類庫，JDK5開始引入的實際上是僞泛型，在生成的Java字節碼中是不包含泛型中的類型信息的。使用泛型的時候加上的類型參數，會在編譯器在編譯的時候去掉。這個過程就稱爲類型擦除。如在代碼中定義的List<String>等類型，在編譯後都會變成List，也就天然兼容了JDK5以前的代碼。
Java的泛型機制和C++等的泛型機制實現不一樣，Java的泛型靠的仍是類型擦除，目標代碼只會生成一份，犧牲的是運行速度。C++的模板會對針對不一樣的模板參數靜態實例化，目標代碼體積會稍大一些，運行速度會快不少。this

進行類型擦除後，類型參數原始類型（raw type）就是擦除去了泛型信息，最後在字節碼中的類型變量的真正類型。不管什麼時候定義一個泛型類型，相應的原始類型都會被自動地提供。類型變量被擦除，並使用其限定類型（無限定的變量用Object）替換。spa

class Pair<T> {
    private T value;
    public T getValue() {
        return value;
    }
    public void setValue(T  value) {
        this.value = value;
    }
} 
  
Pair<T>的原始類型爲：
class Pair {
    private Object value;
    public Object getValue() {
        return value;
    }
    public void setValue(Object  value) {
        this.value = value;
    }
}

在Pair<T>中，類型擦除，使用Object,其結果就是一個普通的類，如同泛型加入java編程語言以前已經實現的那樣。在程序中能夠包含不一樣類型的Pair，如Pair<String>或Pair<Integer>，可是，擦除類型後它們就成爲原始的Pair類型了，原始類型都是Object。ArrayList<Integer>被擦除類型後，原始類型也變成了Object，經過反射咱們就能夠存儲字符串了。code

在調用泛型方法的時候，能夠指定泛型，也能夠不指定泛型。在不指定泛型的狀況下，泛型變量的類型爲 該方法中的幾種類型的同一個父類的最小級，直到Object。在指定泛型的時候，該方法中的幾種類型必須是該泛型實例類型或者其子類。對象

public class Test1 {
 
   public static void main(String[] args) {
 
      /** 不指定泛型的時候 */
      int i = Test1.add(1, 2); // 這兩個參數都是Integer，因此T爲Integer類型
      Number f = Test1.add(1, 1.2);// 這兩個參數一個是Integer，以風格是Float，因此取同一父類的最小級，爲Number
      Object o = Test1.add(1, "asd");// 這兩個參數一個是Integer，以風格是Float，因此取同一父類的最小級，爲Object
 
      /** 指定泛型的時候 */
      int a = Test1.<Integer> add(1, 2);// 指定了Integer，因此只能爲Integer類型或者其子類
      int b = Test1.<Integer> add(1, 2.2);// 編譯錯誤，指定了Integer，不能爲Float
      Number c = Test1.<Number> add(1, 2.2); // 指定爲Number，因此能夠爲Integer和Float
   }
 
   // 這是一個簡單的泛型方法
   public static <T> T add(T x, T y) {
      return y;
   }
}

由於類型擦除的問題，全部的泛型類型變量最後都會被替換爲原始類型，但在泛型的使用中，咱們不須要對取出的數據作強制轉換。blog

public class Test1 {
 
    public static void main(String[] args) {
        List<Integer> a = new ArrayList();
        a.add(1);
 
        for (int i = 0 ; i < a.size(); i++) {
            int result = a.get(i);
            System.out.println(result);
        }
    }
}

咱們從字節碼的角度來探索一下。

public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/util/ArrayList
       3: dup
       4: invokespecial #3                  // Method java/util/ArrayList."<init>":()V
       7: astore_1
       8: aload_1
       9: iconst_1
      10: invokestatic  #4                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      13: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
      18: pop
      19: iconst_0
      20: istore_2
      21: iload_2
      22: aload_1
      23: invokeinterface #6,  1            // InterfaceMethod java/util/List.size:()I
      28: if_icmpge     58
      31: aload_1
      32: iload_2
      33: invokeinterface #7,  2            // InterfaceMethod java/util/List.get:(I)Ljava/lang/Object;
      38: checkcast     #8                  // class java/lang/Integer       這裏JVM作了強轉
      41: invokevirtual #9                  // Method java/lang/Integer.intValue:()I
      44: istore_3
      45: getstatic     #10                 // Field java/lang/System.out:Ljava/io/PrintStream;
      48: iload_3
      49: invokevirtual #11                 // Method java/io/PrintStream.println:(I)V
      52: iinc          2, 1
      55: goto          21
      58: return

在偏移量38的位置能夠看到，JVM使用了checkcast指令，說明雖然在編譯時進行了類型擦除，可是JVM中仍然保留了類型參數的元信息，在取出時自動進行了強轉，這也算是使用泛型的方便之處吧。

在別人的例子有看到說類型擦除和多態的衝突，舉了一個例子。

public class Test1 {
 
   public static void main(String[] args) {
      DateInter dateInter = new DateInter();
      dateInter.setValue(new Date());
      dateInter.setValue(new Object());// 編譯錯誤
   }
}
 
class Pair<T> {
   private T value;
 
   public T getValue() {
      return value;
   }
 
   public void setValue(T value) {
      this.value = value;
   }
}
 
class DateInter extends Pair<Date> {
   @Override
   public Date getValue() {
      return super.getValue();
   }
 
   @Override
   public void setValue(Date value) {
      super.setValue(value);
   }
}

由於在類型擦除後，父類也就變成了一個普通的類，以下所示

class Pair {
   private Object value;
 
   public Object getValue() {
      return value;
   }
 
   public void setValue(Object value) {
      this.value = value;
   }
}

但這樣setValue就從重寫變成了重載，顯然打破了想達到的目的，那麼JVM是如何幫助解決這個衝突的呢？答案是 JVM幫咱們搭了一個橋，具體咱們從字節碼的角度再來看看。

class DateInter extends Pair<java.util.Date> {
  DateInter();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method Pair."<init>":()V
       4: return
 
  public java.util.Date getValue();
    Code:
       0: aload_0
       1: invokespecial #2                  // Method Pair.getValue:()Ljava/lang/Object;
       4: checkcast     #3                  // class java/util/Date
       7: areturn
 
  public void setValue(java.util.Date);
    Code:
       0: aload_0
       1: aload_1
       2: invokespecial #4                  // Method Pair.setValue:(Ljava/lang/Object;)V
       5: return
 
  public void setValue(java.lang.Object);
    Code:
       0: aload_0
       1: aload_1
       2: checkcast     #3                  // class java/util/Date
       5: invokevirtual #5                  // Method setValue:(Ljava/util/Date;)V
       8: return
 
  public java.lang.Object getValue();
    Code:
       0: aload_0
       1: invokevirtual #6                  // Method getValue:()Ljava/util/Date;
       4: areturn
}

從編譯的結果來看，咱們本意重寫setValue和getValue方法的子類，有4個方法，最後的兩個方法，就是編譯器本身生成的橋接方法。能夠看到橋方法的參數類型都是Object，也就是說，子類中真正覆蓋父類兩個方法的就是這兩個咱們看不到的橋方法，打在咱們本身定義的setvalue和getValue方法上面的@Oveerride只不過是假象。而橋方法的內部實現，就只是去調用咱們本身重寫的那兩個方法。
因此，虛擬機巧妙的使用了巧方法，來解決了類型擦除和多態的衝突。

最後附上最近在瀏覽一些別人經驗時獲得一些tips。

  1. 使用JSON串反序列化對象集合時，記得標註對象的class類型，否則會獲得一個只有原始類型也就是Object的集合，可能引發類型轉換錯誤，尤爲是在服務調用的這種場景下。
  2. 重視編譯器提出的警告信息。
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程