Kotlin 是一門功能強大且靈活的編程語言，除了基礎語法外，它還提供了許多高級特性，可以幫助你編寫更簡潔、高效和可維護的代碼。以下是 Kotlin 的一些高級用法，涵蓋了協程、擴展函數、屬性委托、內聯類、反射等內容。

1. 協程（Coroutines）
   協程是 Kotlin 中用于簡化異步編程的核心特性。它允許你以同步的方式編寫異步代碼，避免回調地獄。

1.1 基本用法

import kotlinx.coroutines.*fun main() = runBlocking {launch {delay(1000) // 非阻塞延遲println("World!")}println("Hello,")
}

runBlocking：阻塞當前線程，直到協程執行完畢。

launch：啟動一個新的協程。

1.2 異步返回值
使用 async 和 await 獲取異步結果：

fun main() = runBlocking {val result = async {delay(1000)"Hello, World!"}println(result.await()) // 輸出：Hello, World!
}

1.3 結構化并發
通過 CoroutineScope 管理協程的生命周期：

fun main() = runBlocking {val scope = CoroutineScope(Dispatchers.Default)scope.launch {delay(1000)println("Task completed")}delay(500) // 等待一段時間scope.cancel() // 取消協程
}

2. 擴展函數（Extension Functions）
   擴展函數允許你為現有類添加新方法，而無需修改其源代碼。

2.1 基本用法

fun String.isPalindrome(): Boolean {return this == this.reversed()
}fun main() {println("racecar".isPalindrome()) // 輸出：true
}

2.2 擴展屬性

val String.lastChar: Charget() = this[length - 1]fun main() {println("Kotlin".lastChar) // 輸出：n
}

3. 屬性委托（Property Delegation）
   屬性委托允許你將屬性的 getter 和 setter 邏輯委托給另一個對象。

3.1 使用 lazy 實現懶加載

val lazyValue: String by lazy {println("計算值")"Hello"
}fun main() {println(lazyValue) // 第一次訪問時計算println(lazyValue) // 直接使用緩存值
}

3.2 使用 Delegates.observable 監聽屬性變化

import kotlin.properties.Delegatesvar observedValue: String by Delegates.observable("初始值") { _, old, new ->println("值從 $old 變為 $new")
}fun main() {observedValue = "新值" // 輸出：值從 初始值 變為 新值
}

4. 內聯類（Inline Classes）
   內聯類用于封裝一個值，同時避免運行時開銷。

4.1 基本用法

inline class Password(val value: String)fun main() {val password = Password("123456")println(password.value) // 輸出：123456
}

4.2 優化性能
內聯類在運行時會被替換為原始值，避免額外的對象分配。

5. 反射（Reflection）
   反射允許你在運行時檢查類和對象的屬性和方法。

5.1 獲取類的信息

import kotlin.reflect.full.memberPropertiesdata class User(val name: String, val age: Int)fun main() {val user = User("Alice", 25)val properties = User::class.memberPropertiesfor (property in properties) {println("${property.name} = ${property.get(user)}")}
}

5.2 動態調用方法

import kotlin.reflect.full.functionsclass Calculator {fun add(a: Int, b: Int): Int = a + b
}fun main() {val calculator = Calculator()val addFunction = Calculator::class.functions.find { it.name == "add" }!!val result = addFunction.call(calculator, 2, 3) as Intprintln(result) // 輸出：5
}

6. 高階函數與 Lambda 表達式
   高階函數是指以函數作為參數或返回值的函數。

6.1 基本用法

fun operateOnNumbers(a: Int, b: Int, operation: (Int, Int) -> Int): Int {return operation(a, b)
}fun main() {val sum = operateOnNumbers(2, 3) { x, y -> x + y }println(sum) // 輸出：5
}

6.2 內聯函數
使用 inline 關鍵字避免 Lambda 表達式的運行時開銷：

inline fun measureTime(block: () -> Unit) {val start = System.currentTimeMillis()block()val end = System.currentTimeMillis()println("耗時：${end - start} 毫秒")
}fun main() {measureTime {Thread.sleep(1000)}
}

7. 密封類（Sealed Classes）
   密封類用于表示受限的類層次結構，子類必須在同一文件中定義。

7.1 基本用法

sealed class Result
data class Success(val data: String) : Result()
data class Error(val message: String) : Result()fun handleResult(result: Result) {when (result) {is Success -> println("成功：${result.data}")is Error -> println("錯誤：${result.message}")}
}fun main() {val result = Success("數據加載成功")handleResult(result) // 輸出：成功：數據加載成功
}

8. 泛型與型變
   8.1 泛型類

class Box<T>(val value: T)fun main() {val box = Box(42)println(box.value) // 輸出：42
}

8.2 型變（Variance）
協變（out）：允許子類型替換父類型。

class Producer<out T>(val value: T)

逆變（in）：允許父類型替換子類型。

class Consumer<in T> {fun consume(value: T) {println(value)}
}

9. DSL（領域特定語言）
   Kotlin 的 DSL 功能允許你創建領域特定語言，使代碼更具表現力。

9.1 構建 HTML DSL

class HTML {fun body(block: Body.() -> Unit) {val body = Body()body.block()println(body)}
}class Body {var content: String = ""fun p(block: () -> String) {content += "<p>${block()}</p>"}
}fun html(block: HTML.() -> Unit): HTML {val html = HTML()html.block()return html
}fun main() {html {body {p { "Hello, World!" }}}
}

10. 總結
    Kotlin 的高級特性包括：

協程：簡化異步編程。

擴展函數和屬性：增強現有類的功能。

屬性委托：簡化屬性邏輯。

內聯類：優化性能。

反射：動態操作類和對象。

高階函數與 Lambda：支持函數式編程。

密封類：受限的類層次結構。

泛型與型變：增強類型安全性。

DSL：創建領域特定語言。

掌握這些高級用法，可以讓你在 Kotlin 中編寫更高效、靈活和可維護的代碼！