日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產品馬上在線溝通
服務時間:8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
Java泛型你必須知道的知識

 一 什么是泛型

Java 泛型(generics)是 JDK 5 中引入的一個新特性, 泛型提供了編譯時類型安全檢測機制,該機制允許程序員在編譯時檢測到非法的類型。

簡單理解就是:泛型指定編譯時的類型,減少運行時由于對象類型不匹配引發(fā)的異常。其主要用途是提高我們的代碼的復用率。

我們Java標準庫中的ArrayList就是泛型使用的典型應用:

 
 
 
  1. public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable { 
  2.         
  3.       ...... 
  4.  
  5.     public ArrayList(Collection c) { 
  6.         elementData = c.toArray(); 
  7.         if ((size = elementData.length) != 0) { 
  8.             // c.toArray might (incorrectly) not return Object[] (see 6260652) 
  9.             if (elementData.getClass() != Object[].class) 
  10.                 elementData = Arrays.copyOf(elementData, size, Object[].class); 
  11.         } else { 
  12.             // replace with empty array. 
  13.             this.elementData = EMPTY_ELEMENTDATA; 
  14.         } 
  15.     } 
  16.  
  17.     public void sort(Comparator c) { 
  18.         final int expectedModCount = modCount; 
  19.         Arrays.sort((E[]) elementData, 0, size, c); 
  20.         if (modCount != expectedModCount) { 
  21.             throw new ConcurrentModificationException(); 
  22.         } 
  23.         modCount++; 
  24.     } 
  25.     
  26.   ..... 
  27.  
  28.     public E get(int index) { 
  29.         rangeCheck(index); 
  30.  
  31.         return elementData(index); 
  32.     } 
  33.  
  34.     public boolean add(E e) { 
  35.         ensureCapacityInternal(size + 1);  // Increments modCount!! 
  36.         elementData[size++] = e; 
  37.         return true; 
  38.     } 
  39.  
  •  源碼中,ArrayList 中的E稱為類型參數(shù)變量,而整個ArrayList 我們稱為泛型類型。 我們可以指定除基本類型之外的任何類型,如:ArrayList 。
  • 源碼中Collection 中? 通配符類型 表示類型的上界,表示參數(shù)化類型的可能是T 或是 T的子類。
  • 源碼中Comparator 表示類型下界(Java Core中叫超類型限定),表示參數(shù)化類型是此類型的超類型(父類型),直至Object。

二 extends和super通配符

在定義泛型類型Generic 的時候,也可以使用extends通配符來限定T的類型:

 
 
 
  1. public class Generic { ... } 

現(xiàn)在,我們只能定義:

 
 
 
  1. Generic p1 = null; 
  2. Generic p2 = new Generic<>(1, 2); 
  3. Generic p3 = null; 

因為Number、Integer和Double都符合 。

非Number類型將無法通過編譯:

 
 
 
  1. Generic p1 = null; // compile error! 
  2. Generic p2 = null; // compile error! 

     因為String、Object都不符合 ,因為它們不是Number類型或Number的子類。

    我們看一個例子:

     
     
     
    1. public class Test { 
    2.  
    3.     static class Food { 
    4.  
    5.     } 
    6.  
    7.     static class Fruit extends Food { 
    8.     } 
    9.  
    10.     static class Apple extends Fruit { 
    11.     } 
    12.  
    13.     static class Orange extends Fruit { 
    14.     } 
    15.  
    16.     public void testExtend() { 
    17.         List list = new ArrayList(); 
    18.  
    19.         //無法安全添加任何具有實際意義的元素,報錯,extends為上界通配符,只能取值,不能放. 
    20.         //因為Fruit的子類不只有Apple還有Orange,這里不能確定具體的泛型到底是Apple還是Orange,所以放入任何一種類型都會報錯 
    21.  
    22.         //list.add(new Apple()); 
    23.         //list.add(new Orange()); 
    24.  
    25.         //可以添加null,因為null可以表示任何類型 
    26.         list.add(null); 
    27.  
    28.         //可以正常獲取,用java多態(tài) 
    29.         Food foot = list.get(0); 
    30.         Apple apple = (Apple) list.get(0); 
    31.     } 
    32.  
    33.     public void testSuper() { 
    34.         List list = new ArrayList(); 
    35.  
    36.         //super為下界通配符,可以存放元素,但是也只能存放當前類或者子類的實例,以當前的例子來講, 
    37.         list.add(new Fruit()); 
    38.         list.add(new Apple()); 
    39.  
    40.         //無法確定Fruit的父類是否只有Food一個(Object是超級父類) 
    41.         //因此放入Food的實例編譯不通過,只能放自己的實例 或者根據(jù)java多態(tài)的特性放子類實例 
    42.         //list.add(new Food()); 
    43.         //List list2 = new ArrayList(); 
    44.         //Fruit fruit = list.get(0); //不能確定返回類型 
    45.  
    46.     } 
    47.  

     在testExtend方法中,因為泛型中用的是extends,在向list中存放元素的時候,我們并不能確定List中的元素的具體類型,即可能是Apple也可能是Orange。因此調用add方法時,不論傳入new Apple()還是new Orange(),都會出現(xiàn)編譯錯誤。

    理解了extends之后,再看super就很容易理解了,即我們不能確定testSuper方法的參數(shù)中的泛型是Fruit的哪個父類,因此在調用get方法時只能返回Object類型。結合extends可見,在獲取泛型元素時,使用extends獲取到的是泛型中的上邊界的類型(本例子中為Fruit),范圍更小。

    總結:

    • 在使用泛型時,存取元素時用super。
    • 獲取元素時,用extends。

    有了上面的結論我們看下Java標準庫的Collections類定義的copy()方法,這個copy()方法的定義就完美地展示了extends和super的意圖:

    • copy()方法內部不會讀取dest,因為不能調用dest.get()來獲取T的引用;
    • copy()方法內部也不會修改src,因為不能調用src.add(T)。
     
     
     
    1. public class Collections { 
    2.     // 把src的每個元素復制到dest中: 
    3.     public static  void copy(List dest, List src) { 
    4.         for (int i=0; i
    5.             T t = src.get(i); 
    6.             dest.add(t); 
    7.         } 
    8.     } 

     三 泛型擦除

    Java的泛型是偽泛型,這是因為Java在編譯期間,所有的泛型信息都會被擦掉,正確理解泛型概念的首要前提是理解類型擦除。Java的泛型基本上都是在編譯器這個層次上實現(xiàn)的,在生成的字節(jié)碼中是不包含泛型中的類型信息的,使用泛型的時候加上類型參數(shù),在編譯器編譯的時候會去掉,這個過程成為類型擦除

    我們看一個示例:

     
     
     
    1. public class Test2 { 
    2.  
    3.     public static void main(String[] args) { 
    4.         Map map = new HashMap<>(); 
    5.         Animal animal = new Animal(); 
    6.         animal.setVegetarian(true); 
    7.         animal.setEats("fish"); 
    8.         map.put("cat", animal); 
    9.  
    10.         String json = new Gson().toJson(map); 
    11.         System.out.println(json); 
    12.  
    13.         Map jsonToMap = fromJson(json); 
    14.         System.out.println(jsonToMap); 
    15.  
    16.         Animal animal1 = jsonToMap.get("cat"); 
    17.         System.out.println(animal1.getEats()); 
    18.     } 
    19.  
    20.     public static  T fromJson(String str) { 
    21.         return new Gson().fromJson(str, new TypeToken() { 
    22.         }.getType()); 
    23.     } 
    24.  

     上的代碼運行會提示如下異常:

     
     
     
    1. Exception in thread "main" java.lang.ClassCastException: com.google.gson.internal.LinkedTreeMap cannot be cast to com.uaf.rabbitmq.producer.Animal 
    2.     at com.uaf.rabbitmq.producer.Test2.main(Test2.java:30) 

     異常原因主要是這句:new Gson().fromJson(str, new TypeToken () {}.getType());

    這句在實際執(zhí)行的時候,List 中的T并未傳入實際的泛型參數(shù),導致Gson按照LinkedTreeMap來解析JSON,以致發(fā)生了錯誤;這就是一個在編譯期泛型類型擦除所導致的問題;

    解決這個問題我們需要修改fromJson方法

     
     
     
    1. public class Test2 { 
    2.  
    3.     public static void main(String[] args) { 
    4.         Map map = new HashMap<>(); 
    5.         Animal animal = new Animal(); 
    6.         animal.setVegetarian(true); 
    7.         animal.setEats("fish"); 
    8.         map.put("cat", animal); 
    9.  
    10.         String json = new Gson().toJson(map); 
    11.         System.out.println(json); 
    12.  
    13.         Map jsonToMap = fromJson(json,  
    14.         new TypeToken>() {}.getType()); 
    15.         System.out.println(jsonToMap); 
    16.  
    17.         Animal animal1 = jsonToMap.get("cat"); 
    18.         System.out.println(animal1.getEats()); 
    19.  
    20.     } 
    21.  
    22.     public static  T fromJson(String str, Type type) { 
    23.         return new Gson().fromJson(str, type); 
    24.     } 
    25.  

     在Gson中提供了TypeToken解決泛型運行時類型擦除問題,TypeToken 這個類來幫助我們捕獲像Map這樣的泛型信息。上文創(chuàng)建了一個匿名內部類,這樣Java編譯器就會把泛型信息編譯到這個匿名內部類里,然后在運行時就可以被getType()方法用反射API提取到。


    分享標題:Java泛型你必須知道的知識
    本文URL:http://www.5511xx.com/article/coegcse.html