Kotlin（十四）泛型

1.泛型类、泛型函数

  1）泛型类可以接收任意类型。Package(t: T)

   2）泛型类中定义的泛型参数，通常用T（Type）表示，(t: T) 这个表示泛型类Package的主构造函数可以接收T类型的属性。

   3）openPackage(): T定义一个返回T类型的泛型函数。

  4）fun 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  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）定义泛型类约束： 表示只能接收Fruit类或子类。和Java中的作用是一样的。

 Kotlin中定义泛型约束

 
class Package<T:Fruit>(t: T) {
    private val product: T = t
 
    fun openPackage(): T {
        return product
    }
 
    fun  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 extends Fruit> {
    public T t;
 
    public Package(T t) {
        this.t = t;
    }
 
    public T openPackage() {
        return t;
    }
}

3.泛型类接收的参数也可以是一个集合：

class Package<T:Fruit>(list:List) {
    var list = list
    fun get(index:Int):Fruit = list[index]
}

 vararg items: T 就表示可以存放多个。vararg就是对应java中的可变参数。可以用一个数组来接收它 Array ，这里的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中可以通过反射的方式，来获取泛型的类型。