【Kotlin】扩展函数总结 ★ ( 超类扩展函数 | 私有扩展函数 | 泛型扩展函数 | 扩展属性 | 定义扩展文件 | infix 关键字用法 | 重命名扩展函数 | 标准库扩展函数 )

文章目录

​

• 一、扩展函数简介
• 二、为 Any 超类定义扩展函数
• 三、private 私有扩展函数
• 四、泛型扩展函数
• 五、标准函数 let 函数是泛型扩展函数
• 六、扩展属性
• 七、可空类扩展
• 八、使用 infix 关键字修饰单个参数扩展函数的简略写法
• 九、定义扩展文件
• 十、重命名扩展函数
• 十一、Kotlin 标准库扩展函数

一、扩展函数简介

为 现有类 定义 扩展函数 , 可以在 不修改 原有类 的情况下 增加类的功能 ;

Kotlin 中如果类 没有被 open 关键字修饰 , 则该类 不能被继承 , 如果想要扩展该类 , 可以使用 扩展函数 ;

扩展函数 可以作用于 自定义的类 , 也可以作用于 系统自带的类 , 如 String , List , 等 标准库 API 类 ;

为 某个类 定义扩展函数 , 格式为 :

fun 类名.扩展函数名(参数列表): 返回值类型 {
	函数体
}

定义扩展函数 与 定义普通函数唯一的区别是 扩展函数 前多了 类名. ;

下面的代码中 , 为 String 定义扩展函数 , 拼接原字符串和扩展函数参数 , 并将结果返回 ;

代码示例 :

/**
 * 为 String 定义扩展函数, 拼接原字符串和扩展函数参数, 并将结果返回
 */
fun String.addStr(str: String): String {
    println("this = $this, string = $str")
    return this + str
}

fun main() {
    println("123".addStr("abc"))
}

执行结果 :

this = 123, string = abc
123abc

二、为 Any 超类定义扩展函数

扩展函数 的特点 是 为 父类定义扩展函数 , 子类也可以调用该扩展函数 ;

为 Any 超类 定义 扩展函数 , 那么 所有的 Any 子类 都可以 调用该 扩展函数 ;

一旦在 Any 超类中定义了扩展函数 , 则在整个项目中 , 该扩展函数都有效 ;

这就导致了 Kotlin 的框架非常灵活 , 使用别人的 SDK 时会发现 为各种现有类定义的 扩展函数 ;

代码示例 : 在下面的代码中 , 为 Any 超类 定义了 printSelf 扩展函数 , 所有的类 如 : String , Int , Boolean 等类的实例对象 , 都可以调用该 printSelf 扩展函数 ;

fun Any.printSelf() {
    println(this)
}

fun main() {
    "abc".printSelf()
    88.printSelf()
    true.printSelf()
}

执行结果 :

abc
88
true

三、private 私有扩展函数

如果 扩展函数 使用 private 修饰 , 则该扩展函数 只在该 Kotlin 代码文件中有效 , 在其它的 Kotlin 代码中就无法调用了 ;

代码示例 :

在 Hello.kt 代码中 , 使用 private 定义了 Any 超类的扩展函数 , 在本代码中的 main 函数中调用该扩展函数是有效的 ;

private fun Any.printSelf() {
    println(this)
}

fun main() {
    "abc".printSelf()
    88.printSelf()
    true.printSelf()
}

在 另外一个 Kotlin 代码中 , 调用该 Any 扩展函数 , 就会报编译时报错信息 ;

Cannot access 'printSelf': it is private in file

四、泛型扩展函数

泛型扩展函数 可以支持 任何类型的 接收者 ( 调用函数的实例对象 ) , 同时还可以 获取 接收者 的 泛型参数类型 ;

泛型扩展函数 格式 : 一般 泛型扩展函数 都是为了 配合 链式编程 , 其 返回值类型 就是 接收者泛型参数类型 ;

fun <T> T.函数名(参数列表): T {
	函数体
}

代码示例 : 在该代码中 , 定义了一个 泛型扩展函数 , 为泛型 T 定义了扩展函数 printSelf , 在函数中打印 接收者 , 并将接收者返回 , 该泛型可以是任意类型 ;

在 main 函数中 , 先调用 字符串实力对象 的 printSelf 泛型扩展函数打印自身 , 然后调用 字符串的扩展函数 String.addStr 拼接字符串 , 最后再次 调用 字符串实力对象 的 printSelf 泛型扩展函数打印自身 , 这样实现了一个链式编程 ;

// 泛型扩展函数 
fun <T> T.printSelf(): T{
    println(this)
    return this
}

// 字符串扩展函数
fun String.addStr(str: String): String {
    println("this = $this, string = $str")
    return this + str
}

fun main() {
	// 链式编程
    "abc".printSelf().addStr("123").printSelf()
}

执行结果 :

abc
this = abc, string = 123
abc123

五、标准函数 let 函数是泛型扩展函数

标准库 中的 let 函数 , 就是 泛型扩展函数 ,

• inline 关键字表明该函数是 内联函数 , 其中的 匿名函数 参数在编译时直接将函数体拷贝到使用位置 , 避免创建匿名函数相关对象 , 造成堆内存开销 ;
• 该函数中涉及到 两个泛型 T 和 R , 在 fun 关键字后声明 ,
• 为 泛型 T 定义了一个扩展函数 let ,
• 传入 (T) -> R 类型的匿名函数 , 该 Lambda 表达式 返回 R 类型 实例对象 ,
• 该 扩展函数 最终返回 R 类型 实例对象 ,

/**
 * 调用以' this '值作为参数的指定函数[block]，并返回其结果。
 *
 * 有关详细使用信息，请参阅[scope functions]的文档
 * (https://kotlinlang.org/docs/reference/scope-functions.html#let)。
 */
@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}

在使用 Lambda 表达式作为参数的时候 , Kotlin 编译器直接将 inline 内联函数 的 函数体 直接拷贝到 使用位置 ; 内联函数 类似于 C 语言中的 预编译指令 宏定义 , 在编译时直接替换拷贝宏定义内容 ; Kotlin 中的 内联函数 也是一种 编译时 进行 宏替换的操作 ;

内联函数参考 【Kotlin】函数 ⑦ ( 内联函数 | Lambda 表达式弊端 | “ 内联 “ 机制避免内存开销 - 将使用 Lambda 表达式作为参数的函数定义为内联函数 | 内联函数本质 - 宏替换 ) 博客进行理解 ;

Kotlin 中的标准库函数 , 参考 【Kotlin】标准库函数总结 ( apply 函数 | let 函数 | run 函数 | with 函数 | also 函数 | takeIf 函数 | takeUnless 函数 ) , 基本都是 泛型扩展函数 ;

六、扩展属性

上一篇博客 【Kotlin】扩展函数 ( 扩展函数简介 | 为 Any 超类定义扩展函数 | private 私有扩展函数 | 泛型扩展函数 | 标准函数 let 函数是泛型扩展函数 ) 中 , 介绍了给 现有类 定义 扩展函数 , 此外还可以 给现有类定义 扩展属性 ;

为现有类定义 扩展属性 语法格式为 :

val 现有类类名.扩展属性名: 扩展属性类型
	get() = {} 

var 现有类类名.扩展属性名: 扩展属性类型
	get() = {} 
	set() = {} 

• 扩展属性 不能 进行初始化 , 必须在 getter 函数中进行初始化 ;
• val 只读类型变量 扩展属性 必须提供 getter 函数 ;
• var 可变类型变量 扩展属性 必须提供 getter 和 setter 函数 ;

代码示例 : 在该代码中 , 为 String 类型定义了 扩展属性 extAttribute , 由于是 val 只读变量 , 因此必须在其 setter 函数 中进行初始化变量 , 并且 不能提供 setter 函数 ;

val String.extAttribute: Int
    get() {
        return 10
    }

fun String.addStr(str: String): String {
    println("this = $this, string = $str")
    return this + str
}

fun main() {
    println("123".addStr("abc"))
    println("123".extAttribute)
}

执行结果 :

this = 123, string = abc
123abc
10

七、可空类扩展

之前讲的定义扩展函数 , 扩展属性 , 都是为 非空类型 定义的 ,

如果要为 可空类型 定义扩展函数 , 则需要在 扩展函数 中 处理时 , 要多考虑一层 接收者 this 为空 的 情况 ;

注意下面的调用细节 :

• 如果定义的 扩展函数 是 为 非空类型定义的 , 可空类型变量 想要调用该 扩展函数 , 在调用时使用 " ?. " 进行调用即可 ;

	可空类型实例对象?.非空类型扩展函数

• 如果定义的 扩展函数 是为 可空类型定义的 , 可空类型变量 想要调用该 扩展函数 , 在调用时直接使用 " . " 进行调用即可 ;

	可空类型实例对象.可空类型扩展函数

代码示例 :

fun String?.addStr(str: String): String {
    if (this == null) {
        println("this = $this, string = $str, 接收者为空")
        return str
    } else {
        println("this = $this, string = $str, 接收者不为空")
        return this + str
    }
}

fun main() {
    var nullString: String? = null

    println("123".addStr("abc"))
    println(nullString.addStr("abc"))
}

执行结果 :

this = 123, string = abc, 接收者不为空
123abc
this = null, string = abc, 接收者为空
abc

八、使用 infix 关键字修饰单个参数扩展函数的简略写法

如果 扩展函数 只有 一个参数 , 并且在 扩展函数 定义时 使用了 infix 关键字修饰 , 在调用该扩展函数时 , 可以省略 接收者与函数之间的点 和 参数列表的括号 ;

调用 使用 infix 关键字修饰 的 单个参数扩展函数 :

接收者 函数名 函数参数 

也可以使用 传统方式调用 :

接收者.函数名(函数参数)

Map 中 创建 的 Pair 实例对象 的 to 函数 , 就是 被 infix 修饰的 泛型扩展函数 , 最终产生的是 Pair 实例对象 ;

/**
 * 从this和[that]创建类型为[Pair]的元组。
 *
 * 这对于创建噪音更少的[Map]字面量很有用，例如:
 * @sample samples.collections.Maps.Instantiation.mapFromPairs
 */
public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)

代码示例 :

infix fun String.addStr(str: String): String {
    return this + str
}

fun main() {
    println("123".addStr("abc"))

    // 简略写法如下
    println("123" addStr "abc")
}

执行结果 :

123abc
123abc

九、定义扩展文件

如果定义的 扩展函数 需要在 多个 Kotlin 代码文件 中使用 , 则需要在 单独的 Kotlin 文件 中定义 , 该文件被称为 扩展文件 ;

定义 标准库函数 的 Standard.kt 就是 独立的 扩展文件 ;

代码示例 : 扩展文件一般都 单独定义在一个 Package 中 , 命名一般是 XxxExt.kt , 在该代码中扩展文件定义在了 kim.hsl.extension 包中 , 扩展文件名称是 IterableExt.kt ;

package kim.hsl.extension

/**
 * 定义 Iterable<T> 扩展函数
 * 将集合随机打乱顺序, 返回第一个元素, 也就是获取集合中的随机元素
 * 函数必须是 public 函数, 不能是 private 函数
 */
fun <T> Iterable<T>.randomElement(): T = this.shuffled().first()

执行结果 :

Tom
Jerry

十、重命名扩展函数

如果 对 要调用的 扩展函数 名字不满意 , 则可以 使用 as 关键字 重命名扩展函数 ;

注意 : 一旦使用了 重命名扩展函数 , 则原扩展函数不能使用 , 一旦使用 , 直接报 Unresolved reference: randomElement 错误 ;

代码示例 :

import kim.hsl.extension.randomElement as getRandomElement

fun main() {
    val list = listOf("abc", "123", "Tom", "Jerry")
    println(list.getRandomElement())

    val set = setOf("abc", "123", "Tom", "Jerry")
    println(set.getRandomElement())
}

执行结果 :

Jerry
Jerry

十一、Kotlin 标准库扩展函数

Kotlin 标准库 提供的功能 , 都是通过 扩展函数 实现的 , 为 现有类 扩展的 标准库文件 都是 在 类名的基础上加上 s 来命名的 , 如 :

• 为 Sequence 类提供的扩展函数 , 定义在 Sequences.kt 代码中 ;
• 为 Range 类提供的扩展函数 , 定义在 Ranges.kt 代码中 ;
• 为 Map 类提供的扩展函数 , 定义在 Maps.kt 代码中 ;

标准库 中的 let 函数 , 就是 泛型扩展函数 ,

• inline 关键字表明该函数是 内联函数 , 其中的 匿名函数 参数在编译时直接将函数体拷贝到使用位置 , 避免创建匿名函数相关对象 , 造成堆内存开销 ;
• 该函数中涉及到 两个泛型 T 和 R , 在 fun 关键字后声明 ,
• 为 泛型 T 定义了一个扩展函数 let ,
• 传入 (T) -> R 类型的匿名函数 , 该 Lambda 表达式 返回 R 类型 实例对象 ,
• 该 扩展函数 最终返回 R 类型 实例对象 ,

/**
 * 调用以' this '值作为参数的指定函数[block]，并返回其结果。
 *
 * 有关详细使用信息，请参阅[scope functions]的文档
 * (https://kotlinlang.org/docs/reference/scope-functions.html#let)。
 */
@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}

在使用 Lambda 表达式作为参数的时候 , Kotlin 编译器直接将 inline 内联函数 的 函数体 直接拷贝到 使用位置 ; 内联函数 类似于 C 语言中的 预编译指令 宏定义 , 在编译时直接替换拷贝宏定义内容 ; Kotlin 中的 内联函数 也是一种 编译时 进行 宏替换的操作 ;

内联函数参考 【Kotlin】函数 ⑦ ( 内联函数 | Lambda 表达式弊端 | “ 内联 “ 机制避免内存开销 - 将使用 Lambda 表达式作为参数的函数定义为内联函数 | 内联函数本质 - 宏替换 ) 博客进行理解 ;

Kotlin 中的标准库函数 , 参考 【Kotlin】标准库函数总结 ( apply 函数 | let 函数 | run 函数 | with 函数 | also 函数 | takeIf 函数 | takeUnless 函数 ) , 基本都是 泛型扩展函数 ;