Android

关注公众号 jb51net

关闭
首页 > 软件编程 > Android > Kotlin泛型

Kotlin泛型的使用介绍

作者：niuyongzhi

泛型，即 "参数化类型"，将类型参数化，可以用在类，接口，方法上。与 Java 一样，Kotlin 也提供泛型，为类型安全提供保证，消除类型强转的烦恼

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中可以通过反射的方式，来获取泛型的类型。

到此这篇关于Kotlin泛型的使用介绍的文章就介绍到这了,更多相关Kotlin泛型内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文