基本语法

1. Kotlin 程序结构

Kotlin 程序的基本结构：

1
2
3

fun main() {
    println("Hello, World!") // 输出语句
}

2. 变量与数据类型

Kotlin 使用 val 和 var 定义变量：

**val**：不可变变量（类似 Java 的 final）
**var**：可变变量

1 2	val name: String = "Alice" // 不可变变量 var age: Int = 25 // 可变变量

Kotlin 支持类型推断，可以省略变量类型：

1 2	val name = "Alice" // 自动推断为 String var age = 25 // 自动推断为 Int

常见数据类型：

整数：Int, Long, Short, Byte
浮点数：Double, Float
字符：Char
布尔型：Boolean
字符串：String

Kotlin 中的数字没有隐式拓宽转换

小数部分与整数部分之间用句点（.）分隔对于以小数初始化的变量，编译器会推断为 Double 类型

如需将一个值显式指定为 Float 类型，请添加 f 或 F 后缀。s

3. 条件语句

if-else

fun main() {
    val a = 10
    val b = 20

    // 传统用法
    if (a > b) {
        println("a is greater")
    } else {
        println("b is greater")
    }

    // 表达式用法
    val max = if (a > b) a else b
    println("Max: $max")
}

when 表达式

类似 Java 的 switch，但更强大：

fun main() {
    val x = 3
    when (x) {
        1 -> println("x is 1")
        2, 3 -> println("x is 2 or 3")
        in 4..10 -> println("x is between 4 and 10")
        else -> println("x is something else")
    }
}

4. 循环语句

for 循环

for (i in 1..5) {
    println(i) // 输出 1 到 5
}

for (i in 1 until 5) {
    println(i) // 输出 1 到 4
}

for (i in 5 downTo 1 step 2) {
    println(i) // 输出 5, 3, 1
}

while 和 do-while

var x = 5
while (x > 0) {
    println(x)
    x--
}

do {
    println(x)
    x++
} while (x < 5)

5. 函数

定义函数

fun add(a: Int, b: Int): Int {
    return a + b
}

fun main() {
    println(add(3, 5)) // 输出 8
}

单表达式函数

1	fun subtract(a: Int, b: Int) = a - b

默认参数与命名参数

fun greet(name: String = "Guest") {
    println("Hello, $name!")
}

fun main() {
    greet()           // 输出 Hello, Guest!
    greet("Alice")    // 输出 Hello, Alice!
}

6. 空安全

Kotlin 提供了空安全操作符，避免空指针异常。

可空类型：

1 2	var name: String? = null // 可为空 name = "Kotlin"

安全调用操作符 `?.`

1	val length = name?.length // 如果 name 为空，则返回 null

Elvis 操作符 `?:`

1	val length = name?.length ?: 0 // 如果 name 为空，则返回 0

非空断言 `!!`

1	val length = name!!.length // 如果 name 为空，则抛出异常

7. 字符串模板

1
2
3

val name = "Alice"
val age = 25
println("My name is $name and I am $age years old.") // 输出 My name is Alice and I am 25 years old.

8. 集合

列表（List）

不可变列表：

1 2	val list = listOf(1, 2, 3) println(list[0]) // 输出 1

可变列表：

1
2
3

val mutableList = mutableListOf(1, 2, 3)
mutableList.add(4)
println(mutableList) // 输出 [1, 2, 3, 4]

映射（Map）

不可变 Map：

1 2	val map = mapOf("key1" to "value1", "key2" to "value2") println(map["key1"]) // 输出 value1

可变 Map：

1
2
3

val mutableMap = mutableMapOf("key1" to "value1")
mutableMap["key2"] = "value2"
println(mutableMap) // 输出 {key1=value1, key2=value2}

9. 类与对象

定义类

class Person(val name: String, var age: Int)

fun main() {
    val person = Person("Alice", 25)
    println(person.name) // 输出 Alice
    person.age = 26
    println(person.age)  // 输出 26
}

主构造函数与次构造函数

class Person(val name: String) {
    var age: Int = 0

    constructor(name: String, age: Int) : this(name) {
        this.age = age
    }
}

10. 扩展函数

扩展函数允许为已有类添加新函数：

fun String.lastChar(): Char = this[this.length - 1]

fun main() {
    println("Kotlin".lastChar()) // 输出 n
}

11. Lambda 表达式

定义 Lambda：

1 2	val sum = { a: Int, b: Int -> a + b } println(sum(3, 5)) // 输出 8

在集合中使用：

1
2
3

val list = listOf(1, 2, 3, 4, 5)
val evenNumbers = list.filter { it % 2 == 0 }
println(evenNumbers) // 输出 [2, 4]

12. 异常处理

try {
    val x = 10 / 0
} catch (e: ArithmeticException) {
    println("ArithmeticException: ${e.message}")
} finally {
    println("Finally block executed")
}

高级特性

1. 扩展函数与扩展属性

扩展函数允许为现有类添加新功能，而无需修改原代码。

扩展函数

fun String.isPalindrome(): Boolean {
    return this == this.reversed()
}

fun main() {
    println("radar".isPalindrome()) // 输出 true
    println("hello".isPalindrome()) // 输出 false
}

扩展属性

val String.firstChar: Char
    get() = this[0]

fun main() {
    println("Kotlin".firstChar) // 输出 K
}

2. 高阶函数与 Lambda 表达式

高阶函数

高阶函数是以函数作为参数或返回值的函数。

fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

fun main() {
    val sum = calculate(3, 5) { x, y -> x + y }
    println(sum) // 输出 8
}

Lambda 表达式

Lambda 是匿名函数的一种形式。

1 2	val greet = { name: String -> "Hello, $name" } println(greet("Kotlin")) // 输出 Hello, Kotlin

3. 内联函数（inline）

内联函数优化了高阶函数的性能，避免了额外的函数调用开销。

inline fun measureTime(action: () -> Unit) {
    val start = System.currentTimeMillis()
    action()
    val end = System.currentTimeMillis()
    println("Elapsed time: ${end - start} ms")
}

fun main() {
    measureTime {
        Thread.sleep(1000) // 模拟耗时操作
    }
}

4. 协程（Coroutines）

协程是 Kotlin 用于简化异步任务的工具。

基本用法

需要在项目中添加协程库依赖：

1	implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4")

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(1000L)
        println("World!")
    }
    println("Hello,")
}

构建器

launch：启动一个协程，不返回结果。

async：启动一个协程，并返回结果。

1 2	val result = async { compute() } println("Result: ${result.await()}")

5. 数据类（Data Class）

数据类会自动生成 toString、equals、hashCode 和 copy 方法。

data class User(val name: String, val age: Int)

fun main() {
    val user = User("Alice", 25)
    println(user) // 输出 User(name=Alice, age=25)
    val newUser = user.copy(age = 30)
    println(newUser) // 输出 User(name=Alice, age=30)
}

6. 密封类（Sealed Class）

密封类用于定义受限的类层次结构，通常用于表示状态或事件。

sealed class Result {
    data class Success(val data: String) : Result()
    object Error : Result()
}

fun handleResult(result: Result) {
    when (result) {
        is Result.Success -> println("Success: ${result.data}")
        Result.Error -> println("Error")
    }
}

7. 泛型

基本泛型

class Box<T>(val value: T)

fun main() {
    val intBox = Box(123)
    val strBox = Box("Hello")
    println(intBox.value) // 输出 123
    println(strBox.value) // 输出 Hello
}

协变与逆变

协变（out）：只能生产（读取）类型。
逆变（in）：只能消费（写入）类型。

class Producer<out T>(val value: T) {
    fun get(): T = value
}

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

8. 对象表达式与单例

对象表达式

对象表达式用于创建匿名类实例。

val obj = object {
    val name = "Anonymous"
}

println(obj.name) // 输出 Anonymous

单例模式

使用 object 定义单例：

object Singleton {
    fun greet() = "Hello from Singleton!"
}

fun main() {
    println(Singleton.greet())
}

9. 委托

类委托

通过关键字 by 将一个接口的实现委托给另一个类。

interface Printer {
    fun print()
}

class DefaultPrinter : Printer {
    override fun print() = println("Default Printing")
}

class CustomPrinter(printer: Printer) : Printer by printer

fun main() {
    val printer = CustomPrinter(DefaultPrinter())
    printer.print() // 输出 Default Printing
}

属性委托

通过 by 使用委托属性。

import kotlin.properties.Delegates

var observableValue: String by Delegates.observable("Initial") { _, old, new ->
    println("Value changed from $old to $new")
}

fun main() {
    observableValue = "Updated"
}

10. 类型别名

类型别名可以为复杂的类型定义更简单的名称。

typealias StringMap = Map<String, String>

val myMap: StringMap = mapOf("key" to "value")
println(myMap) // 输出 {key=value}

11. 注解与反射

注解

自定义注解可以用于元数据描述。

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class MyAnnotation(val value: String)

@MyAnnotation("Example Class")
class Example

反射

使用 kotlin.reflect 进行类反射。

import kotlin.reflect.full.*

fun main() {
    val kClass = Example::class
    val annotation = kClass.findAnnotation<MyAnnotation>()
    println(annotation?.value) // 输出 Example Class
}

12. DSL（领域特定语言）

Kotlin 的灵活语法支持创建 DSL。

fun html(block: Html.() -> Unit): Html {
    val html = Html()
    html.block()
    return html
}

class Html {
    fun body(block: Body.() -> Unit) {
        val body = Body()
        body.block()
    }
}

class Body {
    fun p(text: String) {
        println("<p>$text</p>")
    }
}

fun main() {
    // html {} 是对 html 函数的一次调用，并通过 DSL（Domain Specific Language，领域特定语言）的语法传递了一个 Lambda 表达式。html {} 是一种 DSL        语法
    html {
        body {
            p("Hello, DSL!")
        }
    }
}

输出：

1	<p>Hello, DSL!</p>

DSL 写法

person {
    name = "Alice"
    age = 25
    introduce()
}

等价传统写法

如果没有 DSL 语法，代码等价于：

val person = Person()
person.name = "Alice"
person.age = 25
person.introduce()

等价使用 apply 的写法

Kotlin 的 apply 函数提供了类似的能力：

val person = Person().apply {
    name = "Alice"
    age = 25
    introduce()
}

普通 Lambda

普通的 Lambda 表达式的形式如下：

1	val lambda: (String) -> Unit = { input -> println(input) }

调用时：

1	lambda("Hello, World!")

在普通 Lambda 中，input 是显式的参数。

带接收者的 Lambda

带接收者的 Lambda 表达式允许使用一个特定类型的对象作为上下文（接收者），在 Lambda 中可以直接访问接收者的成员：

1	val lambdaWithReceiver: String.() -> Unit = { println(this) }