第3章：基础语法速览

快速掌握 Kotlin 核心语法，从变量到函数一网打尽

3.1 变量与常量

val vs var — 不可变与可变

让我们从案件的第一条线索开始调查。Kotlin 的变量声明现场只留下了两个「嫌疑人」：val 和 var。先破解它们的名字密码 —— val 是 value（值）的缩写，意味着一旦赋值就不能再改变，强调的是「这是一个确定的值」；var 是 variable（变量）的缩写，意味着它的值可以随时变化。记住这两个英文原词，就永远不会搞混：value 不变，variable 可变。

下面这张对照表就是关键证据：

现在，让我们来验证这条线索。看看实际的代码证据：

// val — 不可变（推荐优先使用）
val name = "Kotlin"
// name = "Java"  // 编译错误！val 不能重新赋值

// var — 可变
var count = 0
count = 1       // OK，var 可以重新赋值
count = 2       // OK

类型推断

接下来，我注意到一个重要线索：Kotlin 编译器有一项出色的「侦查能力」—— 类型推断。它可以根据赋值自动推断变量类型，不需要你显式声明。这就像我根据现场遗留的证据，就能推理出嫌疑人的身份一样！

// 编译器自动推断类型
val name = "Kotlin"          // 推断为 String
val age = 25                 // 推断为 Int
val pi = 3.14               // 推断为 Double
val isKotlinFun = true       // 推断为 Boolean

从这段代码中，我们能推理出什么？对比 Java，Kotlin 简洁了很多：

// Java — 必须写类型
final String name = "Kotlin";
final int age = 25;

// Kotlin — 类型推断，省去冗余
val name = "Kotlin"
val age = 25

显式类型声明

当然，有时候侦探也需要明确亮出证据。你可以手动指定类型，或者在没有初始值时必须指定 —— 这是 Kotlin 的铁律，不可违反：

// 显式声明类型
val age: Int = 25
val price: Double = 9.99
val greeting: String = "你好"

// 没有初始值时，必须显式声明类型
val result: Int
result = calculateSomething()  // 稍后赋值（仅限一次）

编译时常量：const val

在深入调查中，我发现了一个更严格的「嫌疑人」—— const val。它用于声明编译时常量，类似于 Java 中的 static final。它必须是顶层声明或 object 的成员，且值必须是基本类型或 String。这条线索表明，const val 的值在编译阶段就已经锁定，不可能在运行时改变：

// 编译时常量 — 在编译阶段就确定值
const val MAX_COUNT = 100
const val BASE_URL = "https://api.example.com"
const val PI = 3.14159265

// 对比 Java:
// public static final int MAX_COUNT = 100;
// public static final String BASE_URL = "https://api.example.com";

3.2 基本数据类型

数字类型

接下来，我们来调查 Kotlin 数据类型的真相。这里有一条至关重要的线索：Kotlin 中没有 Java 的原始类型（primitive types），一切皆对象。但编译器会在可能的情况下优化为 JVM 原始类型 —— 这就好比嫌疑人表面上伪装成了对象，但在底层却悄悄地以原始类型的身份运行：

// 整数类型
val byte: Byte = 127               // 8 位
val short: Short = 32767           // 16 位
val int: Int = 2147483647          // 32 位
val long: Long = 9999999999L       // 64 位，注意后缀 L

// 浮点数类型
val float: Float = 3.14f           // 32 位，注意后缀 f
val double: Double = 3.14159265    // 64 位（默认）

// 数字字面量中可以用下划线增加可读性
val million = 1_000_000
val hexColor = 0xFF00FF
val binaryByte = 0b11010010

布尔、字符

// Boolean
val isVisible: Boolean = true
val isEmpty = false

// Char — 单引号
val letter: Char = 'A'
val digit: Char = '9'
val chinese: Char = '中'

字符串与字符串模板

我在代码现场发现了一件「秘密武器」—— Kotlin 的字符串模板。经过推理，我断定这是 Kotlin 最实用的特性之一，它比 Java 的字符串拼接简洁太多了。让我们来收集证据：

val name = "Kotlin"
val version = 2.0

// 简单变量引用 — 用 $
val msg1 = "Hello, $name"                 // "Hello, Kotlin"

// 表达式 — 用 ${}
val msg2 = "$name $version 已发布"         // "Kotlin 2.0 已发布"

val list = listOf("A", "B", "C")
val msg3 = "共 ${list.size} 个元素"       // "共 3 个元素"
val msg4 = "大写: ${name.uppercase()}"   // "大写: KOTLIN"

对比 Java 的字符串拼接 —— 证据确凿，Kotlin 的写法更胜一筹：

// Java — 冗长的字符串拼接
String msg = "Hello, " + name + "! 共 " + list.size() + " 个元素";

// Kotlin — 清晰的字符串模板
val msg = "Hello, $name! 共 ${list.size} 个元素"

Kotlin 还支持多行字符串（raw string），用三个双引号。这条线索在处理 JSON、SQL 等场景时尤其有用：

val json = """
    {
        "name": "$name",
        "version": $version
    }
""".trimIndent()

数组

// 通用数组
val names: Array<String> = arrayOf("Alice", "Bob", "Charlie")
val numbers = arrayOf(1, 2, 3, 4, 5)

// 原始类型数组（性能更好，避免装箱）
val intArr: IntArray = intArrayOf(1, 2, 3)
val doubleArr: DoubleArray = doubleArrayOf(1.0, 2.0)

// 访问元素
println(names[0])      // "Alice"
names[1] = "Bobby"     // 修改元素

类型转换

注意了！这是一条容易让人「翻车」的线索。Kotlin 不会进行隐式类型转换，必须显式调用转换函数。在我看来，这种设计就像严格的法庭规则 —— 每一步操作都必须有明确的依据，不允许任何含糊不清的推理：

val intVal: Int = 42

// 错误！不能隐式转换
// val longVal: Long = intVal   // 编译错误

// 正确 — 显式转换
val longVal: Long = intVal.toLong()
val doubleVal: Double = intVal.toDouble()
val stringVal: String = intVal.toString()

// 字符串转数字
val parsed: Int = "123".toInt()
val safeP: Int? = "abc".toIntOrNull()  // 转换失败返回 null，不会崩溃

3.3 控制流

if 是表达式

案件进入了新的阶段 —— 控制流调查。我发现了第一条重要线索：在 Kotlin 中，if 不仅仅是语句，它还是一个表达式，可以有返回值。这意味着你不再需要三元运算符 ? :。用推理来理解：既然 if 能返回值，那三元运算符就成了多余的「嫌疑人」—— 被排除了！

// if 作为表达式 — 替代三元运算符
val a = 10
val b = 20
val max = if (a > b) a else b    // max = 20

// 也可以带代码块
val description = if (a > b) {
    println("a 更大")
    "a wins"    // 最后一个表达式是返回值
} else {
    println("b 更大")
    "b wins"
}

让我把各路「嫌疑人」摆在一起做个对比，这样真相就更清楚了：

// Java — 三元运算符
int max = (a > b) ? a : b;

// Python — 条件表达式
// max = a if a > b else b

// Kotlin — if 表达式（更可读）
val max = if (a > b) a else b

when 表达式

现在，案件迎来了最精彩的转折 —— when 表达式登场！经过细致的排查，我可以确认它是 Kotlin 中替代 switch 的终极利器，功能强大得多。让我们逐步收集证据：

// 基本用法 — 匹配值
val dayOfWeek = 3
val dayName = when (dayOfWeek) {
    1 -> "周一"
    2 -> "周二"
    3 -> "周三"
    4 -> "周四"
    5 -> "周五"
    6, 7 -> "周末"           // 多个值合并
    else -> "未知"            // 默认分支
}

从这段代码中，我们能推理出什么？when 还能匹配范围，这比 switch 灵活多了：

// 匹配范围
val score = 85
val grade = when (score) {
    in 90..100 -> "优秀"
    in 80..89  -> "良好"
    in 70..79  -> "中等"
    in 60..69  -> "及格"
    else       -> "不及格"
}

更令人惊讶的证据 —— when 还能匹配类型，并且自动进行智能转换：

// 匹配类型
fun describe(obj: Any): String = when (obj) {
    is Int    -> "整数: $obj"
    is String -> "字符串，长度 ${obj.length}"  // 智能类型转换！
    is Boolean -> "布尔值: $obj"
    else     -> "未知类型"
}

还有最后一条线索 —— 无参 when，它可以作为 if-else 链的更优雅替代：

// 无参 when — 作为 if-else 链的替代（更优雅）
val temperature = 35
val weather = when {
    temperature < 0   -> "严寒"
    temperature < 10  -> "寒冷"
    temperature < 25  -> "舒适"
    temperature < 35  -> "炎热"
    else              -> "酷暑"
}

for 循环与区间

让我们继续追踪下一条线索 —— for 循环。Kotlin 的 for 循环与区间运算符搭配使用，形成了一套优雅的遍历体系：

// 遍历区间
for (i in 1..5) {
    print("$i ")    // 输出: 1 2 3 4 5
}

// until — 不包含末尾
for (i in 0 until 5) {
    print("$i ")    // 输出: 0 1 2 3 4
}

// downTo — 倒序
for (i in 5 downTo 1) {
    print("$i ")    // 输出: 5 4 3 2 1
}

// step — 指定步长
for (i in 0..10 step 2) {
    print("$i ")    // 输出: 0 2 4 6 8 10
}

遍历集合也留下了清晰的证据 —— Kotlin 提供了多种方式：

// 遍历集合
val fruits = listOf("苹果", "香蕉", "橙子")

for (fruit in fruits) {
    println(fruit)
}

// 使用 indices 获取索引
for (i in fruits.indices) {
    println("$i: ${fruits[i]}")
}

// 使用 withIndex() 同时获取索引和值
for ((index, fruit) in fruits.withIndex()) {
    println("$index: $fruit")
}
// 输出:
// 0: 苹果
// 1: 香蕉
// 2: 橙子

while / do-while

这两个嫌疑人的行为模式和其他语言几乎一致，不需要过多调查：

// while — 先判断后执行
var n = 5
while (n > 0) {
    print("$n ")    // 输出: 5 4 3 2 1
    n--
}

// do-while — 先执行后判断（至少执行一次）
var input: String
do {
    input = readLine() ?: ""
    println("你输入了: $input")
} while (input != "quit")

区间运算总结

将所有区间相关的线索汇总到一张证据表中：

3.4 函数

基本定义

案件来到了「函数」这一关键现场。经过仔细调查，我发现 Kotlin 的函数定义规则十分清晰 —— 用 fun 关键字开头，参数类型在名称后面，返回类型紧随其后：

// 标准函数定义
fun add(a: Int, b: Int): Int {
    return a + b
}

// 调用
val sum = add(3, 5)  // 8

让我们把各路「嫌疑人」排列对比，真相自然浮现：

// Java
public int add(int a, int b) {
    return a + b;
}

// Python
// def add(a, b):
//     return a + b

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

单表达式函数

我在调查中发现了一条精妙的线索：当函数体只有一个表达式时，可以用 = 简写，返回类型也可以省略。这就是 Kotlin 追求简洁的决定性证据：

// 标准写法
fun add(a: Int, b: Int): Int {
    return a + b
}

// 单表达式简写 — 省去花括号和 return
fun add(a: Int, b: Int) = a + b

// 更多示例
fun isEven(n: Int) = n % 2 == 0
fun greeting(name: String) = "Hello, $name!"
fun max(a: Int, b: Int) = if (a > b) a else b

默认参数

又一条关键线索浮出水面 —— Kotlin 支持给函数参数设置默认值，从而大幅减少方法重载的需要。对一个侦探来说，这就像是找到了一个能替代多条分散线索的核心证据：

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

greet()                        // Hello, World!
greet("Kotlin")               // Hello, Kotlin!
greet("Kotlin", ".")         // Hello, Kotlin.

对比 Java，不再需要写一堆重载方法了 —— 这是铁证：

// Java — 需要多个重载
void greet() { greet("World"); }
void greet(String name) { greet(name, "!"); }
void greet(String name, String punctuation) {
    System.out.println("Hello, " + name + punctuation);
}

// Kotlin — 一个函数搞定
fun greet(name: String = "World", punctuation: String = "!") {
    println("Hello, $name$punctuation")
}

命名参数

这条线索与默认参数联合使用时威力倍增。调用函数时可以指定参数名，让代码更清晰，也可以跳过中间的默认参数 —— 这是我在侦查中发现的最优雅的搭配组合：

fun createUser(
    name: String,
    age: Int = 0,
    email: String = "",
    isAdmin: Boolean = false
) {
    println("$name, $age, $email, admin=$isAdmin")
}

// 使用命名参数 — 跳过中间参数，代码更易读
createUser(name = "Alice", isAdmin = true)
createUser(name = "Bob", email = "bob@example.com")
createUser(name = "Charlie", age = 30, email = "c@test.com")

可变参数：vararg

fun printAll(vararg messages: String) {
    for (msg in messages) {
        println(msg)
    }
}

printAll("Hello", "World", "Kotlin")

// 展开数组传入 vararg — 使用 * 展开运算符
val words = arrayOf("Hello", "World")
printAll(*words)

Unit 返回类型

Unit 相当于 Java 的 void，表示函数不返回有意义的值。根据我的推理，省略不写是更常见的做法：

// 显式写 Unit
fun logMessage(msg: String): Unit {
    println("[LOG] $msg")
}

// 省略 Unit（推荐）
fun logMessage(msg: String) {
    println("[LOG] $msg")
}

3.5 与其他语言的对比小贴士

现在让我们把所有收集到的线索汇总到一张「案件证据总表」中。如果你有 Java、C++ 或 Python 经验，下面这张对照表能帮你快速建立映射关系 —— 就像把嫌疑人的指纹与数据库比对一样高效：

val name = "柯南"         // String — 名字不变，用 val
var age = 17              // Int — 年龄会变，用 var
val pi = 3.14159265       // Double — 圆周率是常数，用 val
var counter = 0           // Int — 计数器需要累加，用 var

// 验证：可以修改 var，不能修改 val
age = 18                  // OK
counter = counter + 1     // OK
// name = "新一"           // 编译错误！val 不能重新赋值

fun evaluateScore(score: Int): String = when (score) {
    100           -> "满分！完美推理！"
    in 90..99    -> "优秀"
    in 80..89    -> "良好"
    in 60..79    -> "及格"
    in 0..59     -> "不及格"
    else          -> "无效分数"
}

// 测试
println(evaluateScore(100))  // 满分！完美推理！
println(evaluateScore(85))   // 良好
println(evaluateScore(42))   // 不及格
println(evaluateScore(-1))   // 无效分数

val detective = "柯南"
val casesResolved = 312
val successRate = 99.7

val detective = "柯南"
val casesResolved = 312
val successRate = 99.7

// 基础版
val report = "侦探$detective 已成功破获 $casesResolved 起案件，破案率高达 $successRate%！"
println(report)
// 侦探柯南已成功破获 312 起案件，破案率高达 99.7%！

// 进阶版 — 使用表达式
val report2 = "侦探${detective.uppercase()} 已成功破获 ${casesResolved} 起案件（名字共 ${detective.length} 个字），破案率 $successRate%！"
println(report2)
// 侦探柯南 已成功破获 312 起案件（名字共 2 个字），破案率 99.7%！

fun formatClue(
    content: String,
    caseNumber: Int = 1,
    priority: String = "普通",
    isVerified: Boolean = false
): String {
    val status = if (isVerified) "已验证" else "未验证"
    return "[案件#$caseNumber][$priority] $content ($status)"
}

// 调用 1：只传内容
println(formatClue("现场发现指纹"))
// [案件#1][普通] 现场发现指纹 (未验证)

// 调用 2：传内容和优先级（使用命名参数跳过 caseNumber）
println(formatClue(content = "发现可疑脚印", priority = "紧急"))
// [案件#1][紧急] 发现可疑脚印 (未验证)

// 调用 3：传内容、案件编号和已验证标志（跳过 priority）
println(formatClue(content = "嫌疑人不在场证明", caseNumber = 7, isVerified = true))
// [案件#7][普通] 嫌疑人不在场证明 (已验证)

fun investigate(clue: Any): String = when {
    clue is Int && clue > 0           -> "正整数线索：值为 $clue"
    clue is Int                        -> "无效线索：整数 $clue 不是正数"
    clue is String && clue.isNotEmpty() -> "文字线索：内容为 \"$clue\"，共 ${clue.length} 个字符"
    clue is String                     -> "空白线索：没有内容"
    clue == true                       -> "确认线索：已核实"
    clue == false                      -> "否定线索：已排除"
    else                               -> "未知线索：类型为 ${clue::class.simpleName}"
}

// 测试
println(investigate(42))          // 正整数线索：值为 42
println(investigate(-5))          // 无效线索：整数 -5 不是正数
println(investigate("指纹"))      // 文字线索：内容为 "指纹"，共 2 个字符
println(investigate(""))          // 空白线索：没有内容
println(investigate(true))        // 确认线索：已核实
println(investigate(false))       // 否定线索：已排除
println(investigate(3.14))        // 未知线索：类型为 Double