Kotlin 是一门功能强大且灵活的编程语言，除了基础语法外，它还提供了许多高级特性，可以帮助你编写更简洁、高效和可维护的代码。以下是 Kotlin 的一些高级用法，涵盖了协程、扩展函数、属性委托、内联类、反射等内容。
- 协程（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() // 取消协程
}
- 扩展函数（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
}
- 属性委托（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 = "新值" // 输出：值从 初始值 变为 新值
}
- 内联类（Inline Classes）
内联类用于封装一个值，同时避免运行时开销。
4.1 基本用法
inline class Password(val value: String)fun main() {val password = Password("123456")println(password.value) // 输出：123456
}
4.2 优化性能
内联类在运行时会被替换为原始值，避免额外的对象分配。
- 反射（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
}
- 高阶函数与 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)}
}
- 密封类（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.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)}
}
- 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!" }}}
}
- 总结
Kotlin 的高级特性包括：
协程：简化异步编程。
扩展函数和属性：增强现有类的功能。
属性委托：简化属性逻辑。
内联类：优化性能。
反射：动态操作类和对象。
高阶函数与 Lambda：支持函数式编程。
密封类：受限的类层次结构。
泛型与型变：增强类型安全性。
DSL：创建领域特定语言。
掌握这些高级用法，可以让你在 Kotlin 中编写更高效、灵活和可维护的代码！