全文大約【4600】字，不說廢話，只講可以讓你學到技術、明白原理的純干貨!本文帶有豐富的案例及配圖視頻，讓你更好地理解和運用文中的技術概念，并可以給你帶來具有足夠啟迪的思考......
一. 泛型方法
1.簡介
我們可以在定義接口和類時使用泛型，這樣該接口和類中的所有方法及成員變量等處，也都可以使用該泛型。但其實泛型可以應用在整個類上，也可以只應用在類中的某個方法上。也就是說，方法所在的類可以是泛型類，也可以不是泛型類。方法中是否帶有泛型，與其所在的類有沒有泛型沒有關系。
泛型方法是在調用方法時才確定類型的方法，泛型可以使得該方法獨立于類而產生變化。另外，static靜態方法無法訪問泛型類的類型參數，因此，如果想讓一個static方法具有泛型能力，就必須使該靜態方法成為泛型方法。
2.語法
我們在定義泛型方法時，需要在方法名的前面添加類型參數。定義泛型方法的語法格式如下：
[訪問權限修飾符] [static] [final] <類型參數列表> 返回值類型 方法名([形式參數列表])例如：
public static <T> List showInfo(Class<T> clazz,int userId){}一般情況下，我們編寫泛型方法時，必須在該方法的名稱前聲明要使用的泛型，并且可以同時聲明多個泛型，中間也是用逗號分割。接下來小編就定義一個泛型方法，給大家具體介紹一下泛型方法的創建和使用。
3. 代碼案例
這里我們定義一個泛型方法，用于對數組排序后再遍歷元素輸出，代碼如下：
import java.util.Arrays;
/**
* @author 一一哥Sun
*/
public class Demo04 {
//定義了一個靜態的泛型方法，遍歷數組中的每個元素
public static <T> void printArray(T[] arr) {
//先對數組進行排序
Arrays.sort(arr);
//再遍歷數組元素
for (T t : arr) {
System.out.print(t + " ");
}
System.out.println();
}
public static void main(String[] args) {
Integer[] nums= {100,39,8,200,65};
//調用泛型方法
printArray(nums);
}
}在上面的代碼中，printArray()就是一個泛型方法，該方法中使用了類型參數T。并且我們在方法的參數中，使用類型參數T定義了一個泛型數組T[]，接著對該數組進行排序和遍歷。這樣以后無論我們傳入任何類型的數組，都可以在不進行類型轉換的前提下，輕松實現排序等功能了，這樣我們之前提的需求也就很容易實現了。
二. 通配符
除了以上這些用法之外，泛型中還有一個很重要的通配符功能，接下來我們就來看看它是怎么回事。
1.簡介
泛型中的通配符其實也是一種特殊的泛型類型，也稱為通配符類型參數。利用通配符類型參數，可以讓我們編寫出更通用的代碼，甚至可以在不知道實際類型的情況下使用它們。我們一般是使用 ? 來代替具體的類型參數，例如 List 在邏輯上可以等同于 List、List 等所有 List<具體類型實參> 的類。
對此，有的小伙伴可能會很好奇，我們為什么需要通配符呢?其實之所以會出現通配符，主要是在開發時，有時候我們需要一個泛型類型，但我們卻不知道該使用哪個具體的類型。在這種情況下，我們就可以使用通配符類型參數，讓代碼更加地通用。比如，我們想編寫一個可以接受任何類型的集合，并返回其中最大的元素時，此時我們可能并不確定到底該傳入哪個具體的集合，那使用通配符就會更好一些。
2.通配符的形式
泛型通配符在具體使用時，有如下三種實現形式：
● 未限定通配符(?)：?表示未知類型的通配符;
● 上限通配符(? extends T)：?表示類型上限的通配符，T是一個類或接口;
● 下限通配符(? super T)：?表示類型下限的通配符，T是一個類或接口。
接下來小編針對以上這三種形式，分別通過幾個案例來給大家講解其用法。
3.未限定通配符(?)
未限定通配符(?)是一種表示未知類型的通配符，它可以在需要一個類型參數的情況下使用。但由于沒有限制，因此它只能用于簡單的情況，例如集合中的迭代器或者返回類型是泛型的方法等。下面是一個簡單的例子：
import java.util.ArrayList;
import java.util.List;
/**
* @author 一一哥Sun
*/
public class Demo05 {
public static void main(String[] args) {
List<String> names = new ArrayList<String>();
List<Integer> ages = new ArrayList<Integer>();
List<Number> numbers = new ArrayList<Number>();
names.add("一一哥");
names.add("秦始皇");
ages.add(28);
ages.add(50);
ages.add(28);
numbers.add(100);
numbers.add(800);
printElement(names);
printElement(ages);
printElement(numbers);
}
//未限定通配符的使用
public static void printElement(List<?> data) {
for(int i=0;i<data.size();i++) {
//data.getClass().getSimpleName():用于獲取某個類的類名
System.out.println(data.getClass().getSimpleName()+"--data: " + data.get(i));
}
}
}在這個例子中，printElement()方法就接受了一個未知類型的List集合，所以names，ages，numbers都可以作為這個方法的實參，這就是未限定通配符的作用。
4. PECS原則
PECS是Producer Extends Consumer Super的縮寫，這是關于Java泛型的一種設計原則。該原則表示，如果我們需要返回T，它是生產者(Producer)，要使用extends通配符;如果需要寫入T，它就是消費者(Consumer)，要使用super通配符。該原則可以指導我們在使用泛型時，該如何定義類型參數的上限和下限。
當我們使用泛型時，可能需要定義類型參數的上限和下限。例如，我們想要編寫一個方法來處理一些集合類型，但我們不知道這些集合中到底有什么類型的元素，此時我們就可以定義一個類型參數來處理所有的集合類型。一般我們可以利用extends來設置泛型上限，利用super來設置泛型下限。接下來小編會在下面的第5和第6小結中，給大家講解泛型的上限和下限具體該如何實現，請大家繼續往下學習。
5. 上限通配符(? extends T)
上限通配符(?extends T)是一種表示類型上限的通配符，其中T是一個類或接口，泛型類的類型必須實現或繼承 T這個接口或類。它指定了可以使用的類型上限，主要是用于限制輸入的參數類型。
import java.util.ArrayList;
import java.util.List;
/**
* @author 一一哥Sun
*/
public class Demo06 {
public static void main(String[] args) {
List<String> names = new ArrayList<String>();
List<Integer> ages = new ArrayList<Integer>();
List<Number> numbers = new ArrayList<Number>();
names.add("一一哥");
names.add("秦始皇");
ages.add(28);
ages.add(50);
ages.add(28);
numbers.add(100);
numbers.add(800);
//String等非Number類型就不行
//printElementUpbound(names);
//泛型值只能是Number及其子類類型,所以Integer/Double/Float等類型都可以，但String就不行
printElementUpbound(ages);
printElementUpbound(numbers);
}
//上限通配符的使用，這里的泛型值只能是Number及其子類類型
public static void printElementUpbound(List<? extends Number> data) {
for(int i=0;i<data.size();i++) {
//data.getClass().getSimpleName():用于獲取某個類的類名
System.out.println(data.getClass().getSimpleName()+"--data: " + data.get(i));
}
}
}在這個例子中，printElementUpbound方法中的集合泛型，可以是Number類或其子類，除此之外的其他類型都不行。也就是說，我們只能使用Number或其子類作為類型參數，泛型類型的上限是Number，這就是上限通配符的含義。
6. 下限通配符(? super T)
下限通配符(?super T)是一種表示類型下限的通配符，其中T是一個類或接口。它指定了可以使用的類型下限，主要用于限制輸出的參數類型。下面是一個簡單的例子：
import java.util.ArrayList;
import java.util.List;
/**
* @author 一一哥Sun
* V我領資料：syc_2312119590
* 各平臺都有小編的同名博客哦
*/
public class Demo07 {
public static void main(String[] args) {
List<String> names = new ArrayList<String>();
List<Integer> ages = new ArrayList<Integer>();
List<Double> numbers = new ArrayList<Double>();
names.add("一一哥");
names.add("秦始皇");
ages.add(28);
ages.add(50);
ages.add(28);
numbers.add(100.0);
numbers.add(800.9);
//String等非Number類型就不行
//printElementUpbound(names);
//此時Double類型也不行
//printElementDownbound(numbers);
//泛型值只能是Integer及其父類類型,所以Double/Float/String等類型都不可以
printElementDownbound(ages);
}
//下限通配符的使用，這里的泛型值只能是Integer及其父類類型
public static void printElementDownbound(List<? super Integer> data) {
for(int i=0;i<data.size();i++) {
System.out.println(data.getClass().getSimpleName()+"--data: " + data.get(i));
}
}
}在這個例子中，printElementDownbound方法中的集合泛型，可以是Integer或其父類型，即類型下限是Integer，除此之外的其他類型都不行。也就是說，我們只能使用Integer或其父類作為類型參數，泛型類型的下限是Integer，這就是下限通配符的含義。
7. 和的區別
在這里，小編要給大家再總結一下和的區別：
● 允許調用T get()這樣的讀方法來獲取T對象的引用，但不允許調用set(T)這樣的寫方法來傳入T的引用(傳入null除外);
● 允許調用set(T)這樣的寫方法傳入T對象的引用，但不允許調用T get()這樣的讀方法來獲取T對象的引用(獲取Object除外)。
● 即允許讀不允許寫，允許寫不允許讀。
大家注意，無論是未限定通配符、上限通配符還是下限通配符，我們既可以在方法中使用，也可以在類或接口中使用。
三. 泛型擦除
我們在學習泛型時，除了要掌握上面這些泛型類、泛型接口、泛型方法以及通配符等內容之外，還要學習泛型擦除的相關內容。那么什么是泛型擦除呢?我們繼續往下學習吧。
1.簡介
所謂的泛型擦除(Type Erasure)，就是指在編譯時，JVM編譯器會將所有的泛型信息都擦除掉，變成原始類型，一般是將泛型的類型參數替換成具體類型的上限或下限(如果沒有指定上界，則默認為Object)。
換句話說，雖然我們在代碼中使用了泛型，但在編譯后，所有的泛型類型都會被擦除掉，轉而使用其對應的原始類型。這就是Java泛型的底層實現原理。這樣設計的目的是為了兼容舊的JDK版本，使得Java具有了較好的向后兼容性，舊的非泛型代碼可以直接使用泛型類庫，而不需要進行任何修改。同時，Java也提供了反射機制來操作泛型類型，使得泛型類型在某些情況下還是可以被獲取到的，所以即使有泛型擦除，仍然也不會太影響Java虛擬機的運行時效率。
比如，在我們定義一個泛型類時，我們會使用泛型類型參數來代替具體的類型，好比下面這個例子：
public class Box<T> {
private T content;
public Box(T content) {
this.content = content;
}
public T getContent() {
return content;
}
public void setContent(T content) {
this.content = content;
}
}2.泛型擦除帶來的限制
在編譯之后，這個泛型類的類型參數T就會被擦除，成為其對應的原始類型Object。這也意味著，我們無法在運行時獲取到泛型的實際類型參數，所以泛型擦除的使用會有一些限制。首先由于泛型類型參數被擦除了，因此我們在運行時就無法獲得泛型類型參數的信息。例如，如果我們有一個List類型的變量，在運行時我們就無法獲得這個List集合中的元素類型是Integer。另一個限制是在使用泛型類型時，還需要注意類型安全性。在編譯階段，編譯器會檢查泛型類型的類型安全性;但在運行階段，由于泛型類型參數被擦除了，因此就無法保證類型安全性了。泛型擦除的限制，主要表現在以下幾個方面：
無法使用基本類型實例化類型參數;
無法在運行時獲取泛型類型信息;
泛型類型參數不能用于靜態變量或靜態方法;
不能實例化T類型。
接下來小編再給大家具體分析一下這些限制。
2.1 無法使用基本類型實例化類型參數
Java泛型中的類型參數不能是基本類型，只能是類或接口類型。例如，以下代碼在編譯階段會出錯，無法通過編譯：
List<int> list = new ArrayList<int>();正確的寫法是使用基本類型對應的包裝類型，如下所示：
List<Integer> list = new ArrayList<Integer>();2.2 無法在運行時獲取泛型類型信息
由于泛型擦除的存在，導致我們在程序運行時無法獲取泛型類型的信息。例如，以下代碼在運行時就無法獲取List的元素類型：
List<String> list = new ArrayList<String>();
Class<?> clazz = list.getClass();
Type type = clazz.getGenericSuperclass();
// 輸出：class java.util.ArrayList<E>
System.out.println(type); 在輸出的結果中，我們只能得到ArrayList的類型信息，而無法獲取到集合中具體的泛型類型信息，也就是獲取不到String的信息。但如果我們就是想在運行時獲取到泛型的實際類型參數，其實可以參考以下方式進行實現：
public class Box<T> {
private T content;
public Box(T content) {
this.content = content;
}
public T getContent() {
return content;
}
public void setContent(T content) {
this.content = content;
}
public Class<?> getContentType() {
return content.getClass();
}
}
在上面的代碼中，我們新增了一個方法 getContentType()，該方法用于返回泛型類型參數的實際字節碼類型，以后我們通過調用這個方法，就可以間接地獲取到泛型類型的信息了。
2.3 泛型類型參數不能用于靜態變量或靜態方法
由于泛型類型參數是在實例化對象時才被確定的，因此不能在靜態變量或靜態方法中使用泛型類型參數。例如，以下代碼是無法編譯通過的：
public class MyClass<T> {
//這樣的代碼編譯不通過
private static T value;
public static void setValue(T value) {
MyClass.value = value;
}
}正確的寫法是使用一個實際類型來代替泛型類型參數：
public class MyClass {
private static String value;
public static void setValue(String value) {
MyClass.value = value;
}
}2.4 不能實例化T類型
比如在下面的案例中：
public class MyClass<T> {
private T first;
private T last;
public MyClass() {
first = new T();
last = new T();
}
}上述代碼無法通過編譯，因為構造方法的兩行語句：
first = new T();
last = new T(); 擦拭后實際上變成了：
first = new Object();
last = new Object(); 這樣一來，創建new MyClass()和創建new MyClass()就變成了Object，編譯器會阻止這種類型不對的代碼。如果我們想對泛型T進行實例化，需要借助Class參數并集合反射技術來實現，且在使用時也必須傳入Class。
四. 結語
不過，盡管泛型擦除有一些限制，但泛型仍然不失為一種強大的編程工具，它可以提高代碼的可讀性和可維護性。通過合理地使用泛型，我們可以在編譯時進行類型檢查，避免類型轉換的錯誤和運行時異常，從而提高了代碼的安全性和可靠性。同時，我們也需要了解Java泛型擦除的限制，以便在實際應用中做出正確的決策。
京公網安備 11010802030320號