?
/* *作者：呆萌老師 *?csdn認證講師 *?51cto高級講師 *?騰訊課堂認證講師 *?網易云課堂認證講師 *?華為開發者學堂認證講師 *?愛奇藝千人名師計劃成員 *在這里給大家分享技術、知識和生活 *各種干貨，記得關注哦！ *vx：it_daimeng */
1. 概述
泛型在java中有很重要的地位，在面向物件編程及各種設計模式中有非常廣泛的應用，
什么是泛型？為什么要使用泛型？
泛型，即“引數化型別”，之前我們定義方法時有形參，然后呼叫此方法時傳遞實參，那么引數化型別怎么理解呢？顧名思義，就是將型別由原來的具體的型別引數化，類似于方法中的變數引數，此時型別也定義成引數形式（可以稱之為型別形參），然后在使用/呼叫時傳入具體的型別（型別實參），
泛型的本質是為了引數化型別（在不創建新的型別的情況下，通過泛型指定的不同型別來控制形參具體限制的型別），也就是說在泛型使用程序中，操作的資料型別被指定為一個引數，這種引數型別可以用在類、介面和方法中，分別被稱為泛型類、泛型介面、泛型方法，
2. 一個被舉了無數次的例子：
List arrayList = new ArrayList();
arrayList.add("aaaa");
arrayList.add(100);
for(int i = 0; i< arrayList.size();i++){
String item = (String)arrayList.get(i);
Log.d("泛型測驗","item = " + item);
}
毫無疑問，程式的運行結果會以崩潰結束：
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
ArrayList可以存放任意型別，例子中添加了一個String型別，添加了一個Integer型別，再使用時都以String的方式使用，因此程式崩潰了，為了解決類似這樣的問題（在編譯階段就可以解決），泛型應運而生，
我們將第一行宣告初始化list的代碼更改一下，編譯器會在編譯階段就能夠幫我們發現類似這樣的問題，
List<String> arrayList = new ArrayList<String>();
...
//arrayList.add(100); 在編譯階段，編譯器就會報錯
3. 特性
泛型只在編譯階段有效，看下面的代碼：
List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();
Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();
if(classStringArrayList.equals(classIntegerArrayList)){
Log.d("泛型測驗","型別相同");
}
輸出結果：D/泛型測驗: 型別相同，
通過上面的例子可以證明，在編譯之后程式會采取去泛型化的措施，也就是說Java中的泛型，只在編譯階段有效，在編譯程序中，正確檢驗泛型結果后，會將泛型的相關資訊擦出，并且在物件進入和離開方法的邊界處添加型別檢查和型別轉換的方法，也就是說，泛型資訊不會進入到運行時階段，
對此總結成一句話：泛型型別在邏輯上看以看成是多個不同的型別，實際上都是相同的基本型別，
4. 泛型的使用
泛型有三種使用方式，分別為：泛型類、泛型介面、泛型方法
4.3 泛型類
泛型型別用于類的定義中，被稱為泛型類，通過泛型可以完成對一組類的操作對外開放相同的介面，最典型的就是各種容器類，如：List、Set、Map，
泛型類的最基本寫法（這么看可能會有點暈，會在下面的例子中詳解）：
class 類名稱 <泛型標識：可以隨便寫任意標識號，標識指定的泛型的型別>{
private 泛型標識 /*（成員變數型別）*/ var;
.....
}
}
一個最普通的泛型類：
//此處T可以隨便寫為任意標識，常見的如T、E、K、V等形式的引數常用于表示泛型
//在實體化泛型類時，必須指定T的具體型別
public class Generic<T>{
//key這個成員變數的型別為T,T的型別由外部指定
private T key;
public Generic(T key) { //泛型構造方法形參key的型別也為T，T的型別由外部指定
this.key = key;
}
public T getKey(){ //泛型方法getKey的回傳值型別為T，T的型別由外部指定
return key;
}
}
//泛型的型別引數只能是型別別（包括自定義類），不能是簡單型別
//傳入的實參型別需與泛型的型別引數型別相同，即為Integer.
Generic<Integer> genericInteger = new Generic<Integer>(123456);
//傳入的實參型別需與泛型的型別引數型別相同，即為String.
Generic<String> genericString = new Generic<String>("key_vlaue");
Log.d("泛型測驗","key is " + genericInteger.getKey());
Log.d("泛型測驗","key is " + genericString.getKey());
泛型測驗: key is 123456
泛型測驗: key is key_vlaue
定義的泛型類，就一定要傳入泛型型別實參么？并不是這樣，在使用泛型的時候如果傳入泛型實參，則會根據傳入的泛型實參做相應的限制，此時泛型才會起到本應起到的限制作用，如果不傳入泛型型別實參的話，在泛型類中使用泛型的方法或成員變數定義的型別可以為任何的型別，
看一個例子：
Generic generic = new Generic("111111");
Generic generic1 = new Generic(4444);
Generic generic2 = new Generic(55.55);
Generic generic3 = new Generic(false);
Log.d("泛型測驗","key is " + generic.getKey());
Log.d("泛型測驗","key is " + generic1.getKey());
Log.d("泛型測驗","key is " + generic2.getKey());
Log.d("泛型測驗","key is " + generic3.getKey());
泛型測驗: key is 111111
泛型測驗: key is 4444
泛型測驗: key is 55.55
泛型測驗: key is false
注意：
泛型的型別引數只能是型別別，不能是簡單型別，
不能對確切的泛型型別使用instanceof操作，如下面的操作是非法的，編譯時會出錯，
if(ex_num instanceof Generic<Number>){
}
4.4 泛型介面
泛型介面與泛型類的定義及使用基本相同，泛型介面常被用在各種類的生產器中，可以看一個例子：
//定義一個泛型介面
public interface Generator<T> {
public T next();
}
當實作泛型介面的類，未傳入泛型實參時：
/**
* 未傳入泛型實參時，與泛型類的定義相同，在宣告類的時候，需將泛型的宣告也一起加到類中
* 即：class FruitGenerator<T> implements Generator<T>{
* 如果不宣告泛型，如：class FruitGenerator implements Generator<T>，編譯器會報錯："Unknown class"
*/
class FruitGenerator<T> implements Generator<T>{
@Override
public T next() {
return null;
}
}當實作泛型介面的類，傳入泛型實參時：
/**
* 傳入泛型實參時：
* 定義一個生產器實作這個介面,雖然我們只創建了一個泛型介面Generator<T>
* 但是我們可以為T傳入無數個實參，形成無數種型別的Generator介面，
* 在實作類實作泛型介面時，如已將泛型型別傳入實參型別，則所有使用泛型的地方都要替換成傳入的實參型別
* 即：Generator<T>，public T next();中的的T都要替換成傳入的String型別，
*/
public class FruitGenerator implements Generator<String> {
private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
@Override
public String next() {
Random rand = new Random();
return fruits[rand.nextInt(3)];
}
}
4.5 泛型通配符
我們知道Ingeter是Number的一個子類，同時在特性章節中我們也驗證過Generic<Ingeter>與Generic<Number>實際上是相同的一種基本型別，那么問題來了，在使用Generic<Number>作為形參的方法中，能否使用Generic<Ingeter>的實體傳入呢？在邏輯上類似于Generic<Number>和Generic<Ingeter>是否可以看成具有父子關系的泛型型別呢？
為了弄清楚這個問題，我們使用Generic<T>這個泛型類繼續看下面的例子：
public void showKeyValue1(Generic<Number> obj){
Log.d("泛型測驗","key value is " + obj.getKey());
}
Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);
showKeyValue(gNumber);
// showKeyValue這個方法編譯器會為我們報錯：Generic<java.lang.Integer>
// cannot be applied to Generic<java.lang.Number>
// showKeyValue(gInteger);
通過提示資訊我們可以看到Generic<Integer>不能被看作為`Generic<Number>的子類，由此可以看出:同一種泛型可以對應多個版本（因為引數型別是不確定的），不同版本的泛型類實體是不兼容的，
回到上面的例子，如何解決上面的問題？總不能為了定義一個新的方法來處理Generic<Integer>型別的類，這顯然與java中的多臺理念相違背，因此我們需要一個在邏輯上可以表示同時是Generic<Integer>和Generic<Number>父類的參考型別，由此型別通配符應運而生，
我們可以將上面的方法改一下：
public void showKeyValue1(Generic<?> obj){
Log.d("泛型測驗","key value is " + obj.getKey());
}
型別通配符一般是使用？代替具體的型別實參，注意了，此處’？’是型別實參，而不是型別形參 ，重要說三遍！此處’？’是型別實參，而不是型別形參 ！ 此處’？’是型別實參，而不是型別形參 ！再直白點的意思就是，此處的？和Number、String、Integer一樣都是一種實際的型別，可以把？看成所有型別的父類，是一種真實的型別，
可以解決當具體型別不確定的時候，這個通配符就是 ? ；當操作型別時，不需要使用型別的具體功能時，只使用Object類中的功能，那么可以用 ? 通配符來表未知型別，
4.6 泛型方法
一 泛型方法的介紹
如果定義類、介面是沒有使用型別形參，但定義方法時想自己定義型別形參，這也是可以的，JDK1.5還提供了泛型方法的支持，
泛型方法的語法格式為：
修飾符 <T , S> 回傳值型別 方法名(形參串列)
{
//方法體...
}
泛型方法的方法簽名比普通方法的方法簽名多了型別形參宣告，型別形參宣告以尖括號括起來，多個型別形參之間以逗號（,）隔開，所有型別形參宣告放在方法修飾符和方法回傳值型別之間，
二 泛型方法的正確使用
1 代碼示例
import java.util.*;
public class GenericMethodTest
{
// 宣告一個泛型方法，該泛型方法中帶一個T型別形參，
static <T> void fromArrayToCollection(T[] a, Collection<T> c)
{
for (T o : a)
{
c.add(o);
}
}
public static void main(String[] args)
{
Object[] oa = new Object[100];
Collection<Object> co = new ArrayList<>();
// 下面代碼中T代表Object型別
fromArrayToCollection(oa, co);
String[] sa = new String[100];
Collection<String> cs = new ArrayList<>();
// 下面代碼中T代表String型別
fromArrayToCollection(sa, cs);
// 下面代碼中T代表Object型別
fromArrayToCollection(sa, co);
Integer[] ia = new Integer[100];
Float[] fa = new Float[100];
Number[] na = new Number[100];
Collection<Number> cn = new ArrayList<>();
// 下面代碼中T代表Number型別
fromArrayToCollection(ia, cn);
// 下面代碼中T代表Number型別
fromArrayToCollection(fa, cn);
// 下面代碼中T代表Number型別
fromArrayToCollection(na, cn);
// 下面代碼中T代表Object型別
fromArrayToCollection(na, co);
// 下面代碼中T代表String型別，但na是一個Number陣列，
// 因為Number既不是String型別，
// 也不是它的子類，所以出現編譯錯誤
// fromArrayToCollection(na, cs);
}
}
2 代碼說明
與類、介面中使用泛型引數不同的是，方法中的泛型引數無需顯式傳入實際型別引數，因為編譯器根據實參推斷型別形參的值，它通常推斷出最直接的型別引數，例如：呼叫如下代碼，
fromArrayToCollection(sa, cs);
上面代碼中cs是一個Collection<String>型別，與方法定義時的fromArrayToCollection(T[] a, Collection<T> c)進行比較，只比較泛型引數，不能發現該T型別形參代表的實際型別是String型別，
三 泛型方法的錯誤使用
1 代碼示例
import java.util.*;
public class ErrorTest
{
// 宣告一個泛型方法，該泛型方法中帶一個T型別形參
static <T> void test(Collection<T> from, Collection<T> to)
{
for (T ele : from)
{
to.add(ele);
}
}
public static void main(String[] args)
{
List<Object> as = new ArrayList<>();
List<String> ao = new ArrayList<>();
// 下面代碼將產生編譯錯誤
test(as , ao);
}
}
2 運行結果
錯誤: 無法將類 ErrorTest中的方法 test應用到給定型別;
test(as , ao);
^
需要: Collection<T>,Collection<T>
找到: List<Object>,List<String>
原因: 推斷型別不符合等式約束條件
推斷: String
等式約束條件: String,Object
其中, T是型別變數:
T擴展已在方法 <T>test(Collection<T>,Collection<T>)中宣告的Object
1 個錯誤
3 代碼說明
上面程式中呼叫了test方法傳入了兩個實際引數，其中as的資料型別是List<String>,而ao的資料型別是List<Object>,與泛型方法簽名進行對比test(Collection<T> a,Collection<T> c)，編譯器無法正確識別T所代表實際型別，
四 改進上面這個例子
1 代碼示例
import java.util.*;
public class RightTest
{
// 宣告一個泛型方法，該泛型方法中帶一個T形參
static <T> void test(Collection<? extends T> from , Collection<T> to)
{
for (T ele : from)
{
to.add(ele);
}
}
public static void main(String[] args)
{
List<Object> ao = new ArrayList<>();
List<String> as = new ArrayList<>();
// 下面代碼完全正常
test(as , ao);
}
}
2 代碼說明
該代碼可以編譯通過，它改變了test簽名，將該方法的前一個形參型別改為Collection<? extends T>，這種采用型別通配符的表示方式，只要test方法的前一個Collection集合里的元素型別是后一個Collection集合里的元素型別的子類即可，
4.6 泛型上下邊界
在使用泛型的時候，我們還可以為傳入的泛型型別實參進行上下邊界的限制，如：型別實參只準傳入某種型別的父類或某種型別的子類，
1)? extends E 是 泛型 的上邊界
? extends E 的意思是： E 代表 父類 ， ？代表 子類 ， 所有父類E 可以 使用到的功能 E的所有的子類 都可以使用，如：addAll（? extends E）, addAll可以向集合中添加E類的物件元素，同時也可以向集合中添加 E類 所有子類的物件元素 ，
- ? Super E 是泛型的下邊界
? super E 的意思是： ? 代表 父類 ， E代表 子類 ， 代表可以使用E和E的父類
4.7 java泛型中<?>和<T>有什么區別
T 代表一種型別
加在類上:class SuperClass<A>{}
加在方法上:
public <T>void fromArrayToCollection(T[] a, Collection<T> c){}
方法上的<T>代表括號里面要用到泛型引數，若類中傳了泛型，此處可以不傳，呼叫型別上面的泛型引數，前提是方法中使用的泛型與類中傳來的泛型一致，
class People<T>{
public void show(T a) {
}
}
T extends T2 指傳的引數為T2或者T2的子型別，
?是通配符,泛指所有型別
一般用于定義一個參考變數,這么做的好處是,如下所示,定義一個sup的參考變數，就可以指向多個物件，
SuperClass<?> sup = new SuperClass<String>("lisi");
sup = new SuperClass<People>(new People());
sup = new SuperClass<Animal>(new Animal());
若不用?,用固定的型別的話，則：
SuperClass<String> sup1 = new SuperClass<String>("lisi");
SuperClass<People> sup2 = new SuperClass<People>("lisi");
SuperClass<Animal> sup3 = new SuperClass<Animal>("lisi");
這就是?通配符的好處，
? extends T 指T型別或T的子型別
? super T 指T型別或T的父型別
這個兩個一般也是和?一樣用在定義參考變數中，但是傳值范圍不一樣
T和？運用的地方有點不同,?是定義在參考變數上,T是類上或方法上
?
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/502220.html
標籤：其他
下一篇：函式的遞回