Kotlin 核心概念完全指南

Kotlin 是一种在 JVM 上运行、兼有面向对象与函数式特性的现代化静态类型语言。本教程将带你快速理解 Kotlin 最核心的语法与概念，让你从零开始轻松上手。

避免空指针：Kotlin 的空安全

空安全是 Kotlin 最受欢迎的特性。默认情况下，所有类型都不能为 null，如果想允许空值，必须显式使用 ?。

var neverNull: String = "Hello"
// neverNull = null  // 编译错误

var nullable: String? = "World"
nullable = null      // 允许

安全调用操作符 ?. 会在对象为 null 时直接返回 null，而不会抛出空指针异常。

val length = nullable?.length   // 如果 nullable 为 null，length 也是 null

如果确信变量一定不为 null，可以使用 !! 操作符，但 null 时仍然会抛出异常，慎用。

val length = nullable!!.length   // 强制解包，有风险

对于条件处理，?:（Elvis 操作符）提供了默认值。

val len = nullable?.length ?: 0   // 如果为 null，取 0

变量声明：val 与 var

Kotlin 鼓励使用不可变变量，用 val 声明只读变量（类似 Java 的 final），使用 var 声明可变变量。

val immutable = 10      // 不可重新赋值
var mutable = 20        // 可以改变
mutable = 30

类型推断可以省略类型声明，但也可以明确指定。

val count: Int = 5
val message = "Hello"   // 自动推断为 String

函数的定义与默认参数

函数使用 fun 关键字，参数 名称在前，类型在后，返回类型写在参数列表后。

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

当函数体只有单个表达式时，可以使用表达式体语法。

fun multiply(a: Int, b: Int) = a * b

默认参数与命名参数

参数可以设定默认值，调用时可以省略有默认值的参数。

fun greet(name: String, greeting: String = "Hello"): String {
    return "$greeting, $name!"
}

greet("Kotlin")               // Hello, Kotlin!
greet("Kotlin", "Hi")         // Hi, Kotlin!

可以使用命名参数让代码更清晰。

greet(greeting = "Hey", name = "Dev")

控制流：if、when 与循环

智能的 if 表达式

Kotlin 中 if 可以作为表达式直接返回值。

val max = if (a > b) a else b

强大的 when 替代 switch

when 支持任意表达式作为分支条件，还可以检查类型、范围等。

fun describe(obj: Any): String =
    when (obj) {
        1          -> "One"
        "Hello"    -> "Greeting"
        is Long    -> "Long number"
        !is String -> "Not a string"
        else       -> "Unknown"
    }

when 也可以不带参数，仅作为条件链。

val result = when {
    x in 1..10 -> "介于1到10之间"
    x == 0     -> "是零"
    else       -> "其他"
}

循环

for 循环遍历任何提供迭代器（iterator）的对象。

for (i in 1..5) print(i)        // 输出 12345
for (item in list) println(item)

while 和 do-while 与 Java 类似。

while (condition) {
    // ...
}

类与对象

Kotlin 的类声明简洁，构造函数可以直接写在类头部。

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

这样同时声明了属性 name（只读）和 age（可变），并自动生成了 getter/setter。

类体中可以添加额外的属性和方法。

class Rectangle(val width: Int, val height: Int) {
    val area get() = width * height   // 自定义 getter
    fun isSquare() = width == height
}

创建对象不需要 new 关键字。

val person = Person("Alice", 30)

数据类：专门用于数据承载

data class 自动生成 equals、hashCode、toString、copy 等方法。

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

val user1 = User("Bob", 1)
val user2 = user1.copy(id = 2)  // 复制并修改 id

继承与接口

Kotlin 中所有类默认是 final 的，要允许继承必须使用 open。

open class Animal(val name: String)
class Dog(name: String, val breed: String) : Animal(name)

接口定义用 interface，实现类用 : 表示。

interface Drivable {
    fun drive()
}

class Car : Drivable {
    override fun drive() {
        println("Vroom")
    }
}

扩展函数：向已有类添加方法

不需要继承或装饰器，可以直接为已有类定义新函数。

fun String.removeFirstLast(): String =
    this.substring(1, this.length - 1)

"Hello".removeFirstLast()   // "ell"

扩展函数是静态解析的，不会真正修改原类，但写法极其自然。

高阶函数与 Lambda

Kotlin 支持函数作为参数或返回值，这种函数称为高阶函数。

fun calculate(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
    return operation(x, y)
}

val sum = calculate(3, 4) { a, b -> a + b }   // 7

当最后一个参数是 Lambda 时，可以将 Lambda 移到括号外，如上例所示。

常见的高阶函数有 map、filter、fold 等，对集合操作极佳。

val numbers = listOf(1, 2, 3, 4)
val doubled = numbers.map { it * 2 }     // [2, 4, 6, 8]
val evens = numbers.filter { it % 2 == 0 } // [2, 4]

it 是单个参数 Lambda 的默认名称。

协程：简洁的异步与并发

协程是 Kotlin 处理异步任务的官方解决方案，让你的代码像同步一样编写，但实际以异步方式执行。使用前需添加依赖 kotlinx-coroutines-core。

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(1000L)
        println("World!")
    }
    println("Hello,")
}
// 输出: Hello, (等待1秒) World!

• launch 启动新协程，不阻塞当前线程。
• delay 是挂起函数，暂停协程但不阻塞线程。
• runBlocking 创建顶层协程作用域，用于测试或主函数。

对于实际项目，通常使用 coroutineScope 或 viewModelScope 管理生命周期。

总结

Kotlin 核心概念包括：

• 空安全 彻底消除 null 引用带来的崩溃。
• 简洁的语法 变量声明、函数、类都比 Java 更清晰。
• 强大的控制流 when 和表达式形式使代码更直观。
• 数据类 自动生成样板代码。
• 扩展函数 无需修改原类即可增加功能。
• 高阶函数与 Lambda 让函数式编程变得自然。
• 协程 提供简洁高效的并发模型。

掌握这些核心概念，你就已经能够高效地使用 Kotlin 编写各种现代应用程序了。