空安全详解

前置知识#

• Kotlin 与协程 Channel：建议先完成前一篇的学习

学习目标#

• 掌握「1. 历史动机与发展脉络」的核心机制、典型用法与常见陷阱
• 掌握「2. 形式化定义」的核心机制、典型用法与常见陷阱
• 掌握「3. 理论推导与原理解析」的核心机制、典型用法与常见陷阱
• 掌握「4. 代码示例」的核心机制、典型用法与常见陷阱
• 掌握「5. 对比分析」的核心机制、典型用法与常见陷阱

1. 历史动机与发展脉络#

1.1 问题背景：十亿美元的错误#

1965 年，Tony Hoare 在设计 ALGOL W 时引入了”空引用”（Null Reference）概念。他后来在 2009 年的 QCon 演讲中将其称为”my billion-dollar mistake”：

I call it my billion-dollar mistake. It was the invention of the null reference in 1965. … This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years.

空引用的根本问题：

1. 类型系统漏洞：任何引用类型 T 都可以赋值为 null，但 null 并不是 T 的有效实例。
2. 运行时错误：对 null 调用方法会抛出 NullPointerException（NPE），难以预测与防御。
3. 传播性：null 会沿着调用链传播，导致错误源头难以定位。
4. API 文档负担：开发者必须依赖文档或约定标注可空性，编译器无法强制。

Kotlin 的设计目标：

• 类型系统层解决：在编译期区分可空与不可空类型，将 NPE 从运行时提前到编译期。
• 显式空处理：开发者必须显式处理可空值，避免遗漏。
• Java 互操作：通过平台类型平滑过渡，不破坏既有 Java 生态。
• 零开销：在 JVM 平台不增加运行时开销，仅依赖注解与编译器检查。

1.2 学术背景：Option 类型与类型系统#

Kotlin 空安全的思想根植于函数式编程与类型理论：

• ML 语言（1973）：引入 option 类型，用 SOME(v) 与 NONE 显式表示”可能没有值”。
• Haskell（1990）：Maybe a = Just a | Nothing，通过 Monad 实现 >>= 链式操作。
• Scala（2004）：Option[T] 类型，Some[T] 与 None，配合 flatMap 链式处理。
• Rust（2010）：Option<T> 枚举，强制 match 穷尽性检查。
• Swift（2014）：Optional<T> 类型，语法糖 T?，与 Kotlin 高度相似。

Kotlin 的设计选择：

• 语法糖 T?：借鉴 Swift，比 Haskell 的 Maybe 更轻量。
• 操作符 ?. / ?:：借鉴 Groovy 的安全导航运算符。
• 不引入 Monad：与 Scala/Haskell 不同，Kotlin 不强制 Option 作为容器类型，保持 T? 与 T 的高度互操作。

1.3 Kotlin 1.0（2016）：空安全初版#

Kotlin 1.0 引入完整的空安全类型系统：

// Kotlin 1.0
var name: String = "Alice"  // 不可空
var nick: String? = null    // 可空

val len: Int? = name?.length  // 安全调用
val length: Int = name?.length ?: 0  // Elvis

此时已包含：

1. 可空类型 T? 与不可空类型 T。
2. 安全调用 ?.、Elvis ?:、非空断言 !!、安全转换 as?。
3. 智能转换：if (x != null) { x.length }。
4. 平台类型 T!：Java 互操作时的延迟决策。
5. lateinit var：延迟初始化的不可空属性。
6. 集合的 filterNotNull、mapNotNull 扩展。

1.4 Kotlin 1.1（2017）：契约预览与 provideDelegate#

Kotlin 1.1 引入了 provideDelegate 运算符（详见委托属性），间接改进了空安全：

class User {
    val name: String by notNullProperty { "default" }
}

同时引入实验性的”契约”（Contracts）API：

// 实验性
fun requireNotNull(x: T?): T {
    contract { returns() implies (x != null) }
    if (x == null) throw IllegalArgumentException()
    return x
}

1.5 Kotlin 1.2-1.3（2018）：契约稳定与 KMP#

Kotlin 1.3 将契约机制稳定化，并扩展到标准库：

1. requireNotNull 契约：调用后编译器知道参数非 null。
2. checkNotNull 契约：同上，但抛出 IllegalStateException。
3. assert 契约：断言后编译器细化类型。
4. KMP 一致性：JVM、JS、Native 平台的空安全行为完全一致。

1.6 Kotlin 1.4-1.5（2020-2021）：跨平台空安全改进#

Kotlin 1.4-1.5 在跨平台空安全方面有显著改进：

1. @Nullable 注解标准化：全面支持 JSpecify、JSR-305、JetBrains Annotations。
2. Enum.entries：替代 values()，避免数组拷贝。
3. orEmpty 系列扩展：String?.orEmpty()、Collection<T>?.orEmpty()。

1.7 Kotlin 1.6-1.7（2021-2022）：K2 与智能转换优化#

Kotlin 1.6-1.7 的 K2 编译器预览对智能转换进行了优化：

1. 更精细的控制流分析：K2 能在更多场景下推断类型细化，减少冗余的 !!。
2. 跨函数智能转换：K2 能识别 requireNotNull、checkNotNull 的契约。
3. 更友好的错误信息：K2 能精确指出智能转换失败的原因。

1.8 Kotlin 1.8-1.9（2023）：与 JSpecify 集成#

Kotlin 1.8-1.9 与 JSpecify（Java 标准空安全注解）深度集成：

1. JSpecify 注解识别：@Nullable、@NonNull、@NullMarked。
2. 类型参数级空安全：List<@Nullable String> 与 List<String> 区分。
3. 跨模块空安全：KMP 项目中可空类型信息在模块间传递。

1.9 Kotlin 2.0（2024 年 5 月）：K2 全面成熟#

Kotlin 2.0 的 K2 编译器对空安全进行了全面优化：

1. 更精确的智能转换：K2 能识别更多边界条件，如 when 分支、try 表达式。
2. 更快的类型推断：K2 的类型推断速度提升约 30%，减少编译时间。
3. 跨模块空安全检查：K2 在编译时检查跨模块的可空类型一致性。
4. 更友好的平台类型警告：K2 能精确指出平台类型的风险点。

1.10 JetBrains 的设计哲学#

JetBrains 在设计 Kotlin 空安全时遵循了以下哲学：

1. 编译期优先：错误在编译期暴露，而非运行时崩溃。
2. 显式优于隐式：可空类型必须显式声明（T?），不可空是默认。
3. 渐进式严格：初学者用 ?. 与 ?:，高级用户用契约与 Result。
4. Java 互操作优先：平台类型保证与 Java 代码无缝互操作。
5. 零运行时开销：JVM 上不增加额外的 null 检查字节码（除 lateinit 与 !!）。
6. 可读性：?. 与 ?: 比 Optional.flatMap 更接近”自然语言”。

1.11 时间线总览#

2. 形式化定义#

2.1 类型系统的空安全扩展#

设 $\tau$ 为 Kotlin 的类型集合。Kotlin 在 $\tau$ 上定义可空类型构造器 $?$：

其中 $\tau_\top$ 是包含原类型与 $\text{Null}$ 的扩展类型集合。即：

不可空类型 $T$ 与可空类型 $T?$ 的关系：

即 $T$ 是 $T?$ 的子类型。任何 $T$ 类型的值都可以赋给 $T?$ 类型的变量，反之不行。

2.2 Null 类型#

Null 是 Kotlin 类型系统的”底层类型”（Bottom Type），记作 Nothing?：

Nothing? 是所有可空类型的子类型：

这意味着 null 可以赋给任何可空类型 $T?$，但不能赋给不可空类型 $T$。

2.3 子类型关系的形式化#

Kotlin 的子类型关系 $\sqsubseteq$ 在引入可空性后变为：

即：如果 $T_1$ 是 $T_2$ 的子类型，则 $T_1$ 也是 $T_2?$ 的子类型；但 $T_1?$ 不是 $T_2$ 的子类型。

特殊地：

2.4 安全调用操作符 ?.#

安全调用操作符的形式化定义：

更精确地，对于方法调用 x?.method(args)：

返回类型为 $R?$，其中 $R$ 是 method 的返回类型。

2.5 Elvis 运算符 ?:#

Elvis 运算符的形式化定义：

更一般地，右侧可以是任意表达式：

返回类型为 $T$，即不可空。

2.6 非空断言操作符 !!#

非空断言的形式化定义：

!! 是”逃生舱”，将可空类型强制转换为不可空类型，但代价是可能的运行时 NPE。

2.7 安全转换操作符 as?#

安全转换的形式化定义：

返回类型为 $U?$，转换失败时返回 null 而非抛出 ClassCastException。

2.8 智能转换（Smart Casts）#

智能转换的形式化定义涉及控制流分析（CFA）。设 $\Gamma$ 为类型环境，$P$ 为谓词（如 is、!= null）：

即在 P(x) 成立的分支内，$x$ 的类型从 $T?$ 细化为 $T$。

更具体地，对于 if (x != null)：

智能转换的有效性依赖于：

1. 变量不可变：val 或 final 属性；var 在多线程下可能被修改。
2. 作用域内：智能转换仅在控制流分支内有效。
3. 无副作用：检查与使用之间变量未被重新赋值。

2.9 平台类型（Platform Types）#

平台类型的形式化定义：

其中 $T_\text{unknown}$ 表示”未知可空性”。平台类型在 Kotlin 中无法直接声明，仅通过 Java 互操作引入。

平台类型的传播规则：

1. 赋值给可空类型：val x: String? = java.getString()，按 String? 处理。
2. 赋值给不可空类型：val x: String = java.getString()，按 String 处理，但运行时可能 NPE。
3. 传递给 Kotlin 函数：按目标参数类型推断。
4. 链式调用：java.getList().size 的类型是 Int!，传播平台类型。

2.10 lateinit 的形式化#

lateinit var 的形式化定义：

其中 $T_\text{uninitialized}$ 是一个特殊的内部类型，在初始化前为”未初始化状态”，初始化后为 $T$。

访问语义：

2.11 契约（Contracts）的形式化#

契约机制允许函数告知编译器关于参数或控制流的信息：

其中 Effect 包括：

• returns() implies (condition)：函数返回时条件成立。
• callsInPlace(lambda, kind)：lambda 在函数内被调用。
• returns(value) implies (condition)：返回特定值时条件成立。

形式化地，requireNotNull 的契约：

编译器利用此契约进行智能转换：

fun process(x: String?) {
    requireNotNull(x)
    // 此处 x 已被智能转换为 String
    println(x.length)
}

2.12 JVM 字节码层面的空安全#

在 JVM 字节码层面，T 与 T? 没有运行时差异（都是引用类型）。空安全通过以下机制实现：

1. 编译时检查：编译器在调用 ?.、?:、!! 时插入 null 检查。
2. 注解：通过 @Nullable、@NotNull 注解（org.jetbrains.annotations）在字节码中标注可空性，供 Java 调用者使用。
3. Intrinsics.checkNotNull：Kotlin 编译器在公共 API 参数上插入运行时检查（默认启用，可通过 -Xno-param-assertions 关闭）。

?. 的字节码等价物：

// 源码：x?.length
// 字节码等价：
Integer length = (x != null) ? x.length() : null;

?: 的字节码等价物：

// 源码：x ?: ""
// 字节码等价：
String result = (x != null) ? x : "";

!! 的字节码等价物：

// 源码：x!!
// 字节码等价：
if (x == null) {
    Intrinsics.throwNpe();
}
String result = x;

3. 理论推导与原理解析#

3.1 子类型关系的代数性质#

Kotlin 的可空类型构造器 $?$ 满足以下代数性质：

1. 吸收律（左）：$T?? = T?$。即对可空类型再取可空，结果仍是可空类型。
2. 单位律：$T \sqsubseteq T?$。任何不可空类型是其可空版本的子类型。
3. 传递律：若 $T_1 \sqsubseteq T_2$，则 $T_1? \sqsubseteq T_2?$。
4. 反单调性：若 $T_1? \sqsubseteq T_2$，则 $T_1 \sqsubseteq T_2$（即不可空版本也是子类型）。

形式化证明性质 1：

3.2 智能转换的正确性证明#

智能转换的核心是控制流分析（CFA）。考虑：

fun process(x: String?) {
    if (x != null) {
        // 此处 x: String
        println(x.length)
    }
}

证明在 if 分支内 $x : \text{String}$：

1. 进入分支的条件是 $x \neq \text{null}$。
2. $x$ 是 val（不可变），在分支内 $x$ 的值不会改变。
3. 由 $x : \text{String?}$ 与 $x \neq \text{null}$，推出 $x : \text{String}$（因为 $\text{String?} = \text{String} \cup \{\text{Null}\}$）。

形式化地：

3.3 智能转换的失效场景#

智能转换在以下场景失效：

1. var 属性：多线程下可能被修改。
2. 开放属性：子类可能覆盖 getter，返回值不一致。
3. 委托属性：getter 行为不确定。
4. 跨函数：函数调用后变量可能被修改。
5. 非局部属性：可能被其他代码修改。

class Example {
    var x: String? = null
    
    fun process() {
        if (x != null) {
            // 错误：x 是 var 属性，智能转换失效
            // println(x.length)  // 编译错误
            println(x!!.length)  // 需要 !!
        }
    }
}

编译器保守地认为 var 属性在 if 检查与使用之间可能被其他线程修改，因此不应用智能转换。

3.4 平台类型的传播规则#

平台类型 $T!$ 在 Kotlin 代码中的传播遵循以下规则：

1. 直接赋值：根据目标类型推断。
2. 函数调用：根据参数类型推断。
3. 链式调用：平台类型传播到结果。
4. 集合操作：List<String!>! 表示列表本身与元素都可空性未知。

// Java 代码：String getName()
val name = javaService.getName()  // 类型推断为 String!

// 赋值给可空：String?
val nullableName: String? = javaService.getName()

// 赋值给不可空：String（运行时可能 NPE）
val nonNullName: String = javaService.getName()

形式化地，平台类型的传播：

3.5 ?. 链式的类型推导#

考虑：

val street: String? = company?.department?.manager?.address?.street

类型推导规则：

即链式 ?. 的结果类型是”所有链节点的可空类型的累积”。任何一节为 null，整个表达式为 null。

3.6 ?: 与 ?. 的等价性#

x ?: default 等价于 if (x != null) x else default，也等价于 x?.let { it } ?: default（但后者有额外开销）。

形式化地：

编译器对 ?: 进行优化，避免重复计算 $x$。

3.7 lateinit 与 lazy 的字节码对比#

lateinit var x: String 的字节码（简化）：

// 字段
private String x;

// getter
public String getX() {
    if (this.x == null) {
        Intrinsics.throwUninitializedPropertyAccessException("x");
    }
    return this.x;
}

// setter
public void setX(String x) {
    this.x = x;
}

val x: String by lazy { "hello" } 的字节码（简化）：

// 委托字段
private final Lazy<String> x$delegate = LazyKt.lazy(() -> "hello");

// getter
public String getX() {
    return this.x$delegate.getValue();
}

对比：

3.8 契约机制的实现原理#

契约通过 kotlin.contracts 包实现。requireNotNull 的源码（简化）：

public inline fun <T : Any> requireNotNull(value: T?): T {
    contract {
        returns() implies (value != null)
    }
    if (value == null) {
        throw IllegalArgumentException("Required value was null.")
    }
    return value
}

编译器在遇到 requireNotNull(x) 后，根据契约 returns() implies (x != null) 进行智能转换：

fun process(x: String?) {
    requireNotNull(x)
    // 编译器根据契约知道 x != null
    // 因此智能转换为 String
    println(x.length)
}

形式化地，契约是一个”编译期断言”：

3.9 Result<T> 与 T? 的语义差异#

Result<T> 是 Kotlin 标准库提供的”可能失败”类型：

public value class Result<out T> {
    public companion object {
        public inline fun <T> success(value: T): Result<T>
        public inline fun <T> failure(exception: Throwable): Result<T>
    }
}

Result<T> 与 T? 的对比：

Result 在”需要区分’无值’与’失败‘“的场景下优于 T?。

3.10 集合的可空性#

Kotlin 区分四种集合类型：

1. List<String>：列表本身不可空，元素不可空。
2. List<String?>：列表本身不可空，元素可空。
3. List<String>?：列表本身可空，元素不可空。
4. List<String?>?：列表本身可空，元素可空。

形式化地：

val names: List<String?> = listOf("Alice", null, "Bob")
val filtered: List<String> = names.filterNotNull()  // ["Alice", "Bob"]
val lengths: List<Int> = names.mapNotNull { it?.length }  // [5, 3]

filterNotNull 的形式化：

4. 代码示例#

4.1 基础：可空类型与不可空类型#

# 编译与运行
kotlinc -script nullable_basic.kts

// nullable_basic.kts
fun main() {
    var name: String = "Alice"  // 不可空
    var nick: String? = null    // 可空
    
    // 不可空类型不能赋值为 null
    // name = null  // 编译错误：Null can not be a value of a non-null type String
    
    // 可空类型的成员不能直接访问
    // println(nick.length)  // 编译错误：Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type String?
    
    // 安全调用
    val len: Int? = nick?.length
    println("Length: $len")  // null
    
    // Elvis 运算符
    val length: Int = nick?.length ?: 0
    println("Length with default: $length")  // 0
    
    // 非空断言
    var value: String? = "Hello"
    println(value!!.length)  // 5
    // value = null
    // println(value!!.length)  // 运行时：NullPointerException
    
    // 安全转换
    val obj: Any = "hello"
    val str: String? = obj as? String  // "hello"
    val num: Int? = obj as? Int  // null
    println("String: $str, Int: $num")
}

4.2 智能转换：控制流细化#

kotlinc -script smart_casts.kts

// smart_casts.kts
fun process(s: String?) {
    // if 分支内的智能转换
    if (s != null) {
        // s 自动从 String? 转换为 String
        println(s.length)  // 无需 ?. 或 !!
    }
}

fun describe(x: Any) = when (x) {
    is String -> x.length      // x 自动转换为 String
    is Int -> x.toDouble()     // x 自动转换为 Int
    is List<*> -> x.size       // x 自动转换为 List
    else -> "未知类型"
}

fun handle(value: Any) {
    if (value is String) {
        println(value.uppercase())  // value 自动转换为 String
    }
    
    // !is 检查
    if (value !is String) {
        println("Not a string")
        return
    }
    // 此处 value 自动转换为 String（因 !is 分支返回）
    println(value.length)
}

// while 循环中的智能转换
fun readInput(): String? = readLine()

fun processInput() {
    var input: String? = readInput()
    while (input != null) {
        process(input)  // input 自动转换为 String
        input = readInput()
    }
}

fun process(s: String) {
    println("Processed: $s")
}

fun main() {
    process("hello")
    println(describe(42))
    println(describe("world"))
    println(describe(listOf(1, 2, 3)))
}

4.3 安全调用链：深层嵌套#

kotlinc -script safe_chain.kts

// safe_chain.kts
data class Address(val street: String?, val city: String?)
data class User(val name: String?, val address: Address?)

fun getStreet(user: User?): String {
    // 链式安全调用 + Elvis 默认值
    return user?.address?.street ?: "未知街道"
}

fun getFullInfo(user: User?): String {
    val name = user?.name ?: "匿名"
    val street = user?.address?.street ?: "未知街道"
    val city = user?.address?.city ?: "未知城市"
    return "$name, $street, $city"
}

fun main() {
    val user = User("Alice", Address("Main St", "NYC"))
    println(getStreet(user))  // Main St
    println(getStreet(null))  // 未知街道
    
    val nullUser: User? = null
    println(getFullInfo(nullUser))  // 匿名, 未知街道, 未知城市
    
    // 链式调用中的多个 ?. 与 ?: 混合
    val result = user?.address?.city?.takeIf { it.length > 2 } ?: "短"
    println(result)  // NYC
}

4.4 let、run、with 处理空值#

kotlinc -script scope_functions.kts

// scope_functions.kts
data class User(val name: String?, val age: Int?)

fun main() {
    val user = User("Alice", 25)
    
    // let：对非空值执行操作（通过 it 引用）
    user.name?.let {
        println("名字: $it, 长度: ${it.length}")
    }
    
    // run：对非空值执行代码块（通过 this 引用）
    user.name?.run {
        println("名字: $this, 长度: ${length}")
    }
    
    // also：执行副作用，返回原值
    val processedName = user.name?.also {
        println("处理中: $it")
    }?.uppercase()
    println("处理结果: $processedName")
    
    // takeIf / takeUnless：条件判断
    val validName = user.name?.takeIf { it.length > 2 }
    val invalidName = user.name?.takeUnless { it.isBlank() }
    println("Valid: $validName, Invalid: $invalidName")
    
    // 组合使用
    user.age?.let { age ->
        if (age >= 18) {
            println("成年人")
        } else {
            println("未成年")
        }
    } ?: println("年龄未知")
}

4.5 集合的可空处理#

kotlinc -script nullable_collections.kts

// nullable_collections.kts
fun main() {
    val names: List<String?> = listOf("Alice", null, "Bob", null, "Charlie")
    
    // filterNotNull：过滤 null 值，得到非空类型列表
    val nonNull: List<String> = names.filterNotNull()
    println(nonNull)  // [Alice, Bob, Charlie]
    
    // mapNotNull：映射并过滤 null
    val lengths: List<Int> = names.mapNotNull { it?.length }
    println(lengths)  // [5, 3, 7]
    
    // forEach 中处理 null
    names.forEach { name ->
        name?.let {
            println("名字: $it, 长度: ${it.length}")
        }
    }
    
    // OrNull 系列
    val list = listOf("a", "b", "c")
    val first = list.firstOrNull()
    val last = list.lastOrNull()
    val element = list.getOrNull(5)  // null
    println("First: $first, Last: $last, Element at 5: $element")
    
    val numbers = listOf(3, 1, 4, 1, 5, 9, 2, 6)
    val min = numbers.minOrNull()
    val max = numbers.maxOrNull()
    println("Min: $min, Max: $max")
    
    // 空列表的 firstOrNull / lastOrNull
    val empty = emptyList<String>()
    println("Empty first: ${empty.firstOrNull()}")  // null
    
    // indexOfFirst / indexOfLast
    val index = names.indexOfFirst { it == "Bob" }
    println("Bob index: $index")
}

4.6 前置条件检查#

kotlinc -script preconditions.kts

// preconditions.kts
fun processName(name: String?) {
    // requireNotNull：参数校验，失败抛 IllegalArgumentException
    requireNotNull(name) { "姓名不能为空" }
    // 此处 name 自动智能转换为 String（依赖契约）
    println("姓名长度: ${name.length}")
}

fun processAge(age: Int?) {
    require(age != null) { "年龄不能为 null" }
    require(age >= 0) { "年龄不能为负数: $age" }
    require(age <= 150) { "年龄异常: $age" }
    println("有效年龄: $age")
}

class Service {
    private var initialized: Boolean = false
    
    fun process() {
        // checkNotNull：状态检查，失败抛 IllegalStateException
        check(initialized) { "服务未初始化，请先调用 init()" }
        // 处理逻辑
    }
    
    fun init() {
        initialized = true
    }
}

class Config {
    private var _value: String? = null
    val value: String
        get() {
            // 自定义错误处理
            return _value ?: throw IllegalStateException("配置未加载")
        }
}

fun main() {
    processName("Alice")
    processAge(25)
    // processName(null)  // IllegalArgumentException: 姓名不能为空
    
    val service = Service()
    // service.process()  // IllegalStateException: 服务未初始化
    service.init()
    service.process()
    
    val config = Config()
    // config.value  // IllegalStateException: 配置未加载
}

4.7 lateinit 延迟初始化#

kotlinc -script lateinit_demo.kts

// lateinit_demo.kts
class UserController {
    // lateinit 只能用于 var，且类型必须非空
    lateinit var userService: UserService
    lateinit var repository: UserRepository
    
    fun setup() {
        userService = UserService()
        repository = UserRepository()
    }
    
    fun processUser(id: String): String {
        // 访问未初始化的 lateinit 会抛出 UninitializedPropertyAccessException
        return userService.getUser(id)
    }
    
    // 检查是否已初始化（Kotlin 1.2+）
    fun isReady(): Boolean {
        return ::userService.isInitialized && ::repository.isInitialized
    }
}

class UserService {
    fun getUser(id: String): String = "User-$id"
}

class UserRepository

// Android ViewBinding 场景
class MainActivity {
    private lateinit var binding: ViewBinding
    
    fun onCreate() {
        binding = ViewBinding.inflate()
        binding.textView.text = "Hello"
    }
}

class ViewBinding {
    val textView = TextView()
    companion object {
        fun inflate(): ViewBinding = ViewBinding()
    }
}

class TextView {
    var text: String = ""
}

fun main() {
    val controller = UserController()
    println("Ready: ${controller.isReady()}")  // false
    controller.setup()
    println("Ready: ${controller.isReady()}")  // true
    println(controller.processUser("123"))
}

4.8 lazy 惰性求值#

kotlinc -script lazy_demo.kts

// lazy_demo.kts
import kotlin.properties.Delegates

class Config {
    // lazy 委托，惰性求值
    val databaseUrl: String by lazy {
        println("Initializing database URL...")
        System.getenv("DATABASE_URL") ?: "default-url"
    }
    
    // observable：监听属性变化
    var featureFlag: Boolean by Delegates.observable(false) { _, old, new ->
        println("Feature flag changed: $old -> $new")
    }
    
    // vetoable：校验新值
    var port: Int by Delegates.vetoable(8080) { _, old, new ->
        if (new in 1..65535) {
            true  // 接受
        } else {
            println("Invalid port: $new, keeping $old")
            false  // 拒绝
        }
    }
}

fun main() {
    val config = Config()
    
    // lazy 只在首次访问时初始化
    println("Before access")
    println("URL: ${config.databaseUrl}")
    println("URL again: ${config.databaseUrl}")  // 不会再次初始化
    
    // observable
    config.featureFlag = true   // 输出: Feature flag changed: false -> true
    config.featureFlag = false  // 输出: Feature flag changed: true -> false
    
    // vetoable
    config.port = 3000  // 接受
    println("Port: ${config.port}")
    config.port = 99999  // 拒绝
    println("Port: ${config.port}")  // 仍是 3000
}

4.9 自定义契约#

kotlinc -script custom_contract.kts

// custom_contract.kts
import kotlin.contracts.*

// 自定义契约函数
fun requireNonEmpty(value: String?) {
    contract {
        returns() implies (value != null && value.isNotEmpty())
    }
    if (value.isNullOrEmpty()) {
        throw IllegalArgumentException("Value must be non-empty")
    }
}

fun requirePositive(value: Int) {
    contract {
        returns() implies (value > 0)
    }
    if (value <= 0) {
        throw IllegalArgumentException("Value must be positive")
    }
}

fun process(value: String?) {
    requireNonEmpty(value)
    // 此处 value 已被智能转换为非空 String
    // 且契约保证 isNotEmpty()
    println("Processing: ${value.length} chars")
}

fun calculate(n: Int) {
    requirePositive(n)
    // 编译器知道 n > 0
    val result = 100 / n  // 不会除零
    println("Result: $result")
}

fun main() {
    process("hello")
    calculate(10)
    // process(null)  // IllegalArgumentException
    // calculate(-1)  // IllegalArgumentException
}

4.10 Result 类型：函数式错误处理#

kotlinc -script result_type.kts

// result_type.kts
import java.io.File

// 使用 Result 包装可能失败的操作
fun readFile(path: String): Result<String> = runCatching {
    File(path).readText()
}

fun parseInt(s: String): Result<Int> = runCatching {
    s.toInt()
}

fun divide(a: Int, b: Int): Result<Int> = runCatching {
    if (b == 0) throw ArithmeticException("Division by zero")
    a / b
}

fun main() {
    // 基本使用
    val result = readFile("nonexistent.txt")
    println("Success: ${result.isSuccess}")
    println("Failure: ${result.isFailure}")
    println("Get: ${result.getOrNull()}")
    println("Exception: ${result.exceptionOrNull()?.message}")
    
    // getOrElse：失败时返回默认值
    val content = readFile("nonexistent.txt").getOrElse { "default" }
    println("Content: $content")
    
    // map：转换成功值
    val length = readFile("nonexistent.txt")
        .map { it.length }
        .getOrElse { 0 }
    println("Length: $length")
    
    // recover：失败时恢复
    val recovered = divide(10, 0)
        .recover { e ->
            println("Error: ${e.message}")
            -1
        }
        .getOrThrow()
    println("Recovered: $recovered")
    
    // 链式处理
    val finalResult = parseInt("42")
        .mapCatching { it * 2 }
        .getOrThrow()
    println("Final: $finalResult")
    
    // T? 与 Result<T> 的互转
    val nullable: String? = "hello"
    val result2 = nullable?.let { Result.success(it) } ?: Result.failure(NullPointerException())
    println("From nullable: ${result2.getOrNull()}")
    
    val toNullable: String? = result2.getOrNull()
    println("To nullable: $toNullable")
}

4.11 Java 互操作：平台类型#

# 假设有 Java 类 JavaService
kotlinc -cp . -script platform_types.kts

// platform_types.kts
// 假设 JavaService 是 Java 类：
// public class JavaService {
//     public String getName() { return null; }
//     public List<String> getNames() { return null; }
// }

// 模拟 Java 服务
class JavaService {
    // 模拟 Java 方法（不标注可空性）
    fun getName(): String? = null  // 在 Kotlin 中显式声明可空
    fun getNames(): List<String>? = null
}

fun main() {
    val service = JavaService()
    
    // 平台类型：JavaService.getName() 的类型是 String!（平台类型）
    // 在 Kotlin 中，根据使用方式推断
    val name1: String = service.getName()!!  // 强制非空（运行时可能 NPE）
    val name2: String? = service.getName()  // 安全处理
    val name3 = service.getName()  // 推断为 String?（因方法签名标注）
    
    println("Name1: ${name1 ?: "null"}")
    println("Name2: $name2")
    println("Name3: $name3")
    
    // 安全调用链
    val length = service.getName()?.length ?: 0
    println("Length: $length")
    
    // 集合的平台类型
    val names = service.getNames()
    val size = names?.size ?: 0
    println("Names size: $size")
}

// 推荐做法：为 Java 互操作添加 @Nullable / @Nullable 注解
// Java 代码：
// @NotNull
// public String getName() { return "Alice"; }
//
// @Nullable
// public String getOptionalName() { return null; }

4.12 sealed class 与空安全#

kotlinc -script sealed_nullable.kts

// sealed_nullable.kts
// 使用 sealed class 替代可空类型，提供更多信息
sealed class UserResult {
    data class Success(val user: User) : UserResult()
    object NotFound : UserResult()
    data class Error(val message: String) : UserResult()
}

data class User(val id: String, val name: String)

class UserService {
    private val users = mapOf(
        "1" to User("1", "Alice"),
        "2" to User("2", "Bob")
    )
    
    // 返回 sealed class，而非 User?
    fun findById(id: String): UserResult = when (id) {
        in users -> UserResult.Success(users[id]!!)
        "error" -> UserResult.Error("Service unavailable")
        else -> UserResult.NotFound
    }
}

fun process(result: UserResult) {
    // when 表达式穷尽性检查
    when (result) {
        is UserResult.Success -> println("Found: ${result.user.name}")
        UserResult.NotFound -> println("User not found")
        is UserResult.Error -> println("Error: ${result.message}")
    }
}

// 使用 Optional<T> 自定义类型
sealed class Optional<out T> {
    object None : Optional<Nothing>()
    data class Some<T>(val value: T) : Optional<T>()
    
    companion object {
        fun <T> of(value: T?): Optional<T> = if (value != null) Some(value) else None
        fun <T> empty(): Optional<T> = None
    }
}

fun <T, R> Optional<T>.map(f: (T) -> R): Optional<R> = when (this) {
    is Optional.None -> Optional.None
    is Optional.Some -> Optional.Some(f(value))
}

fun <T, R> Optional<T>.flatMap(f: (T) -> Optional<R>): Optional<R> = when (this) {
    is Optional.None -> Optional.None
    is Optional.Some -> f(value)
}

fun <T> Optional<T>.getOrElse(default: T): T = when (this) {
    is Optional.None -> default
    is Optional.Some -> value
}

fun main() {
    val service = UserService()
    
    process(service.findById("1"))
    process(service.findById("999"))
    process(service.findById("error"))
    
    // Optional 使用
    val value: String? = "hello"
    val opt = Optional.of(value)
    
    val length = opt.map { it.length }.getOrElse(0)
    println("Length: $length")
    
    val empty: String? = null
    val emptyOpt = Optional.of(empty)
    val emptyLength = emptyOpt.map { it.length }.getOrElse(-1)
    println("Empty length: $emptyLength")
}

4.13 多值可空组合：自定义 safeLet#

kotlinc -script safe_let.kts

// safe_let.kts
// 自定义多值可空组合

// 双值组合
fun <T1, T2, R> safeLet(
    v1: T1?,
    v2: T2?,
    block: (T1, T2) -> R
): R? {
    return if (v1 != null && v2 != null) block(v1, v2) else null
}

// 三值组合
fun <T1, T2, T3, R> safeLet(
    v1: T1?,
    v2: T2?,
    v3: T3?,
    block: (T1, T2, T3) -> R
): R? {
    return if (v1 != null && v2 != null && v3 != null) block(v1, v2, v3) else null
}

// 四值组合
fun <T1, T2, T3, T4, R> safeLet(
    v1: T1?,
    v2: T2?,
    v3: T3?,
    v4: T4?,
    block: (T1, T2, T3, T4) -> R
): R? {
    return if (v1 != null && v2 != null && v3 != null && v4 != null) block(v1, v2, v3, v4) else null
}

// 使用 Optional + 契约
import kotlin.contracts.*

fun <T1, T2, R> zipValues(
    v1: T1?,
    v2: T2?,
    block: (T1, T2) -> R
): R? {
    contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
    return if (v1 != null && v2 != null) block(v1, v2) else null
}

data class User(val name: String, val age: Int)
data class Address(val city: String, val zip: String)

fun main() {
    val name: String? = "Alice"
    val age: Int? = 25
    val city: String? = "NYC"
    val zip: String? = "10001"
    
    // 双值组合
    val user = safeLet(name, age) { n, a -> User(n, a) }
    println("User: $user")
    
    // 三值组合
    val info = safeLet(name, age, city) { n, a, c -> "$n ($a) from $c" }
    println("Info: $info")
    
    // 四值组合
    val fullInfo = safeLet(name, age, city, zip) { n, a, c, z -> "$n ($a) from $c, $z" }
    println("Full: $fullInfo")
    
    // 任一为 null 时返回 null
    val nullName: String? = null
    val partial = safeLet(nullName, age) { n, a -> User(n, a) }
    println("Partial: $partial")  // null
    
    // zipValues（带契约，支持智能转换）
    val result = zipValues(name, age) { n, a -> "$n is $a years old" }
    println("Zipped: $result")
}

4.14 Android 视图绑定#

# Android 项目，假设有 ViewBinding
# 详见 Android 官方文档

// AndroidViewBinding.kt（示意）
// 使用委托属性封装 ViewBinding

import kotlin.properties.ReadOnlyProperty
import kotlin.reflect.KProperty

// 自定义委托：封装 ViewBinding 的延迟初始化
class ViewBindingDelegate<T> : ReadOnlyProperty<androidx.fragment.app.Fragment, T> {
    private var binding: T? = null
    
    override fun getValue(thisRef: androidx.fragment.app.Fragment, property: KProperty<*>): T {
        // 已缓存则返回
        binding?.let { return it }
        
        // 否则创建（实际项目中通过反射或 Generated Binding）
        throw IllegalStateException("ViewBinding not initialized")
    }
    
    fun clear() {
        binding = null
    }
}

// 使用示例（伪代码，需 Android 环境）
/*
class MyFragment : Fragment() {
    private val binding: MyFragmentBinding by ViewBindingDelegate()
    
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        binding = MyFragmentBinding.inflate(inflater, container, false)
        return binding.root
    }
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding.textView.text = "Hello"
    }
    
    override fun onDestroyView() {
        super.onDestroyView()
        // 清理 binding 引用
        (binding as? ViewBindingDelegate<*>)?.clear()
    }
}
*/

// 简化版：使用 lazy + viewLifecycleOwner
class SimpleFragment {
    private val binding by lazy {
        // 实际：MyFragmentBinding.inflate(layoutInflater)
        "MyFragmentBinding"
    }
    
    fun onViewCreated() {
        println("Binding: $binding")
    }
}

fun main() {
    val fragment = SimpleFragment()
    fragment.onViewCreated()
}

4.15 数据库实体可空处理#

kotlinc -script db_entities.kts

// db_entities.kts
// 数据库实体中可空字段的正确处理

// 模拟数据库行
class DataRow {
    private val data = mutableMapOf<String, Any?>()
    
    fun put(key: String, value: Any?) {
        data[key] = value
    }
    
    // 返回平台类型
    fun get(key: String): Any? = data[key]
    
    // 类型安全的获取
    inline fun <reified T> getTyped(key: String): T? {
        val value = data[key] ?: return null
        return if (value is T) value else null
    }
}

// 实体定义
data class UserEntity(
    val id: Long,
    val name: String,           // NOT NULL
    val email: String?,         // NULLABLE
    val age: Int?,               // NULLABLE
    val deletedAt: String?      // NULLABLE
)

// 映射函数
fun mapUser(row: DataRow): UserEntity {
    return UserEntity(
        id = row.getTyped<Long>("id") ?: throw IllegalStateException("id is required"),
        name = row.getTyped<String>("name") ?: throw IllegalStateException("name is required"),
        email = row.getTyped<String>("email"),
        age = row.getTyped<Int>("age"),
        deletedAt = row.getTyped<String>("deleted_at")
    )
}

fun main() {
    val row = DataRow()
    row.put("id", 1L)
    row.put("name", "Alice")
    row.put("email", null)
    row.put("age", 25)
    // deleted_at 未设置
    
    val user = mapUser(row)
    println("User: $user")
    println("Email is null: ${user.email == null}")
    
    // 使用 ?. 与 ?: 处理可空字段
    val displayEmail = user.email ?: "未填写"
    println("Display email: $displayEmail")
    
    // 条件判断
    if (user.age != null && user.age >= 18) {
        println("成年人")
    }
    
    // 已删除用户
    if (user.deletedAt != null) {
        println("用户已删除于: ${user.deletedAt}")
    } else {
        println("活跃用户")
    }
}

4.16 Kotlin 与 Java 互操作最佳实践#

# 假设有 Java 类，使用 @Nullable / @NotNull 注解
kotlinc -cp . -script interop_best.kts

// interop_best.kts
// 模拟带注解的 Java 类
import org.jetbrains.annotations.Nullable
import org.jetbrains.annotations.NotNull

class JavaServiceWithAnnotations {
    @NotNull
    fun getRequiredName(): String = "Alice"
    
    @Nullable
    fun getOptionalName(): String? = null
    
    @NotNull
    fun getList(): List<String> = listOf("a", "b", "c")
}

class JavaServiceWithoutAnnotations {
    // 无注解的 Java 方法（平台类型）
    fun getName(): String = "Bob"  // Kotlin 中当作 String!
}

fun main() {
    val service1 = JavaServiceWithAnnotations()
    
    // 有注解时，Kotlin 能正确推断
    val name: String = service1.getRequiredName()  // String
    val optional: String? = service1.getOptionalName()  // String?
    val list: List<String> = service1.getList()  // List<String>
    
    println("Required: $name")
    println("Optional: $optional")
    println("List: $list")
    
    val service2 = JavaServiceWithoutAnnotations()
    
    // 无注解时，平台类型
    // 推荐做法 1：赋值给可空类型
    val name2: String? = service2.getName()
    println("Platform nullable: $name2")
    
    // 推荐做法 2：使用安全调用
    val length = service2.getName()?.length ?: 0
    println("Platform safe: $length")
    
    // 不推荐：直接赋值给不可空（运行时可能 NPE）
    // val unsafe: String = service2.getName()
}

5. 对比分析#

5.1 与 Java 的对比#

// Java 代码
String name = getName();  // 可能为 null
if (name != null) {
    System.out.println(name.length());
}

// Optional
Optional<String> opt = Optional.ofNullable(getName());
opt.ifPresent(n -> System.out.println(n.length()));

// Kotlin 代码
val name: String? = getName()
name?.let { println(it.length) }

5.2 与 Swift 的对比#

// Swift 代码
let name: String? = getName()
if let n = name {
    print(n.count)
}

// Optional chaining
let length = name?.count ?? 0

5.3 与 C# 的对比#

// C# 8.0+
string? name = GetName();
int? length = name?.Length;
int safeLength = name?.Length ?? 0;

5.4 与 TypeScript 的对比#

// TypeScript
let name: string | null = getName();
let length: number | null = name?.length;
let safeLength: number = name?.length ?? 0;

// 非空断言
let forced: string = name!;

5.5 与 Rust 的对比#

// Rust 代码
let name: Option<String> = get_name();
match name {
    Some(n) => println!("{}", n.len()),
    None => println!("No name"),
}

// if let 语法糖
if let Some(n) = name {
    println!("{}", n.len());
}

5.6 与 Go 的对比#

// Go 代码
name, err := getName()
if err != nil {
    return err
}
// 使用 name

// Kotlin 代码
val name = getName()  // 返回 String? 或 Result<String>
name?.let { /* 使用 */ }

5.7 跨语言对比表#

6. 常见陷阱与最佳实践#

6.1 陷阱 1：过度使用 !!#

反模式：

// 错误：过度使用 !!
val user = getUser()!!
val name = user.name!!
val length = name.length!!

问题：!! 会将可空类型强制转换为不可空，但代价是运行时 NPE。每个 !! 都是潜在的崩溃点。

最佳实践：

// 正确：使用 ?. 与 ?: 优雅处理
val length = getUser()?.name?.length ?: 0

何时可以使用 !!：

1. 明确知道值非空：如刚初始化的 lateinit var。
2. 第三方 API 文档保证：但应优先用 requireNotNull。
3. 测试代码：测试中可以使用 !! 简化断言。

6.2 陷阱 2：lateinit 用于可空场景#

反模式：

// 错误：lateinit 用于可能不初始化的场景
class UserController {
    lateinit var userService: UserService  // 如果 setup() 未调用则崩溃
    
    fun process() {
        userService.process()  // UninitializedPropertyAccessException
    }
}

最佳实践：

// 正确：使用可空类型 + 显式检查
class UserController {
    private var userService: UserService? = null
    
    fun setup() {
        userService = UserService()
    }
    
    fun process() {
        userService?.process() ?: throw IllegalStateException("Not initialized")
    }
}

// 或使用 lazy
class UserController {
    val userService: UserService by lazy { UserService() }
    
    fun process() {
        userService.process()
    }
}

lateinit 适用场景：

1. 确定会被初始化：如 Android Activity.onCreate。
2. 不可空的引用类型：lateinit 不支持 Int、Boolean 等基本类型。
3. 需要可变：lateinit 必须是 var。

6.3 陷阱 3：平台类型未显式处理#

反模式：

// 错误：未显式处理平台类型
val name = javaService.getName()  // 类型是 String!（平台类型）
println(name.length)  // 如果 name 为 null，运行时 NPE

最佳实践：

// 正确：显式声明可空性
val name: String? = javaService.getName()  // 当作可空
val length = name?.length ?: 0

// 或强制非空（确保不抛 NPE）
val safeName: String = javaService.getName() ?: "default"

// 推荐：为 Java API 添加 @Nullable / @NotNull 注解
// Java 代码：
// @Nullable String getName()
// @NotNull String getRequiredName()

6.4 陷阱 4：智能转换失效#

反模式：

// 错误：var 属性智能转换失效
class Example {
    var name: String? = null
    
    fun process() {
        if (name != null) {
            // 编译错误：Smart cast to 'String' is impossible, because 'name' is a mutable property
            // println(name.length)
            println(name!!.length)  // 需要 !!
        }
    }
}

原因：var 属性在多线程下可能被修改，编译器保守地不应用智能转换。

最佳实践：

// 正确：使用局部变量
class Example {
    var name: String? = null
    
    fun process() {
        val n = name  // 局部变量
        if (n != null) {
            println(n.length)  // 智能转换生效
        }
    }
}

// 或使用 val
class Example {
    val name: String? = null  // val 时智能转换可能生效
    
    fun process() {
        if (name != null) {
            // name 是 final val，智能转换生效
            println(name.length)
        }
    }
}

6.5 陷阱 5：?.let 与智能转换的混淆#

反模式：

// 错误：误以为 ?.let 内的 it 是原变量
fun process(x: String?) {
    x?.let {
        // it 是 String 类型，但 x 仍是 String?
        // 试图修改 x 不会影响 it
    }
}

正确理解：

fun process(x: String?) {
    x?.let { nonNull ->
        // nonNull 是 String 类型（it 的别名）
        println(nonNull.length)
        
        // 但 x 仍然是 String?，因为 let 接收的是 x 的非空拷贝
        // 不能在 let 内通过 x 访问非空成员
    }
}

6.6 陷阱 6：?: 优先级问题#

反模式：

// 错误：误以为 ?: 优先级低于 +
val result = x ?: "default" + "suffix"
// 实际解析为：x ?: ("default" + "suffix")
// 而非：(x ?: "default") + "suffix"

最佳实践：

// 正确：使用括号明确优先级
val result = (x ?: "default") + "suffix"

?: 的优先级低于 +、-、*、/，与 || 相同。

6.7 陷阱 7：as? 与泛型#

反模式：

// 错误：as? 与泛型类型擦除
val list: List<*> = listOf(1, 2, 3)
val stringList = list as? List<String>  // 不会返回 null（类型擦除）
stringList?.forEach { 
    // 运行时：ClassCastException（实际是 List<Int>）
    println(it.length)
}

原因：JVM 的泛型类型擦除导致 as? 无法检查元素类型。

最佳实践：

// 正确：使用 filterIsNotNull 或显式检查
val list: List<*> = listOf(1, 2, 3)
val stringList: List<String> = list.filterIsInstance<String>()
println(stringList)  // []（无 String 元素）

// 或手动检查
val first = list.firstOrNull()
if (first is String) {
    println(first.length)
}

6.8 陷阱 8：lateinit 用于基本类型#

反模式：

// 错误：lateinit 不支持基本类型
class Example {
    // lateinit var count: Int  // 编译错误：'lateinit' modifier is not allowed on properties of primitive types
    // lateinit var flag: Boolean  // 编译错误
    
    // 替代方案 1：使用可空类型
    var count: Int? = null
    
    // 替代方案 2：使用 Delegates.notNull
    var port: Int by Delegates.notNull()
}

6.9 陷阱 9：requireNotNull 后的智能转换#

反模式：

// 误以为 requireNotNull 后 x 变为非空
fun process(x: String?) {
    requireNotNull(x)
    // 编译器根据契约知道 x != null
    // 但如果 x 是 var 属性，智能转换可能失效
    println(x.length)  // 在局部变量场景下生效
}

class Example {
    var x: String? = null
    
    fun process() {
        requireNotNull(x)
        // 错误：x 是 var 属性，契约不保证后续访问
        // println(x.length)  // 编译错误
        println(x!!.length)
    }
}

6.10 陷阱 10：Result 的误用#

反模式：

// 错误：将 Result 用作返回类型（官方不推荐）
fun findUser(id: String): Result<User> {
    // ...
}

// 在 Stream 中使用
val users = ids.map { findUser(it) }
    .filter { it.isSuccess }
    // ...

官方建议：Result 不应用作公共 API 的返回类型，而是用于内部错误处理。公共 API 应使用 T? 或 sealed class。

// 正确：公共 API 使用 sealed class
sealed class FindResult {
    data class Success(val user: User) : FindResult()
    object NotFound : FindResult()
}

fun findUser(id: String): FindResult {
    // ...
}

6.11 陷阱 11：forEach 中的 null 检查#

反模式：

// 错误：在 forEach 中使用 !!
val names: List<String?> = listOf("Alice", null, "Bob")
names.forEach {
    println(it!!.length)  // NPE
}

最佳实践：

// 正确：使用 ?. 或 filterNotNull
names.forEach { name ->
    name?.let { println(it.length) }
}

// 或先过滤
names.filterNotNull().forEach { println(it.length) }

6.12 陷阱 12：契约的滥用#

反模式：

// 错误：滥用契约，提供错误信息
fun isNotNull(x: Any?): Boolean {
    contract {
        returns(true) implies (x != null)
    }
    return x != null
}

// 使用
fun process(x: String?) {
    if (isNotNull(x)) {
        // 编译器认为 x 非 null
        println(x.length)
    }
}

问题：虽然语法正确，但契约应反映函数的真实行为，不能误导编译器。

最佳实践：契约应与函数实现一致，且用于表达编译器无法自动推断的事实。

6.13 最佳实践总结#

1. 优先使用 ?. 与 ?:，避免 !!。
2. lateinit 用于确定会初始化的场景，否则用 lazy 或可空类型。
3. 平台类型显式声明，避免隐式传播。
4. 使用局部变量触发智能转换，避免对 var 属性的多次访问。
5. filterNotNull 与 mapNotNull 优于手动过滤。
6. requireNotNull 与 checkNotNull 用于前置条件。
7. 公共 API 优先使用 sealed class，而非 Result 或 T?。
8. 跨模块 API 添加空安全注解（@Nullable / @NotNull）。
9. 测试代码可适度使用 !! 简化断言。
10. safeLet 等组合器用于多值同时非空，避免嵌套 ?.let。

7. 工程实践#

7.1 团队规范建议#

7.1.1 空安全规范

// 规范示例
class UserService {
    // 公共 API：明确标注可空性
    fun findById(id: String): User? {
        // ...
    }
    
    fun requireById(id: String): User {
        return findById(id) ?: throw UserNotFoundException(id)
    }
    
    // 内部方法：使用 requireNotNull 简化
    fun process(id: String) {
        val user = requireNotNull(findById(id)) { "User $id not found" }
        // 此处 user 是 User（非空）
    }
}

7.1.2 Detekt 规则

# detekt.yml
complexity:
  active: true
  LongMethod:
    threshold: 60

potential-bugs:
  active: true
  UnsafeCallOnNullableType:
    active: true  # 禁止 !!
  LateinitUsage:
    active: false  # 允许 lateinit，但建议在规范中约束

style:
  active: true
  ReturnCount:
    active: false  # 允许多 return
  MandatoryBracesLoops:
    active: false