Kotlin泛型简单理解

泛型使用方法

在类上使用泛型

类上面使用泛型，需要把泛型声明在类名后，使用尖括号表示

class C1<T>{
    fun print(t:T){
        print(t.toString())
    }
}

泛型函数

在fun关键字后使用声明

fun <T> method1(t:T):String{
    println(t.toString())
    return t.toString()
}

型变

Java的型变

Java是不型变的，可以这么理解：

List<String> 并不是List<Object>

举例如下代码是不可以编译通过的，因为无法型变

interface Collection<E> …… {
  void addAll(Collection<E> items);
}
void copyAll(Collection<Object> to, Collection<String> from) {
  to.addAll(from);
  // Collection<String> 不是 Collection<Object> 的子类型
}

kotlin协变

kotlin的协变使用out关键字表示，而java的协变用? extends E表示

如果一个类的泛型使用了协变<out T>,则T类型只能做为方法的返回值，不可以做为方法的形参。

举例：下面的代码中我们调用Factory.getCar最终获取的都是Car的类型，是安全的

open class Car{

}
class Taxi: Car() {
    fun drive(){
        println("开汽车")
    }
}
class Truck: Car() {
    fun drive(){
        println("开卡车")
    }
}
class Factory<out T>(private val car:T){
    fun getCar():T{
        return car
    }
//    fun setCar(t:T){//这个方法编译报错，因为T是协变的，所以只能获取（被消费），不能设置（被生产）
//        this.car=t
//    }
}

kotlin逆变

kotlin的逆变用in关键字表示，而java的逆变用? super E表示

同样用上面协变的代码举例，将T加上in修饰后，泛型就变为逆变的，此时Factory方法中getCar方法就会编译器报错，因为逆变的类型只能设置（被生产），不能获取（被消费）

open class Car{

}
class Taxi: Car() {
    fun drive(){
        println("开汽车")
    }
}
class Truck: Car() {
    fun drive(){
        println("开卡车")
    }
}
class Factory<in T>(private var car:T){
//    fun getCar():T{//Type parameter T is declared as 'in' but occurs in 'out' position in type T
//        return car
//    }
    fun setCar(t:T){//这个方法编译报错，因为T是协变的，所以只能获取（消费），不能设置（生产）
        this.car=t
    }
}

上界

Java和Kotlin指定上界的方式

• Java中泛型上界的表示方式：

Foo<T extend Noo>//表示泛型T是Noo的子类型

• Kotlin中泛型上界的表示方式

Foo<T : Noo>//表示泛型T是Noo的子类型

Kotlin 方法中指定多个上界

kotlin可以使用where关键字实现方法中泛型指定多个上界
示例代码如下：

open class A{

}
interface B{

}
class C: A(),B{
    
}
class D: A() {
    
}

fun <T> copy(t:T,list:MutableList<T>) :List<A>
        where T:A,
              T:B{//where T:A,T:B 表示泛型T有两个上界A和B，其中A和B之中A是一个类B是接口，也就是说指定两个上界的时候只能有一个上界是类
    list.add(t)
    return list
}

fun main() {
    val list = mutableListOf<C>()
    copy(C(),list)//因为C同时是A和B的子类，所以这里编译可以通过
//    copy(D(),list)//因为D是A的子类，不是C的子类，所以这里编译器会直接提示错误
}