Java泛型的原理分析是怎樣的

這篇文章將為大家詳細講解有關Java泛型的原理分析是怎樣的，文章內容質量較高，因此小編分享給大家做個參考，希望大家閱讀完這篇文章后對相關知識有一定的了解。

一、前言

泛型在java中有很重要的地位，在實際開發中用處也很大。

二、泛型

泛型：是jdk5中引入的特性，他提供編譯是類型是類型的安全檢測機制，這個機制允許在編譯時檢測到非法的類型，它的本質是參數化類型，也就是所操作的數據類型不變指定為一個參數

將原來具體的類型參數化，然后再使用/調用的時候傳入具體的參數

泛型的類型：

①：泛型類

②：泛型方法 

③：泛型接口

三、泛型定義的格式：

<類型> ：指定一種類型的格式，這里的類型可以看成是形參。

<類型1，類型2...>:指定多種類型的格式，多種類型之間用逗號隔開，這里的類型類型1，類型2可以看成是形參，將來具體調用的時候的參數看成是實參，這里的泛型只能是引用類型。

什么是引用類型？

除了八大基本類型其他的都是引用類型，如基本類型對應的包裝類

• boolean -->Boolean

• char --->Character

• byte -->Byte

• short -->Short

• int -->Integer

• long -->Long

• float -->Float

• double -->Double

泛型的好處是：  

• 把運行得問題提前到編譯時期   

• 避免了強制轉換

沒指定類型默認是Object類型

舉個例子，當沒有使用泛型時：

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
public class 泛型Demo {
    public static void main(String[] args) {
        //創建一個對象
        Map map=new HashMap();
        //添加數據
        map.put(1, "張三");
        map.put(2, "李四");
        map.put(3,"王五");
        map.put(5, 6);//加了不一樣的類型數據
 
        //鍵的集合
        Set keySet=map.keySet();
        //鍵找值
        for(Object key: keySet){
            String value=(String)map.get(key);
            System.out.println(key+":"+value);
        }
 
 
    }
}

報了一個類型轉換異常(int會自動轉化成Integer），Integer不能轉為String

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
 

 此時泛型的好處就體現出來了，將運行時會出現的錯誤拉到了編譯期間。

 當然也可以在輸出是采用Object接收

        //鍵的集合
        Set keySet=map.keySet();
        //鍵找值
        for(Object key: keySet){
           Object value=map.get(key);
          //  String value=(String)map.get(key);
            System.out.println(key+":"+value);
        }

這樣也可以得到想要的結果。

四、泛型類

泛型類的定義格式：

修飾符 class 類名<類型> { }

舉例：

public class Generic<T>{}

這里的T可以使任意標識，常見的如T、E、K、V等形式常用于表示泛型。

泛型類下

public class Generic<T> {
    //定義一個變量，提供get set方法
    private T t;
    public T getT(){
        return t;
    }
    public void SetT(T t){
        this.t=t;
    }
    
}

測試類下

public class GenericDemo {
    public static void main(String[] args) {
        Generic<String> g1=new Generic<>();
        g1.SetT("章三");
        System.out.println(g1.getT());
        System.out.println("------------------");
        Generic<Integer> g2=new Generic<>();
        g2.SetT(100);
        System.out.println(g2.getT());
    }
}

運行結果

 定義這個泛型類的好處就是可以在測試中輸入各種你想要的類型。

五、泛型方法

定義泛型方法的格式：

修飾符 <類型> 返回值類型 方法名 （類型 類型名）

舉例：

public <T> void show (T t){}

泛型方法

 public class Generic {
public <T> void show(T t){
    System.out.println(t);
}
}

泛型方法測試下：

public class GenericDemo {
    public static void main(String[] args) {
       Generic g=new Generic();
       g.show("張三");
       g.show(100);
       g.show(true);
   g.show(null);
    }
}

運行結果

 泛型方法比泛型類方便許多，直接在這使用即可，可以用個中類型的參數

六、泛型接口

格式：修飾符 interface 接口名<類型>{}

舉例：

public interface Generic<T>{}

既然是接口那就得定義一個類 去實現這個接口

泛型接口：

public interface Generic<T>{}

 GenricImp類下：

public class GenricImp<T> Generic<T>{
   public void show(T t){
     System.out.println(t);   
   }
  
}

 GenricDemo類下：

public class GenricDemo{
   public static void main(String[]args){
        Generic<String> g1=new GenericImp<String>();
       g1.show("張三");
   Generic<Integer> g2=new GenericImp<Integer>();
       g2.show(100);
   }
}

七、類型通配符

<? extends T>上限通配，？表示是T的一個未知子類。

<? super T>下限通配，？表示是T的一個未知父類。

關于Java泛型的原理分析是怎樣的就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。