Kotlin 扩展函数：fun Type.extension()

Kotlin 的扩展函数让你无需修改原始类，就能为其添加新功能。这种机制让代码更简洁、更具表达力，尤其适合封装通用逻辑或为第三方库类增加便捷方法。

理解扩展函数的基本语法

定义一个扩展函数的格式是：在函数名前加上“接收者类型.”。这个“接收者类型”就是你要扩展的类。

例如，为 String 类添加一个判断是否为空白字符串的方法：

fun String.isNullOrBlank(): Boolean {
    return this == null || this.trim().isEmpty()
}

注意：

• 函数名前的 String. 表示这是对 String 类的扩展。
• 函数体内通过 this 引用调用该函数的对象（即接收者）。
• 实际上，Kotlin 标准库已经提供了 isNullOrBlank()，这里仅作示例。

调用扩展函数的方式和调用普通成员函数完全一样：

val text: String? = "  "
if (text.isNullOrBlank()) {
    println("文本为空或全是空格")
}

即使 text 是可空类型 String?，只要扩展函数定义在非空类型 String 上，Kotlin 编译器会自动处理安全调用（但需注意：若 text 为 null，直接调用会抛出 NullPointerException，除非你定义的是 String?. 扩展）。

为可空类型定义扩展函数

如果你希望扩展函数能安全处理 null 值，定义时应将接收者类型声明为可空：

fun String?.safeLength(): Int {
    return this?.length ?: 0
}

现在可以安全地对可能为 null 的字符串调用：

val name: String? = null
println(name.safeLength()) // 输出 0，不会崩溃

关键点：String? 和 String 是两个不同的接收者类型。前者允许 null，后者不允许。

扩展函数不能访问私有成员

记住：扩展函数虽然看起来像类的成员，但它实际上是一个静态工具函数。因此，它无法访问被扩展类的私有或受保护成员。

例如，以下代码会编译失败：

class Secret {
    private val code = "1234"
}

fun Secret.revealCode() {
    println(this.code) // ❌ 编译错误：code 是 private 的
}

扩展函数只能访问公开（public）或内部（internal）可见的成员。

在实际项目中组织扩展函数

为了避免命名冲突和提高可维护性，将扩展函数放在合适的文件或对象中。

方案一：按功能分类放入文件

创建 StringExtensions.kt 文件：

// StringExtensions.kt
package com.example.utils

fun String.isValidEmail(): Boolean {
    return this.contains("@") && this.contains(".")
}

fun String.toTitleCase(): String {
    return this.split(" ").joinToString(" ") { it.capitalize() }
}

然后在其他地方导入使用：

import com.example.utils.isValidEmail

val email = "user@example.com"
if (email.isValidEmail()) {
    // 处理有效邮箱
}

方案二：将相关扩展放入伴生对象或顶层对象

如果扩展函数只在特定上下文中使用，可以将其放入 object 中以限定作用域：

object DateUtils {
    fun Long.toDateString(): String {
        return java.time.Instant.ofEpochMilli(this)
            .atZone(java.time.ZoneId.systemDefault())
            .toLocalDate().toString()
    }
}

// 调用时需通过对象名
val timestamp = System.currentTimeMillis()
println(DateUtils.toDateString(timestamp))

但这种方式失去了“像成员函数一样调用”的优势，通常推荐使用顶层扩展函数。

扩展函数 vs 成员函数：优先级规则

当一个类同时拥有同名的成员函数和扩展函数时，成员函数优先。

class Person(val name: String) {
    fun describe(): String {
        return "Member: $name"
    }
}

fun Person.describe(): String {
    return "Extension: $name"
}

val p = Person("Alice")
println(p.describe()) // 输出 "Member: Alice"

要调用扩展函数，必须显式导入并确保没有成员函数干扰，或者换一个名字。

扩展属性（只读）

除了函数，Kotlin 还支持扩展属性，但只能定义 val（只读），不能有幕后字段。

val String.wordCount: Int
    get() = this.split(" ").size

// 使用
val sentence = "Hello world Kotlin"
println(sentence.wordCount) // 输出 3

扩展属性本质上是一个无参的扩展函数，只是语法更简洁。

避免滥用：何时不该使用扩展函数

虽然扩展函数很强大，但并非所有场景都适用。不要为了炫技而随意扩展标准库或第三方类。

以下情况应避免使用：

• 扩展逻辑与原类职责无关（如给 Int 添加 sendEmail()）。
• 扩展函数仅在一个地方使用，且逻辑简单。
• 可能导致命名冲突（如多个库都扩展了 String 的 format() 方法）。

优先考虑组合或工具类，只有当扩展能显著提升代码可读性和复用性时才使用。

示例：为 Android View 添加便捷方法

在 Android 开发中，扩展函数极为常见。例如，简化 View 的可见性控制：

import android.view.View

fun View.show() {
    this.visibility = View.VISIBLE
}

fun View.hide() {
    this.visibility = View.GONE
}

fun View.isVisible(): Boolean {
    return this.visibility == View.VISIBLE
}

使用时：

val button = findViewById<Button>(R.id.myButton)
button.show()
if (button.isVisible()) {
    // 执行操作
}

这种写法比直接写 button.visibility = View.VISIBLE 更语义化。

扩展函数的编译本质

Kotlin 编译器会将扩展函数编译为静态方法。例如：

fun String.shout(): String = this.uppercase() + "!"

会被编译成类似 Java 的形式：

public static final String shout(String receiver) {
    return receiver.toUpperCase() + "!";
}

调用 str.shout() 实际上是 YourFileKt.shout(str)。这也是为什么扩展函数不能访问私有成员——它本质上不在类内部。

理解这一点有助于调试和阅读字节码。

常见陷阱与解决方案

陷阱 1：平台类型导致的空指针异常

从 Java 返回的 String!（平台类型）调用非空扩展函数可能崩溃：

val javaStr: String = someJavaMethod() // 实际可能是 null
javaStr.isNullOrBlank() // 如果 javaStr 为 null，会抛出 NPE

解决：对来自 Java 的值先做空检查，或定义 String?. 扩展。

陷阱 2：泛型扩展中的类型擦除

fun <T> List<T>.firstOrNull(predicate: (T) -> Boolean): T? {
    for (item in this) {
        if (predicate(item)) return item
    }
    return null
}

这段代码没问题，但若试图根据 T 的具体类型做分支（如 if (T == String::class)），会因类型擦除失败。不要依赖运行时泛型类型信息。

陷阱 3：扩展函数无法被子类重写

扩展函数不是虚函数，不能被 override：

open class Animal
class Dog : Animal()

fun Animal.sound() = "Generic"
fun Dog.sound() = "Woof"

val dog: Animal = Dog()
println(dog.sound()) // 输出 "Generic"，不是 "Woof"

因为扩展函数的分发基于静态类型（这里是 Animal），而非运行时类型。若需多态行为，应使用成员函数。

最佳实践清单

1. 命名清晰：扩展函数名应准确描述其行为，如 isValidEmail() 比 check() 更好。
2. 限制作用域：通过 private 或 internal 修饰符控制可见性，避免污染全局命名空间。
3. 文档注释：为公共扩展函数添加 KDoc 注释，说明用途和边界条件。
4. 避免副作用：扩展函数应尽量保持纯函数特性，不修改外部状态。
5. 测试覆盖：像普通函数一样为扩展函数编写单元测试。

/**
 * 检查字符串是否符合简单邮箱格式（包含 @ 和 .）
 * 注意：这不是完整的 RFC 合规验证，仅用于基本检查
 */
fun String.isValidEmail(): Boolean {
    return this.isNotBlank() && this.contains("@") && this.contains(".")
}

遵循这些原则，扩展函数将成为你 Kotlin 工具箱中最锋利的刀之一。