空安全详解（Null Safety in Depth）

本文档对标 MIT 6.005、Stanford CS193P、CMU 15-410 教学水准，系统讲解 Kotlin 空安全（Null Safety）机制从设计哲学到 JVM 字节码实现的完整链路。内容覆盖 Kotlin 1.0 至 2.0 的演进，包括可空类型、智能转换（Smart Casts）、平台类型（Platform Types）、lateinit、Elvis 运算符、安全调用链等核心主题，配套企业级生产代码、跨语言对比、形式化推导与习题解析。

目录

1. 学习目标
2. 历史动机与发展脉络
3. 形式化定义
4. 理论推导与原理解析
5. 代码示例
6. 对比分析
7. 常见陷阱与最佳实践
8. 工程实践
9. 案例研究
10. 习题
11. 参考文献
12. 延伸阅读

1. 学习目标

本章节遵循 Bloom 教育目标分类学（Bloom’s Taxonomy）的六个认知层级，由低阶到高阶逐层递进。

1.1 Remember（记忆）

完成本章节后，学习者应能够准确记忆以下知识点：

• 复述 Kotlin 区分可空类型（T?）与不可空类型（T）的类型系统设计。
• 列举四大空安全操作符：安全调用 ?.、Elvis 运算符 ?:、非空断言 !!、安全转换 as?。
• 背诵智能转换（Smart Casts）的触发条件：is 检查、null 检查、when 分支。
• 记忆 lateinit 与 lazy 的语义差异：前者用于 var 延迟初始化，后者用于 val 惰性求值。
• 列举平台类型（Platform Type）的表示形式：String!、List<Int!>!、Map<String!, Int!>!。
• 复述 filterNotNull、mapNotNull、forEachNotNull 三个集合操作函数的签名与用途。
• 记忆 requireNotNull、checkNotNull 两个前置条件函数的语义：失败时抛出 IllegalArgumentException 与 IllegalStateException。
• 列举 OrNull 系列扩展：firstOrNull、lastOrNull、getOrNull、minOrNull、maxOrNull。

1.2 Understand（理解）

• 用自己的语言解释”-billion-dollar mistake”（Tony Hoare 1965 年引入空引用）的历史背景与代价。
• 解释可空类型在 JVM 字节码层面的表示：通过 @Nullable 注解（org.jetbrains.annotations）实现，运行时无类型差异。
• 描述智能转换的实现机制：编译器在控制流图中维护类型细化（Type Narrowing）信息，在安全分支内将 T? 细化为 T。
• 阐述平台类型的必要性：Java 代码不携带空安全信息，Kotlin 无法确定其是否可空，因此推迟到使用处决策。
• 解释 ?.let { ... } 与 ?.run { ... } 在空安全处理中的差异：前者通过 it 引用，后者通过 this 引用。
• 理解 ?: 与 || 的语义差异：前者用于 null 合并，后者用于布尔或运算。
• 解释 lateinit 的实现：编译器在字段上添加 @NotNull 注解，并在 getter 中插入 null 检查（抛出 UninitializedPropertyAccessException）。
• 描述契约（Contract）机制对智能转换的辅助作用：requireNotNull(x) 后编译器知道 x 不为 null。

1.3 Apply（应用）

• 在 API 响应处理中使用 ?. 链式调用与 ?: 默认值，优雅处理深层嵌套的 null。
• 在集合操作中使用 filterNotNull、mapNotNull 过滤 null 元素，得到非空类型集合。
• 使用 requireNotNull 与 ?: 配合，实现函数前置参数校验与状态检查。
• 使用 lateinit 实现 Android Activity 的 ViewBinding 延迟初始化。
• 使用 safeLet、zipValues 等自定义扩展，处理多个可空值的同时非空逻辑。
• 在 Java 互操作场景中显式标注 @Nullable / @NotNull，消除平台类型歧义。
• 使用 sealed class + Nothing 表示”不可能有值”的分支，借助编译器穷尽性检查。

1.4 Analyze（分析）

• 反编译 Kotlin 代码，分析 ?. 在字节码中等价于 if (x != null) f(x) else null 的实现。
• 对比 lateinit var 与 by lazy { } 在字节码层面的差异：前者是字段 + null 检查，后者是 Lazy 对象 + 双重检查锁。
• 分析智能转换在复杂控制流中的限制：跨函数、跨线程、val vs var 的差异。
• 解构平台类型的传播规则：String! 传给 Kotlin 函数时，按目标类型推断（String 或 String?）。
• 分析 contract 的实现原理：通过 callsInPlace、returns 等契约告知编译器控制流信息。

1.5 Evaluate（评价）

• 评价 Kotlin 选择”类型系统层”而非”运行时检查”实现空安全的设计权衡。
• 评价 !! 操作符的存在价值：是”逃生舱”还是”代码异味”？
• 评价平台类型的设计：是”实用性妥协”还是”类型安全漏洞”？
• 评估 lateinit 的设计：相比 lazy，它的不可空保证较弱，是否值得引入？
• 评价智能转换的语义限制：在多线程场景下智能转换可能失效，是否过于宽松？
• 评估 Result<T> 类型在空安全中的角色：是否应替代 T? 用于”可能失败”的场景？

1.6 Create（创造）

• 设计并实现一个完整的”可空值组合器”（Nullable Combinator）：支持 map2、map3、flatMap 等高阶操作。
• 设计一个基于 sealed class 的 Optional<T> 类型，提供 map、flatMap、filter、getOrElse 操作。
• 实现一个”防御式 Java 互操作层”：自动将平台类型转换为可空类型，并提供 requireNotNull 包装。
• 撰写一份团队空安全规范：何时用 lateinit、何时用 lazy、何时用 T?、何时禁用 !!。
• 设计一个基于契约的自定义智能转换函数：fun <T> T?.requireNonNull(): T 在调用后使编译器知道 this 非 null。

2. 历史动机与发展脉络

2.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 平台不增加运行时开销，仅依赖注解与编译器检查。

2.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 的高度互操作。

2.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 扩展。

2.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
}

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

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

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

2.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()。

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

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

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

2.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 项目中可空类型信息在模块间传递。

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

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

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

2.10 JetBrains 的设计哲学

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

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

2.11 时间线总览

1965  ALGOL W — Tony Hoare 引入空引用（"十亿美元的错误"）
1973  ML — 引入 option 类型，函数式空安全开端
1990  Haskell — Maybe monad，类型系统化空安全
2004  Scala — Option[T]，函数式容器
2014  Swift — Optional<T>，语法糖 T?
2016  Kotlin 1.0 — 空安全初版，T?/?. /?:/!!/as?
2017  Kotlin 1.1 — 实验性契约 API
2018  Kotlin 1.3 — 契约稳定，KMP 一致性
2020  Kotlin 1.4 — @Nullable 注解标准化
2022  Kotlin 1.7 — K2 预览，智能转换优化
2023  Kotlin 1.9 — JSpecify 集成
2024  Kotlin 2.0 — K2 GA，跨模块空安全检查

3. 形式化定义

3.1 类型系统的空安全扩展

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

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

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

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

3.2 Null 类型

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

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

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

3.3 子类型关系的形式化

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

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

特殊地：

3.4 安全调用操作符 ?.

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

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

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

3.5 Elvis 运算符 ?:

Elvis 运算符的形式化定义：

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

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

3.6 非空断言操作符 !!

非空断言的形式化定义：

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

3.7 安全转换操作符 as?

安全转换的形式化定义：

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

3.8 智能转换（Smart Casts）

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

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

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

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

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

3.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!，传播平台类型。

3.10 lateinit 的形式化

lateinit var 的形式化定义：

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

访问语义：

3.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)
}

3.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;

4. 理论推导与原理解析

4.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：

4.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}\}$）。

形式化地：

4.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 检查与使用之间可能被其他线程修改，因此不应用智能转换。

4.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()

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

4.5 ?. 链式的类型推导

考虑：

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

类型推导规则：

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

4.6 ?: 与 ?. 的等价性

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

形式化地：

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

4.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();
}

对比：

4.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)
}

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

4.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?。

4.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 的形式化：

5. 代码示例

5.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")
}

5.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)))
}

5.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
}

5.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("年龄未知")
}

5.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")
}

5.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: 配置未加载
}

5.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"))
}

5.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
}

5.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
}

5.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")
}

5.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; }

5.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")
}

5.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")
}

5.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()
}

5.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("活跃用户")
    }
}

5.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()
}

6. 对比分析

6.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) }

6.2 与 Swift 的对比

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

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

6.3 与 C# 的对比

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

6.4 与 TypeScript 的对比

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

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

6.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());
}

6.6 与 Go 的对比

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

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

6.7 跨语言对比表

7. 常见陷阱与最佳实践

7.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. 测试代码：测试中可以使用 !! 简化断言。

7.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。

7.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()

7.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)
        }
    }
}

7.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 访问非空成员
    }
}

7.6 陷阱 6：?: 优先级问题

反模式：

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

最佳实践：

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

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

7.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)
}

7.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()
}

7.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)
    }
}

7.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 {
    // ...
}

7.11 陷阱 11：forEach 中的 null 检查

反模式：

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