1.泛型类、泛型函数
1）泛型类可以接收任意类型。Package<T>(t: T)
2）泛型类中定义的泛型参数<T>，通常用T（Type）表示，(t: T) 这个表示泛型类Package的主构造函数可以接收T类型的属性。
3）openPackage(): T定义一个返回T类型的泛型函数。
4）fun <R> getProductName(block: (T) -> R): R getProductName的返回值是R(英文的Return)，接收一个匿名函数为参数block: (T) -> R，这个匿名函数的参数是T，返回值是R。也就是说，匿名函数的返回值，就是getProductName的返回值。这个和前面讲到的apply、let、run、with等是一样的多参数函数。
//泛型类
class Package<T>(t: T) {
private val product: T = t
//泛型函数
fun openPackage(): T {
return product
}
//多参数泛型函数
fun <R> getProductName(block: (T) -> R): R {
return block(product)
}
}
fun main() {
val pkg = Package(Phone("IPhone"))
println(pkg.openPackage())
println(pkg.getProductName {
it.name
})
val pkg2 = Package(Fruit("Apple"))
println(pkg2.openPackage())
println(pkg2.getProductName {
it.name
})
}
2.泛型类型约束。上面的泛型类，可以接收任意类型。如果我们只想某个类接收特定类型的，可以使用泛型约束。
1）定义一个父类Fruit和两个子类，Apple和Banana
open class Fruit(val name:String){
}
class Apple(name:String) : Fruit(name){
}
class Banana(name:String):Fruit(name){
}
2）定义泛型类约束：<T:Fruit> 表示只能接收Fruit类或子类。和Java中的<? extends Fruit>作用是一样的。
Kotlin中定义泛型约束
class Package<T:Fruit>(t: T) {
private val product: T = t
fun openPackage(): T {
return product
}
fun <R> getProductName(block: (T) -> R): R {
return block(product)
}
}
fun main() {
//定义了泛型约束的类，只能放Fruit的子类
val pkg = Package(Apple("apple"))
val pkg2 = Package(Banana("banana"))
//Phone类型是放不进去的
val pkg3 = Package(Phone("Iphone"))
}
Java中定义泛型约束
public class Package<T extends Fruit> {
public T t;
public Package(T t) {
this.t = t;
}
public T openPackage() {
return t;
}
}
3.泛型类接收的参数也可以是一个集合：
class Package<T:Fruit>(list:List<T>) {
var list = list
fun get(index:Int):Fruit = list[index]
}
vararg items: T 就表示可以存放多个。vararg就是对应java中的可变参数。可以用一个数组来接收它Array<out T> ，这里的out 就是协变的意思。表示，可以就收该类或该类的子类。
class Package<T : Fruit>(vararg items: T) {
var itmes: Array<out T> = items
operator fun get(index: Int): Fruit = itmes[index]
}
fun main() {
val p = Package22(listOf(Apple("apple")))
println(p.get(0))
val p2 = Package(Apple("apple"))
println(p2[0])
}
4.协变out，逆变in
out T 对应java中的 ？extend T
int T 对应java中的？super T
5.类型擦除
对应java和Kotlin，泛型都值存在于编译期，运行后，就不存在泛型的概念，而是指定类型。
如果我们想要检查所传入泛型的类型，在kotlin中可以使用reified 关键字。在Java中可以通过反射的方式，来获取泛型的类型。
