Kotlin泛型-扩展函数
泛型的函数或者变量可以接收任何类型；扩展可以在不直接修改类定义的情况下增加类功能，扩展可以用于自定义类，也可以用于比如List、String， 以及Kotlin标准库里的其他类。和继承相似，扩展也能共享类行为，在你无法接触某个类定义，或者某个类没有使用open修饰符，导致你无法继承它时，扩
展就是增加类功能的最好选择。
其它Kotlin文章
Android学习Kotlin之一、常量-条件-函数-高阶函数
Android学习Kotlin之二、Null安全 -字符串操作- 类型转换
Android学习Kotlin之三、标准库函数-集合List-Set-Map
Android学习Kotlin之四、定义类-初始化-继承
Android学习Kotlin之五、对象-接口-抽象类
Android学习Kotlin之六、泛型-扩展函数
本编文章会讲到的知识点
- 泛型
- 定义泛型
- 注意
- 泛型函数
- 多泛型参数
- 泛型类型约束
- vararg关键字
- []操作符获取
- out(协变) in(逆变)
- out&in案例
- reified
- 扩展函数
- 定义扩展函数
- 泛型扩展函数
- 扩展属性
- infix关键字
- 带接收者的函数字面量
泛型
定义泛型
泛型类的构造函数可以接受任何类型。
GenericityBox类指定的泛型参数由放在一对<> 里的字母T表示，T是个代表item类型的占位
符。GenericityBox类接受任何类型的item作为主构造函数值(item: T)，并将item值赋给
同样是T类型的subject私有属性。
/**
* 定义泛型
*/
class GenericityBox<T>(item:T){
var able = false
private var mSub:T = item
fun getT(): T? {
return mSub.takeIf { able }
}
fun <R> getTR(subi:(T)->R): R ?{
return subi(mSub).takeIf { able }
}
}
class Gen(var name:String,var age:Int)
class Cup(val name:String)
注意
泛型参数通常用字母T (代表英文type)表示，当然，想用其他字母，甚至是英
文单词都是可以的。不过，其他支持泛型的语言都在用这个约定俗成的T，所以
建议你继续用它，这样写出的代码别人更容易理解。
泛型函数
泛型参数也可以用于函数，定义一个函数用于获取泛型。
// 1.定义泛型类
class GenericityBox<T>(item:T){
var able = false
private var mSub:T = item
fun getT(): T? {
return mSub.takeIf { able }
}
}
// 2.使用泛型函数
val box3:GenericityBox<Gen> = GenericityBox(Gen("小明",12))
val box4:GenericityBox<Cup> = GenericityBox(Cup("小芳"))
box3.getT()?.run {
println("box3=$name")
}
box4.able = true
box4.getT()?.run {
println("box4=$name")
}
多泛型参数
泛型函数或泛型类也可以有多个泛型参数。
// 1. 定义泛型
class GenericityBox<T>(item:T){
var able = false
private var mSub:T = item
fun <R> getTR(subi:(T)->R): R ?{
return subi(mSub).takeIf { able }
}
}
// 2.使用多泛型参数
val box5:GenericityBox<Gen> = GenericityBox(Gen("小明",16))
box5.able = true
val cup = box5.getTR {
Cup(it.name)
}
println("cup=${cup?.name}")// 打印cup=小明
泛型类型约束
如果要确保GenericityBox里面只能装指定类型的物品，如Gen类型， 怎么办?
// 1.泛型类型约束 指定类型为Gen
class GenericityBox2<T:Gen>(item:T){
private var mSub:T = item
fun getName():String{
return mSub.name
}
}
//2.使用泛型类型约束
val box6:GenericityBox2<Gen> = GenericityBox2(Gen("小鹏",18))
// val b:GenericityBox2<Cup> 报错 泛型指定为Gen
println("box6=${box6.getName()}")//打印小鹏
vararg关键字
GenericityBox能存放任何类型的Gen实例，但一次只能放-一个，如果需要放入多个实
例呢?
// 1.定义一个指定类型的类，并且接收多个对象
class GenericityBox3<T:Gen>(vararg item : T){
var able = false
var mSub: Array<out T> = item
fun getT(index:Int):T{
return mSub[index]
}
}
//2.使用vararg关键字 传入多个Gen对象
val box7:GenericityBox3<Gen> = GenericityBox3(Gen("小张",10),Gen("小六",12))
println("box7=${box7.getT(1)}")//打印 Gen(name=小六, age=12)
[]操作符获取
想要通过[ ]操作符取值，可以重载运算符函数get函数。
// 1.重载运算符函数get函数
class GenericityBox4<T:Gen>(vararg item : T){
var mSub: Array<out T> = item
operator fun get(index: Int) :T{
return mSub[index]
}
}
// 2.使用[]操作符取值
val box8:GenericityBox4<Gen> = GenericityBox4(Gen("小张",10),Gen("小六",12))
println("box8=${box8[0]}")
out(协变) in(逆变)
out(协变)
out (协变)，如果泛型类只将泛型类型作为函数的返回(输出)，那么使用out,可以称之为生产类/接口，因为它主要是用来生产(produce) 指定的泛型对象。
// 泛型只作为函数的输出
interface ProductionOut<out T>{
fun onOut():T
}
in(逆变)
in (逆变)，如果泛型类只将泛型类型作为函数的入参(输入)，那么使用in,可以称之为消费者类/接口，因为它主要是用来消费(consume)指定的泛型对象。
// 泛型只作为函数的入参
interface ProductionIn<in T>{
fun onIn(item:T)
}
Invariant(不变)
如果既将泛型作为函数参数，又将泛型作为函数的输出，那就既不用in 也不用out。
// 即是协变又是逆变
interface ProductionOutIn<T>{
fun onOut():T
fun onIn(item:T)
}
out&in案例
1.定义生产接口和消费接口，先不使用out和in
interface OnProductionOut<T>{
fun onOut():T
}
interface OnConsumerIn<in T>{
fun onIn(item:T)
}
2.定义三个类 食物 快餐 汉堡，分别是集成关系
open class Food
open class FastFood:Food()
class Burger:FastFood()
- 使用out
1.定义三个生产食物的类分别实现OnProductionOut类
class FoodOut:OnProductionOut<Food>{
override fun onOut(): Food {
println("FoodOut")
return Food()
}
}
class FastFoodOut:OnProductionOut<FastFood>{
override fun onOut(): FastFood {
println("FastFoodOut")
return FastFood()
}
}
class BurgerOut:OnProductionOut<Burger>{
override fun onOut(): Burger {
println("BurgerOut")
return Burger()
}
}
2.赋值使用
java中使用泛型初始化左侧定义的泛型一定要和右侧初始化的泛型一致，比如 List<A> = new List<B> 会报错，kotlin中也是一样
val mProduction1 : OnProductionOut<Food> = FoodOut() // 不报错， FoodOut()定义的泛型是Food
val mProduction2 : OnProductionOut<Food> = FastFoodOut() // 报错，FastFoodOut()定义的泛型是FastFood，而左侧定义类型是Food
val mProduction3 : OnProductionOut<Food> = BurgerOut()// 报错，BurgerOut()定义的泛型是Burger，而左侧定义类型是Food
3.修改接口添加out，再使用就不会报错了，因为子类泛型对象可以赋值给父类泛型对象。
// 协变
interface OnProductionOut<T>{
fun onOut():T
}
// 逆变
interface OnConsumerIn<T>{
fun onIn(item:T)
}
val mProduction1 : OnProductionOut<Food> = FoodOut()
val mProduction2 : OnProductionOut<Food> = FastFoodOut()
val mProduction3 : OnProductionOut<Food> = BurgerOut()
- 使用in
1.定义三个消费者
class FoodIn:OnConsumerIn<Food>{
override fun onIn(item: Food) {
println("FoodIn")
}
}
class FastFoodIn :OnConsumerIn<FastFood> {
override fun onIn(item: FastFood) {
println("FastFoodIn")
}
}
class BurgerIn:OnConsumerIn<Burger> {
override fun onIn(item: Burger) {
println("BurgerIn")
}
}
2.使用
val mConsumer1 : OnConsumerIn<Burger> = FoodIn()// 报错，左侧泛型和右侧泛型类型不一致
val mConsumer2 : OnConsumerIn<Burger> = FastFoodIn()// 报错，左侧泛型和右侧泛型类型不一致
val mConsumer3 : OnConsumerIn<Burger> = BurgerIn()// 不报错 左侧泛型和右侧泛型类型一致
3.修改接口添加in，再使用就不会报错了，因为父类泛型对象可以赋值给子类泛型对象。
interface OnConsumerIn<in T>{
fun onIn(item:T)
}
val mConsumer1 : OnConsumerIn<Burger> = FoodIn()
val mConsumer2 : OnConsumerIn<Burger> = FastFoodIn()
val mConsumer3 : OnConsumerIn<Burger> = BurgerIn()
reified
有时候，你可能想知道某个泛型参数具体是什么类型，reified关 键字能帮你检查泛型参数类型。Kotlin不 允许对泛型参数T做类型检查，因为泛型参数类型会被类型擦除，也就是说，T的类型信息在运行时是不可知的，Java也有这样的规则。
- 错误写法
Kotlin不 允许对泛型参数T做类型检查，因为泛型参数类型会被类型擦除
图片.png
-
使用inline reified
图片.png
/**
* 1.定义测试类
*/
class GenericityBox5<T : ReifiedParent> {
/**
* 需求 从集合中随机一个对象 判断随机的对象是不是穿过来的类型 如果是就返回随机对象，否则就执行传过来的方法
*/
inline fun <reified T> randomOrBackup(backup: () -> T): T {
val mList: MutableList<ReifiedParent> = mutableListOf(
ReifiedSon1("小明"),
ReifiedSon2("小芳")
)
val random = mList.shuffled().first()
println("random=$random")
return if (random is T) {
random
} else {
backup()
}
}
}
//2.使用
val box9: GenericityBox5<ReifiedParent> = GenericityBox5()
val bean = box9.randomOrBackup {
println("其他操作。。。")
ReifiedSon1("小明")
}
println("bean=$bean")
-
随机的类型和泛型类型一致
图片.png -
随机的类型和泛型类型不一致
图片.png
扩展函数
定义扩展函数
定义扩展函数和定义一般函数差不多，但有一点大不一样，除了函数定义，你还
需要指定接受功能扩展的接收者类型，后面会说到。
// 给字符串后面添加内容
fun String.addS(s: String) = this + s
// 给Any类添加一个函数
fun Any.easyPrint() = println(this)
// 使用扩展函数
println("小明".addS("HHHHHH"))
"郭襄".easyPrint()
6666.easyPrint()
泛型扩展函数
新的泛型扩展函数不仅可以支持任何类型的接收者，还保留了接收者的类型信息，使用泛型类型后，扩展函数能够支持更多类型的接收者，适用范围更广了。
// 泛型扩展函数 打印之后再把当前对象返回给调用者
fun <T> T.easyPrint2(): T {
println(this)
return this
}
"杨过".easyPrint2().addS("爱小龙女").easyPrint()
- let扩展函数
泛型扩展函数在Kotlin标准库里随处可见，例如let函数，let函数被定义成了泛型
扩展函数，所以能支持任何类型，它接收一-个lambda表达式，这个lambda表达
式接收者T作为值参，返回的R-lambda表达式返回的任何新类型。
扩展属性
除了给类添加功能扩展函数外，你还可以给类定义扩展属性，给String类添加一个扩展，这个扩展属性可以统计字符串里有多少个元音字母。
//定义扩展属性
val String.numV
get() = count { "abc".contains(it) }
// 使用扩展属性
"asdfgzxc".numV.easyPrint()// 打印2
infix关键字
infix关键字适用于有单个参数的扩展和类函数，可以让你以更简洁的语法调用函数,如果一个函数定义使用了infix关键字，那么调用它时，接收者和函数之间的点操作以及参数的一对括号都可以不要。
// 定义一个可空并使用infix修饰的扩展函数
infix fun String?.setName(d:String) = println(this ?: d)
// 可空变量
var name:String? = null
// 普通使用
name.setName("小笼包")
// 省略使用
name setName "贾玲"
带接收者的函数字面量
apply函数是如何做到支持接收者对象的隐式调用的。
