Kotlin 高阶特性从入门到精通：深入语言核心实战全指南

// 不使用 inline：Lambda 会创建对象、虚方法调用
fun <T> lock(lock: Lock, body: () -> T): T {
    lock.lock()
    try { return body() } finally { lock.unlock() }
}

// 使用 inline：编译后直接展开，零额外开销
inline fun <T> lock(lock: Lock, body: () -> T): T {
    lock.lock()
    try { return body() } finally { lock.unlock() }
}

// 调用
lock(myLock) { computeSomething() }
// 编译后等效于：
// myLock.lock()
// try { computeSomething() } finally { myLock.unlock() }

inline fun foo(inlined: () -> Unit, noinline notInlined: () -> Unit) {
    // inlined 被内联展开到调用点
    inlined()
    // notInlined 保持为普通 Lambda 对象，可以传递
    executor.execute(notInlined)
}

inline fun f(crossinline body: () -> Unit) {
    val f = object : Runnable {
        override fun run() = body()  // body 在其他上下文中执行，不允许 return
    }
    f.run()
}

// 如果不用 crossinline，body 中的 return 会尝试从 f 返回，这是非法的

// 没有 reified：需要传入 Class<T>
fun <T> Activity.find(type: Class<T>): T {
    return findViewById(type, R.id.container)
}
find(MyView::class.java)

// 有 reified：直接推断类型
inline fun <reified T> Activity.find(): T {
    return findViewById(T::class.java, R.id.container)
}
find<MyView>()

// 实际应用场景：类型安全的 Intent 启动
inline fun <reified T : Activity> Context.startActivity() {
    val intent = Intent(this, T::class.java)
    startActivity(intent)
}
startActivity<MainActivity>()

val foo: Foo inline get() = Foo()

inline var bar: Bar
    get() = createBar()
    set(v) { saveBar(v) }

@PublishedApi
internal fun internalHelper() { /* ... */ }

inline fun publicInlineFunc() {
    internalHelper()  // 允许，因为标记了 @PublishedApi
}

class Box<T>(t: T) { var value = t }
val box = Box(1)  // 编译器自动推断为 Box<Int>

interface Source<out T> {
    fun nextT(): T  // T 只出现在返回值，安全
}

fun demo(strs: Source<String>) {
    val objects: Source<Any> = strs  // ✅ 安全：String 是 Any 的子类型
}

interface Comparable<in T> {
    operator fun compareTo(other: T): Int  // T 只出现在参数，安全
}

fun demo(x: Comparable<Number>) {
    val y: Comparable<Double> = x  // ✅ 安全：能比较 Number 的肯定能比较 Double
}

// Array<out Any>：只读投影，禁止 set
fun copy(from: Array<out Any>, to: Array<Any>) {
    for (i in from.indices) to[i] = from[i]  // from[i] 是 get，允许
    // from[i] = "x"  // ❌ 编译错误：out 投影禁止写入
}

// Array<in String>：只写投影，禁止 get
fun fill(arr: Array<in String>, value: String) {
    arr[0] = value  // 允许
    // val s: String = arr[0]  // ❌ 编译错误：in 投影禁止读取为 String
}

interface Foo<T> { fun get(): T; fun set(value: T) }

fun process(foo: Foo<*>) {
    // Foo<out Any?>：可以安全读取为 Any?
    val value: Any? = foo.get()
    // foo.set("x")  // ❌ 编译错误：无法安全写入
}

// 单一上界
fun <T : Comparable<T>> sort(list: List<T>) { /* ... */ }

// 多个上界：使用 where
fun <T> copyWhenGreater(list: List<T>, threshold: T): List<String>
    where T : CharSequence, T : Comparable<T> {
    return list.filter { it > threshold }.map { it.toString().uppercase() }
}

// ❌ 不能做运行时类型检查
if (obj is List<Int>) { /* ... */ }  // 编译错误

// ✅ 可以检查星投影
if (obj is List<*>) { /* ... */ }

// ✅ 使用 reified 保留类型信息（仅限 inline 函数）
inline fun <reified T> cast(obj: Any): T {
    return obj as T  // 编译期已知道 T 的具体类型
}

fun String.truncate(maxLength: Int): String {
    return if (this.length <= maxLength) this else take(maxLength - 3) + "..."
}

// 调用
println("Hello World".truncate(8))  // "He..."

fun <T> List<T>.endpoints(): Pair<T, T> = first() to last()

val numbers = listOf(1, 2, 3, 4, 5)
println(numbers.endpoints())  // (1, 5)

fun Any?.toSafeString(): String {
    return if (this == null) "null" else toString()
}

println(null.toSafeString())  // "null"

data class User(val firstName: String, val lastName: String)

val User.fullName: String
    get() = "$firstName $lastName"

val User.emailUsername: String
    get() = "${firstName.lowercase()}.${lastName.lowercase()}"

// 使用
val user = User("John", "Doe")
println(user.fullName)       // "John Doe"
println(user.emailUsername)  // "john.doe"

open class Shape
class Rectangle : Shape()

fun Shape.getName() = "Shape"
fun Rectangle.getName() = "Rectangle"

fun printName(s: Shape) = println(s.getName())

printName(Rectangle())  // 输出: "Shape"（不是 "Rectangle"！）

class MyClass {
    companion object {
        // companion body
    }
}

fun MyClass.Companion.log(msg: String) {
    println("[MyClass] $msg")
}

// 调用
MyClass.log("Hello")  // 不需要实例

interface Base {
    fun print()
    fun printLine()
}

class BaseImpl(val x: Int) : Base {
    override fun print() { print(x) }
    override fun printLine() { println(x) }
}

class Derived(b: Base) : Base by b

fun main() {
    val base = BaseImpl(10)
    Derived(base).print()       // 输出: 10
    Derived(base).printLine()   // 输出: 10
}

class Derived(b: Base) : Base by b {
    override fun print() { print("abc") }
}

fun main() {
    val base = BaseImpl(10)
    val derived = Derived(base)
    derived.print()       // 输出: abc（使用重写实现）
    derived.printLine()   // 输出: 10（使用委托实现）
}

class Example {
    var p: String by Delegate()
}
// 读取 e.p → Delegate.getValue(e, property)
// 赋值 e.p = "NEW" → Delegate.setValue(e, property, "NEW")

val lazy1: String by lazy { "computed" }  // 默认：线程安全（synchronized）
val lazy2: String by lazy(LazyThreadSafetyMode.PUBLICATION) { "computed" }  // 可能多次执行，首次返回值为准
val lazy3: String by lazy(LazyThreadSafetyMode.NONE) { "computed" }  // 无锁，单线程最快

class User(val map: Map<String, Any?>) {
    val name: String by map
    val age: Int by map
}

val user = User(mapOf("name" to "Alice", "age" to 30))
println(user.name)  // "Alice"
println(user.age)   // 30

class ResourceLoader<T>(val id: Int) {
    operator fun provideDelegate(thisRef: MyUI, prop: KProperty<*>): ReadOnlyProperty<MyUI, T> {
        checkResourceExists(id)  // 在绑定前校验
        return createResource(id)
    }
}

val image by ResourceLoader<ImageResource>(R.id.image_id)

sealed class Result<out T> {
    data class Success<out T>(val data: T) : Result<T>()
    data class Error(val exception: Throwable) : Result<Nothing>()
    object Loading : Result<Nothing>()
}

fun handleResult(result: Result<String>): String = when (result) {
    is Result.Success -> "Data: ${result.data}"
    is Result.Error -> "Error: ${result.exception.message}"
    Result.Loading -> "Loading..."
    // 无需 else，编译器保证全覆盖
}

sealed interface PaymentMethod
sealed class CardPayment : PaymentMethod {
    protected constructor()  // 默认
    private constructor(token: String) : this()  // 更严格
    // public constructor() : this()  // ❌ 编译错误
}

class CreditCard(val number: String) : CardPayment()
class DebitCard(val number: String) : CardPayment()
object Cash : PaymentMethod

// enum 可以实现密封接口
enum class DigitalPayment(val name: String) : PaymentMethod {
    APPLE_PAY, GOOGLE_PAY, SAMSUNG_PAY
}

sealed class UiState<out T> {
    object Loading : UiState<Nothing>()
    data class Success<out T>(val data: T) : UiState<T>()
    data class Failure(val error: Throwable) : UiState<Nothing>()
}

// ViewModel 中
class UserViewModel : ViewModel() {
    private val _state = MutableStateFlow<UiState<List<User>>>(UiState.Loading)
    val state: StateFlow<UiState<List<User>>> = _state

    fun loadUsers() {
        viewModelScope.launch {
            _state.value = UiState.Loading
            try {
                val users = userRepository.getAll()
                _state.value = UiState.Success(users)
            } catch (e: Exception) {
                _state.value = UiState.Failure(e)
            }
        }
    }
}

// 完整形式
val sum: (Int, Int) -> Int = { x, y -> x + y }

// 类型推断
val sum = { x: Int, y: Int -> x + y }

// 作为参数传递
fun operate(a: Int, b: Int, op: (Int, Int) -> Int) = op(a, b)
operate(3, 4, sum)  // 7

// 类型：String.() -> Int
val stringLength: String.() -> Int = { this.length }

println("Hello".stringLength())  // 5

// 实际应用中：
fun StringBuilder.build(init: StringBuilder.() -> Unit): StringBuilder {
    this.init()
    return this
}

val result = StringBuilder().build {
    append("Hello")
    append(" ")
    append("World")
}

// let：空安全链式转换
val name: String? = null
val length = name?.let { it.uppercase().length }  // null

// apply：对象配置
val user = User().apply {
    firstName = "John"
    lastName = "Doe"
    age = 30
}

// also：副作用
val numbers = mutableListOf(1, 2, 3)
    .also { println("Before: $it") }
    .map { it * 2 }
    .also { println("After: $it") }

fun simple(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(100)  // 模拟异步操作
        emit(i)     // 发出值
    }
}

suspend fun main() {
    simple().collect { value -> println(value) }  // 1, 2, 3（间隔 100ms）
}

// transform：一个输入产生多个输出
(1..3).asFlow().transform { request ->
    emit("Making request $request")
    emit("Result: ${request * 2}")
}.collect { println(it) }
// 输出: Making request 1, Result: 2, Making request 2, Result: 4, ...

// combine：响应式组合（常用于 UI 状态）
val flow1 = flowOf(1, 2, 3).onEach { delay(100) }
val flow2 = flowOf("A", "B").onEach { delay(150) }

flow1.combine(flow2) { num, str -> "$num$str" }
    .collect { println(it) }
// 输出: 1A, 2A, 2B, 3B

// collect：最基本的终止操作符
flow.collect { println(it) }

// toList / toSet：收集为集合
val list = flow.toList()

// first / single：取第一个/唯一的元素
val first = flow.first()

// reduce / fold：聚合
val sum = flowOf(1, 2, 3, 4, 5).reduce { a, b -> a + b }  // 15
val folded = flowOf(1, 2, 3).fold("") { acc, v -> acc + v }  // "123"

fun numbers(): Flow<Int> = flow {
    for (i in 1..5) {
        if (i == 3) throw RuntimeException("Error at 3")
        emit(i)
    }
}

// 方式一：try/catch
try {
    numbers().collect { println(it) }
} catch (e: Exception) {
    println("Caught: $e")
}

// 方式二：catch 操作符（推荐，只捕获上游异常）
numbers()
    .catch { e -> println("Caught: $e") }
    .collect { println(it) }

// catch 可以 emit 回退值
numbers()
    .catch { e -> emit(-1) }
    .collect { println(it) }  // 1, 2, -1

// buffer()：发射器和收集器并发运行
flow
    .buffer()
    .collect { delay(300); println(it) }

// conflate()：慢消费者跳过中间值，只保留最新
flow
    .conflate()
    .collect { delay(300); println(it) }

// collectLatest()：每次新值到达时取消之前的处理
flow
    .collectLatest { value ->
        delay(300)  // 如果新值在 300ms 内到达，此延迟会被取消
        println(value)
    }

fun numbers(): Flow<Int> = flow {
    println("Flow started on ${Thread.currentThread().name}")
    for (i in 1..3) {
        delay(100)
        emit(i)
    }
}.flowOn(Dispatchers.IO)  // 上游在 IO 线程执行

// collect 仍在调用者的上下文执行
numbers().collect { println("Collected $it on ${Thread.currentThread().name}") }

class UserViewModel : ViewModel() {
    private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
    val uiState: StateFlow<UiState> = _uiState

    fun loadUser() {
        viewModelScope.launch {
            _uiState.value = UiState.Loading
            try {
                val user = userRepository.fetchUser()
                _uiState.value = UiState.Success(user)
            } catch (e: Exception) {
                _uiState.value = UiState.Error(e)
            }
        }
    }
}

// Compose 中收集
@Composable
fun UserScreen(viewModel: UserViewModel = hiltViewModel()) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
    when (uiState) {
        is UiState.Loading -> Loading()
        is UiState.Success -> Content((uiState as UiState.Success).user)
        is UiState.Error -> Error((uiState as UiState.Error).message)
    }
}

class NotificationManager {
    private val _events = MutableSharedFlow<Notification>(extraBufferCapacity = 10)
    val events: SharedFlow<Notification> = _events

    suspend fun send(notification: Notification) {
        _events.emit(notification)
    }
}

// 多个订阅者各自收到完整的事件流
lifecycleScope.launch {
    notificationManager.events.collect { showNotification(it) }
}

suspend fun main() = coroutineScope {
    // launch：不阻塞当前作用域
    val job = launch {
        delay(1000)
        println("Background task done")
    }
    println("Continues immediately")
    job.join()  // 等待完成

    // async：并行获取多个结果
    val page1 = async { fetchPage(1) }
    val page2 = async { fetchPage(2) }
    val allContent = page1.await() + page2.await()
}

suspend fun main() {
    coroutineScope {
        launch {
            launch {
                delay(2000)
                println("Nested child completed")
            }
            println("Child 1 started")
        }
        launch {
            delay(1000)
            println("Child 2 completed")
        }
    }
    println("All children completed")  // 最后执行
}

// 取消
val job = launch {
    repeat(1000) { i ->
        println("Working $i")
        delay(100)
        // 协程内部自动检查取消状态
        ensureActive()  // 手动检查（可选）
    }
}
delay(500)
job.cancel()  // 请求取消
job.join()    // 等待取消完成
println("Cancelled")

// 超时
withTimeout(1000L) {
    repeat(1000) { i ->
        println("Working $i")
        delay(200)
    }
}  // 超时抛出 TimeoutCancellationException

// 超时不抛异常，返回 null
val result = withTimeoutOrNull(1000L) {
    doSomething()
}
if (result == null) println("Timed out")

suspend fun main() {
    // 切换执行上下文
    withContext(Dispatchers.IO) {
        // 数据库/网络 I/O
    }

    withContext(Dispatchers.Default) {
        // CPU 密集型计算
    }

    // 自定义线程池
    val dispatcher = Executors.newFixedThreadPool(4).asCoroutineDispatcher()
    withContext(dispatcher) {
        // 在自定义线程池执行
    }
}

suspend fun main() = coroutineScope {
    val channel = Channel<Int>()

    // 生产者
    launch {
        for (i in 1..5) {
            channel.send(i * i)
            delay(100)
        }
        channel.close()  // 通知消费者不再有数据
    }

    // 消费者
    launch {
        for (value in channel) {
            println("Received: $value")
        }
        println("Channel closed")
    }
}

// launch 中的异常：默认取消父作用域
val job = GlobalScope.launch {
    try {
        doSomethingRisky()
    } catch (e: Exception) {
        // 处理异常，防止取消传播
    }
}

// 使用 CoroutineExceptionHandler
val handler = CoroutineExceptionHandler { _, exception ->
    println("Caught: $exception")
}
val job = GlobalScope.launch(handler) {
    throw RuntimeException("Error")
}

// SupervisorJob：子协程异常不影响兄弟协程
val scope = CoroutineScope(SupervisorJob())
scope.launch { taskA() }  // 失败不影响 taskB
scope.launch { taskB() }

class HTML {
    val children = mutableListOf<Tag>()
    fun body(init: Body.() -> Unit) {
        val body = Body()
        body.init()
        children.add(body)
    }
}

class Body {
    val children = mutableListOf<Tag>()
    fun p(init: P.() -> Unit) {
        val p = P()
        p.init()
        children.add(p)
    }
}

class P {
    var text = ""
}

// DSL 构建器函数
fun html(init: HTML.() -> Unit): HTML {
    val html = HTML()
    html.init()
    return html
}

// 使用
val result = html {
    body {
        p { text = "Hello World" }
    }
}

@DslMarker
@Target(AnnotationTarget.CLASS, AnnotationTarget.TYPE)
annotation class HtmlTagMarker

@HtmlTagMarker abstract class Tag

@HtmlTagMarker class HTML : Tag()
@HtmlTagMarker class Body : Tag()
@HtmlTagMarker class P : Tag()

// 现在:
html {
    body {
        // body { }  // ❌ 编译错误：不允许访问外层 Body 接收者
        p { }       // ✅ 当前作用域内的方法
    }
}

abstract class TagWithText(name: String) : Tag(name) {
    // 重载一元 + 操作符，用于添加纯文本
    operator fun String.unaryPlus() {
        children.add(TextElement(this))
    }
}

// DSL 中使用
p {
    +"This is some "
    b { +"bold" }
    +" text."
}

data class ServerConfig(
    val host: String,
    val port: Int,
    val ssl: Boolean,
    val endpoints: List<Endpoint>
)

data class Endpoint(val path: String, val method: String)

class ServerConfigBuilder {
    var host: String = "localhost"
    var port: Int = 8080
    var ssl: Boolean = false
    private val endpoints = mutableListOf<Endpoint>()

    fun endpoint(path: String, method: String = "GET") {
        endpoints.add(Endpoint(path, method))
    }

    fun build() = ServerConfig(host, port, ssl, endpoints.toList())
}

fun server(init: ServerConfigBuilder.() -> Unit): ServerConfig {
    val builder = ServerConfigBuilder()
    builder.init()
    return builder.build()
}

// 使用
val config = server {
    host = "api.example.com"
    port = 443
    ssl = true
    endpoint("/users", "GET")
    endpoint("/users", "POST")
    endpoint("/users/{id}", "PUT")
    endpoint("/users/{id}", "DELETE")
}

data class Point(val x: Int, val y: Int) {
    // 二元操作符：+
    operator fun plus(other: Point) = Point(x + other.x, y + other.y)

    // 二元操作符：-
    operator fun minus(other: Point) = Point(x - other.x, y - other.y)

    // 一元操作符：负号
    operator fun unaryMinus() = Point(-x, -y)

    // 复合赋值：+=
    operator fun inc() = Point(x + 1, y + 1)

    // 索引访问：[]
    operator fun get(index: Int) = when (index) {
        0 -> x
        1 -> y
        else -> throw IndexOutOfBoundsException()
    }

    // 包含：in
    operator fun contains(point: Point) = x == point.x && y == point.y

    // 范围：..
    operator fun rangeTo(other: Point) = PointRange(this, other)

    // 调用：()
    operator fun invoke(scale: Int) = Point(x * scale, y * scale)
}

// 使用
val p1 = Point(1, 2)
val p2 = Point(3, 4)

println(p1 + p2)     // Point(4, 6)
println(p1 - p2)     // Point(-2, -2)
println(-p1)         // Point(-1, -2)
println(p1[0])       // 1
println(p2 in p1)    // false
println(p1(3))       // Point(3, 6)

class BitArray(val bits: IntArray) {
    infix fun shl(n: Int): BitArray {
        return BitArray(bits.map { it shl n }.toIntArray())
    }

    infix fun shr(n: Int): BitArray {
        return BitArray(bits.map { it shr n }.toIntArray())
    }

    infix fun and(other: BitArray): BitArray {
        return BitArray(bits.zip(other.bits).map { (a, b) -> a and b }.toIntArray())
    }

    infix fun or(other: BitArray): BitArray {
        return BitArray(bits.zip(other.bits).map { (a, b) -> a or b }.toIntArray())
    }
}

// 使用中缀调用
val a = BitArray(intArrayOf(1, 0, 1))
val b = BitArray(intArrayOf(0, 1, 1))
val result = a shl 2 and b or a  // 链式中缀调用

// 标准库中的中缀调用
val map = mapOf(1 to "one", 2 to "two")  // to 是中缀函数
val filtered = list filter { it > 0 }    // filter 可以作为中缀

// 密封类建模 API 响应
sealed class ApiResponse<out T> {
    data class Success<out T>(val data: T) : ApiResponse<T>()
    data class Error(val code: Int, val message: String) : ApiResponse<Nothing>()
    object Loading : ApiResponse<Nothing>()
}

// reified 类型安全的 JSON 解析
inline fun <reified T> String.parseJson(): T {
    return ObjectMapper().readValue(this, object : TypeReference<T>() {})
}

// 扩展函数：安全执行 API 调用
suspend fun <T> suspendCatching(block: suspend () -> T): ApiResponse<T> = try {
    ApiResponse.Success(block())
} catch (e:HttpException) {
    ApiResponse.Error(e.code(), e.message() ?: "HTTP Error")
} catch (e: Exception) {
    ApiResponse.Error(-1, e.message ?: "Unknown error")
}

// 内联函数：带重试的 API 调用
inline fun <reified T> withRetry(
    maxRetries: Int = 3,
    crossinline block: suspend () -> T
): suspend () -> ApiResponse<T> = {
    repeat(maxRetries) { attempt ->
        val result = suspendCatching { block() }
        if (result is ApiResponse.Success) return@withRetry result
        if (attempt < maxRetries - 1) delay(1000L * (attempt + 1))
    }
    ApiResponse.Error(-1, "Failed after $maxRetries retries")
}

// 使用
val apiCall = withRetry(maxRetries = 3) {
    httpClient.get("/api/users/1").parseJson<User>()
}
val response = apiCall()

@DslMarker
annotation class QueryDsl

@QueryDsl
class QueryBuilder {
    private val columns = mutableListOf<String>()
    private val tables = mutableListOf<String>()
    private var whereClause: String? = null
    private var orderBy: String? = null
    private var limit: Int? = null

    fun select(vararg cols: String) {
        columns.addAll(cols)
    }

    fun from(vararg tables: String) {
        this.tables.addAll(tables)
    }

    infix fun String.eq(value: Any) = "$this = '${value.toString().escapeSql()}'"
    infix fun String.gt(value: Any) = "$this > '${value.toString().escapeSql()}'"
    infix fun String.like(pattern: String) = "$this LIKE '$pattern'"

    fun where(condition: String) {
        whereClause = condition
    }

    fun orderBy(column: String, desc: Boolean = false) {
        orderBy = "$column ${if (desc) "DESC" else "ASC"}"
    }

    fun limit(n: Int) { limit = n }

    fun build(): String {
        val col = columns.joinToString(", ").takeIf { it.isNotEmpty() } ?: "*"
        var sql = "SELECT $col FROM ${tables.joinToString(", ")}"
        whereClause?.let { sql += " WHERE $it" }
        orderBy?.let { sql += " ORDER BY $it" }
        limit?.let { sql += " LIMIT $it" }
        return sql
    }
}

fun query(init: QueryBuilder.() -> Unit): String {
    val builder = QueryBuilder()
    builder.init()
    return builder.build()
}

// 使用
val sql = query {
    select("id", "name", "email")
    from("users")
    where ("age" gt 18 and "status" eq "active")
    orderBy("name")
    limit(10)
}
// SELECT id, name, email FROM users WHERE age > '18' AND status = 'active' ORDER BY name ASC LIMIT 10

val lazyVal by lazy { compute() }
var observable by Delegates.observable(0) { _, old, new -> }
var vetoable by Delegates.vetoable(0) { _, _, new -> new > 0 }
val fromMap by map  // Map<String, Any?>
var byRef by ::otherProperty

interface Producer<out T> { fun produce(): T }     // 只产出 → out
interface Consumer<in T> { fun consume(t: T) }     // 只消费 → in
interface Both<T> { fun get(): T; fun set(t: T) }  // 两者都有 → 不变

// 中间操作符（返回 Flow）
.map { }.filter { }.transform { }.take(n).drop(n)
.distinctUntilChanged().zip(other).combine(other)
.catch { }.retry(n).flowOn(dispatcher).buffer()

// 终止操作符（suspend 函数）
.collect { }.toList().toSet().first().single()
.reduce { }.fold(initial) { }