fun <T> List<T>.slice(indices: IntRange): List<T>
<T>: 類(lèi)型函數(shù)聲明
List<T>: 接收者和返回類(lèi)型使用了類(lèi)型形參

（1）類(lèi)型參數(shù)約束
表示上界約束時(shí)： fun <T: Number> List<T>.sum() :T
T : Number 中
T是類(lèi)型參數(shù)豫领，Number是上界

一旦使用了類(lèi)型形參T的上界魂角，你就可以把類(lèi)型T的值當(dāng)作它的上界（類(lèi)型）的值使用。
如:
// 指定Number為類(lèi)型形參的上界
fun <T:Number> oneHalf(value: T): Double{
// 調(diào)用Numbe類(lèi)中的方法
return value.toDouble()
}

（2）聲明帶類(lèi)型參數(shù)約束的函數(shù)
// 這個(gè)函數(shù)的實(shí)參必須是可比較的元素
fun <T: Comparable<T>> max(first: T, second: T): T{
return if (first > second) first else second
}
如果傳入無(wú)法比較的參數(shù)時(shí)伴网，代碼將無(wú)法編譯：
max("Kotlin", 42) // 拋出異常

（3）為一個(gè)類(lèi)型參數(shù)定義多個(gè)約束
where關(guān)鍵字 為一個(gè)類(lèi)型參數(shù)定義多個(gè)約束時(shí)使用
// 這里為類(lèi)型T指定多個(gè)約束 ，where 后就是約束
fun <T> ensureTrailingPeriod(seq: T) where T : CharSequence, T : Appendable{
// 調(diào)用 Appendable 接口的方法
if (!seq.endsWith('.')){
seq.append('.')
}
}

（4）讓類(lèi)型形參非空

// 這里聲明的泛型函數(shù)是沒(méi)有指定上界的盅粪，但是內(nèi)部機(jī)制會(huì)吧這個(gè)泛型
// 函數(shù)默認(rèn)使用 Any? 作為上界
class Processo<T> {
// 這里的 value 是可空的掷漱，盡管T沒(méi)有使用問(wèn)號(hào)標(biāo)記
fun process(value: T){
value?.hashCode()
}
}
fun testPro(){
// 可用類(lèi)型 String 用來(lái)替換T
val mullableStringProcesso = Processo<String?>()
// 使用 “null” 作為 “value”實(shí)參代碼可以編譯
mullableStringProcesso.process(null)
}

設(shè)置泛型始終都為不可空的
// 這里設(shè)置上界為 Amy ,確保了T類(lèi)型永遠(yuǎn)都是非空類(lèi)型
class Processo<T:Any> {
fun process(value: T){
value?.hashCode()
}
}
fun testPro(){
// 由于泛型的上界為 Any 不為空秦士，所以無(wú)法設(shè)置泛型類(lèi)型為可空類(lèi)型
val mullableStringProcesso = Processo<String?>()

}

（5）運(yùn)行時(shí)的泛型：擦出和實(shí)例化類(lèi)型參數(shù)
Jvm上的泛型一般是通過(guò)類(lèi)型擦除實(shí)現(xiàn)的。

（6）類(lèi)型的檢查和轉(zhuǎn)換
如何檢查一個(gè)值是否是列表：
如：
if (value is List<*>) { ... }
想要檢查一個(gè)值是否為列表栓辜，不可以在列表聲明使用具體類(lèi)型的列表恋拍，必須使用 * 來(lái)代替泛型類(lèi)型才可以對(duì)這個(gè)值進(jìn)行檢查
如：
if( value is List<String>) { ... } // 這里使用了具體的 String,所以代碼不會(huì)編譯

" * " : 稱為星號(hào)投影

（7）對(duì)未知泛型類(lèi)型 和 已知類(lèi)型做類(lèi)型轉(zhuǎn)換
如：
// 這里 c 的泛型類(lèi)型 是未知的
fun printlnSum( c: Collection<*> ){
val intList = c as? List<Int> ? :throw IllegalArgumentException("List is expected")
println( inList.sum() )
}
調(diào)用：
println( setOf(1, 2, 3)) // Set不是列表，拋出異常
println(listOf("a", "b", "c" )) // 類(lèi)型轉(zhuǎn)換成功藕甩，但后面拋出了另外的異常

如果吧 * 號(hào)換成具體類(lèi)型施敢，那么轉(zhuǎn)換就可以成功

（8）聲明帶實(shí)化類(lèi)型參數(shù)的函數(shù)
fun <T> isA(value : Any) = value is T
// 這段代碼是無(wú)法編譯的周荐，因?yàn)闊o(wú)法知道泛型的類(lèi)型

reified: reified 的意思是實(shí)化（具體化）。而作為 Kotlin 的一個(gè)方法 泛型 關(guān)鍵字僵娃，它代表你可以在方法體內(nèi)訪問(wèn)泛型指定的JVM類(lèi)對(duì)象概作。必須以 inline 內(nèi)聯(lián)方式聲明這個(gè)方法才有效。

理解： 內(nèi)聯(lián)函數(shù)的類(lèi)型實(shí)參能夠被實(shí)化默怨，意味著你可以在運(yùn)行時(shí)引用實(shí)際的類(lèi)型實(shí)參讯榕，reified 關(guān)鍵字的聲明就是讓當(dāng)前泛型類(lèi)型可以在運(yùn)行時(shí)得到具體的類(lèi)型，就是類(lèi)型參數(shù)不會(huì)在運(yùn)行時(shí)擦除匙睹。

加上inline reified 后愚屁，函數(shù)可以編譯
// 聲明帶實(shí)體化類(lèi)型參數(shù)的函數(shù)
// reified T ： 可以在運(yùn)行時(shí)得到這個(gè)泛型的類(lèi)型
inline fun <reified T> isA(value: Any) = value is T

（9）使用標(biāo)準(zhǔn)庫(kù)的函數(shù)

val items = listOf("one" ,2 ,"three")
/*
使用它來(lái)檢查列表中的值是不是指定為該類(lèi)型實(shí)參的類(lèi)實(shí)例

println(items.filterIsInstance<String>())
[one, three]
*/

// "reified" 聲明了類(lèi)型參數(shù)不會(huì)在運(yùn)行時(shí)擦除
inline fun <reified T> Iterable<*>.filterIsInstance() : List<T>{
val destination = mutableListOf<T>()
// 迭代當(dāng)前列表實(shí)例中的元素并放入element
for (element in this) {
// 可以檢查元素是不是為指定為類(lèi)型實(shí)參類(lèi)的實(shí)例
if (element is T){
destination.add(element)
}
}
return destination
}

為什么實(shí)化只對(duì)內(nèi)聯(lián)函數(shù)有效：
編譯把實(shí)現(xiàn)內(nèi)聯(lián)函數(shù)的字節(jié)碼插入每一次調(diào)用發(fā)生的地方，每次你調(diào)用帶實(shí)化類(lèi)型參數(shù)的函數(shù)時(shí)痕檬，編譯器都知道這次特定調(diào)用中用作列席實(shí)參的確切類(lèi)型霎槐。因此，編譯器都知道這次特定調(diào)用中作為類(lèi)型實(shí)參的具體字節(jié)碼梦谜。
如：
filterIsInstance<String>
和
for (element in this){
if(element is String){
destination.add(element)
}
}
著兩段代碼時(shí)等價(jià)的

（10）調(diào)用實(shí)化類(lèi)型參數(shù)代替類(lèi)引用
val serviceImpl = ServiceLoader.load(Service::class.java)
:: class.java 的語(yǔ)法展現(xiàn)了如何獲取java.lang.Class 對(duì)應(yīng)的Kotlin類(lèi)

使用帶實(shí)化參數(shù)的函數(shù)重寫(xiě)這個(gè)例子
val serviceImpl = loadService<Service>()

具體實(shí)現(xiàn)
// 類(lèi)型參數(shù)標(biāo)記成了 “reified”
inline fun <reified T: Activity> Context.startActivity(){
// 把T::class 當(dāng)成類(lèi)型參數(shù)的類(lèi)訪問(wèn)
val intent = Intent(this, T::class.java)
startActivity(intent)
}

oninline: 這個(gè)標(biāo)記關(guān)鍵字可以把內(nèi)聯(lián)函數(shù)的某段語(yǔ)句或者字段標(biāo)記為非內(nèi)聯(lián)的

（11）類(lèi)丘跌，類(lèi)型和子類(lèi)型；

子類(lèi)：如B 實(shí)現(xiàn)了 A 就等于B 是A 的子類(lèi)

類(lèi)型：兩種對(duì)象的分類(lèi)唁桩，如Int 是 Number類(lèi)型碍岔，反過(guò)來(lái)Number是Int類(lèi)型

子類(lèi)型：如：Int? 可以存入 整型數(shù)據(jù)和null ， int 只可以存入整型數(shù)據(jù)朵夏，所以Int 是 Int? 的子類(lèi)型

（12）協(xié)變
如果A是B的子類(lèi)型，那么List<A> 就是 List<B>的子類(lèi)型榆纽，這樣的類(lèi)或者接口被稱為協(xié)變的仰猖。

函數(shù)的參數(shù)類(lèi)型叫做in位置，函數(shù)的返回類(lèi)型叫做out位置奈籽。

協(xié)變：
open class Animal{}
class Herd<T: Animal>{}
fun feedAll(animals: Herd<Animal>){}

class Cat: Animal(){}
fun takeCareOfCats(cats: Herd<cat>){
// 這里即使cats 的類(lèi)型是Herd<Cat> 類(lèi)型的饥侵，而Cat又是繼承Animal類(lèi)，也無(wú)法編譯
feedAll(cats)
}

如果把 Herd<T: Animal> 的T前面加上 out 代碼就可以編譯成功

重申：（關(guān)鍵字 out）
Herd<out T: Animal >時(shí)衣屏，子類(lèi)型化會(huì)被保留（producer<Cat>）是Producer<Animal>的子類(lèi)型

// MutableList不能在T上聲明成協(xié)變的
interface MuableList<T>：List<T>, MutableCollection<T>{
// 因?yàn)門(mén)用在了in位置
override fun add(element: T): Boolean
}

（13）逆變：反轉(zhuǎn)子類(lèi)型化關(guān)系（關(guān)鍵字 in）
逆變： 如果B 是A 的子類(lèi)型躏升，那么Comsumer<A>就是 Comsumer<B>的子類(lèi)型。狼忱，類(lèi)型A和類(lèi)型B交換了位置膨疏，所以我們說(shuō)子類(lèi)型被反轉(zhuǎn)了。

協(xié)變钻弄，逆變總結(jié)：fun transform(t: T): T ,t : T 這個(gè)T是in位置佃却，返回值類(lèi)型的T是out位置

Kotlin的
MutableList<out T> 和java 中的 MutableList< ? extends T> 是一個(gè)意思
MutableList<in T> 和Java 中的MutableList<? super T> 是一個(gè)意思

協(xié)變：
producer<out T>
類(lèi)的子類(lèi)型化保留了：producer<Car>是Producer<Animal>的子類(lèi)型(可以使用T的子類(lèi)型)
T只能在out位置
逆變：
Consumer<in: T>
子類(lèi)型化反轉(zhuǎn)了： Comsumer<Animal>是Consumer<Cat>的類(lèi)型(可以使用T的父類(lèi)型)
T只能在in位置
不變型：
MutableList<T>
沒(méi)有子類(lèi)型化
T可以在如何位置

使用點(diǎn)變型：在類(lèi)型出現(xiàn)的地方指定變型
使用不變型類(lèi)型參數(shù)的數(shù)據(jù)拷貝函數(shù) ,能夠把一個(gè)列表中的元素拷貝到拎一個(gè)列表
引入一個(gè)泛型：
fun <T> copyData(source: MutableList<T>), destination: MutableList<T>{
for(Item in source){
destination.add(item)
}
}

引入多個(gè)泛型：
fun <T: R, R> copyData(source: MutableList<T>, destination: MutableList<R>){
for(Item in source){
destination.add(item)
}
}

帶out投影類(lèi)型的數(shù)據(jù)拷貝函數(shù)：
// 可以給類(lèi)型的用法加上out 關(guān)鍵字，沒(méi)有使用那些T 用在 in 位置的方法
fun <T> copyData(source: MuableList<out T> , destination: MutableList<T>){
for(item in source){
destination.add(item)
}
}

帶in投影類(lèi)型參數(shù)的數(shù)據(jù)拷貝函數(shù)
// 允許目標(biāo)元素的類(lèi)型是來(lái)源元素類(lèi)型的超類(lèi)型
fun <T> copyData(source: MutableList<T> , destination: MutableList<in T>){
for(item in source){
destination.add(item)
}
}

（14）星號(hào)投影
寫(xiě)法一：List<*> 一個(gè)包含未知類(lèi)型元素的列表窘俺，相當(dāng)于Java的List<?>