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

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

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
精通Java，卻不了解泛型？

本文轉載自微信公眾號「小菜良記」，作者 蔡不菜丶。轉載本文請聯(lián)系小菜良記公眾號。

我們上面既然都說到了泛型，那么我們這篇文章就來重新復習一下泛型吧!

一、初識泛型

在沒有泛型的出現(xiàn)之前，我們通常是使用類型為 Object 的元素對象。比如我們可以構建一個類型為 Object 的集合，該集合能夠存儲任意數(shù)據(jù)類型的對象，但是我們從集合中取出元素的時候我們需要明確的知道存儲每個元素的數(shù)據(jù)類型，這樣才能進行元素轉換，不然會出現(xiàn) ClassCastException 異常。

1. 什么是泛型

泛型是在 Java1.5 之后引入的一個新特性，它特性提供了編譯時類型安全監(jiān)測機制，該機制允許我們在編譯時監(jiān)測出非法的類型數(shù)據(jù)結構。

它的本質就是參數(shù)化類型，也就是所操作的數(shù)據(jù)類型被指定為一個參數(shù)。這種參數(shù)類型可以用在 類、接口和方法 中，分別被稱為 泛型類、泛型接口和泛型方法

2. 使用好處

類型安全

有了泛型的存在，只要編譯時沒有出現(xiàn)警告，那么運行時就不會出現(xiàn) ClassCastException 異常。

  • 消除強制類型轉換

從泛型集合中取出元素我們可以不用進行類型的轉換

  • 可讀性更高

可以直接看出集合中存放的是什么數(shù)據(jù)類型的元素

二、泛型的使用

1. 使用場景

1)泛型類

基本語法

 
 
 
 
    
  
  
  
  
  1. class 類名稱 <泛型標識，泛型標識，…> {
    2. 
  
  
  
  
  2.   private 泛型標識 變量名; 
    3. 
  
  
  
  
  3.   .....
    4. 
  
  
  
  
  4. }
    5.

使用示例

 
 
 
 
    
  
  
  
  
  1. class Result{
    2. 
  
  
  
  
  2.     private T data;
    3. 
  
  
  
  
  3. }
    4.

注：

Java 1.7 之后可以進行類型推斷，后面 <> 中的具體的數(shù)據(jù)類型可以省略不寫：

 
 
 
 
    
  
  
  
  
  1. 類名<具體的數(shù)據(jù)類型> 對象名 = new 類名<>();
    2.
  • 如果我們使用的時候沒有用到 <> 來制定數(shù)據(jù)類型，那么操作類型則是 Object
  • 泛型內的類型參數(shù)只能是類 類型，而不能是基本數(shù)據(jù)類型，例如int,double,float...
  • 當我們傳入不同數(shù)據(jù)類型進行構造對象時，邏輯上可以看成是多個不同的數(shù)據(jù)類型，但實際上都是相同類型

以上便是泛型類的簡單用法，我們想要使用哪種類型，就在創(chuàng)建的時候指定類型，使用的時候，該類就會自動轉換成用戶想要使用的類型。

那么如果我們定義了一個泛型類，構造對象的時候卻沒有聲明數(shù)據(jù)類型，那么默認為 Object 類型，取出數(shù)據(jù)的時候則需要進行類型轉換：

 
 
 
 
    
  
  
  
  
  1. Result objectRes = new Result("testObejct");
    2. 
  
  
  
  
  2. String str = (String) objectRes.getData();
    3. 
  
  
  
  
  3. System.out.println(str);
    4.

規(guī)則：

子類也是泛型類，那么子類和父類的泛型類型要一致

 
 
 
 
    
  
  
  
  
  1. public class ResultChild extends Result {}
    2.

子類不是泛型類，那么父類要指定數(shù)據(jù)類型

 
 
 
 
    
  
  
  
  
  1. public class ResultChild extends Result {}
    2.

2)泛型接口

基本語法

 
 
 
 
    
  
  
  
  
  1. public 接口名稱 <泛型標識, 泛型標識, ...>{
    2. 
  
  
  
  
  2.     泛型標識 方法名();
    3. 
  
  
  
  
  3.     ...
    4. 
  
  
  
  
  4. }
    5.

使用示例

 
 
 
 
    
  
  
  
  
  1. public interface ResultInterface {
    2. 
  
  
  
  
  2.     T getData();
    3. 
  
  
  
  
  3. }
    4.

泛型接口與泛型類一樣，有以下規(guī)則：

  • 實現(xiàn)類不是泛型類，接口要明確數(shù)據(jù)類型
  • 實現(xiàn)類也是泛型類，實現(xiàn)類和接口的泛型類型要一致

3)泛型方法

在 Java 中，泛型類和泛型接口的定義相對比較簡單，但是 泛型方法 就比較復雜。

  • 泛型類，是在實例化類的時候指明泛型的具體類型
  • 泛型方法，是在調用方法的時候指明泛型的具體類型

基本語法

 
 
 
 
    
  
  
  
  
  1. 修飾符  返回值類型 方法名(形參列表){}
    2.

修飾符與返回值類型之間的 用于聲明此方法為泛型方法

只有聲明了 的方法才是泛型方法，就算返回值類型中的泛型類使用泛型的成員方法也并不是泛型方法

表明該方法將使用泛型類型 T，此時才可以在方法中使用泛型類型 T

使用示例

 
 
 
 
    
  
  
  
  
  1. private  Result getResult(T data) {
    2. 
  
  
  
  
  2.  return new Result(data);
    3. 
  
  
  
  
  3. }
    4.

泛型方法與可變參數(shù)：

 
 
 
 
    
  
  
  
  
  1. private  void printData(T... data) {
    2. 
  
  
  
  
  2.     for (T t : data) {
    3. 
  
  
  
  
  3.         System.out.println(t);
    4. 
  
  
  
  
  4.     }
    5. 
  
  
  
  
  5. }
    6.

注：

  • 泛型方法能使方法獨立于類而產生變化
  • 如果 靜態(tài)(static) 方法 要使用泛型能力，就必須使其成為泛型方法

2. 類型通配符

1)什么是類型通配符

  • 類型通配符一般使用 " ? " 代替具體的實參類型
  • 類型通配符是 實參類型 ，而不是 形參類型

類型通配符又分為 類型通配符的上限 和 類型通配符的下限

2)基本語法

類型通配符的上限：

 
 
 
 
    
  
  
  
  
  1. 類/接口
    2.

類/接口

注：要求該泛型的類型，只能是實參類型，或實參類型的 子類 類型

類型通配符的下限：

 
 
 
 
    
  
  
  
  
  1. 類/接口
    2.

注：要求該泛型的類型，只能是實參類型，或實參類型的 父類 類型

2)使用示例

類型通配符的上限：

如果我們要打印一個 List 的值，我們可能會這么做：

 
 
 
 
    
  
  
  
  
  1. private void printData(List list) {
    2. 
  
  
  
  
  2.     for (int i = 0; i < list.size(); i++) {
    3. 
  
  
  
  
  3.         System.out.println(list.get(i));
    4. 
  
  
  
  
  4.     }
    5. 
  
  
  
  
  5. }
    6.

看上去沒啥問題，但是又覺得怪怪的。因為這就跟黑匣子一樣，我根本不知道這個 List 里面裝的是什么類型的參數(shù)。那我們就在傳參的時候定義一下類型：

 
 
 
 
    
  
  
  
  
  1. private void printData(List list) {
  
  
  
  
  2.     for (Object o : list) {
    3. 
  
  
  
  
  3.         System.out.println(o);
    4. 
  
  
  
  
  4.     }
    5. 
  
  
  
  
  5. }
    6. 
 
 
 
 
    但是這樣定義又太廣泛了，Object 是所有類型的父類，如果說我想這個方法只能操作數(shù)字類型的元素，那我就能用上 類型通配符的上限 來解決這個問題了：
     
 
 
 
      
  
  
  
  
    1. private void printData(List numList) {
      2. 
  
  
  
  
    2.     for (Number number : numList) {
      3. 
  
  
  
  
    3.         System.out.println(number);
      4. 
  
  
  
  
    4.     }
      5. 
  
  
  
  
    5. }
      6. 
 
 
 
 
    但我們需要使用這個方法時候我們就很直觀的可以看出來，這個方法傳的實參只能是 Number 的子類。
     
 
 
 
      
  
  
  
  
    1. printData(Arrays.asList(1, 2, 3));
      2. 
  
  
  
  
    2. printData(Arrays.asList(1L, 2L, 3L));
      3. 
 
 
 
 
    類型通配符的下限：
    上面我們了解到 類型通配符上限的使用 ，那么 類型通配符上限 是如何使用的?
    類型通配符上限 在我們平時開發(fā)中使用的頻率也相對較少。編譯器只知道集合元素是下限的父類型，但具體是哪一種父類型是不確定的。因此，從集合中取元素只能被當成Object類型處理(編譯器無法確定取出的到底是哪個父類的對象)。
    我們可以自定義一個復制集合的函數(shù)：
    

      

    • 首先定義兩個類：
      • 

    

     
 
 
 
      
  
  
  
  
    1. public class Animal {
      2. 
  
  
  
  
    2. }
      3. 
  
  
  
  
    3. public class Pig extends Animal{
      4. 
  
  
  
  
    4. }
      5. 
 
 
 
 
      

    • 定義一個復制函數(shù)：
      • 

    

     
 
 
 
      
  
  
  
  
    1. private static  Collection copy(Collection parent, Collection child) {
      2. 
  
  
  
  
    2.     for (T t : child) {
      3. 
  
  
  
  
    3.         parent.add(t);
      4. 
  
  
  
  
    4.     }
      5. 
  
  
  
  
    5.     return parent;
      6. 
  
  
  
  
    6. }
      7. 
 
 
 
 
      

    • 使用：
      • 

    

     
 
 
 
      
  
  
  
  
    1. List animals = new ArrayList<>();
      2. 
  
  
  
  
    2. List pigs = new ArrayList<>();
      3. 
  
  
  
  
    3. pigs.add(new Pig());
      4. 
  
  
  
  
    4. pigs.add(new Pig());
      5. 
  
  
  
  
    5. copy(animals,pigs);
      6. 
  
  
  
  
    6. System.out.println(animals);
      7. 
 
 
 
 
    3. 類型擦除
    因為泛型信息只存在于代碼編譯階段，所以在進入 JVM 之前，會把與泛型相關的信息擦除，這就稱為 類型擦除
    1)無限制類型擦除
    類型擦除前：
     
 
 
 
      
  
  
  
  
    1. public class Result{
      2. 
  
  
  
  
    2.     private T data;
      3. 
  
  
  
  
    3. }
      4. 
 
 
 
 
    類型擦除后：
     
 
 
 
      
  
  
  
  
    1. public class Result{
      2. 
  
  
  
  
    2.     private Object data;
      3. 
  
  
  
  
    3. }
      4. 
 
 
 
 
    2)有限制類型擦除
    類型擦除前：
     
 
 
 
      
  
  
  
  
    1. public class Result{
      2. 
  
  
  
  
    2.     private T data;
      3. 
  
  
  
  
    3. }
      4. 
 
 
 
 
    類型擦除后：
     
 
 
 
      
  
  
  
  
    1. public class Result{
      2. 
  
  
  
  
    2.     private Number data;
      3. 
  
  
  
  
    3. }
      4. 
 
 
 
 
    3)擦除方法中類型定義的參數(shù)
    類型擦除前：
     
 
 
 
      
  
  
  
  
    1. private  T getValue(T value){
      2. 
  
  
  
  
    2.     return value;
      3. 
  
  
  
  
    3. }
      4. 
 
 
 
 
    類型擦除后：
     
 
 
 
      
  
  
  
  
    1. private Number getValue(Number value){
      2. 
  
  
  
  
    2.     return value;
      3. 
  
  
  
  
    3. }
      4. 
 
 
 
 
                                                    
    
                                                當前題目：精通Java，卻不了解泛型？                                                
    
                                                網(wǎng)站地址：http://www.5511xx.com/article/dppppsj.html