类型系统深入

// Any 类的核心定义（简化版）
// 位于 kotlin 包中，是所有 Kotlin 类的隐式父类
public open class Any {
    // 比较两个对象是否"相等"
    // 默认实现是引用相等（===），子类通常会重写
    public open operator fun equals(other: Any?): Boolean
    
    // 返回对象的哈希码，用于 HashMap、HashSet 等数据结构
    // 契约：equals 相等的对象必须有相同的 hashCode
    public open fun hashCode(): Int
    
    // 返回对象的字符串表示
    // 默认返回 "类名@哈希码"，子类通常会重写以提供更有意义的信息
    public open fun toString(): String
}

// 场景一：作为通用容器的类型参数
// 当你需要存储任意类型的对象时
val mixedList: MutableList<Any> = mutableListOf(
    "Hello",           // String 类型
    42,                // Int 类型（自动装箱）
    3.14,              // Double 类型
    listOf(1, 2, 3)    // List<Int> 类型
)
 
// 场景二：作为函数参数，接受任意非空值
fun printInfo(obj: Any) {
    // 所有对象都保证有这三个方法
    println("类型: ${obj::class.simpleName}")  // 获取运行时类型名
    println("toString: $obj")                   // 调用 toString()
    println("hashCode: ${obj.hashCode()}")      // 调用 hashCode()
}
 
// 场景三：类型检查与智能转换的基础
fun processAny(value: Any) {
    // 使用 when 表达式进行类型分发
    when (value) {
        is String -> println("字符串长度: ${value.length}")  // 智能转换为 String
        is Int -> println("整数的平方: ${value * value}")    // 智能转换为 Int
        is List<*> -> println("列表大小: ${value.size}")     // 智能转换为 List
        else -> println("未知类型: ${value::class}")
    }
}

// Any：所有"非空"类型的父类型
// Any?：所有类型（包括可空类型）的父类型
 
val nonNullValue: Any = "Hello"    // ✅ 正确：String 是 Any 的子类型
// val nonNullValue2: Any = null   // ❌ 编译错误：null 不能赋给 Any
 
val nullableValue: Any? = null     // ✅ 正确：Any? 可以持有 null
val alsoNullable: Any? = "Hello"   // ✅ 正确：Any? 也可以持有非空值
 
// 类型层次关系
// Any? 是真正的"万能类型"，Any 是"万能非空类型"
fun acceptAnything(value: Any?) {
    // value 可能是 null，必须进行空检查
    if (value != null) {
        println(value.toString())  // 安全调用
    }
}

┌─────────────────────────────────────────────────┐
│                    Any?                         │
│  ┌───────────────────────────────────────────┐  │
│  │                  Any                      │  │
│  │  ┌─────────┐ ┌─────────┐ ┌─────────────┐  │  │
│  │  │ String  │ │   Int   │ │ CustomClass │  │  │
│  │  └─────────┘ └─────────┘ └─────────────┘  │  │
│  └───────────────────────────────────────────┘  │
│                    null                         │
└─────────────────────────────────────────────────┘

// Nothing 的定义（概念性的，实际无法实例化）
public class Nothing private constructor() {
    // 私有构造函数，永远无法创建实例
    // 这个类存在的意义不是被实例化，而是作为类型系统的一部分
}

// 抛出异常的函数 —— 永远不会正常返回
fun fail(message: String): Nothing {
    // 这个函数执行后，控制流永远不会继续
    // 要么抛出异常，要么进入无限循环
    throw IllegalArgumentException(message)
}
 
// 无限循环的函数 —— 同样永不返回
fun infiniteLoop(): Nothing {
    while (true) {
        // 永远执行下去...
        Thread.sleep(1000)
    }
}
 
// 实际应用：结合 Elvis 操作符
fun getUser(id: Int): User {
    // 如果 findUser 返回 null，则调用 fail()
    // 由于 fail() 返回 Nothing，整个表达式的类型是 User
    return findUser(id) ?: fail("User not found: $id")
}
 
// 为什么这能工作？
// Nothing 是所有类型的子类型，所以 Nothing 也是 User 的子类型
// 因此 "User ?: Nothing" 的结果类型是 User

// 空列表的类型推断
val emptyList: List<Nothing> = emptyList()
 
// 为什么是 List<Nothing>？
// 因为列表为空，没有任何元素，所以元素类型可以是"任何类型的子类型"
// Nothing 正是这样的类型
 
// 这使得空列表可以赋值给任何类型的列表变量
val stringList: List<String> = emptyList()  // ✅ List<Nothing> 兼容 List<String>
val intList: List<Int> = emptyList()        // ✅ List<Nothing> 兼容 List<Int>
val anyList: List<Any> = emptyList()        // ✅ List<Nothing> 兼容 List<Any>

// Kotlin 标准库中的 TODO 函数
public inline fun TODO(): Nothing = throw NotImplementedError()
 
public inline fun TODO(reason: String): Nothing = 
    throw NotImplementedError("An operation is not implemented: $reason")
 
// 使用示例
fun calculateComplexAlgorithm(): Double {
    TODO("等待算法专家实现")
    // 编译器知道这行代码永远不会执行
    // 所以不会报"缺少 return 语句"的错误
}
 
// TODO() 的妙用：占位符开发
class UserRepository {
    fun findById(id: Long): User = TODO()      // 暂未实现
    fun save(user: User): Unit = TODO()        // 暂未实现
    fun delete(id: Long): Boolean = TODO()     // 暂未实现
}

// Nothing：没有任何值，是所有类型的子类型
// Nothing?：只有一个值 null，是所有可空类型的子类型
 
val nothingValue: Nothing = ???  // ❌ 不可能，Nothing 没有任何实例
 
val nothingNullable: Nothing? = null  // ✅ 唯一可能的值就是 null
 
// Nothing? 的实际意义
// 它是 null 字面量的类型
val justNull = null  // 类型推断为 Nothing?

// Unit 的定义
public object Unit {
    // Unit 是一个单例对象
    // 只有一个实例，就是 Unit 本身
    override fun toString() = "kotlin.Unit"
}
 
// Unit 作为返回类型
fun printMessage(message: String): Unit {
    println(message)
    // 隐式返回 Unit
    // return Unit  // 可以显式写，但通常省略
}
 
// 省略 Unit 的简写形式（最常见）
fun printMessage2(message: String) {
    println(message)
    // 返回类型推断为 Unit
}

// 在 Java 中，你需要区分 Function 和 Consumer
// Java: Function<String, Void> vs Consumer<String>
 
// 在 Kotlin 中，一切都是返回值的函数
val printFunction: (String) -> Unit = { message ->
    println(message)
    // 隐式返回 Unit
}
 
// 高阶函数可以统一处理
fun <T, R> transform(value: T, transformer: (T) -> R): R {
    return transformer(value)
}
 
// 无论返回什么类型，都可以使用同一个函数
val result1: Int = transform("Hello") { it.length }        // 返回 Int
val result2: Unit = transform("Hello") { println(it) }     // 返回 Unit

// Unit 可以作为泛型参数，这是 void 做不到的
interface Callback<T> {
    fun onSuccess(result: T)
    fun onError(error: Throwable)
}
 
// 当不需要返回数据时，使用 Unit
class VoidCallback : Callback<Unit> {
    override fun onSuccess(result: Unit) {
        println("操作成功完成")
    }
    
    override fun onError(error: Throwable) {
        println("操作失败: ${error.message}")
    }
}
 
// 协程中的常见模式
// suspend fun doSomething(): Unit
// Deferred<Unit> 表示一个没有返回值的异步操作

// Kotlin 的 Unit 返回函数
fun kotlinFunction(): Unit {
    println("Kotlin function")
}
 
// 从 Java 调用时，返回类型是 void
// Java: kotlinFunction();  // 返回 void
 
// 但如果你需要在 Java 中获取 Unit 实例
// Java: Unit unit = KotlinFileKt.kotlinFunction();  // 也可以

// ┌─────────────┬──────────────────────────────────────────────────┐
// │   概念       │                    说明                          │
// ├─────────────┼──────────────────────────────────────────────────┤
// │ Java void   │ 关键字，表示无返回值，不是类型                      │
// │ Java Void   │ void 的包装类，唯一值是 null                       │
// │ Kotlin Unit │ 真正的类型，单例对象，有且仅有一个实例               │
// └─────────────┴──────────────────────────────────────────────────┘
 
// Unit 的优势演示
fun demonstrateUnitAdvantage() {
    // 1. 可以存储在变量中
    val unit: Unit = Unit
    
    // 2. 可以作为表达式的值
    val result = if (true) {
        println("执行某操作")
        // 这个分支返回 Unit
    } else {
        println("执行另一操作")
        // 这个分支也返回 Unit
    }
    // result 的类型是 Unit
    
    // 3. 可以用在集合中
    val unitList: List<Unit> = listOf(Unit, Unit, Unit)
    
    // 4. 可以进行比较（虽然没什么意义）
    println(Unit == Unit)  // true，因为是单例
    println(Unit === Unit) // true，同一个实例
}

// 综合示例：展示三种类型的协作
class TypeHierarchyDemo {
    
    // Any：接受任意非空值
    fun logAny(value: Any) {
        println("[LOG] ${value::class.simpleName}: $value")
    }
    
    // Unit：表示"执行动作，不关心返回值"
    fun performAction(action: () -> Unit) {
        println("开始执行动作...")
        action()  // 执行传入的动作
        println("动作执行完毕")
    }
    
    // Nothing：表示"此路不通"
    fun validatePositive(number: Int): Int {
        return if (number > 0) {
            number
        } else {
            // fail() 返回 Nothing，所以整个 if 表达式返回 Int
            fail("数字必须为正数，实际值: $number")
        }
    }
    
    private fun fail(message: String): Nothing {
        throw IllegalArgumentException(message)
    }
    
    // 综合运用
    fun demonstrate() {
        // Any 的使用
        logAny("Hello")      // 字符串
        logAny(42)           // 整数
        logAny(listOf(1,2))  // 列表
        
        // Unit 的使用
        performAction {
            println("这是一个返回 Unit 的 lambda")
        }
        
        // Nothing 的使用（通过 validatePositive）
        val validNumber = validatePositive(10)  // 正常返回 10
        // val invalid = validatePositive(-5)   // 会抛出异常
    }
}

// 非空类型：保证永远不会是 null
var name: String = "Alice"      // ✅ 正确
// name = null                  // ❌ 编译错误：Null can not be a value of a non-null type String
 
// 可空类型：显式声明"这个值可能为 null"
var nullableName: String? = "Bob"  // ✅ 正确
nullableName = null                 // ✅ 正确：String? 允许 null
 
// 类型推断也遵循这个规则
val inferredNonNull = "Hello"      // 推断为 String（非空）
val inferredNullable: String? = null  // 必须显式声明类型，因为 null 本身无法推断具体类型

// 核心规则：非空类型是可空类型的子类型
// String <: String?（String 是 String? 的子类型）
 
val nonNull: String = "Hello"
val nullable: String? = nonNull    // ✅ 正确：子类型可以赋值给父类型
 
// 反过来不行
val anotherNullable: String? = "World"
// val anotherNonNull: String = anotherNullable  // ❌ 编译错误：需要显式处理可能的 null

┌─────────────────────────────────────────┐
│              String?                    │
│  ┌─────────────────────────────────┐    │
│  │           String                │    │
│  │   "Hello"  "World"  "Kotlin"    │    │
│  └─────────────────────────────────┘    │
│                null                     │
└─────────────────────────────────────────┘
 
String? = String ∪ {null}

val nullableString: String? = "Hello"
 
// 不能直接调用成员方法或访问属性
// val length = nullableString.length  // ❌ 编译错误：Only safe (?.) or non-null asserted (!!.) calls are allowed
 
// 必须先处理 null 的可能性
// 方式一：显式 null 检查
if (nullableString != null) {
    // 在这个作用域内，编译器知道 nullableString 不是 null
    // 发生"智能转换"（Smart Cast）为 String
    val length = nullableString.length  // ✅ 正确
    println("长度: $length")
}
 
// 方式二：使用安全调用操作符（下一节详解）
val safeLength = nullableString?.length  // ✅ 正确，返回 Int?
 
// 方式三：使用 Elvis 操作符提供默认值（后续详解）
val lengthOrZero = nullableString?.length ?: 0  // ✅ 正确，返回 Int

// 参数可空性
fun greet(name: String?) {
    // name 可能为 null，必须安全处理
    if (name != null) {
        println("Hello, $name!")
    } else {
        println("Hello, stranger!")
    }
}
 
// 调用示例
greet("Alice")  // 输出: Hello, Alice!
greet(null)     // 输出: Hello, stranger!
 
// 返回值可空性
fun findUserById(id: Int): User? {
    // 可能找到用户，也可能返回 null
    return database.query("SELECT * FROM users WHERE id = ?", id)
}
 
// 调用者必须处理可能的 null
val user: User? = findUserById(42)
// user.name  // ❌ 编译错误
user?.name    // ✅ 安全调用

val nullableString: String? = "Hello, Kotlin"
 
// 安全调用：如果 nullableString 不为 null，调用 length；否则整个表达式返回 null
val length: Int? = nullableString?.length  // 结果: 13
 
// 当值为 null 时
val nullString: String? = null
val nullLength: Int? = nullString?.length  // 结果: null（不会抛出 NPE）
 
// 等价的传统写法（更冗长）
val traditionalLength: Int? = if (nullableString != null) {
    nullableString.length
} else {
    null
}

// 重要：安全调用的返回类型总是可空的
val str: String? = "Hello"
 
val length: Int? = str?.length      // 返回 Int?，不是 Int
val upper: String? = str?.uppercase()  // 返回 String?，不是 String
 
// 即使原始值不为 null，编译器也无法在编译期确定这一点
// 因此返回类型必须是可空的
 
// 如果你确定值不为 null，可以使用 !! 或提供默认值
val definiteLength: Int = str?.length ?: 0      // 使用 Elvis 提供默认值
val assertedLength: Int = str?.length!!         // 使用非空断言（有风险）

class Person(val name: String, var email: String?)
 
val person: Person? = Person("Alice", "alice@example.com")
 
// 安全调用属性
val email: String? = person?.email  // 如果 person 为 null，返回 null
 
// 安全调用方法
val emailLength: Int? = person?.email?.length  // 链式安全调用
 
// 安全调用与赋值结合
person?.email = "newemail@example.com"  // 如果 person 为 null，赋值不会执行
 
// 安全调用执行代码块（配合 let）
person?.let { p ->
    // 只有当 person 不为 null 时，这个代码块才会执行
    // 在这里，p 是非空的 Person 类型
    println("Name: ${p.name}, Email: ${p.email}")
}

// 语法：nullableValue ?: defaultValue
// 语义：如果 nullableValue 不为 null，返回它；否则返回 defaultValue
 
val nullableName: String? = null
val name: String = nullableName ?: "Unknown"  // 结果: "Unknown"
 
val anotherName: String? = "Alice"
val result: String = anotherName ?: "Unknown"  // 结果: "Alice"

// 用法一：提供默认值
fun getDisplayName(user: User?): String {
    return user?.name ?: "Guest"
}
 
// 用法二：提供默认计算
fun getConfigValue(key: String): Int {
    val value: Int? = config[key]
    return value ?: computeDefaultValue(key)  // 只有在 value 为 null 时才计算默认值
}
 
// 用法三：抛出异常
fun requireUser(user: User?): User {
    return user ?: throw IllegalArgumentException("User cannot be null")
}
 
// 用法四：提前返回（Early Return）
fun processUser(user: User?) {
    val validUser = user ?: return  // 如果 user 为 null，直接返回
    // 下面的代码中，validUser 保证不为 null
    println("Processing user: ${validUser.name}")
}
 
// 用法五：结合 Nothing 类型
fun getUser(id: Int): User {
    return findUserById(id) ?: fail("User not found: $id")
    // fail() 返回 Nothing，所以整个表达式类型是 User
}
 
private fun fail(message: String): Nothing {
    throw IllegalStateException(message)
}

// 可以链式使用多个 Elvis 操作符，实现"回退链"
fun getDisplayName(user: User?): String {
    return user?.nickname      // 首选：昵称
        ?: user?.name          // 其次：真名
        ?: user?.email         // 再次：邮箱
        ?: "Anonymous"         // 最后：匿名
}
 
// 实际场景：配置优先级
fun getServerUrl(): String {
    return System.getenv("SERVER_URL")           // 环境变量优先
        ?: config.getProperty("server.url")      // 其次配置文件
        ?: "http://localhost:8080"               // 最后默认值
}

// 最常见的组合模式
val user: User? = findUser(id)
 
// 模式一：获取属性或默认值
val userName: String = user?.name ?: "Unknown"
 
// 模式二：链式调用后提供默认值
val city: String = user?.address?.city ?: "Unknown City"
 
// 模式三：执行操作或替代操作
user?.sendNotification() ?: logWarning("User not found, notification skipped")
 
// 模式四：转换后提供默认值
val nameLength: Int = user?.name?.length ?: 0

val nullableString: String? = "Hello"
 
// 非空断言：将 String? 转换为 String
val nonNullString: String = nullableString!!  // ✅ 正确，因为值确实不为 null
 
// 当值为 null 时
val nullString: String? = null
// val crash: String = nullString!!  // ❌ 运行时抛出 NullPointerException（KotlinNullPointerException）

// 场景一：你比编译器更了解情况
class UserManager {
    private var currentUser: User? = null
    
    fun login(user: User) {
        currentUser = user
    }
    
    fun getCurrentUserName(): String {
        // 业务逻辑保证：调用此方法时用户一定已登录
        // 但编译器不知道这一点
        return currentUser!!.name
    }
}
 
// 场景二：与 Java 代码互操作
// Java 方法返回的类型在 Kotlin 中是"平台类型"
// 如果你确定它不会返回 null
val javaResult: String = javaObject.getStringValue()!!
 
// 场景三：测试代码中
@Test
fun testUserCreation() {
    val user = createUser("Alice")
    // 在测试中，我们期望 user 不为 null
    // 如果为 null，测试应该失败
    assertEquals("Alice", user!!.name)
}

// ⚠️ 危险用法：盲目使用 !!
fun dangerousCode(input: String?) {
    val length = input!!.length  // 如果 input 为 null，程序崩溃
}
 
// ✅ 更好的做法：使用安全调用 + Elvis
fun saferCode(input: String?): Int {
    return input?.length ?: 0
}
 
// ✅ 更好的做法：显式检查并处理
fun explicitCode(input: String?): Int {
    if (input == null) {
        throw IllegalArgumentException("Input cannot be null")
        // 或者 return 0
        // 或者 log warning 并返回默认值
    }
    return input.length  // 智能转换，不需要 !!
}
 
// ✅ 最佳实践：在边界处验证，内部使用非空类型
fun processInput(input: String?) {
    val validInput = input ?: throw IllegalArgumentException("Input required")
    // validInput 是 String 类型，后续代码无需处理 null
    doSomethingWith(validInput)
}

// ❌ 代码异味：连续使用 !!
val city = user!!.address!!.city!!
 
// 问题：
// 1. 如果任何一个为 null，你不知道是哪个
// 2. 异常信息不明确
// 3. 代码脆弱，难以维护
 
// ✅ 更好的做法
val city = user?.address?.city ?: "Unknown"
 
// 或者，如果确实需要非空
val city = user?.address?.city 
    ?: throw IllegalStateException("User must have a complete address")

// 假设我们有一个可空的字符串
val nullableString: String? = getStringFromSomewhere()
 
// 方式一：显式 null 检查（最传统）
if (nullableString != null) {
    println(nullableString.length)  // 智能转换
}
 
// 方式二：安全调用（最常用）
println(nullableString?.length)  // 输出 null 或长度
 
// 方式三：安全调用 + Elvis（需要默认值时）
println(nullableString?.length ?: 0)  // 输出 0 或长度
 
// 方式四：非空断言（确定不为 null 时）
println(nullableString!!.length)  // 可能抛出 NPE

fun main() {
    val a: String? = "Kotlin"
    val b: String? = null
    
    val result1 = a?.length ?: -1
    val result2 = b?.length ?: -1
    val result3 = a?.let { it.uppercase() } ?: "DEFAULT"
    val result4 = b?.let { it.uppercase() } ?: "DEFAULT"
    
    println("$result1, $result2, $result3, $result4")
}

// 假设有一个复杂的对象结构
data class Address(val street: String?, val city: String?)
data class Company(val address: Address?)
data class Employee(val name: String, val company: Company?)
 
// 传统的空安全处理方式 - 嵌套判断
fun getCityTraditional(employee: Employee?): String? {
    if (employee != null) {  // 第一层判断
        val company = employee.company
        if (company != null) {  // 第二层判断
            val address = company.address
            if (address != null) {  // 第三层判断
                return address.city  // 终于可以访问 city
            }
        }
    }
    return null  // 任何一层为 null，返回 null
}
 
// 使用安全调用链 - 优雅简洁
fun getCityWithSafeCall(employee: Employee?): String? {
    return employee?.company?.address?.city  // 一行搞定，任何一环为 null，整体返回 null
}
 
// 测试用例
fun main() {
    val emp1 = Employee("张三", Company(Address("中关村大街", "北京")))
    val emp2 = Employee("李四", Company(Address("淮海路", null)))  // city 为 null
    val emp3 = Employee("王五", Company(null))  // address 为 null
    val emp4 = Employee("赵六", null)  // company 为 null
    
    println(getCityWithSafeCall(emp1))  // 输出: 北京
    println(getCityWithSafeCall(emp2))  // 输出: null (city 为 null)
    println(getCityWithSafeCall(emp3))  // 输出: null (address 为 null)
    println(getCityWithSafeCall(emp4))  // 输出: null (company 为 null)
}

// 场景：发送邮件给员工，但只有当员工的邮箱不为 null 时才发送
data class User(val name: String, val email: String?)
 
fun sendEmail(email: String) {
    println("发送邮件到: $email")
}
 
// 不使用 let - 需要显式判空
fun notifyUserWithoutLet(user: User?) {
    if (user != null) {  // 判空
        val email = user.email  // 提取 email
        if (email != null) {  // 再次判空
            sendEmail(email)  // 执行操作
        }
    }
}
 
// 使用 ?. 配合 let - 简洁优雅
fun notifyUserWithLet(user: User?) {
    user?.email?.let { email ->  // 只有 user 和 email 都非空时，lambda 才执行
        sendEmail(email)  // 在 lambda 内部，email 是智能转换为非空的 String 类型
    }
    // 如果 user 或 email 为 null，整个 let 被跳过，不会执行 sendEmail
}
 
// 更简洁的写法 - 使用 it 隐式参数
fun notifyUserConcise(user: User?) {
    user?.email?.let { sendEmail(it) }  // it 代表非空的 email
}
 
// 测试
fun main() {
    val user1 = User("Alice", "alice@example.com")
    val user2 = User("Bob", null)  // email 为 null
    val user3: User? = null  // user 为 null
    
    notifyUserWithLet(user1)  // 输出: 发送邮件到: alice@example.com
    notifyUserWithLet(user2)  // 不执行，因为 email 为 null
    notifyUserWithLet(user3)  // 不执行，因为 user 为 null
}

data class Config(val timeout: Int, val retryCount: Int)
 
// 不使用 let - 重复的 ?.
fun processConfigWithoutLet(config: Config?) {
    val timeout = config?.timeout ?: 5000  // 默认 5000ms
    val retryCount = config?.retryCount ?: 3  // 默认 3 次
    println("超时设置: ${timeout}ms, 重试次数: $retryCount")
}
 
// 使用 let - 避免重复
fun processConfigWithLet(config: Config?) {
    config?.let {  // 在 lambda 内部，it 是智能转换为非空的 Config
        println("超时设置: ${it.timeout}ms, 重试次数: ${it.retryCount}")
        // 可以直接访问 it.timeout 和 it.retryCount，无需重复 ?.
    } ?: run {  // 配合 Elvis 操作符，处理 config 为 null 的情况
        println("使用默认配置")
    }
}

data class Person(var name: String, var age: Int)
 
// let: 以 lambda 参数形式传递对象，返回 lambda 结果
fun example1(person: Person?) {
    val result = person?.let {
        println("姓名: ${it.name}")  // it 代表 person
        it.age  // 返回 age
    }
    println("结果: $result")  // 如果 person 为 null，result 也为 null
}
 
// apply: 以 this 形式访问对象，返回对象本身，常用于对象配置
fun example2(person: Person?) {
    person?.apply {
        name = "修改后的姓名"  // 直接使用属性名，this 可省略
        age = 30  // 配置多个属性
    }?.also {  // 链式调用 also
        println("配置完成: $it")  // also 也以 it 形式传递
    }
}
 
// run: 以 this 形式访问对象，返回 lambda 结果
fun example3(person: Person?) {
    val description = person?.run {
        "姓名: $name, 年龄: $age"  // 直接访问 name 和 age
    } ?: "无人员信息"  // 配合 Elvis 提供默认值
    println(description)
}
 
// also: 以 lambda 参数形式传递对象，返回对象本身，常用于副作用操作
fun example4(person: Person?) {
    person?.also {
        println("记录日志: 访问了 ${it.name}")  // 执行副作用（如日志、调试）
    }?.let {
        // 继续链式处理
        it.age + 1  // 计算某些值
    }
}
 
// 测试
fun main() {
    val person = Person("张三", 25)
    example1(person)  // 输出: 姓名: 张三 \n 结果: 25
    example2(person)  // 输出: 配置完成: Person(name=修改后的姓名, age=30)
    example3(person)  // 输出: 姓名: 修改后的姓名, 年龄: 30
    example4(person)  // 输出: 记录日志: 访问了 修改后的姓名
}

// 模拟一个网络请求返回的 JSON 数据结构
data class ApiResponse(val code: Int, val data: UserData?)
data class UserData(val user: UserInfo?)
data class UserInfo(val profile: Profile?)
data class Profile(val avatarUrl: String?, val bio: String?)
 
// 场景：从 API 响应中提取用户头像 URL，如果不存在则使用默认值
fun extractAvatar(response: ApiResponse?): String {
    return response
        ?.takeIf { it.code == 200 }  // 只处理成功的响应 (code 200)
        ?.data  // 提取 data
        ?.user  // 提取 user
        ?.profile  // 提取 profile
        ?.avatarUrl  // 提取 avatarUrl
        ?.takeUnless { it.isBlank() }  // 排除空字符串
        ?: "https://example.com/default-avatar.png"  // 任何一环出问题，使用默认头像
}
 
// 场景：链式调用配合集合操作
fun extractActiveUserNames(response: ApiResponse?): List<String> {
    return response
        ?.data
        ?.user
        ?.let { userInfo ->  // 非空时执行复杂逻辑
            // 假设 UserInfo 有一个好友列表
            listOf(userInfo.profile?.bio ?: "无签名")  // 简化示例
        }
        ?.filterNotNull()  // 过滤掉 null 元素
        ?.filter { it.isNotEmpty() }  // 过滤空字符串
        ?: emptyList()  // 默认返回空列表
}
 
// 测试
fun main() {
    val response1 = ApiResponse(200, UserData(UserInfo(Profile("avatar.jpg", "Hello"))))
    val response2 = ApiResponse(404, null)  // 错误响应
    val response3 = ApiResponse(200, UserData(UserInfo(Profile("", "Hi"))))  // 头像为空
    
    println(extractAvatar(response1))  // 输出: avatar.jpg
    println(extractAvatar(response2))  // 输出: https://example.com/default-avatar.png
    println(extractAvatar(response3))  // 输出: https://example.com/default-avatar.png (空字符串被过滤)
}

// takeIf: 条件为 true 时返回对象本身，否则返回 null
val validAge = age.takeIf { it >= 18 }  // 只有年龄 >= 18 才返回 age
 
// takeUnless: 条件为 false 时返回对象本身，否则返回 null
val nonEmptyName = name.takeUnless { it.isBlank() }  // 只有名字非空才返回 name

// Java 类
public class JavaUser {
    private String name;  // 在 Java 中，String 可能是 null
    
    public String getName() {
        return name;  // 可能返回 null，但 Java 没有类型系统层面的约束
    }
    
    public void setName(String name) {
        this.name = name;  // 允许传入 null
    }
}

// Kotlin 代码调用 Java 类
fun testPlatformType() {
    val javaUser = JavaUser()  // 创建 Java 对象
    
    // getName() 返回平台类型 String!
    val name1 = javaUser.name  // name1 的类型是 String!（平台类型）
    
    // 开发者可以选择将其视为非空类型
    val name2: String = javaUser.name  // 视为 String，如果实际为 null 会抛 NPE
    
    // 或者视为可空类型
    val name3: String? = javaUser.name  // 视为 String?，安全但需要额外判空
    
    // 直接使用也是允许的（相当于信任 Java 代码不返回 null）
    println(javaUser.name.length)  // 如果 name 为 null，这里会抛 NPE
    
    // 安全的做法：使用安全调用
    println(javaUser.name?.length)  // 推荐方式，避免 NPE
}

fun demonstratePlatformTypeError() {
    val javaUser = JavaUser()
    javaUser.name = null  // Java 允许设置为 null
    
    // 下面这行代码会在运行时抛出 NPE，错误信息会提到 String!
    val length = javaUser.name.length
    // 错误信息示例:
    // kotlin.NullPointerException: javaUser.name must not be null
    // 类型显示为: String! (Platform Type)
}

// 不良实践：让平台类型在 Kotlin 代码中传播
class KotlinService {
    private val javaUser = JavaUser()
    
    // 糟糕：返回平台类型，将不确定性传递给调用者
    fun getUserName() = javaUser.name  // 返回 String!
}
 
// 良好实践：在边界处消除平台类型
class KotlinServiceSafe {
    private val javaUser = JavaUser()
    
    // 方案 1：如果确信 Java 代码不会返回 null，显式声明为非空
    fun getUserName(): String {
        return javaUser.name ?: throw IllegalStateException("Name must not be null")
        // 或者使用非空断言（不推荐，除非绝对确定）
        // return javaUser.name!!
    }
    
    // 方案 2：保守做法，声明为可空类型
    fun getUserNameSafe(): String? {
        return javaUser.name  // 平台类型 String! 安全地转换为 String?
    }
    
    // 方案 3：提供默认值
    fun getUserNameOrDefault(): String {
        return javaUser.name ?: "Unknown"  // Elvis 操作符提供默认值
    }
}

// Java 代码使用注解
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class AnnotatedJavaUser {
    @NotNull  // 明确标注非空
    public String getUsername() {
        return "admin";
    }
    
    @Nullable  // 明确标注可空
    public String getEmail() {
        return null;
    }
    
    public String getPhone() {  // 没有注解，仍然是平台类型
        return null;
    }
}

fun testAnnotatedJavaTypes() {
    val user = AnnotatedJavaUser()
    
    // username 被识别为 String（非空），因为有 @NotNull
    val username: String = user.username  // OK，类型安全
    // val usernameNullable: String? = user.username  // 编译警告：不需要可空类型
    
    // email 被识别为 String?（可空），因为有 @Nullable
    val email: String? = user.email  // OK
    // val emailNonNull: String = user.email  // 编译错误：类型不匹配
    
    // phone 没有注解，仍然是 String!（平台类型）
    val phone1: String = user.phone  // 允许但有风险
    val phone2: String? = user.phone  // 安全做法
}

// 陷阱 1：平台类型在链式调用中传播
fun trap1() {
    val javaUser = JavaUser()
    // 如果 getName() 返回 null，这里会 NPE
    // 因为平台类型允许你假设它非空
    val upperName = javaUser.name.uppercase()  // 危险！
    
    // 安全做法
    val safeUpperName = javaUser.name?.uppercase()  // 使用安全调用
}
 
// 陷阱 2：集合的平台类型
fun trap2() {
    val javaList: List<String> = JavaCollectionProvider.getStringList()  // List<String!>!
    // 这个列表本身可能为 null，列表元素也可能为 null
    
    // 危险：假设列表和元素都非空
    for (item in javaList) {  // 可能 NPE（如果 javaList 为 null）
        println(item.length)  // 可能 NPE（如果 item 为 null）
    }
    
    // 安全做法
    javaList?.forEach { item ->  // 安全调用处理列表本身的可空性
        item?.let { println(it.length) }  // 安全调用处理元素的可空性
    }
}
 
// 陷阱 3：平台类型的泛型
fun trap3() {
    val javaMap: Map<String, String> = JavaCollectionProvider.getStringMap()
    // 实际类型是 Map<String!, String!>!
    // Key 可能为 null，Value 可能为 null，整个 Map 也可能为 null
    
    val value = javaMap["key"]  // value 是 String!（平台类型）
    // 如果 value 为 null，下面会 NPE
    println(value.length)  // 危险！
}

// gradle.properties 或 build.gradle.kts
kotlin {
    explicitApi = ExplicitApiMode.Strict  // 强制显式声明公共 API 的可见性和类型
}

class UserService(private val javaUser: JavaUser) {
    // 选项在下方
}

fun processUser() {
    val javaUser = JavaUser()  // Java 类，未使用空性注解
    val name = javaUser.name   // 1
    val upper = name?.uppercase()  // 2
    val length = upper!!.length  // 3
    println(length)  // 4
}

// Java 传统写法
if (obj instanceof String) {
    String str = (String) obj;  // 需要显式转换
    System.out.println(str.length());
}

// Kotlin 智能转换
if (obj is String) {
    println(obj.length)  // 编译器自动将 obj 转换为 String 类型
}

fun describe(obj: Any): String {
    // obj 的声明类型是 Any
    
    if (obj is String) {
        // 在这个 if 块中,编译器知道 obj 一定是 String 类型
        // 因此自动将 obj 转换为 String,可以直接访问 String 的属性和方法
        return "字符串,长度为 ${obj.length}"
    }
    
    if (obj is Int) {
        // 在这个 if 块中,obj 被智能转换为 Int
        return "整数,值为 $obj"
    }
    
    if (obj !is Double) {
        // 使用 !is 进行否定检查
        return "不是 Double 类型"
    }
    // 注意:在 !is 检查之后的 else 分支中,编译器也能进行智能转换
    
    return "其他类型"
}
 
// 更复杂的示例:结合逻辑运算符
fun processData(data: Any?) {
    // 使用 && 运算符,右侧可以安全使用智能转换
    if (data is String && data.length > 0) {
        // data 已被智能转换为 String(非空)
        println("非空字符串: ${data.uppercase()}")
    }
    
    // 使用 || 运算符
    if (data !is String || data.isEmpty()) {
        // 在 || 的右侧,data 已被智能转换为 String
        println("空字符串或非字符串类型")
        return
    }
    // 执行到这里,编译器知道 data 必定是非空的 String
    println("确定是非空字符串: $data")
}

class Container {
    var data: Any = "初始值"  // 成员属性
    
    fun process() {
        // ❌ 错误:成员属性 var 无法智能转换
        if (data is String) {
            // 编译错误:Smart cast to 'String' is impossible
            // 原因:data 是 var 属性,可能在其他线程或其他代码中被修改
            // println(data.length)
        }
        
        // ✅ 解决方案 1: 使用局部变量缓存
        val localData = data  // 创建局部 val 引用
        if (localData is String) {
            println(localData.length)  // 智能转换生效
        }
        
        // ✅ 解决方案 2: 显式转换
        if (data is String) {
            val str = data as String
            println(str.length)
        }
    }
    
    // ✅ val 属性可以智能转换(有条件)
    val immutableData: Any = "不变"
    
    fun processImmutable() {
        if (immutableData is String) {
            println(immutableData.length)  // 可以智能转换
        }
    }
}
 
// 局部变量的智能转换
fun localVariableExample() {
    var localVar: Any = "可变局部变量"
    
    // ✅ 局部 var 可以智能转换
    if (localVar is String) {
        // 编译器能追踪局部变量的生命周期和修改情况
        println(localVar.length)  // 智能转换生效
    }
    
    // ✅ 局部 val 更容易智能转换
    val localVal: Any = "不可变局部变量"
    if (localVal is String) {
        println(localVal.length)  // 智能转换生效
    }
}

class RiskExample {
    var data: Any = "字符串"
    
    fun riskyOperation() {
        if (data is String) {
            // 假设这里智能转换生效
            // 但在访问 data.length 之前,另一个线程可能执行:
            // data = 123  (修改为 Int)
            // 此时访问 data.length 会导致类型错误
        }
    }
}

fun controlFlowScope(obj: Any) {
    // 场景 1: if-else 分支
    if (obj is String) {
        println(obj.length)  // ✅ if 块内有效
    } else {
        // ❌ else 块内智能转换无效,obj 仍是 Any
        // println(obj.length)  // 编译错误
    }
    // ❌ if 块外部无效
    // println(obj.length)  // 编译错误
    
    // 场景 2: 提前返回后的智能转换
    if (obj !is String) {
        return  // 提前返回
    }
    // ✅ 执行到这里,编译器知道 obj 必定是 String
    println(obj.length)  // 智能转换有效
    
    // 场景 3: && 运算符
    if (obj is String && obj.isNotEmpty()) {
        // ✅ && 右侧,obj 已是 String
        println(obj[0])
    }
    
    // 场景 4: || 运算符
    if (obj !is String || obj.isEmpty()) {
        return
    }
    // ✅ 执行到这里,obj 必定是非空 String
    println(obj.length)
}

fun captureExample(obj: Any) {
    // ❌ 捕获的 var 变量无法智能转换
    var mutableObj: Any = obj
    if (mutableObj is String) {
        // ✅ 直接访问可以
        println(mutableObj.length)
        
        val lambda = {
            // ❌ lambda 中无法智能转换
            // 原因:lambda 可能在 mutableObj 修改后执行
            // println(mutableObj.length)  // 编译错误
        }
    }
    
    // ✅ val 变量可以在 lambda 中智能转换
    val immutableObj: Any = obj
    if (immutableObj is String) {
        val lambda = {
            println(immutableObj.length)  // ✅ 智能转换有效
        }
        lambda()
    }
}

// 基础用法:类型匹配
fun describeType(obj: Any): String = when (obj) {
    is String -> {
        // obj 自动转换为 String
        "字符串,长度: ${obj.length}, 内容: $obj"
    }
    is Int -> {
        // obj 自动转换为 Int
        "整数,值: $obj, 二进制: ${obj.toString(2)}"
    }
    is List<*> -> {
        // obj 自动转换为 List
        "列表,元素个数: ${obj.size}"
    }
    else -> "未知类型: ${obj::class.simpleName}"
}
 
// 复杂条件组合
fun processValue(value: Any): String = when {
    value is String && value.startsWith("http") -> {
        // 组合条件,value 智能转换为 String
        "URL: ${value.substringAfter("://")}"
    }
    value is Int && value > 0 -> {
        // value 智能转换为 Int
        "正整数: $value"
    }
    value is Int && value < 0 -> {
        // value 智能转换为 Int
        "负整数: ${-value} 的相反数"
    }
    else -> "其他情况"
}
 
// 密封类(Sealed Class)与 when 的完美结合
sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val exception: Exception) : Result()
    object Loading : Result()
}
 
fun handleResult(result: Result): String = when (result) {
    is Result.Success -> {
        // result 智能转换为 Result.Success
        "成功获取数据: ${result.data}"
    }
    is Result.Error -> {
        // result 智能转换为 Result.Error
        "发生错误: ${result.exception.message}"
    }
    Result.Loading -> {
        // 单例对象,直接匹配
        "加载中..."
    }
    // 密封类的 when 必须穷尽所有情况,否则编译错误
}
 
// when 作为表达式,智能转换在每个分支返回
fun calculateLength(obj: Any?): Int = when {
    obj == null -> 0  // 处理 null
    obj is String -> obj.length  // obj 转换为 String
    obj is Collection<*> -> obj.size  // obj 转换为 Collection
    obj is Array<*> -> obj.size  // obj 转换为 Array
    else -> -1  // 无法计算长度
}

// 范围检查与类型检查结合
fun categorize(value: Any): String = when {
    value !is Number -> "非数字类型"
    value is Int && value in 0..10 -> {
        // value 智能转换为 Int
        "0-10 的整数: $value"
    }
    value is Double && value > 100.0 -> {
        // value 智能转换为 Double
        "大于 100 的浮点数: $value"
    }
    else -> "其他数字: $value"
}
 
// 嵌套的智能转换
fun processNested(outer: Any): String {
    return when (outer) {
        is List<*> -> {
            // outer 转换为 List
            when {
                outer.isEmpty() -> "空列表"
                outer.first() is String -> {
                    // outer.first() 转换为 String
                    "字符串列表,首元素: ${outer.first() as String}"
                }
                else -> "非字符串列表"
            }
        }
        is Map<*, *> -> {
            // outer 转换为 Map
            "Map,键值对数量: ${outer.size}"
        }
        else -> "其他类型"
    }
}

// 不安全转换 as:转换失败抛异常
fun unsafeCast(obj: Any): String {
    return obj as String  // 如果 obj 不是 String,抛出 ClassCastException
}
 
// 调用示例
fun testUnsafeCast() {
    val str = unsafeCast("Hello")  // ✅ 成功,返回 "Hello"
    // val num = unsafeCast(123)  // ❌ 抛出异常:ClassCastException
}
 
// 安全转换 as?:转换失败返回 null
fun safeCast(obj: Any): String? {
    return obj as? String  // 如果 obj 不是 String,返回 null
}
 
// 调用示例
fun testSafeCast() {
    val str = safeCast("Hello")  // ✅ 返回 "Hello"
    val num = safeCast(123)      // ✅ 返回 null,不抛异常
    
    // 配合空安全操作符使用
    val length = safeCast("Kotlin")?.length  // 返回 6
    val nullLength = safeCast(123)?.length   // 返回 null
}
 
// 实际应用:处理集合元素
fun processElements(elements: List<Any>) {
    for (element in elements) {
        // 尝试转换为 String 并处理
        val str = element as? String
        if (str != null) {
            println("字符串元素: $str, 长度: ${str.length}")
        } else {
            println("非字符串元素: $element")
        }
    }
}
 
// 更简洁的写法:使用 let
fun processElementsConcise(elements: List<Any>) {
    for (element in elements) {
        // as? 结合 let,只处理转换成功的情况
        (element as? String)?.let { str ->
            println("字符串元素: $str, 长度: ${str.length}")
        }
    }
}

// as? 返回可空类型
val obj: Any = 123
val str: String? = obj as? String  // 类型是 String?,不是 String
 
// 错误示例:不能直接赋值给非空类型
// val nonNullStr: String = obj as? String  // ❌ 编译错误:类型不匹配
 
// 正确做法:处理 null 情况
val nonNullStr: String = (obj as? String) ?: "默认值"  // ✅ 使用 Elvis 操作符

fun compareTypeConversion(obj: Any) {
    // 方式 1: 不安全转换 as
    try {
        val str1 = obj as String  // 可能抛异常
        println("转换成功: $str1")
    } catch (e: ClassCastException) {
        println("转换失败,捕获异常")
    }
    
    // 方式 2: 安全转换 as?
    val str2 = obj as? String  // 不会抛异常,失败返回 null
    if (str2 != null) {
        println("转换成功: $str2")
    } else {
        println("转换失败,返回 null")
    }
    
    // 方式 3: 智能转换 is
    if (obj is String) {
        // obj 自动转换,无需显式 as 或 as?
        println("类型检查成功,自动转换: $obj")
    } else {
        println("类型检查失败")
    }
}

// 场景 1: 解析配置数据
data class Config(val settings: Map<String, Any>)
 
fun getIntSetting(config: Config, key: String): Int {
    // 从 Map 获取值,尝试转换为 Int
    val value = config.settings[key]  // 返回 Any?
    
    // 使用 as? 安全转换,失败返回 null,然后使用 Elvis 提供默认值
    return (value as? Int) ?: 0  // 如果不是 Int 或为 null,返回 0
}
 
fun getStringSetting(config: Config, key: String): String {
    val value = config.settings[key]
    return (value as? String) ?: "未设置"
}
 
// 调用示例
fun testConfig() {
    val config = Config(
        mapOf(
            "timeout" to 5000,      // Int
            "host" to "localhost",  // String
            "port" to "8080"        // String(不是 Int)
        )
    )
    
    println(getIntSetting(config, "timeout"))    // 输出: 5000
    println(getIntSetting(config, "port"))       // 输出: 0 (转换失败)
    println(getIntSetting(config, "missing"))    // 输出: 0 (key 不存在)
    println(getStringSetting(config, "host"))    // 输出: localhost
}
 
// 场景 2: 处理 JSON 数据
data class User(val name: String, val age: Int)
 
fun parseUser(data: Map<String, Any?>): User? {
    // 尝试提取并转换各个字段
    val name = data["name"] as? String ?: return null  // name 必须是 String
    val age = data["age"] as? Int ?: return null       // age 必须是 Int
    
    return User(name, age)
}
 
// 调用示例
fun testParseUser() {
    // ✅ 合法数据
    val validData = mapOf("name" to "Alice", "age" to 30)
    val user1 = parseUser(validData)  // 返回 User("Alice", 30)
    
    // ❌ age 类型错误
    val invalidData1 = mapOf("name" to "Bob", "age" to "thirty")
    val user2 = parseUser(invalidData1)  // 返回 null
    
    // ❌ 缺少字段
    val invalidData2 = mapOf("name" to "Charlie")
    val user3 = parseUser(invalidData2)  // 返回 null
}
 
// 场景 3: 类型过滤与转换
fun filterAndConvertToStrings(items: List<Any>): List<String> {
    return items.mapNotNull { item ->
        // mapNotNull 会自动过滤掉 null 结果
        item as? String  // 只保留成功转换为 String 的元素
    }
}
 
// 调用示例
fun testFilterAndConvert() {
    val mixed = listOf("apple", 123, "banana", 45.6, "cherry", null)
    val strings = filterAndConvertToStrings(mixed)
    println(strings)  // 输出: [apple, banana, cherry]
}
 
// 场景 4: 链式安全转换
interface Animal
class Dog(val name: String) : Animal
class Cat(val name: String) : Animal
 
fun processAnimal(animal: Any) {
    // 链式使用 as? 和安全调用
    val dogName = (animal as? Dog)?.name
    val catName = (animal as? Cat)?.name
    
    when {
        dogName != null -> println("这是一只狗,名字: $dogName")
        catName != null -> println("这是一只猫,名字: $catName")
        else -> println("未知动物")
    }
}
 
// 场景 5: 与 when 表达式结合
fun identifyType(obj: Any): String = when (val converted = obj) {
    is String -> "字符串: $converted"
    is Int -> "整数: $converted"
    else -> {
        // 尝试多种转换
        (converted as? Double)?.let { "浮点数: $it" }
            ?: (converted as? Boolean)?.let { "布尔值: $it" }
            ?: "未知类型: ${converted::class.simpleName}"
    }
}

// ✅ 推荐:结合 Elvis 操作符提供默认值
fun safeConvertWithDefault(obj: Any): String {
    return (obj as? String) ?: "转换失败的默认值"
}
 
// ✅ 推荐:结合 let 处理非 null 情况
fun safeConvertWithLet(obj: Any) {
    (obj as? String)?.let { str ->
        println("成功转换为字符串: $str")
        // 这里可以安全使用 str
    }
}
 
// ✅ 推荐:结合 also 进行链式操作
fun safeConvertChain(obj: Any): String? {
    return (obj as? String)
        ?.trim()
        ?.uppercase()
        ?.also { println("处理后的字符串: $it") }
}
 
// ❌ 不推荐:忽略转换失败的情况
fun unsafeIgnore(obj: Any) {
    val str = obj as? String
    println(str?.length)  // 可能输出 null,但没有合理处理
}
 
// ✅ 推荐:明确处理转换失败
fun safeHandle(obj: Any) {
    val str = obj as? String
    if (str != null) {
        println("字符串长度: ${str.length}")
    } else {
        println("无法转换为字符串")
    }
}

class Example {
    var data: Any = "Hello"
    
    fun process() {
        // 代码片段 A
        if (data is String) {
            println(data.length)
        }
        
        // 代码片段 B
        val local = data
        if (local is String) {
            println(local.length)
        }
        
        // 代码片段 C
        val str = data as? String
        println(str?.length)
        
        // 代码片段 D
        if (data !is String) return
        println(data.length)
    }
}

fun mysterious(items: List<Any>): Int {
    var count = 0
    for (item in items) {
        when {
            item is String && item.length > 5 -> count += 1
            item is Int && item > 10 -> count += 2
            item as? Double != null -> count += 3
        }
    }
    return count
}
 
fun main() {
    val list = listOf("Kotlin", 5, 15, 3.14, "Hi", 20.5)
    println(mysterious(list))
}