2. 程式人生 > >java泛型的基本介紹和使用

java泛型的基本介紹和使用

阿新 • • 發佈：2017-11-13
java

現在開始深入學習java的泛型了，以前一直只是在集合中簡單的使用泛型，根本就不明白泛型的原理和作用。泛型在java中，是一個十分重要的特性，所以要好好的研究下。

一、泛型的基本概念

泛型的定義：泛型是JDK 1.5的一項新特性，它的本質是參數化類型（Parameterized Type）的應用，也就是說所操作的數據類型被指定為一個參數，在用到的時候在指定具體的類型。這種參數類型可以用在類、接口和方法的創建中，分別稱為泛型類、泛型接口和泛型方法。

泛型思想早在C++語言的模板（Templates）中就開始生根發芽，在Java語言處於還沒有出現泛型的版本時，只能通過Object是所有類型的父類和類型強制轉換兩個特點的配合來實現類型泛化。例如在哈希表的存取中，JDK 1.5之前使用HashMap的get()方法，返回值就是一個Object對象，由於Java語言裏面所有的類型都繼承於java.lang.Object，那Object轉型為任何對象成都是有可能的。但是也因為有無限的可能性，就只有程序員和運行期的虛擬機才知道這個Object到底是個什麽類型的對象。在編譯期間，編譯器無法檢查這個Object的強制轉型是否成功，如果僅僅依賴程序員去保障這項操作的正確性，許多ClassCastException的風險就會被轉嫁到程序運行期之中。

泛型技術在C#和Java之中的使用方式看似相同，但實現上卻有著根本性的分歧，C#裏面泛型無論在程序源碼中、編譯後的IL中（Intermediate Language，中間語言，這時候泛型是一個占位符）或是運行期的CLR中都是切實存在的，List<int>與List<String>就是兩個不同的類型，它們在系統運行期生成，有自己的虛方法表和類型數據，這種實現稱為類型膨脹，基於這種方法實現的泛型被稱為真實泛型。

Java語言中的泛型則不一樣，它只在程序源碼中存在，在編譯後的字節碼文件中，就已經被替換為原來的原始類型（Raw Type，也稱為裸類型）了，並且在相應的地方插入了強制轉型代碼，因此對於運行期的Java語言來說，ArrayList<int>與ArrayList<String>就是同一個類。所以說泛型技術實際上是Java語言的一顆語法糖，Java語言中的泛型實現方法稱為類型擦除，基於這種方法實現的泛型被稱為偽泛型。（類型擦除在後面在學習）

使用泛型機制編寫的程序代碼要比那些雜亂的使用Object變量，然後再進行強制類型轉換的代碼具有更好的安全性和可讀性。泛型對於集合類來說尤其有用。

泛型程序設計（Generic Programming）意味著編寫的代碼可以被很多不同類型的對象所重用。


實例分析：

在JDK1.5之前，Java泛型程序設計是用繼承來實現的。因為Object類是所用類的基類，所以只需要維持一個Object類型的引用即可。就比如ArrayList只維護一個Object引用的數組：


[java] view plain copy

  1. public class ArrayList//JDK1.5之前的

  2. {

  3. public

    Object get(int i){......}

  4. public void add(Object o){......}

  5. ......

  6. private Object[] elementData;

  7. }

這樣會有兩個問題：

1、沒有錯誤檢查，可以向數組列表中添加類的對象

2、在取元素的時候，需要進行強制類型轉換

這樣，很容易發生錯誤，比如：


[java] view plain copy

  1. /**jdk1.5之前的寫法，容易出問題*/

  2. ArrayList arrayList1=new ArrayList();

  3. arrayList1.add(1);

  4. arrayList1.add(1L);

  5. arrayList1.add("asa");

  6. int i=(Integer) arrayList1.get(1);//因為不知道取出來的值的類型，類型轉換的時候容易出錯

這裏的第一個元素是一個長整型，而你以為是整形，所以在強轉的時候發生了錯誤。

所以。在JDK1.5之後，加入了泛型來解決類似的問題。例如在ArrayList中使用泛型：

[java] view plain copy

  1. /** jdk1.5之後加入泛型*/

  2. ArrayList<String> arrayList2=new ArrayList<String>(); //限定數組列表中的類型

  3. // arrayList2.add(1); //因為限定了類型，所以不能添加整形

  4. // arrayList2.add(1L);//因為限定了類型，所以不能添加整長形

  5. arrayList2.add("asa");//只能添加字符串

  6. String str=arrayList2.get(0);//因為知道取出來的值的類型，所以不需要進行強制類型轉換


還要明白的是，泛型特性是向前兼容的。盡管 JDK 5.0 的標準類庫中的許多類，比如集合框架，都已經泛型化了，但是使用集合類（比如 HashMap 和 ArrayList）的現有代碼可以繼續不加修改地在 JDK 1.5 中工作。當然，沒有利用泛型的現有代碼將不會贏得泛型的類型安全的好處。


在學習泛型之前，簡單介紹下泛型的一些基本術語，以ArrayList<E>和ArrayList<Integer>做簡要介紹：

整個成為ArrayList<E>泛型類型

ArrayList<E>中的 E稱為類型變量或者類型參數

整個ArrayList<Integer> 稱為參數化的類型

ArrayList<Integer>中的integer稱為類型參數的實例或者實際類型參數

·ArrayList<Integer>中的<Integer>念為typeof Integer

ArrayList稱為原始類型


二、泛型的使用

泛型的參數類型可以用在類、接口和方法的創建中，分別稱為泛型類、泛型接口和泛型方法。下面看看具體是如何定義的。

1、泛型類的定義和使用


一個泛型類（generic class）就是具有一個或多個類型變量的類。定義一個泛型類十分簡單，只需要在類名後面加上<>，再在裏面加上類型參數：

[java] view plain copy

  1. class Pair<T> {

  2. private T value;

  3. public Pair(T value) {

  4. this.value=value;

  5. }

  6. public T getValue() {

  7. return value;

  8. }

  9. public void setValue(T value) {

  10. this.value = value;

  11. }

  12. }

現在我們就可以使用這個泛型類了：

[java] view plain copy

  1. public static void main(String[] args) throws ClassNotFoundException {

  2. Pair<String> pair=new Pair<String>("Hello");

  3. String str=pair.getValue();

  4. System.out.println(str);

  5. pair.setValue("World");

  6. str=pair.getValue();

  7. System.out.println(str);

  8. }


Pair類引入了一個類型變量T，用尖括號<>括起來，並放在類名的後面。泛型類可以有多個類型變量。例如，可以定義Pair類，其中第一個域和第二個域使用不同的類型：

public class Pair<T,U>{......}

註意：類型變量使用大寫形式，且比較短，這是很常見的。在Java庫中，使用變量E表示集合的元素類型，K和V分別表示關鍵字與值的類型。（需要時還可以用臨近的字母U和S）表示“任意類型”。


2、泛型接口的定義和使用

定義泛型接口和泛型類差不多，看下面簡單的例子：


[java] view plain copy

  1. interface Show<T,U>{

  2. void show(T t,U u);

  3. }

  5. class ShowTest implements Show<String,Date>{

  6. @Override

  7. public void show(String str,Date date) {

  8. System.out.println(str);

  9. System.out.println(date);

  10. }

  11. }

測試一下：



[java] view plain copy

  1. public static void main(String[] args) throws ClassNotFoundException {

  2. ShowTest showTest=new ShowTest();

  3. showTest.show("Hello",new Date());

  4. }


3、泛型方法的定義和使用


泛型類在多個方法簽名間實施類型約束。在 List<V> 中，類型參數 V 出現在 get()、add()、contains() 等方法的簽名中。當創建一個 Map<K, V> 類型的變量時，您就在方法之間宣稱一個類型約束。您傳遞給 add() 的值將與 get() 返回的值的類型相同。

類似地，之所以聲明泛型方法，一般是因為您想要在該方法的多個參數之間宣稱一個類型約束。

舉個簡單的例子：


[java] view plain copy

  1. public static void main(String[] args) throws ClassNotFoundException {

  2. String str=get("Hello", "World");

  3. System.out.println(str);

  4. }

  6. public static <T, U> T get(T t, U u) {

  7. if (u != null)

  8. return t;

  9. else

  10. return null;

  11. }




三、泛型變量的類型限定


在上面，我們簡單的學習了泛型類、泛型接口和泛型方法。我們都是直接使用<T>這樣的形式來完成泛型類型的聲明。

有的時候，類、接口或方法需要對類型變量加以約束。看下面的例子：

有這樣一個簡單的泛型方法：


[java] view plain copy

  1. public static <T> T get(T t1,T t2) {

  2. if(t1.compareTo(t2)>=0);//編譯錯誤

  3. return t1;

  4. }

因為，在編譯之前，也就是我們還在定義這個泛型方法的時候，我們並不知道這個泛型類型T，到底是什麽類型，所以，只能默認T為原始類型Object。所以它只能調用來自於Object的那幾個方法，而不能調用compareTo方法。


可我的本意就是要比較t1和t2，怎麽辦呢？這個時候，就要使用類型限定，對類型變量T設置限定（bound）來做到這一點。

我們知道，所有實現Comparable接口的方法，都會有compareTo方法。所以，可以對<T>做如下限定：


[java] view plain copy

  1. public static <T extends Comparable> T get(T t1,T t2) { //添加類型限定

  2. if(t1.compareTo(t2)>=0);

  3. return t1;

  4. }


類型限定在泛型類、泛型接口和泛型方法中都可以使用，不過要註意下面幾點：



1、不管該限定是類還是接口，統一都使用關鍵字 extends

2、可以使用&符號給出多個限定，比如

[java] view plain copy

  1. public static <T extends Comparable&Serializable> T get(T t1,T t2)

3、如果限定既有接口也有類，那麽類必須只有一個，並且放在首位置


[java] view plain copy

  1. public static <T extends Object&Comparable&Serializable> T get(T t1,T t2)


java泛型的基本介紹和使用

相關推薦

泛型深入--java泛型的繼承和實現、泛型擦除

部分 end father 沒有 接口 子類 set int nal 泛型實現類： package generic; /** * 泛型父類：子類為“富二代”：子類的泛型要比父類多 * 1，保留父類的泛型-->子類為泛型類

java泛型的作用和好處

TP 語言 ID 安全 運行期 AI 泛型 tails string類型 轉載於:https://blog.csdn.net/u012760183/article/details/52092692 之前參加面試的時候遇到面試官問泛型的作用,只是說了大概自己的理解, 在此轉載

java 泛型中 T 和 問號（萬用字元）的區別

型別本來有：簡單型別和複雜型別，引入泛型後把複雜型別分的更細了； 現在List<Object>, List<String>是兩種不同的型別;且無繼承關係； 泛型的好處如： 開始版本 public void write(Integer

java泛型詳解和反射泛型通用BaseDao實現

一 泛型的基本概念 1.1什麼是泛型？ 泛型，即“引數化型別”。一提到引數，最熟悉的就是定義方法時有形參，然後呼叫此方法時傳遞實參。那麼引數化型別怎麼理解呢？顧名思義，就是將型別由原來的具體的型別引數化，類似於方法中的變數引數，此時型別也定義成引數形式（可以

Java泛型中T和問號（萬用字元）的區別

型別本來有：簡單型別和複雜型別，引入泛型後把複雜型別分的更細了. 概述 泛型是Java SE 1.5的新特性，泛型的本質是引數化型別，也就是說所操作的資料型別被指定為一個引數。這種引數型別可以用在類、介面和方法的建立中，分別稱為泛型類、泛型介面、泛型方法。 Java語

Java泛型中extends和super的區別？

<? extends T>和<? super T>是Java泛型中的“萬用字元（Wildcards）”和“邊界（Bounds）”的概念。<? extends T>：是指 “上界萬用字元（Upper Bounds Wildcards）”<

Java泛型的約束和侷限性

在使用Java泛型時需要考慮一些限制， 大多數限制都是由於型別擦除所引起的。 1.不能使用基本型別例項化型別引數 型別引數 T不能取8中基本型別，需要的時候採用包裝器型別，如果不能接受這樣的替換時， 可以使用獨立的類和方法來處理。 2.執行時的型別查詢只會

Java泛型 extends,super和萬用字元的理解

1.java泛型的特點 通常情況下，一個編譯器處理泛型有兩種方式：      1.Code specialization。在例項化一個泛型類或泛型方法時都產生一份新的目的碼（位元組碼or二進位制程式

java泛型中extends 和 super的區別

一般對反省中extends 和 super 的區別是這樣介紹的： 關鍵字說明 ? 萬用字元型別<? extends T> 表示型別的上界，表示引數化型別的可能是T 或是 T的子類<? super T> 表示型別下界（Java Core中叫超型別限

深入理解泛型之JAVA泛型的繼承和實現、泛型擦除

info 丟失 導致 bject object 反序列化 自己 inf 圖片 很多的基礎類設計會采用泛型模式，有些應用在使用的時候處於隔離考慮，會進行繼承，此時子類如何繼承泛型類就很講究了，有些情況下需要類型擦除，有些情況下不需要類型擦除，但是大多數情況下，我們需要的是保留

java泛型的基本介紹和使用

java現在開始深入學習java的泛型了，以前一直只是在集合中簡單的使用泛型，根本就不明白泛型的原理和作用。泛型在java中，是一個十分重要的特性，所以要好好的研究下。一、泛型的基本概念 泛型的定義：泛型是JDK 1.5的一項新特性，它的本質是參數化類型（Parameterized Type）的應用，也就是說

java泛型（一）、泛型的基本介紹和使用

 轉載地址  http://m.blog.csdn.net/article/details?id=7864531 現在開始深入學習java的泛型了，以前一直只是在集合中簡單的使用泛型，根本就不明白泛型的原理和作用。泛型在java中，是一個十分重要的特性，所以要好好的研究

Java泛型（一） 泛型的基本使用和介紹

轉載自：http://blog.csdn.net/lonelyroamer/article/details/7864531 現在開始深入學習java的泛型了，以前一直只是在集合中簡單的使用泛型，根本就不明白泛型的原理和作用。泛型在java中，是一個十分重要的特性，所以要

12.Java泛型的原理，基本和高階應用

Java泛型的原理，基本和高階應用 1.體驗泛型 （1）Jdk1.5以前的集合類中存在什麼問題？ 在1.5之前的jdk，我們使用泛型的方式是這樣，當我們給這個集合中存放了值後，我們想要取值的

Java,泛型類型通配符和C#對照

size list ack ace arr 類型通配符 語法 ++ net c#的泛型沒有類型通配符,原因是.net的泛型是CLR支持的泛型,而Java的JVM並不支持泛型,僅僅是語法糖,在編譯器編譯的時候都轉換成object類型 類型通配符在java中表示的是泛型

java泛型中<?>和<T>區別

類型 父類 定義 ext 方法 oid tor 接收 通配符 public static void printColl(ArrayList<?> al){ Iterator<?> it = al.iterator();

JAVA泛型的基本使用

end ++ rc.d param details file println super turn Java1.5版本號推出了泛型，盡管這層語法糖給開發者帶來了代碼復用性方面的提升，可是這只是是編譯器所做的一層語法糖，在真正生成的字節碼中，這類信息卻被擦除了。筆者發

Java泛型方法和構造函數

generic 類型參數 -s con ner 實際類型 非靜態方法 gen 尖括號 可以在方法聲明中定義類型參數，它們在方法的返回類型之前的尖括號中指定。包含泛型方法聲明的類型不必是通用類型。可以在非靜態方法聲明中使用為泛型類型指定的類型參數。 示例 以下代碼顯示如何為方

java泛型中<?>和<T>有什麽區別？

n) add 簽名 object 表達 類型變量 ring 類型 arr public static void printColl(ArrayList<?> al){ Iterator<?> it = al.iterat

Java 泛型 介紹

.class 為什麽 his 能夠 不同 rec args abstract pub 　　為什麽需要泛型？ 1 public class GenericTest { 2 3 public static void main(String[] args) {