【Kotlin】泛型 ① ( 泛型类 | 泛型参数 | 泛型函数 | 多泛型参数 | 泛型类型约束 )

原创

韩曙亮_ 2023-01-28 06:21:12 博主文章分类：Kotlin ©著作权

文章标签 kotlin 泛型泛型参数泛型函数泛型类 文章分类 运维

©著作权归作者所有：来自51CTO博客作者韩曙亮_的原创作品，请联系作者获取转载授权，否则将追究法律责任

文章目录

一、泛型类
二、泛型参数
三、泛型函数
四、多泛型参数
五、泛型类型约束

一、泛型类

定义一个泛型类 ,

将泛型参数 T 放在尖括号 <T> 中 , 该泛型参数放在类名后 , 主构造函数之前 , 该泛型参数 T 是类型占位符 ,

在该泛型类类中可以使用类型占位符 T

可以定义 T 类型成员属性
主构造函数中可以接收 T 类型的实例对象作为参数 ,
T 类型可以作为函数的返回值 ;

通常情况下 , 泛型参数都使用 T 表示 , 使用其它字母或者字符串都可以表示泛型参数 , 但是约定俗成都使用 T 来表示泛型 ;

代码示例 : 下面的代码中 , 声明了 Student 泛型类 , 该泛型类接收 T 类型的泛型参数 , 在主构造函数中接收 T 类型的参数 , 在该泛型类中声明了 T 类型的成员属性 ;

class Student<T>(_item: T) {
    var item: T = _item
    fun log(){
        println("item : $item")
    }
}

fun main() {
    var student: Student<String> = Student("Tom")
    student.log()

    var student2: Student<Int> = Student(18)
    student2.log()
}

执行结果 :

item : Tom
item : 18

二、泛型参数

通常情况下 , 泛型参数都使用 T 表示 , 使用其它字母或者字符串都可以表示泛型参数 , 但是约定俗成都使用 T 来表示泛型 ;

在下面的代码中 , 使用 M 作为泛型参数 ;

代码示例 :

class Student<M>(_item: M) {
    var item: M = _item
    fun log(){
        println("item : $item")
    }
}

fun main() {
    var student: Student<String> = Student("Tom")
    student.log()

    var student2: Student<Int> = Student(18)
    student2.log()
}

执行结果 :

item : Tom
item : 18

三、泛型函数

函数的参数或返回值类型为泛型类型 , 则该函数称为泛型函数 ;

代码示例 : 该代码中 , 泛型函数 logT 的参数和返回值都是 T 泛型参数类型 ;

class Student<T>(_item: T) {
    var item: T = _item

    // 泛型函数 参数 和 返回值 都是 T 类型
    fun logT(t: T): T{
        println("item : $item")
        return item
    }
}

fun main() {
    var student: Student<String> = Student("Tom")
    println(student.logT(student.item))

    var student2: Student<Int> = Student(18)
    println(student2.logT(student2.item))
}

执行结果 :

item : Tom
Tom
item : 18
18

四、多泛型参数

泛型函数中如果涉及到匿名函数参数 , 匿名函数的参数返回值都是泛型的话 , 在该泛型函数中可能需要使用多个泛型 , 使用不同的字母表示不同的泛型 ;

如果函数中引入了新的泛型类型 , 需要在 fun 关键字和函数名之间 , 使用尖括号 <T> 注明 ;

代码示例 :
在本代码中 , logT 函数涉及到了两个泛型参数 , 传入的匿名函数参数类型为 (T) -> R , 需要两个泛型参数来表示其类型 ;
T 类型在泛型类中注明 , 可以在该泛型类 Student 中随意使用 ,
但是泛型参数 R 是首次在该函数中使用 , 因此需要在该函数的 fun 关键字和函数名之间 , 使用尖括号 <R> 注明新的泛型参数 ;

class Student<T>(_item: T) {
    var item: T = _item

    fun <R> logT(action: (T) -> R): R{
        return action(item)
    }
}

fun main() {
    var student: Student<String> = Student("Tom")
    println(student.logT {3.14})

    var student2: Student<Int> = Student(18)
    println(student2.logT {true})
}

执行结果 :

student 实例对象中 , 泛型 T 的实际类型是 String 类型 , 在 logT 中泛型 R 的类型是 Double 类型 ;
student2 实例对象中 , 泛型 T 的实际类型是 Int 类型 , 在 logT 中泛型 R 的类型是 Boolean 类型 ;

3.14
true

五、泛型类型约束

在泛型类 , 泛型函数中 , 使用泛型前 , 需要声明泛型参数 :

泛型类泛型参数声明 : 如果类中引入了新的泛型类型 , 需要在 class 关键字和主构造函数之前 , 使用尖括号 <T> 注明 ;

class Student<T>(_item: T) {
}

泛型函数泛型参数声明 : 如果函数中引入了新的泛型类型 , 需要在 fun 关键字和函数名之前 , 使用尖括号 <T> 注明 ;

fun <R> logT(action: (T) -> R): R{
        return action(item)
    }

在尖括号 <> 中声明泛型参数时 , 可以指定泛型类型的约束 , 如泛型类型必须是某个类型的子类 ;

在下面的代码中 , Soldier 类的泛型进行了约束 , 必须是 Weapon 类的子类类型 ;

class Soldier<T : Weapon>(_item: T) {}

Weapon 类是父类 , 其有一个子类 AK47 类 ;

在创建 Soldier 实例对象时 , 传入子类 AK47 类的实例对象 , 调用其重写父类的 fire 函数 ;

代码示例 :

class Soldier<T : Weapon>(_item: T) {
    var item: T = _item

    fun fight(){
        item.fire()
    }
}

open class Weapon(var name: String){
    open fun fire(){
        println("weapon fire!")
    }
}
class AK47: Weapon("AK47"){
    override fun fire(){
        super.fire()
        println("fire in the hole !")
    }
}

fun main() {
    var soldier: Soldier<AK47> = Soldier(AK47())
    soldier.fight()
}