Java 泛型，瞭解這些就夠用了。

 

此文目錄：

1. Java泛型是什麼？
2. 一般的泛型的寫法示例
3. 類型擦除
4. 爲何要使用Java泛型
5. 經過示例瞭解PECS原則

 

1、Java泛型是什麼？

• 官方定義

泛型是Java SE 1.5的新特性，泛型的本質是參數化類型，也就是說所操做的數據類型被指定爲一個參數。
這種參數類型能夠用在類、接口和方法的建立中，分別稱爲泛型類、泛型接口、泛型方法。

• 通俗解釋

通俗的講，泛型就是操做類型的 佔位符，即：假設佔位符爲T，那麼這次聲明的數據結構操做的數據類型爲T類型。

 

2、一般的泛型寫法示例

• T 類型，用於泛型類或者泛型方法

　　泛型類定義：

public class ApiResult<T> {

   int         resultCode;
    String         resultMsg;
    T             resultObject;
   
　　  //  省略構造方法和 get,set方法。
    
}

　　定義泛型方法：

　　

public class JsonUtil {
    
    public <T> T  str2Json(String jsonText,Class target){
        T result=null;
        //....parse to json 
        return result;
    }
}

 

 

　　使用：

 

　　//泛型類使用
        ApiResult<User> result=new ApiResult<User>();
        result.setResultCode(0);
        result.setResultMsg("success");
        result.setResultObject(new User());

　　　　　　ApiResult<List<User>> result2=new ApiResult<List<User>>();
　　　　　　result.setResultCode(0);
　　　　　　result.setResultMsg("success");
　　　　　　result.setResultObject(userList);

 

　　　　　　ApiResult<Integer> result3=new ApiResult<Integer>();
　　　　　　result3.setResultCode(0);
　　　　　　result3.setResultMsg("success");
　　　　　　result3.setResultObject(99);

　　　　//泛型方法使用

　　　　　　String　userJsonText="....省略",dogJsonText="....省略";;
          User u=JsonUtil.str2Json(jsonText,User.class);
          User u=JsonUtil.str2Json(jsonText,Dog.class);

• 　K,V類型，相似Map接口。

定義：

public class ResultMap<K,V> {

    private K key;
    private V value;
    
   //省略 set ,get  方法


public void put(K key,V value){
        this.key=key;
        this.value=value;
    }
}

使用：

        ResultMap<String,User> resultMap=new ResultMap<>();
        resultMap.put("currentUserKey", new User());

• ？extends 類型

<? extends T> 表示類型的上界，表示參數化類型的多是T 或是 T的子類

• ？supper 類型

<? super T> 表示類型下界（Java Core中叫超類型限定），表示參數化類型是此類型的超類型（父類型），直至Object

　　

　3、類型擦除

　　先看一個例子，Operate類以下：

public class Operate {

    public static void main(String[] args) {

        List<String> names=new ArrayList<String>();
        names.add("Jack");
        names.add("Tom");
        names.add("peter");
        for(String name:names){
            System.out.println("wellcome:"+name);
        }
    }

}

其對應的class文件反編譯以後，咱們使用java-gui反編譯.exe  查看編譯以後的代碼以下

發現沒有，根本沒有<String> 這一部分了。這個限制爲String類型的泛型被「擦除」了。寫代碼的時候，泛型會作校驗，類型不對應的，沒法add,可是編譯以後邊去掉了泛型類型。

 

  4、什麼要使用Java泛型

 在上面 第三部分介紹了「類型擦除」以後，在來講爲何要使用Java泛型就比較好說了。這裏的泛型就至關於「約法三章」，先給你定好「規矩」，我這個List<String> 就是用來操做

String類型的，你插入Person對象就不行。說白了就是爲了類型安全。因此其好處有：

  類型安全：經過知道使用泛型定義的變量的類型限制，編譯器能夠在一個高得多的程度上驗證類型假設。沒有泛型，這些假設就只存在於程序員的頭腦中（或者若是幸運的話，還存在於代碼註釋中）。

消除強制類型轉換：

//該代碼不使用泛型：
List li = new ArrayList();
li.put(new Integer(3));
Integer i = (Integer) li.get(0);


//該代碼使用泛型：
List<Integer> li = new ArrayList<Integer>();
li.put(new Integer(3));
Integer i = li.get(0);

 

 

瞭解了上面的這麼多，已經足夠平常使用泛型了。下面瞭解下PECS原則

5、PECS原則

 

　先看例子：

此處定義三個類，spiring,summer繼承season
public class Season {
  //.....  
}

public class Spring extends Season {
  //......  
}

public class Summer extends Season {
 //.......
}

        List<? extends Season> list1=new ArrayList<>();
        //list1.add(new Spring());//這裏編譯不經過，由於編譯器沒法肯定list所持有的類型。

        List<? extends Season> list2=new ArrayList<Spring>(); // list2.add(new Spring());//也是沒法經過編譯

　　　　//經過上文，咱們知道 ？extends Season表示能夠接收的類型爲 Seaon 或者其子類。
        可是此處不行，由於可能傳入進來的是spring,或者summer,編譯器沒法肯定具體傳遞進來的是什麼，
        因此沒法安全的向其中添加對象，可是它能夠接收子類類型 的賦值。以下：

//
        List<Spring> list3=new ArrayList<Spring>();
        List<? extends Season> list4=list3;//這裏和上面的list2作對比，沒法直接add spring類型的對象
                                           //可是能夠直接將spring類型的list賦值。
        
        List<Season> seasons=new ArrayList<Season>();
        List<? super Spring> spring=seasons;
        spring.add(new Spring());//ok
//        spring.add(new Summer());//error
//        spring.add(new Season());//error
//        spring.add(new Object());//error

 

        List<? super Season> sea=new ArrayList<>();
        sea.add(new Spring());//ok
        sea.add(new Summer());//ok
        sea.add(new Season());//ok
//        sea.add(new Object());//error
        
        List<? super Spring> spring=new ArrayList<>();
        spring.add(new Spring());//ok
//        spring.add(new Summer());//error
//        spring.add(new Season());//error
//        spring.add(new Object());//error

這裏 ，PECS原則 以下：

若是要從集合中讀取類型T的數據，而且不能寫入，可使用 ? extends 通配符；(Producer Extends)
若是要從集合中寫入類型T的數據，而且不須要讀取，可使用 ? super 通配符；(Consumer Super)
若是既要存又要取，那麼就不要使用任何通配符。

 

 

 

Java Queue系列之PriorityQueue

一篇圖看清Java中的各類Queue

 

[spring如何啓動的？這裏結合spring源碼描述了啓動過程](https://www.cnblogs.com/demingblog/p/7443714.html)
[SpringMVC是怎麼工做的,SpringMVC的工做原理](https://www.cnblogs.com/demingblog/p/9925268.html)
[spring 異常處理。結合spring源碼分析400異常處理流程及解決方法](https://www.cnblogs.com/demingblog/p/9218271.html)

[Mybatis Mapper接口是如何找到實現類的-源碼分析](https://www.cnblogs.com/demingblog/p/9544774.html)
[使用Netty實現HTTP服務器](https://www.cnblogs.com/demingblog/p/9970772.html)
[Netty實現心跳機制](https://www.cnblogs.com/demingblog/p/9957143.html)
[Netty系列](https://www.cnblogs.com/demingblog/p/9912099.html)