一、泛型的必要性

【1.1】沒(méi)有泛型之前

在說(shuō)明為什么有泛型之前痴晦，我們先看一段代碼

List AList = new ArrayList();
//編譯通過(guò)南吮，運(yùn)行不報(bào)錯(cuò)
A.add(new B());
//編譯通過(guò)，運(yùn)行報(bào)錯(cuò)
A a = (A) A.get(0);

這段代碼誊酌，現(xiàn)在已經(jīng)很少看到了部凑。但實(shí)際上在Java1.5之前，這是很經(jīng)常寫(xiě)的代碼碧浊，也很容易犯錯(cuò)的代碼涂邀。在上面的代碼中，我們聲明了一個(gè)不知道儲(chǔ)存什么類(lèi)型的List箱锐。雖然我們通過(guò)變量名“AList”來(lái)代表這個(gè)List是存比勉，取A類(lèi)型的集合。但是我們?nèi)匀豢梢詫類(lèi)型的對(duì)象存進(jìn)去。而且取出來(lái)的時(shí)候，我們還需要進(jìn)行類(lèi)型強(qiáng)轉(zhuǎn)颅拦。這就帶來(lái)了兩個(gè)問(wèn)題：

1. 我們無(wú)法在儲(chǔ)存的時(shí)候，就限定輸入的類(lèi)型衣洁。導(dǎo)致可能存入其他類(lèi)型導(dǎo)致CastClassException。
2. 集合元素取出來(lái)的時(shí)候抖仅，我們明明知道是A類(lèi)型的坊夫，但是每次還是都要進(jìn)行一次強(qiáng)轉(zhuǎn)毙替。

出現(xiàn)這問(wèn)題的原因根本在于，ArrayList()底層是使用Object[]實(shí)現(xiàn)的践樱。這樣設(shè)計(jì)的本意是可以讓ArrayList更加的通用，適用于一切類(lèi)型凸丸。

【1.2】有了泛型之后

在了解了上面的需求和痛點(diǎn)后拷邢，我們可以很自然的想起泛型。它可以讓類(lèi)型參數(shù)化屎慢。在引入泛型后瞭稼。上面的代碼我們可以這樣寫(xiě)：

List<A> AList = new ArrayList();
//編譯不通過(guò)。
A.add(new B());
//不再需要強(qiáng)轉(zhuǎn)
A a = A.get(0);

可以看到腻惠，在引入了泛型后环肘，在編譯時(shí)就能進(jìn)行類(lèi)型檢查。但是ArrayList底層實(shí)現(xiàn)還是使用Object[]的集灌，為什么可以不用進(jìn)行類(lèi)型強(qiáng)轉(zhuǎn)呢悔雹？
我們可以看一下ArrayList.get()方法：

ArrayList.java

transient Object[] elementData;
public E get(int index) {
    rangeCheck(index);
    return elementData(index);
}

E elementData(int index) {
    return (E) elementData[index]; //內(nèi)部進(jìn)行類(lèi)型強(qiáng)轉(zhuǎn)
}

【1.3】泛型的必要性總結(jié)

到這里，我們總結(jié)一下引入泛型的好處：

1. 類(lèi)型安全：編譯器可以在編譯時(shí)期就對(duì)類(lèi)型錯(cuò)誤的存取報(bào)錯(cuò)欣喧。
2. 類(lèi)型參數(shù)化腌零，可以寫(xiě)出更加通用的代碼。
3. 簡(jiǎn)化代碼唆阿。
4. 可以自動(dòng)進(jìn)行類(lèi)型轉(zhuǎn)化益涧，獲取數(shù)據(jù)是可以不用進(jìn)行類(lèi)型強(qiáng)轉(zhuǎn)

二、泛型的實(shí)現(xiàn)：類(lèi)型擦除

【2.1】泛型的實(shí)際實(shí)現(xiàn)

其實(shí)關(guān)于泛型的背后實(shí)現(xiàn)驯鳖，我們?cè)谏厦嬗姓f(shuō)到了一些闲询。為了更加深刻的體會(huì)他是通過(guò)類(lèi)型擦除的方式來(lái)實(shí)現(xiàn)泛型的，我們看一下如下代碼的字節(jié)碼：

//沒(méi)有加泛型
ArrayList list = new ArrayList();
//加了泛型
ArrayList<A> AList = new ArrayList();

字節(jié)碼：

//ArrayList list = new ArrayList();
0:  new               #2
3:  dup
4:  invokespecial     #3
7:  astore+1
//ArrayList<A> AList = new ArrayList();
8:  new               #2
11: dup          
12: invokespecial     #3
15: astore_2

可以看到浅辙，ArrayList無(wú)論有沒(méi)有加泛型扭弧，它的字節(jié)碼都是一樣的。那么它是怎么保證我們?cè)谝凰f(shuō)的泛型帶來(lái)的特性呢摔握？其實(shí)類(lèi)型檢查可以通過(guò)編譯器檢查來(lái)實(shí)現(xiàn)寄狼。而類(lèi)型自動(dòng)轉(zhuǎn)化就如我們上面看到的一樣，通過(guò)泛型類(lèi)內(nèi)部強(qiáng)轉(zhuǎn)實(shí)現(xiàn)氨淌。

【2.2】為什么采用類(lèi)型擦除實(shí)現(xiàn)泛型泊愧？

在了解了泛型的實(shí)現(xiàn)機(jī)制以后，我們反過(guò)來(lái)思考一下盛正，Java為什么采用類(lèi)型擦除的方式來(lái)實(shí)現(xiàn)泛型删咱。答案是：向后兼容。 我們知道向后兼容是Java一強(qiáng)調(diào)的一大特性豪筝，而在Java1.5之前痰滋，還沒(méi)有出現(xiàn)泛型的時(shí)期摘能，必然出現(xiàn)了大量如下代碼：

ArrayList list = new ArrayList();

而類(lèi)型擦除的方式實(shí)現(xiàn)泛型，我們可以看到其編譯出來(lái)的字節(jié)碼敲街，和1.5之前的是一樣的团搞，可以說(shuō)是完全兼容。然后泛型的一些特性通過(guò)編譯器和對(duì)現(xiàn)有集合框架類(lèi)的改造實(shí)現(xiàn)多艇。那Kotlin號(hào)稱(chēng)是可以完全兼容Java的逻恐，所以Kotlin的泛型實(shí)現(xiàn)方式當(dāng)然也是和Java一樣的了。

【2.3】泛型類(lèi)型的獲取

通過(guò)上面中我們知道峻黍，為了是提升代碼的通用型复隆，我們使用泛型使類(lèi)型參數(shù)化，抹去了不同類(lèi)型帶來(lái)的差異姆涩。但是在我們編碼過(guò)程中挽拂，我們時(shí)常需要在運(yùn)行中獲取對(duì)象類(lèi)型，而經(jīng)過(guò)類(lèi)型擦除的泛型類(lèi)骨饿，已經(jīng)失去了類(lèi)型參數(shù)的信息亏栈，那么我們有什么辦法可以運(yùn)行中獲取這個(gè)類(lèi)型參數(shù)嗎⊙ⅲ或許我們可以通過(guò)手動(dòng)指定的方式獲取仑扑。具體的代碼如下：

open class A<T>(val data: T, val clazz: Class<T>) {

    fun getType() {
        println(clazz)
    }

}

總結(jié)：這種方式獲取泛型類(lèi)型參數(shù)難免麻煩了一點(diǎn)，而且它不能獲取一個(gè)獲取一個(gè)泛型類(lèi)型置鼻。比如：

//編譯不同過(guò)镇饮，報(bào)錯(cuò)
Class clazz = ArrayList<String>.class

那么我們有沒(méi)有辦法獲取一個(gè)泛型類(lèi)型呢，答案是有的：

【2.3.1】利用匿名內(nèi)部類(lèi)獲取泛型類(lèi)型

val listA = new ArryaList<A>()
val listA2 = object : ArrayList<A>(){}

println(listA.javaClass.genericSuperclass)
println(lstA2.javaClass.genericSuperclass)

//打踊浮：
java.util.AbstractList<E>
java.util.ArrayList<java.lang.String>

總結(jié)：我們發(fā)現(xiàn)储藐，第二種我們可以獲取到list是一個(gè)什么樣的類(lèi)型。而第二種就是聲明了一個(gè)匿名內(nèi)部類(lèi)嘶是。但是為什么匿名內(nèi)部類(lèi)就能獲取到lis泛型參數(shù)的類(lèi)型呢钙勃？其實(shí)類(lèi)型擦除并不是真的將全部的類(lèi)型信息都擦除了，還是會(huì)將類(lèi)型信息放在對(duì)于的class的常量池中的聂喇。

所以我們可以嘗試設(shè)計(jì)出獲取所有類(lèi)型信息的泛型類(lèi)辖源。

open class GenericsToken<T> {
    var type: Type = Any::class.java
    init {
        val superClass = this.javaClass.gnericSuperclass
        type = superClass as ParameterizedType).getActualTypeArguments()[0]
    }
}


fun test() {
    val gt = object : GenericsToken<Map<String, String>>(){}
    println(gt.type)
}

//打印結(jié)果
java.util.Map<java.lang.String, ? extends java.lang.String>

總結(jié)：匿名內(nèi)部類(lèi)在初始化的時(shí)候，綁定父類(lèi)或父類(lèi)接口的相應(yīng)信息希太，這樣可以通過(guò)獲取父類(lèi)或父借口的父接口的泛型類(lèi)型信息來(lái)獲取我們想要的泛型類(lèi)型克饶。其實(shí)常用的Gson框架也是采用這樣的方式獲取的。

val json = new Json("...")
val type = object : TypeToken<List<String>>(){}.type
val stringList = Gson().fromJson<List<String>>(json.type)

【2.3.2】使用 Kotlin 的 reified 關(guān)鍵字獲取泛型類(lèi)型

我們知道Kotlin的內(nèi)聯(lián)函數(shù)是在編譯的時(shí)候誊辉，編譯器把內(nèi)聯(lián)函數(shù)的字節(jié)碼直接插入到調(diào)用的地方矾湃，所以參數(shù)類(lèi)型也會(huì)被插入到字節(jié)碼中。而在內(nèi)聯(lián)函數(shù)中獲取泛型的參數(shù)類(lèi)型也非常簡(jiǎn)單堕澄，只需要加上reified關(guān)鍵字就可以邀跃。

inline fun <reified T> getType(): T {
    return T::class.java
}

三霉咨、類(lèi)型約束。

我們前面說(shuō)的泛型時(shí)拍屑，講到其中一個(gè)特性就是類(lèi)型安全途戒，其實(shí)也就是說(shuō)泛型本身帶有類(lèi)型的約束力。那么這里講的類(lèi)型約束是什么意思呢僵驰。其實(shí)就是對(duì)泛型的約束棺滞。在Java中看我們會(huì)看到如下代碼：

class Test<T extends B> {
...    
}

通過(guò)在T后面加了extends B約束了這個(gè)泛型必須是B的子類(lèi)。那么在Kotlin中矢渊，繼承是用：表示的，所以Kotlin的泛型約束如下：

class Test<T: B>{
    
}

但是枉证，如果我們需要多個(gè)約束呢矮男？在Kotlin中可以使用 where 關(guān)鍵字來(lái)實(shí)現(xiàn)這個(gè)需求如下：

class Test<T> where T: A, T: B{

}

利用where關(guān)鍵字，我們可以約束泛型T必須是A和B的子類(lèi)室谚。

四毡鉴、泛型的變形：協(xié)變和逆變

【4.1】協(xié)變

講義：如果類(lèi)型A是類(lèi)型B的子類(lèi)型，那么Generic<A>也是Generic<B>的子類(lèi)秒赤，這就是協(xié)變猪瞬。
在kotlin中，我們要實(shí)現(xiàn)這種關(guān)系入篮，可以通過(guò)在泛型類(lèi)或者泛型方法的泛型參數(shù)前面加 out 關(guān)鍵字陈瘦。如下：

//定義實(shí)體類(lèi)關(guān)系
open class Flower
class WhiteFlower: Flower(){}
class ReaFlower: Flower(){}

//生產(chǎn)者
interface Product<out T> {
     fun produce(): T
}

class WhiteFlowerProduct<WhiteFlower> {
    //將泛型類(lèi)型作為返回
    override fun produce(): WhiteFlower {
       return WhileFlower();
    }
}

//如下編譯通過(guò)
val product: Product<Flower> = WhiteFLowerProduct()

總結(jié)：可以看到，WhiteFLowerProduct()可以賦值給Product<Flower> 類(lèi)型變量潮售，就是因?yàn)橥ㄟ^(guò)out指明了協(xié)變關(guān)系痊项。而且我們也看到，泛型類(lèi)型做為返回類(lèi)型酥诽，被生產(chǎn)出來(lái)鞍泉。那么如果我們添加一個(gè)泛型類(lèi)型的對(duì)象呢？如下：

interface Product<out T> {
    fun produce(): T
    //編譯器報(bào)錯(cuò)
    fun add(t: T)
}

class WhiteFlowerProduct<WhiteFlower> {
    //將泛型類(lèi)型作為返回
    override fun produce(): WhiteFlower {
       return WhileFlower();
    }
    
    override fun add(flower: WhiteFlower){
       return WhileFlower();
    }
}

結(jié)果是編譯器報(bào)錯(cuò)：Type parameter T is declare as 'out' but occurs in 'in' position in type T肮帐。翻譯過(guò)來(lái)就是被聲明為out的類(lèi)型T不能出現(xiàn)在輸入的位置咖驮。其實(shí)我們通過(guò)'out'關(guān)鍵字也可以知道，被其修飾的泛型只能作為生產(chǎn)者輸出训枢，而不能作為消費(fèi)者輸入托修。所以'out'修飾的泛型常常作為方法的返回而使用。這就是協(xié)變帶來(lái)的限制肮砾。那么協(xié)變?yōu)槭裁床荒茌斎肽鼐魇颉Ｎ覀兛梢圆捎梅醋C法來(lái)理解：假如可以添加，那么會(huì)發(fā)生什么事仗处？

val flowerProduct: Product<Flower> = WhiteFLowerProduct()
//編譯不出錯(cuò)眯勾，但是運(yùn)行時(shí)會(huì)出現(xiàn)類(lèi)型不兼容錯(cuò)誤枣宫。
flowerProduct.add(ReaFlower())

其在Java中，相對(duì)應(yīng)的泛型協(xié)變我們是這樣定義的：<? extends Object> 但是這一不便理解的泛型協(xié)變定義在Kotlin上被改進(jìn)成用out關(guān)鍵字吃环，更加能體現(xiàn)其協(xié)變只讀不可寫(xiě)的特性也颤。

【4.2】逆變

定義：如果類(lèi)型A是類(lèi)型B的子類(lèi)型，反過(guò)來(lái)Generic<B>是Generic<A>的子類(lèi)型郁轻，我們稱(chēng)這種關(guān)系為逆變翅娶。在Kotlin中，我們用'in'關(guān)鍵字來(lái)聲明逆變泛型好唯。如下例子：

val numberComparator = Comparator<Number> {
    n1, n2 -> n1.toDouble.compareTo(n2.toDouble())
}

val daoubleList = mutableListOf(2.0, 3.0)
//針對(duì)Double數(shù)據(jù)類(lèi)型竭沫，我們使用Number類(lèi)型的Comparator
doubleList.sortWith(numberComparator)

val intList = mutableListof(1, 2)
//針對(duì)Int數(shù)據(jù)類(lèi)型，我們?nèi)匀皇褂肗umber 類(lèi)型的Comparator
intList.sortWith(numberComparator)

//可以看到這里對(duì)泛型T骑篙，使用了in關(guān)鍵字蜕提。
public fun <T> MutableList<T>.sortWith(comparator: Comparator<in T>): Unit {
    if (size > 1) java.util.Collections.sort(this, comparator)
}

通過(guò)如上代碼我們知道，本來(lái)Double和Int是Number的子類(lèi)靶端，通過(guò)in修飾符后谎势，Comparator<Number>成為了Comparator<Double> 和 Comparator<Int> 的子類(lèi)，所以可以將Comparator<Number>賦值給Comparator<Double>和Comparator<Int>杨名。從而不用在專(zhuān)門(mén)根據(jù)不同的數(shù)據(jù)類(lèi)型脏榆，定義不同的DoubleComparator、IntComparatort等台谍。
同樣的须喂，通過(guò)它的名字'in'也可以知道。in修飾的泛型只能作為輸入類(lèi)型趁蕊，而不能作為返回類(lèi)型镊折。在Java中它對(duì)應(yīng)著<? super T>。

【4.3】總結(jié)

鳴謝

小弟早期閱讀《Kotlin核心編程》時(shí)赃泡，一直覺(jué)得書(shū)中對(duì)Kotlin的泛型講解得非常好，所以一直有想法寫(xiě)一篇相關(guān)的博文乘盼，也算是讀書(shū)筆記了升熊。文中有不盡之處，歡迎留言指出绸栅。謝謝级野！