Kotlin 初学者泛型简单剖析与使用
Posted 帅次
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Kotlin 初学者泛型简单剖析与使用相关的知识，希望对你有一定的参考价值。
作者简介：CSDN博客专家、华为云·云享专家认证
系列专栏：Kotlin 初学者
学习交流：三人行必有我师焉；择其善者而从之，其不善者而改之。
目录
一、泛型使用
泛型，即 "参数化类型"，将类型参数化，可以用在类，接口，函数上。
与 Java 一样，Kotlin 也提供泛型，为类型安全提供保证，消除类型强转的烦恼。
1.1 泛型的优点
-
类型安全：通用允许仅保留单一类型的对象。泛型不允许存储其他对象。
-
不需要类型转换：不需要对对象进行类型转换。
-
编译时间检查：在编译时检查泛型代码，以便在运行时避免任何问题。
1.2 泛型类
TFood类指定的泛型参数由放在一对<>里的字母T表示，T是个代表item类型的占位符。TFood类接受任何类型的item作为主构造函数值（item: T)。
//1、创建泛型类
class TFood<T>(item:T)
init
// //使用is来检查item的类型。
// if(item is TApple)
// //使用 as?先进行安全类型转换，然后使用?.避免空指针
// println((item as? TApple)?.price)
// else
// println(item)
//
//以上内容，可以用下面一行搞定。
println(if(item is TApple)((item as? TApple)?.price)else item)
//2、创建传入的类
class TApple(var price :Int)
//3、使用
fun main()
//传入Int类型
TFood(30)//30
//传入String类型
TFood("水果")//水果
//传入实体对象
TFood(TApple(13))//13
此处如果不适用泛型，那么根据传入不同的引用类型可能需要创建多个类来接收。
泛型参数通常用字母T(代表英文type）表示，当然也可以用其他字母表示。不过，其他支持泛型的语言都在用这个约定俗成的T，所以建议你继续用它，这样写出的代码别人更容易理解。
1.3 泛型函数
泛型参数也可以用于函数。
定义一个函数用于获取元素，当且仅当泛型类可用时，才能获取元素。
class TFood<T>(item:T)
var tem:T = item
//添加泛型函数
fun getItem():T?
return tem
//多泛型参数,<R>返回泛型类型
fun <R> getItem(itemFun: (T) -> R): R
return itemFun(tem)
//传入String类型
var s = TFood("水果")//水果
//传入实体对象
var apple = TFood(TApple(13))//13
//使用泛型函数
s.getItem().run
println(this)//水果
apple.getItem().run
println(this)//实例对象：TApple@3f3afe78
println(this?.price)//13
//传入Type类型，返回Int类型
var intType = apple.getItem
//it:TApple
it.price
1.4 泛型接口
//定义泛型接口
interface IFoodEffect<T>
fun effect(item:T)
//实现接口
class Banana:IFoodEffect<String>
override fun effect(item: String)
println(item)//item
//使用
Banana().effect("常食香蕉有益于大脑，预防神经疲劳，还有润肺止咳、防止便秘")
二、泛型类型约束
指定参数类型：我想让这个泛型类只能传入某种类型。
open class Vip(price:Int)
class TApple(var price: Int): Vip(price)
class TFood<T:Vip>(item: T)
...
T:Vip，这样写就表示这里只能传入Vip和其子类。这个就类似Java的 <? extends T> 上界通配符
因为Int和String类型未继承Vip类，所以报错。
三、形变
-
out(协变)：它只能出现在函数的输出位置，只能作为返回类型，即生产者。
-
in(逆变)：它只能出现在函数的输入位置，作为参数，只能作为消费类型，即消费者。
-
默认(不变)：如果泛型类既将泛型类型作为函数参数，又将泛型类型作为函数的输出，那么既不用out也不用in。
3.1 不变
泛型类型即作为输出又作为参数。
//不变
interface IUnchanged<T>
//可返回T
fun originally(): T
//可作为参数传入T
fun originally(t:T)
class BigStore:IUnchanged<Fruit>
override fun originally(): Fruit
return Fruit()
override fun originally(t: Fruit)
class SmallStore:IUnchanged<AppleHn>
override fun originally(): AppleHn
return AppleHn()
override fun originally(t: AppleHn)
fun main()
println("-------------")
var bs:IUnchanged<Fruit> = BigStore()
println(bs)
var ss:IUnchanged<AppleHn> = SmallStore()
println(ss)
3.2 out-协变
它只能出现在函数的输出位置，只能作为返回类型，即生产者。
作用：可以将子类泛型对象可以赋值给父类泛型对象。
//out
interface IReturn<out T>
fun effect():T
open class Fruit()
class AppleHn():Fruit()
//生产者
class FruitMarket:IReturn<Fruit>
override fun effect(): Fruit
println("FruitMarket effect")
return Fruit()
class AppleHnMarket:IReturn<AppleHn>
override fun effect(): AppleHn
println("AppleHnMarket effect")
return AppleHn()
fun main()
//out:可以将子类泛型对象(AppleHn)可以赋值给父类泛型对象(Fruit)
var fm:IProduction<Fruit> = FruitMarket()
println(fm.effect())
//am的引用类型是Fruit对象
//但是AppleHnMarket返回的是AppleHn对象。
//这里将AppleHn对象赋值给Fruit对象并返回。
var am:IProduction<Fruit> = AppleHnMarket()
println(am.effect())
3.3 in-逆变
它只能出现在函数的输入位置，只能作为参数，即消费者。
作用：可以将父类泛型对象可以赋值给子类泛型对象。
//in
interface IConsumer<in T>
fun spend(t:T)
class Animal:IConsumer<Fruit>
override fun spend(t: Fruit)
println("Animal spend Fruit")
class People:IConsumer<AppleHn>
override fun spend(t: AppleHn)
println("People spend AppleHn")
fun main()
//in:可以将父类泛型对象(Fruit)可以赋值给子类泛型对象(AppleHn)
var fca: IConsumer<AppleHn> = Animal()
fca.spend(AppleHn())
println(fca)
var fcp: IConsumer<AppleHn> = People()
fcp.spend(AppleHn())
println(fcp)
四、inline + reified
不管是Java还是Kotlin泛型在运行时会被擦除，但Kotlin可以使用内联函数避免这种限制，内联函数的类型形参能够被实化。
inline 函数除了可以提高性能，内联代码之外，另一种场景就是类型参数可以被实化。
如果把函数声明成 inline 并且用 reified 标记类型参数，就可以实化该类型参数。
class BookS<T : androidS>
// fun <T> readBookT(anonymous: () -> T): T
// var list = listOf(
// KotlinS("Kotlin 初学者", 12),
// JavaS("Java 帅次", 28)
// )
// var data = list.shuffled().first()
// return if (data is T)
// data
// else
// anonymous()
//
//
//T的类型由anonymous()返回类型推断决定
inline fun <reified T> readBook(anonymous: () -> T): T
var list = listOf(
KotlinS("Kotlin 初学者", 12),
JavaS("Java 帅次", 28)
)
var data = list.shuffled().first()
println(data)
//如果data是T则返回data,否则执行anonymous()
return if (data is T)
data
else
anonymous()
open class AndroidS(name: String)
class KotlinS(var name: String, var price: Int) : AndroidS(name)
override fun toString(): String
return "KotlinS(name='$name', price=$price)"
class JavaS(var name: String, var price: Int) : AndroidS(name)
override fun toString(): String
return "JavaS(name='$name', price=$price)"
fun main()
var bookS:BookS<AndroidS> = BookS()
//由anonymous()推断决定T的类型，这里的T是KotlinS
var data = bookS.readBook
KotlinS("Anonymous-K",23)
println(data)
泛型T是KotlinS，list随机产生结果有两种分别是KotlinS和JavaS
产生KotlinS运行结果： 直接返回产生的KotlinS
"E:\\Android\\Android StudioO\\jre\\bin\\java.exe"
KotlinS(name='Kotlin 初学者', price=12)
KotlinS(name='Kotlin 初学者', price=12)
Process finished with exit code 0
产生JavaS运行结果： 调用anonymous()函数返回KotlinS
"E:\\Android\\Android StudioO\\jre\\bin\\java.exe"
JavaS(name='Java 帅次', price=28)
KotlinS(name='Anonymous-K', price=23)
Process finished with exit code 0
五、vararg
泛型类一次只能放一个，如果需要放入多个实例呢?
class BookMany<T : AndroidMany>(vararg item: T)
var data: Array<out T> = item
open class AndroidMany(name: String)
class KotlinMany(var name: String, var price: Int) : AndroidMany(name)
override fun toString(): String
return "KotlinS(name='$name', price=$price)"
class JavaMany(var name: String, var price: Int) : AndroidMany(name)
override fun toString(): String
return "JavaS(name='$name', price=$price)"
fun main()
var book = BookMany(
KotlinMany("初学者", 18),
KotlinMany("进阶者", 28),
KotlinMany("终结者", 38),
JavaMany("全面者", 35),
)
println(book)//com.scc.kotlin.primary.classkotlin.BookMany@3d24753a
添加完多个对象，如果直接打印book，那么获取到的是个BookMany对象，那么怎么获取book里面的的对象？
重载运算符函数get函数,通过[]操作符取值。
class BookMany<T : AndroidMany>(vararg item: T)
var data: Array<out T> = item
operator fun get(index:Int) = data[index]
fun main()
var book = BookMany(
KotlinMany("初学者", 18),
KotlinMany("进阶者", 28),
KotlinMany("终结者", 38),
JavaMany("全面者", 35),
)
println(book)//com.scc.kotlin.primary.classkotlin.BookMany@3d24753a
println(book[0])//KotlinS(name='初学者', price=18)
println(book[2])//KotlinS(name='终结者', price=38)
以上是关于Kotlin 初学者泛型简单剖析与使用的主要内容，如果未能解决你的问题，请参考以下文章