全文大約【6000】字，不說廢話，只講可以讓你學(xué)到技術(shù)、明白原理的純干貨!本文帶有豐富的案例及配圖視頻，讓你更好地理解和運用文中的技術(shù)概念，并可以給你帶來具有足夠啟迪的思考......

　　一. 泛型簡介

　　作為Java中常用且重要的一個概念，泛型幫我們實現(xiàn)了代碼重用，也保證了類型安全。但關(guān)于它的詳細(xì)內(nèi)容，目前很多同學(xué)還不清楚，所以接下來小編就帶各位來學(xué)習(xí)這個重要的知識點。

　　1.背景

　　為了能夠讓大家更好地理解泛型的作用，在我們開始學(xué)習(xí)泛型之前，小編先給大家提個開發(fā)需求：

　　我們現(xiàn)在有一個需求，要求你編寫一個對數(shù)組進(jìn)行排序的方法，該方法能夠?qū)Ω↑c型數(shù)組、整型數(shù)組、字符串?dāng)?shù)組或者是其他任何類型的數(shù)組進(jìn)行排序，你該如何實現(xiàn)?

　　有的小伙伴會說，這很簡單啊，我可以利用方法重載，針對每種類型的數(shù)組分別編寫一個排序方法，需要為幾種類型的數(shù)組排序，我就定義幾個排序方法。如果你是這么實現(xiàn)的，小編只能哈哈哈了，這種做法明顯不好，代碼可重用性太差。

　　又有的小伙伴說了，可以定義一個方法，里面設(shè)置一個Object[]類型的參數(shù)，這樣無論是哪種類型都可以處理了。這樣定義方法，比上面那個同學(xué)的想法要稍好一點，但此時我們需要在Object類型和整型、String類型或其他類型之間進(jìn)行強(qiáng)制類型轉(zhuǎn)換。所以這樣做就無法保證集合中元素的類型安全，稍一不慎就可能會導(dǎo)致ClassCastException類型轉(zhuǎn)換異常。

　　so，這也不行，那也不行，到底該怎么辦?這不，為了解決這些問題，所以Java中就產(chǎn)生了泛型這個技術(shù)。

　　2.概念

　　泛型(generics)這個技術(shù)是在JDK 5中引入的新特性，它的本質(zhì)其實是類型參數(shù)化，利用泛型可以實現(xiàn)一套代碼對多種數(shù)據(jù)類型的動態(tài)處理，保證了更好的代碼重用性。并且泛型還提供了編譯時對類型安全進(jìn)行檢測的機(jī)制，該機(jī)制允許我們在編譯時就能夠檢測出非法的類型，提高了代碼的安全性。

　　這種特性，使得泛型成了一種“代碼模板”，讓我們利用一套代碼就能實現(xiàn)對各種類型的套用。也就是說，我們只需要編寫一次代碼，就可以實現(xiàn)萬能匹配，這也是”泛型“這個概念的含義，你可以將其理解為”廣泛的類型“、”非特定的類型“。咱們上面的那個需求，利用泛型就能輕松實現(xiàn)，還不需要進(jìn)行類型的強(qiáng)制轉(zhuǎn)換，并且也保證了數(shù)據(jù)的類型安全。

　　3.作用

　　所以根據(jù)上面泛型的概念，我們可以提取出泛型的核心作用：

　　● 泛型可以在編譯時對類型進(jìn)行安全檢測，使得所有的強(qiáng)制轉(zhuǎn)換都是自動隱式實現(xiàn)的，保證了類型的安全性;

　　● 泛型作為”代碼模板“，實現(xiàn)了一套代碼對各種類型的套用，提高了代碼的可重用性。

　　4.使用場景

　　基于泛型的這些特性和作用，我們可以把泛型用在很多地方，小編在這里給大家做了一個總結(jié)，通常情況下，泛型可以用在如下場景中：

　　● 泛型集合：在各種集合中使用泛型，保證集合中元素的類型安全;

　　● 泛型方法：在各種方法中使用泛型，保證方法中參數(shù)的類型安全;

　　● 泛型類：在類的定義時使用泛型，為某些變量和方法定義通用的類型;

　　● 泛型接口：在接口定義時使用泛型，為某些常量和方法定義通用的類型;

　　● 泛型加反射：泛型也可以結(jié)合反射技術(shù)，實現(xiàn)在運行時獲取傳入的實際參數(shù)等功能。

　　但是我們要注意，無論我們在哪個地方使用泛型，泛型都不能是基本類型，關(guān)于這一點，我會在講解泛型擦除時再細(xì)說。

　　總之，泛型的應(yīng)用場景有很多，以上只是小編給大家總結(jié)的幾個重點使用場景，接下來小編就這幾個場景分別給大家進(jìn)行講解。

　　二. 泛型集合

　　1.簡介

　　泛型最常見的一個用途，就是在集合中對數(shù)據(jù)元素的類型進(jìn)行限定。集合作為一個容器，主要是用來容納保存數(shù)據(jù)元素的，但集合的設(shè)計者并不知道我們會用集合來保存什么類型的對象，所以他們就把集合設(shè)計成能保存任何類型的對象。這就要求集合具有很好的通用性，內(nèi)部可以裝載各種類型的數(shù)據(jù)元素。集合之所以可以實現(xiàn)這一功能，主要是集合的源碼中已經(jīng)結(jié)合泛型做了相關(guān)的設(shè)計，我們來看看Collection的源碼，如下圖所示：

　　而Collection的子類List中也增加了對泛型的支持，如下圖所示：

　　上面的源碼中，集合中的就是泛型，至于泛型的名字為什么叫做”E“，后面小編再跟大家細(xì)說。但不管如何，從這些源碼中我們就可以看出，Java的集合本身就支持泛型了。我們先不管集合底層是如何設(shè)計的，咱們先從基本用法開始學(xué)起。

　　2. 語法

　　在集合中使用泛型其實比較簡單，我們以List集合為例，其基本語法如下：　

//可以省略后面ArrayList里的String，編譯器可以自動根據(jù)前面<>里的類型，推斷出后面<>里使用的泛型類型
List<String> list = new ArrayList<>();

　　上面的語法，其含義是說我們定義了一個ArrayList集合，但該集合不能隨便添加數(shù)據(jù)元素，只能添加String類型的元素。也就是說，在上面的語法中，我們通過泛型，限定了ArrayList集合的元素類型。當(dāng)我們定義List集合時，如果已經(jīng)限定了泛型類型，但后面添加元素時你非得違背這個類型，Java就會在編譯階段報錯，如下圖所示：

　　我們在定義集合時，可以省略后面ArrayList里的String，編譯器可以自動根據(jù)前面<>里的類型，推斷出后面<>里使用的泛型類型。另外Set和Map集合的用法，與List集合類似，我們可以通過下面這個案例來體會一下集合泛型的魅力。

　　3. 代碼案例

　　在本案例中，我們可以給List、Set、Map等集合設(shè)置泛型，從而限定集合中數(shù)據(jù)元素的類型。　

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @author 一一哥Sun
 */
public class Demo01 {
    public static void main(String[] args) {
        //定義集合泛型
        //此時的集合只能接受String類型元素，后面ArrayList<>中的<>，里面的String可寫可不寫
        List<String> list = new ArrayList<>();
        //如果類型不一致，在編譯階段就會檢測出有錯誤，保證了數(shù)據(jù)的安全性
        //list.add(100);
        list.add("Hello");
        String strValue = list.get(0);
        System.out.println("list value="+strValue);
        
        Set<Integer> set=new HashSet<>();
        //set.add("hello");
        set.add(200);
        Iterator<Integer> iterator = set.iterator();
        while(iterator.hasNext()) {
            Integer nextValue = iterator.next();
            System.out.println("set value="+nextValue);
        }
        
        //限定Map集合的key是String類型，value是Long類型
        Map<String,Long> map=new HashMap<>();
        //map.put("number", "10000");
        map.put("number", 10000L);
        Long value = map.get("number");
        System.out.println("map value="+value);
    }
}

　　在這個案例中，我們在集合中通過泛型限定了集合元素的數(shù)據(jù)類型。如果元素的類型與要求的不一致，在編譯階段就會檢測出有錯誤，不需要進(jìn)入到運行階段才能發(fā)現(xiàn)類型不一致。而且我們在獲取集合中的元素時，也不需要進(jìn)行強(qiáng)制類型轉(zhuǎn)換，程序會自動進(jìn)行隱式轉(zhuǎn)換，這就保證了數(shù)據(jù)的安全性，也提高了代碼的執(zhí)行效率。

　　另外我們所使用的泛型參數(shù)，也被稱為類型變量，是用于指定泛型類型名稱的標(biāo)識符。我們可以根據(jù)需要，在集合、類、接口、方法等地方定義一個或多個泛型參數(shù)，這些泛型化的類型參數(shù)也被稱為參數(shù)化的類或參數(shù)化的類型。

　　三. 泛型接口

　　我們除了可以在集合中使用泛型，還可以在定義接口時使用泛型，這也是泛型的常用形式之一。

　　1.語法

　　在定義接口時使用泛型的基本語法格式如下：　　

//在接口名稱后面緊跟泛型<>
public interface InterfaceName<T> {
    // 接口的方法定義
}

//可以同時定義多個泛型，多個泛型用","逗號分割
public interface InterfaceName2<M,N> {
    // 接口的方法定義
}

　　大家注意，這里泛型的名稱T/M/N，其實是我們隨意寫的，我們并不一定非要使用T，也可以使用M、N、E等任意名稱。而之所以使用T，只是采用了Type類型這個單詞的首字母而已。雖然如此，但我們在實際開發(fā)時，為了盡量做到見名知意，請大家還是要盡量采用有意義的名稱，通常會使用如下幾個常用字母：

　　● E - Element(表示集合元素，常在集合中使用);

　　● T - Type(表示Java類，常用在類和接口中);

　　● K - Key(表示鍵);

　　● V - Value(表示值);

　　● N - Number(表示數(shù)值類型);

　　● ? - 表示不確定的Java類型。

　　另外，這里的T只是一種類型參數(shù)，你可以把它理解成是一個”表面的占位符“。在真正賦值時，它可以用任何實際的類型來替代，如Integer、String、自定義類型等。并且我們在定義接口時，可以根據(jù)實際需要，同時定義多個泛型，多個泛型之間用","逗號分割。而在實際使用時，我們需要在該接口名的后面加上一對尖括號，用來傳入實際的類型。

　　2. 代碼案例

　　2.1 定義泛型接口

　　接下來我們再通過一個案例來學(xué)習(xí)一下接口泛型如何使用，這里我們定義一個泛型接口ICompute，內(nèi)部定義了一個用于計算的方法，如下所示：　

/**
 * 定義一個用于計算的接口
 */
public interface ICompute<M,N> {

    //定義一個加法計算的方法
    M add(M m,N n);
}

　　2.2 實現(xiàn)泛型接口

　　接下來我們把這個接口進(jìn)行實現(xiàn)，代碼如下：　

public class Demo02 {
    public static void main(String[] args) {
        //這里壹哥直接利用匿名內(nèi)部類的寫法進(jìn)行實現(xiàn)，大家也可以編寫一個類實現(xiàn)ICompute接口
        //我這里傳入了兩個Integer類型的具體參數(shù)，分別取代M和N
        ICompute<Integer, Integer> iCompute = new ICompute<Integer, Integer>() {
            @Override
            public Integer add(Integer m, Integer n) {
                return m+n;
            }
        };
        
        //調(diào)用上面實現(xiàn)的方法
        Integer result = iCompute.add(100, 200);
        System.out.println("result="+result);
    }
}

　　這里小編直接利用匿名內(nèi)部類的寫法進(jìn)行實現(xiàn)，大家也可以編寫一個類實現(xiàn)ICompute接口。我這里傳入了兩個Integer類型的具體參數(shù)，分別取代M和N，當(dāng)然我們也可以根據(jù)需要，在實現(xiàn)時傳入Float/Double等其他類型。

　　四. 泛型類

　　其實Java的類和接口在很多地方都很類似，所以我們在定義接口時可以使用泛型，也可以在定義類時使用泛型，泛型類常用于類中的屬性類型不確定的情況下，這也是泛型的常用形式之一。

　　1.語法

　　其實泛型類的聲明和普通類的聲明類似，只是在類名后面多添加了一個關(guān)于泛型的聲明。并且泛型類的類型參數(shù)部分，可以包含一個或多個類型參數(shù)，多個參數(shù)間用逗號隔開。一般我們在定義泛型類時，需要在類名后添加類型參數(shù)，語法格式與泛型接口一致，如下所示：　　

public class ClassName<T> {
    // 類的成員變量和方法定義
}

　　泛型類的要求和泛型接口完全一樣，這里小編就不再贅述了。

　　2. 代碼案例

　　2.1 定義泛型類

　　接下來小編定義一個泛型類Pair，它包含兩個類型相同的成員變量：　

public class Pair<T> {

    //我們可以直接把泛型當(dāng)成一個java的“類型”來用，Java類怎么用，泛型就可以怎么用
    //直接利用泛型來定義成員變量
    private T first;
    private T second;

    //構(gòu)造方法中使用泛型
    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    //方法中使用泛型
    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }
}

　　在上述代碼中，我們定義了一個泛型類Pair，它有兩個類型相同的成員變量first和second，以及一個構(gòu)造函數(shù)和兩個訪問成員變量的方法。在定義Pair類時，我們使用了類型參數(shù)T來代表類型，而在實例化該泛型類時，需要指明泛型類中的類型參數(shù)，并賦予泛型類屬性相應(yīng)類型的值，比如指定T是String/Integer/Student/Person等任意類型。

　　2.2 使用泛型類

　　接下來是使用Pair類的具體代碼：　

public class Demo03 {
    public static void main(String[] args) {
        //調(diào)用泛型類
        Pair<String> pair = new Pair<>("Hello", "World");
        // 輸出 "Hello"
        System.out.println("first="+pair.getFirst()); 
        // 輸出 "World"
        System.out.println("last="+pair.getSecond()); 
    }
}

 　　在上述代碼中，我們使用了Pair類，并將類型參數(shù)指定為String類型。然后我們創(chuàng)建了一個Pair對象，并通過getFirst和getSecond方法訪問了成員變量。

　　五. 繼承泛型類和實現(xiàn)泛型接口

　　在Java中，泛型不僅可以用于類、方法的定義，還可以用于類和接口的繼承與實現(xiàn)。接下來小編就給大家詳細(xì)介紹一下，該如何繼承泛型類和實現(xiàn)泛型接口。

　　1.簡介

　　大家要注意，一個被定義為泛型的類和接口，也可以被子類繼承和實現(xiàn)。例如下面的示例代碼，就給大家演示了如何繼承一個泛型類。　

public class FatherClass<T1>{}

public class SonClass<T1,T2,T3> extents FatherClass<T1>{}

　　但是如果我們想要SonClass類在繼承FatherClass類時，能夠保留父類的泛型類型，則需要在繼承時就指定。否則直接使用extends FatherClass語句進(jìn)行繼承操作時，T1、T2 和 T3都會自動變?yōu)镺bject類型，所以一般情況下都是將父類的泛型類型保留。

　　接下來小編會分別給大家介紹一下如何繼承泛型類和實現(xiàn)泛型接口。

　　2. 繼承泛型類

　　2.1 定義泛型父類

　　在Java中，我們可以通過繼承一個泛型類來實現(xiàn)泛型的重用。子類可以繼承父類中定義的泛型類型，并根據(jù)自己的需要，增加、修改泛型類型的參數(shù)，從而實現(xiàn)泛型類的個性化定制。下面是一個泛型類的示例：　　

/**
 * 泛型類
 */
public class GenericClass<T1> {

    private T1 data;

    public GenericClass(T1 data) {
        this.data = data;
    }

    public T1 getData() {
        return data;
    }
}

　　2.2 泛型子類繼承父類

　　我們可以通過繼承GenericClass類，來創(chuàng)建一個新的泛型類SonGenericClass，并增加新的泛型類型：　

/**
 * 泛型類
 */
public class SonGenericClass<T1,T2> extends GenericClass<T1>{

    private T2 otherData;
    
    public SonGenericClass(T1 data, T2 otherData) {
        super(data);
        this.otherData = otherData;
    }
    
    public T2 getOtherData() {
        return otherData;
    }
}

　　在上面的示例中，SonGenericClass類繼承了GenericClass類，并增加了一個新的泛型類型T2。在構(gòu)造方法中，調(diào)用父類的構(gòu)造方法，并傳入T1類型的數(shù)據(jù)，然后再將T2類型的數(shù)據(jù)賦值給類的成員變量otherData。通過這種方式，我們可以創(chuàng)建一個具有更多泛型參數(shù)的類，并且保留了原始泛型類的特性。我們來看看最終的測試結(jié)果：　

public class Demo08 {

    public static void main(String[] args) {
        SonGenericClass<Integer,String> son=new SonGenericClass<>(100, "hello");
        //子類從父類中繼承來的泛型
        Integer data = son.getData();
        String otherData = son.getOtherData();
        System.out.println("t1---data="+data+",t2---data="+otherData);
    }
}

　　這樣，子類通過繼承父類，也自動獲得了父類中的泛型。

　　3. 實現(xiàn)泛型接口

　　3.1 定義泛型接口

　　類似于繼承泛型類，我們也可以通過實現(xiàn)泛型接口，來定義具有多個泛型參數(shù)的接口。實現(xiàn)泛型接口的過程與實現(xiàn)普通接口的過程相同，我們只需要在接口名后面添加這樣的泛型參數(shù)聲明即可。下面是一個泛型接口的示例：　

/**
 * 
 * 定義泛型接口
 */
public interface GenericInterface<T1> {
    
    public void doSomething(T1 data);
}

　　3.2 兩種實現(xiàn)方式

　　我們在實現(xiàn)泛型接口時，可以采用兩種實現(xiàn)方式：

　　指定具體類型：就是在實現(xiàn)接口時，明確指定泛型參數(shù)的具體類型;

　　保留泛型參數(shù)：在實現(xiàn)接口時，不明確指定泛型參數(shù)的具體類型，而是保留泛型參數(shù)。

　　如果是通過指定具體類型的方式進(jìn)行實現(xiàn)，一般形式如下：　

public class StringPair implements Pair<String> {
    .....
}

　　在這種方式中，我們定義了一個Pair接口，然后讓子類StringPair進(jìn)行實現(xiàn)，但在實現(xiàn)時就明確指定了具體的泛型參數(shù)為String。這樣，我們在使用StringPair對象時，就明確知道了類內(nèi)部的數(shù)據(jù)類型。

　　如果是通過保留泛型參數(shù)的方式進(jìn)行實現(xiàn)，一般形式如下：　　

public class NumberPair<T extends 父類型> implements Pair<T> {
    ......
}

　　在這種方式中，我們定義了一個泛型接口Pair，然后定義一個實現(xiàn)字類NumberPair，可以在實現(xiàn)時保留泛型參數(shù)。

　　3.3 實現(xiàn)泛型接口

　　接下來，我們再編寫一個SubGenericInterface類，并通過保留泛型參數(shù)的方式，來實現(xiàn)GenericInterface接口，并增加一個新的泛型類型T2，代碼如下：　

public class SubGenericClass<T1,T2> implements GenericInterface<T1>{

    private T2 otherData;
    
    @Override
    public void doSomething(T1 data) {
        System.out.println("t1="+data);
    }
    
    public SubGenericClass(T2 otherData) {
        this.otherData = otherData;
    }
    
    public T2 getOtherData() {
        return otherData;
    }

}

 　  這樣泛型子類就實現(xiàn)了泛型父類，并在子類中增加了一個新的泛型，最終的結(jié)果如下所示：　

public class Demo09 {

    public static void main(String[] args) {
        SubGenericClass<Integer,String> sub=new SubGenericClass<>("hello");
        sub.doSomething(100);
        String otherData = sub.getOtherData();
        System.out.println("t2---data="+otherData);
    }
}

　　其實，實現(xiàn)泛型接口和繼承泛型類都很簡單，我們只需要在類定義中使用相同的泛型類型參數(shù)，然后實現(xiàn)接口的方法或覆蓋超類的方法即可。

　　以上就是關(guān)于泛型的概念、作用、泛型接口、泛型類等相關(guān)的內(nèi)容，其實泛型的內(nèi)容還有很多，比如泛型方法、泛型擦除和泛型中的通配符等。但受限于篇幅，小編會在下一篇文章中繼續(xù)給大家講解這些內(nèi)容，敬請繼續(xù)關(guān)注哦。

　　五. 結(jié)語

　　至此，在本文中小編就把泛型的概念、作用、泛型接口和泛型類給大家介紹完了，本文重點內(nèi)容如下：

　　● 泛型是一種類型參數(shù)，可以編寫模板代碼來適應(yīng)任意類型;

　　● 泛型在使用時不必對類型進(jìn)行強(qiáng)制轉(zhuǎn)換，它可以通過編譯器在編譯階段對類型進(jìn)行檢查;

　　● 使用泛型時可以把泛型參數(shù)替換成想要的class類型，例如ArrayList，ArrayList等;

　　● 編譯器可以根據(jù)前面的泛型，在后面自動推斷出類型，例如List list = new ArrayList<>();

　　● 如果我們在使用時不指定泛型參數(shù)類型時，編譯器會給出警告，且只能將視為Object類型;

　　● 我們可以在接口和類中定義泛型類型，實現(xiàn)此接口的類必須傳入正確的泛型類型;

　　● 我們可以同時定義多個泛型，例如Map;

　　● 可以繼承泛型類和實現(xiàn)泛型接口。