Kotlin 语言基础与空安全

val a: Int = 42          // 编译为 JVM 的 int 基本类型
val b: Int? = 42         // 可空类型，编译为 Integer，发生装箱
val list = listOf(1, 2, 3)  // List<Int>，元素实际是 Integer

fun sum(xs: List<Int>): Int = xs.sum()   // 求和过程中反复拆箱

val list = mutableListOf(1, 2, 3)
list.add(4)              // 合法：引用没变，内容变了
// list = mutableListOf(5)  // 编译错误：val 不能重新赋值

// Java 侧：没有 @Nullable / @NonNull 标注
public class LegacyUserStore {
    public String findName(long id) {   // 可能返回 null
        return id > 0 ? "leeting" : null;
    }
}

val store = LegacyUserStore()
val name = store.findName(-1)     // 类型是 String!（平台类型）
println(name.length)              // 编译通过，运行时抛 NPE

val name: String? = store.findName(-1)   // 显式声明为可空
println(name?.length)

data class Address(val city: String?)
data class Profile(val address: Address?)

fun cityOf(profile: Profile?): String? =
    profile?.address?.city          // 任一层为 null 即整体为 null

val profile = Profile(Address("杭州"))
println(cityOf(profile))            // 杭州
println(cityOf(null))               // null

fun renderName(raw: String?): String {
    val name = raw?.trim() ?: return "匿名用户"   // 为空直接返回
    if (name.isEmpty()) throw IllegalArgumentException("name blank")
    return name
}

val name: String? = store.findName(1)
val len = name!!.length    // 崩溃时堆栈难以指认来源

class AvatarView {
    var imageUrl: String? = null

    fun load(url: String?) {
        url?.let { safeUrl ->
            // 这里 safeUrl 是非空 String，可以直接用
            println(safeUrl.length)
        }

        // also 不改变接收者，适合做副作用（日志、埋点）
        url?.also { track("avatar_load", it) }?.let { render(it) }
    }

    private fun render(url: String) { /* ... */ }
    private fun track(event: String, url: String) { /* ... */ }
}

fun describe(x: Any?): String = when (x) {
    null -> "空值"
    is String -> "字符串，长度 ${x.length}"   // 已智能转换为 String
    is Int -> "整数 ${x + 1}"
    else -> "未知类型"
}

class Holder { var value: String? = null }

fun bad(h: Holder): Int {
    if (h.value != null) {
        // return h.value.length   // 编译错误：可变属性无法智能转换
    }
    return 0
}

fun good(h: Holder): Int {
    val v = h.value ?: return 0
    return v.length            // 局部 val，智能转换生效
}

import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.contract

@OptIn(ExperimentalContracts::class)
fun requireNonBlank(value: String?, name: String): String {
    contract {
        returns() implies (value != null)   // 正常返回则 value 一定非空
    }
    require(!value.isNullOrBlank()) { "$name 不能为空" }
    return value
}

fun use(raw: String?) {
    requireNonBlank(raw, "title")
    println(raw.length)     // 智能转换为 String，无需 !!
}

sealed interface UiState<out T> {
    data object Loading : UiState<Nothing>
    data class Success<T>(val data: T) : UiState<T>
    data class Error(val code: Int, val message: String) : UiState<Nothing>
}

fun <T> render(state: UiState<T>): String = when (state) {
    is UiState.Loading -> "加载中"
    is UiState.Success -> "数据 ${state.data}"
    is UiState.Error -> "错误 ${state.code}: ${state.message}"
    // 没有 else，新增子类时编译器报错
}

data class User(
    val id: Long,
    val name: String,
    val email: String? = null,
)

val u = User(1, "leeting")
val renamed = u.copy(name = "Leeting Yan")   // 只改一个字段，其余复用
val (id, name) = renamed                     // 解构声明

class Constants {
    companion object {
        @JvmField val TAG: String = "Constants"        // 生成静态字段，无 getter
        @JvmStatic fun create(): Constants = Constants()  // 生成静态方法
        const val MAX_RETRY: Int = 3                    // 编译期常量
    }
}

class Factory @JvmOverloads constructor(
    val name: String,
    val size: Int = 10,          // 生成重载构造，Java 侧可只传 name
) {
    @JvmName("makeFromList")
    fun make(items: List<String>) { /* ... */ }
}

// Kotlin 侧：显式声明可空性，Java 侧通过元数据或注解感知
class UserRepository(private val api: LegacyApi) {
    fun find(id: Long): User? = api.findUser(id)   // 显式可空，调用方必须处理

    fun require(id: Long): User =
        api.findUser(id) ?: throw NoSuchElementException("user $id not found")
}

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

sealed interface Result<out T> {
    data class Ok<T>(val value: T) : Result<T>
    data class Err(val code: Int, val message: String) : Result<Nothing>
}

data class Article(
    val id: Long,
    val title: String,
    val summary: String? = null,
)

interface ArticleApi {
    suspend fun get(id: Long): ArticleDto?      // 平台类型来源：网络层可能返回 null
}

data class ArticleDto(val id: Long, val title: String?, val summary: String?)

class ArticleRepository(private val api: ArticleApi) {

    suspend fun load(id: Long?): Result<Article> = withContext(Dispatchers.IO) {
        val safeId = id?.takeIf { it > 0 } ?: return@withContext Result.Err(400, "非法 id")
        val dto = api.get(safeId) ?: return@withContext Result.Err(404, "文章不存在")
        val title = dto.title?.takeIf { it.isNotBlank() }
            ?: return@withContext Result.Err(500, "标题缺失")
        Result.Ok(
            Article(
                id = dto.id,
                title = title,
                summary = dto.summary?.trim()?.takeIf { it.isNotEmpty() },
            )
        )
    }
}

fun render(result: Result<Article>): String = when (result) {
    is Result.Ok -> result.value.title
    is Result.Err -> "加载失败(${result.code}): ${result.message}"
}