前言

泛型在java中有很重要的地位，無論是開源框架還是JDK源碼都能看到它。

毫不夸張的說，泛型是通用設計上必不可少的元素，所以真正理解與正確使用泛型，是一門必修課。

一：泛型本質(zhì)

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

泛型的本質(zhì)是參數(shù)化類型，即給類型指定一個參數(shù)，然后在使用時再指定此參數(shù)具體的值，那樣這個類型就可以在使用時決定了。這種參數(shù)類型可以用在類、接口和方法中，分別被稱為泛型類、泛型接口、泛型方法。

二：為什么使用泛型

泛型的好處是在編譯的時候檢查類型安全，并且所有的強制轉換都是自動和隱式的，提高代碼的重用率。

（1）保證了類型的安全性。

在沒有泛型之前，從集合中讀取到的每一個對象都必須進行類型轉換，如果不小心插入了錯誤的類型對象，在運行時的轉換處理就會出錯。

比如：沒有泛型的情況下使用集合：

public static void noGeneric() {
ArrayList names = new ArrayList();
names.add("mikechen的互聯(lián)網(wǎng)架構");
names.add(123); //編譯正常
}

有泛型的情況下使用集合：

public static void useGeneric() {
ArrayList<String> names = new ArrayList<>();
names.add("mikechen的互聯(lián)網(wǎng)架構");
names.add(123); //編譯不通過
}

有了泛型后，定義好的集合names在編譯的時候add(123)就會編譯不通過。

相當于告訴編譯器每個集合接收的對象類型是什么，編譯器在編譯期就會做類型檢查，告知是否插入了錯誤類型的對象，使得程序更加安全，增強了程序的健壯性。

（2） 消除強制轉換

泛型的一個附帶好處是，消除源代碼中的許多強制類型轉換，這使得代碼更加可讀，并且減少了出錯機會。
還是舉例說明，以下沒有泛型的代碼段需要強制轉換：

List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);

當重寫為使用泛型時，代碼不需要強制轉換：

List<String> list = new ArrayList<String>();
list.add("hello");
String s = list.get(0); // no cast

（3）避免了不必要的裝箱、拆箱操作，提高程序的性能

在非泛型編程中，將筒單類型作為Object傳遞時會引起B(yǎng)oxing（裝箱）和Unboxing（拆箱）操作，這兩個過程都是具有很大開銷的。引入泛型后，就不必進行Boxing和Unboxing操作了，所以運行效率相對較高，特別在對集合操作非常頻繁的系統(tǒng)中，這個特點帶來的性能提升更加明顯。

泛型變量固定了類型，使用的時候就已經(jīng)知道是值類型還是引用類型，避免了不必要的裝箱、拆箱操作。

object a=1;//由于是object類型，會自動進行裝箱操作。
 
int b=(int)a;//強制轉換，拆箱操作。這樣一去一來，當次數(shù)多了以后會影響程序的運行效率。

使用泛型之后

public static T GetValue<T>(T a)
{
　　return a;
}
 
public static void Main()
{
　　int b=GetValue<int>(1);//使用這個方法的時候已經(jīng)指定了類型是int，所以不會有裝箱和拆箱的操作。
}

（4）提高了代碼的重用性。

三：如何使用泛型

泛型有三種使用方式，分別為：泛型類、泛型接口和泛型方法。

1、泛型類

泛型類：把泛型定義在類上

定義格式：

public class 類名 <泛型類型1,...> {
    
}

注意事項：泛型類型必須是引用類型（非基本數(shù)據(jù)類型）

定義泛型類，在類名后添加一對尖括號，并在尖括號中填寫類型參數(shù)，參數(shù)可以有多個，多個參數(shù)使用逗號分隔：

public class GenericClass<ab,a,c> {}

當然，這個后面的參數(shù)類型也是有規(guī)范的，不能像上面一樣隨意，通常類型參數(shù)我們都使用大寫的單個字母表示：

T：任意類型 type
E：集合中元素的類型 element
K：key-value形式 key
V： key-value形式 value

示例代碼：

泛型類：

public class GenericClass<T> {
    private T value;
 
 
    public GenericClass(T value) {
        this.value = value;
    }
    public T getValue() {
        return value;
    }
    public void setValue(T value) {
        this.value = value;
    }
}

測試類：

//TODO 1:泛型類
GenericClass<String> name = new GenericClass<>("mikechen的互聯(lián)網(wǎng)架構");
System.out.println(name.getValue());
 
 
GenericClass<Integer> number = new GenericClass<>(123);
System.out.println(number.getValue());

運行結果：

2、泛型接口

泛型方法概述：把泛型定義在方法上

定義格式：

public <泛型類型> 返回類型 方法名（泛型類型 變量名） {
    
}

注意要點：

方法聲明中定義的形參只能在該方法里使用，而接口、類聲明中定義的類型形參則可以在整個接口、類中使用。當調(diào)用fun()方法時，根據(jù)傳入的實際對象，編譯器就會判斷出類型形參T所代表的實際類型。

public interface GenericInterface<T> {
void show(T value);}
}
public class StringShowImpl implements GenericInterface<String> {
@Override
public void show(String value) {
System.out.println(value);
}}
 
public class NumberShowImpl implements GenericInterface<Integer> {
@Override
public void show(Integer value) {
System.out.println(value);
}}

注意：使用泛型的時候，前后定義的泛型類型必須保持一致，否則會出現(xiàn)編譯異常：

GenericInterface<String> genericInterface = new NumberShowImpl();//編譯異常

或者干脆不指定類型，那么 new 什么類型都是可以的：

GenericInterface g1 = new NumberShowImpl();
GenericInterface g2 = new StringShowImpl();

3、泛型方法

泛型方法，是在調(diào)用方法的時候指明泛型的具體類型 。

定義格式：

修飾符<代表泛型的變量>返回值類型 方法名(參數(shù)){}

例如：

/**
?????*
?????* @param t 傳入泛型的參數(shù)
?????* @param <T> 泛型的類型
?????* @return T 返回值為T類型
?????* 說明：
?????*???1）public 與 返回值中間<T>非常重要，可以理解為聲明此方法為泛型方法。
?????*???2）只有聲明了<T>的方法才是泛型方法，泛型類中的使用了泛型的成員方法并不是泛型方法。
?????*???3）<T>表明該方法將使用泛型類型T，此時才可以在方法中使用泛型類型T。
?????*???4）與泛型類的定義一樣，此處T可以隨便寫為任意標識，常見的如T、E等形式的參數(shù)常用于表示泛型。
?????*/
????public <T> T genercMethod(T t){
????????System.out.println(t.getClass());
????????System.out.println(t);
????????return t;
????}
?
?
public static void main(String[] args) {
????GenericsClassDemo<String> genericString??= new GenericsClassDemo("helloGeneric"); //這里的泛型跟下面調(diào)用的泛型方法可以不一樣。
????String str = genericString.genercMethod("hello");//傳入的是String類型,返回的也是String類型
????Integer i = genericString.genercMethod(123);//傳入的是Integer類型,返回的也是Integer類型
}
?
?
class java.lang.String
hello
?
?
class java.lang.Integer
123

這里可以看出，泛型方法隨著我們的傳入?yún)?shù)類型不同，他得到的類型也不同。泛型方法能使方法獨立于類而產(chǎn)生變化。

四：泛型通配符

Java泛型的通配符是用于解決泛型之間引用傳遞問題的特殊語法, 主要有以下三類:

//表示類型參數(shù)可以是任何類型
public class Apple<?>{}
?
//表示類型參數(shù)必須是A或者是A的子類
public class Apple<T extends A>{}
?
//表示類型參數(shù)必須是A或者是A的超類型
public class Apple<T supers A>{}

1. 無邊界的通配符(Unbounded Wildcards), 就是, 比如List

無邊界的通配符的主要作用就是讓泛型能夠接受未知類型的數(shù)據(jù).

2. 固定上邊界的通配符(Upper Bounded Wildcards)，采用<? extends E>的形式

使用固定上邊界的通配符的泛型, 就能夠接受指定類及其子類類型的數(shù)據(jù)。

要聲明使用該類通配符, 采用<? extends E>的形式, 這里的E就是該泛型的上邊界。

注意: 這里雖然用的是extends關鍵字, 卻不僅限于繼承了父類E的子類, 也可以代指顯現(xiàn)了接口E的類

3. 固定下邊界的通配符(Lower Bounded Wildcards)，采用<? super E>的形式

使用固定下邊界的通配符的泛型, 就能夠接受指定類及其父類類型的數(shù)據(jù).。

要聲明使用該類通配符, 采用<? super E>的形式, 這里的E就是該泛型的下邊界.。

注意: 你可以為一個泛型指定上邊界或下邊界, 但是不能同時指定上下邊界。

五：泛型中KTVE的含義

果點開JDK中一些泛型類的源碼，我們會看到下面這些代碼：

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
...
}
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
...
}

上面這些泛型類定義中的泛型參數(shù)E、K和V都是什么意思呢？其實這些參數(shù)名稱是可以任意指定，就想方法的參數(shù)名一樣可以任意指定，但是我們通常會起一個有意義的名稱，讓別人一看就知道是什么意思。泛型參數(shù)也一樣，E一般是指元素，用來集合類中。

常見泛型參數(shù)名稱有如下：

E： Element (在集合中使用，因為集合中存放的是元素)

T：Type（Java 類）

K： Key（鍵）

V： Value（值）

N： Number（數(shù)值類型）

？： 表示不確定的java類型

六：泛型的實現(xiàn)原理

泛型本質(zhì)是將數(shù)據(jù)類型參數(shù)化，它通過擦除的方式來實現(xiàn)，即編譯器會在編譯期間「擦除」泛型語法并相應的做出一些類型轉換動作。

看一個例子就應該清楚了，例如：

public class Caculate<T> {
private T num;
}

我們定義了一個泛型類，定義了一個屬性成員，該成員的類型是一個泛型類型，這個 T 具體是什么類型，我們也不知道，它只是用于限定類型的。

反編譯一下這個 Caculate 類：

public class Caculate{
public Caculate(){}
private Object num;
}

發(fā)現(xiàn)編譯器擦除 Caculate 類后面的兩個尖括號，并且將 num 的類型定義為 Object 類型。

那么是不是所有的泛型類型都以 Object 進行擦除呢？大部分情況下，泛型類型都會以 Object 進行替換，而有一種情況則不是。那就是使用到了extends和super語法的有界類型，如：

public class Caculate<T extends String> {
private T num;
}

這種情況的泛型類型，num 會被替換為 String 而不再是 Object。

這是一個類型限定的語法，它限定 T 是 String 或者 String 的子類，也就是你構建 Caculate 實例的時候只能限定 T 為 String 或者 String 的子類，所以無論你限定 T 為什么類型，String 都是父類，不會出現(xiàn)類型不匹配的問題，于是可以使用 String 進行類型擦除。

實際上編譯器會正常的將使用泛型的地方編譯并進行類型擦除，然后返回實例。但是除此之外的是，如果構建泛型實例時使用了泛型語法，那么編譯器將標記該實例并關注該實例后續(xù)所有方法的調(diào)用，每次調(diào)用前都進行安全檢查，非指定類型的方法都不能調(diào)用成功。

實際上編譯器不僅關注一個泛型方法的調(diào)用，它還會為某些返回值為限定的泛型類型的方法進行強制類型轉換，由于類型擦除，返回值為泛型類型的方法都會擦除成 Object 類型，當這些方法被調(diào)用后，編譯器會額外插入一行 checkcast 指令用于強制類型轉換，這一個過程就叫做『泛型翻譯』。

七：關于泛型數(shù)組要提一下

看到了很多文章中都會提起泛型數(shù)組，經(jīng)過查看sun的說明文檔，在java中是”不能創(chuàng)建一個確切的泛型類型的數(shù)組”的。

也就是說下面的這個例子是不可以的：

List<String>[] ls = new ArrayList<String>[10];

而使用通配符創(chuàng)建泛型數(shù)組是可以的，如下面這個例子：

List<?>[] ls = new ArrayList<?>[10];

這樣也是可以的：

List<String>[] ls = new ArrayList[10];

下面使用Sun的一篇文檔的一個例子來說明這個問題：

List<String>[] lsa = new List<String>[10]; // Not really allowed.    
Object o = lsa;    
Object[] oa = (Object[]) o;    
List<Integer> li = new ArrayList<Integer>();    
li.add(new Integer(3));    
oa[1] = li; // Unsound, but passes run time store check    
String s = lsa[1].get(0); // Run-time error: ClassCastException.

這種情況下，由于JVM泛型的擦除機制，在運行時JVM是不知道泛型信息的，所以可以給oa[1]賦上一個ArrayList而不會出現(xiàn)異常，

但是在取出數(shù)據(jù)的時候卻要做一次類型轉換，所以就會出現(xiàn)ClassCastException，如果可以進行泛型數(shù)組的聲明，

上面說的這種情況在編譯期將不會出現(xiàn)任何的警告和錯誤，只有在運行時才會出錯。

而對泛型數(shù)組的聲明進行限制，對于這樣的情況，可以在編譯期提示代碼有類型安全問題，比沒有任何提示要強很多。

下面采用通配符的方式是被允許的:數(shù)組的類型不可以是類型變量，除非是采用通配符的方式，因為對于通配符的方式，最后取出數(shù)據(jù)是要做顯式的類型轉換的。

List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type.    
Object o = lsa;    
Object[] oa = (Object[]) o;    
List<Integer> li = new ArrayList<Integer>();    
li.add(new Integer(3));    
oa[1] = li; // Correct.    
Integer i = (Integer) lsa[1].get(0); // OK

八：最后

以上我就分別從Java泛型的誕生，再到泛型的使用，以及泛型的實現(xiàn)原理等六個方面進行了完整詳解，希望對你有所用！

到此這篇關于Java泛型的文章就介紹到這了,更多相關Java泛型內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論