Kotlin 基础

是什么，为什么存在

Kotlin 的基础语法围绕一个简单目标展开：让程序的约束直接出现在代码里。名称能否重新赋值由 val 或 var 表达，值能否为 null 由类型末尾的 ? 表达，分支可以直接产生结果。编译器因此能在程序运行前拒绝一批不成立的状态。

Kotlin 是静态类型语言。每个表达式都有编译期类型，但局部变量通常不必重复写出类型，因为编译器会做 类型推断（type inference） 。推断不会把语言变成动态类型：val count = 3 一旦推断为 Int，之后就不能把字符串赋给 count。

这些规则会出现在任何 Kotlin 程序中，无论目标是 JVM、JavaScript、Native 还是 Wasm。本页使用普通 Kotlin/JVM 命令行程序说明语言核心，不涉及 Android 生命周期、协程、集合操作链或类设计；这些内容各有独立主题。

这套语法让所有权和失败路径更容易读，少写几个字符只是附带收益。看到 String?，调用方就知道缺失值是契约的一部分；看到没有 else 的枚举 when，维护者就知道新增枚举成员会触发编译检查。

工作原理

声明绑定名称

val 声明只读引用：初始化完成后，这个名称不能指向另一个值。var 声明可重新赋值的引用。局部 val 可以先声明、后赋值一次，但这种写法必须给出类型，而且编译器要能证明每条使用路径都已完成初始化。

只读引用与不可变对象不是一回事。val quantities = intArrayOf(1, 2) 禁止执行 quantities = intArrayOf(3)，却允许执行 quantities[0] = 3，因为数组对象本身仍可修改。选择 val 约束的是名称，而对象是否可变由其类型和 API 决定。

var 适合循环计数、状态机当前位置等确实会变化的绑定。把所有局部量都写成 var 会扩大可变范围，使读者必须追踪更多赋值点。一个实用的判断是：如果删除重新赋值后代码仍能成立，这个绑定就应是 val。

推断仍然产生确定类型

有初始化值时，编译器通常能推断局部变量类型。整数文字通常推断为 Int，超出 Int 范围时推断为 Long；带小数点的文字默认是 Double，f 或 F 后缀表示 Float。类型需要承载接口契约、允许 null 或避免读者猜测时，应显式写出。

Kotlin 的数字类型不会在赋值和函数传参时自动相互转换。需要把 Int 交给接收 Long 的 API 时，写 count.toLong()。显式转换让截断、溢出和精度变化留在代码审查的视线内。

混合数字表达式可以按运算符重载得到较宽的结果，但这不等于所有上下文都有隐式转换。尤其要留意整数除法：5 / 2 的结果是 2，要得到 2.5，至少一个操作数必须是浮点类型。

可空性属于类型

String 不接受 null，而 可空类型（nullable type） String? 接受。可空接收者不能直接访问普通成员；代码必须先证明值非空，使用安全调用 ?.，或者用 Elvis 操作符 ?: 提供另一条路径。

安全调用在接收者为 null 时返回 null，因此调用链的结果往往仍是可空类型。profile?.address?.city 中任何一级缺失，整个表达式都得到 null。?: 只在左侧为 null 时计算右侧，所以右侧可以是默认值、return 或 throw。

编译器能证明一个值在某条控制流路径上具有更具体类型时，会执行 智能转换（smart cast） 。例如，value == null 后立即 return，后续路径中的 value 就可按非空类型使用。这个证明依赖稳定性；可能被其他代码改变的开放属性或可变属性通常不能直接智能转换。

分支也能产生值

if 与 when 既能控制流程，也能作为表达式返回结果。作为值使用的 if 必须覆盖两侧分支，各代码块的最后一个表达式就是该分支结果。这样可以直接初始化 val，避免先声明一个可变临时量再在每个分支赋值。

when 可以匹配值、范围、类型，也可以省略主题后按顺序检查布尔条件。编译器要求作为表达式使用的 when 是 穷尽 when（exhaustive when） 。对枚举或密封层级列出所有已知分支而不写宽泛的 else，新增成员时就会得到编译错误，而不是悄悄落入默认行为。

分支按源码顺序检查，第一个匹配项胜出。范围可能重叠时，顺序就是业务规则的一部分。把更窄、更特殊的条件放在宽泛条件之前，通常比依赖读者自行推导覆盖关系更清楚。

循环处理序列工作

for 循环遍历能提供迭代器的值，常见目标包括范围、数组和集合。1..5 包含两端，1 until 5 不包含末端；降序使用 downTo，间隔使用 step。边界差异会直接影响次数，生成代码尤其容易把 .. 与 until 混用。

while 在每轮之前判断条件，do-while 至少执行一次。break 结束最近一层循环，continue 跳到下一轮；带标签的跳转能跨越嵌套循环，但也会增加控制流成本。能通过提取函数或改写条件消除标签时，代码通常更容易测试。

函数公开契约

函数参数必须声明类型。块函数通常显式声明返回类型，尤其是公共 API；单表达式函数可以从表达式推断返回类型。没有有意义返回值的函数返回 Unit，返回类型通常可以省略。

默认参数在声明处定义缺省行为，命名参数让调用方写出选择。命名参数还允许调整实参顺序，但名称属于 Kotlin API 的源码契约；调用 Java 方法时不能依赖 Java 参数名使用 Kotlin 命名实参。

前置条件可以用 require 表达。条件失败时会抛出 IllegalArgumentException，并把错误定位在调用方给出的无效数据上。对于可以预期的用户输入错误，返回可空值或领域结果类型往往比抛异常更合适；边界应由调用契约决定。

示例

从 val 开始，只缩小必要的可变范围

第一个程序保留一个可变计数器，但客户名、数组引用、单价和结果都是只读绑定。数组内容仍可修改，这正好展示了 val 约束引用而不冻结对象。

金额用整数分表示，避免在这个基础示例中引入二进制浮点舍入。这里的 1_250 仍是普通 Int，下划线只提高数字文字的可读性。若金额与数量的乘积可能超过 Int 范围，应在运算前选择 Long 或专门的金额类型。

在输入边界处理 null 与格式错误

第二个程序把原始字符串解析为 Int?。空白、缺失值和非数字文本都得到 null；调用方再把“无法取得重量”与合法重量的运费档位分开。

fun parseWeight(raw: String?): Int? {
    val normalized = raw?.trim()

    // 提前返回后，normalized 在剩余路径中被智能转换为 String。
    if (normalized.isNullOrEmpty()) return null
    return normalized.toIntOrNull()
}

fun shippingBand(weight: Int): String = when {
    weight <= 0 -> "invalid"
    weight <= 10 -> "standard"
    weight <= 30 -> "heavy"
    else -> "freight"
}

fun main() {
    val inputs = listOf(" 8 ", null, "heavy", "42")

    for (raw in inputs) {
        val weight = parseWeight(raw)
        val band = if (weight == null) "missing" else shippingBand(weight)
        println("${raw ?: "<null>"} -> $band")
    }
}

 8  -> standard
<null> -> missing
heavy -> missing
42 -> freight

toIntOrNull() 把解析失败留在类型中，而不是依赖捕获异常。if 的两侧都产生 String，所以 band 的类型可推断为 String。业务若需要区分“缺失”和“格式错误”，就不应继续把两者压成同一个 null，而应返回能表达不同失败原因的类型。

用默认参数表达常用调用

第三个程序把单位固定在“分”，并用 Long 承载金额。默认参数保留最常见的一件商品、无折扣调用；批量订单通过命名实参写出所有变化点。

fun lineTotal(
    priceCents: Long,
    quantity: Int = 1,
    discountPercent: Int = 0,
): Long {
    require(priceCents >= 0)
    require(quantity >= 0)
    require(discountPercent in 0..100)

    val gross = priceCents * quantity
    return gross * (100 - discountPercent) / 100
}

fun main() {
    val regular = lineTotal(priceCents = 2_500)
    val bulk = lineTotal(
        priceCents = 2_500,
        quantity = 4,
        discountPercent = 10,
    )

    println("Regular cents: $regular")
    println("Bulk cents: $bulk")
}

Regular cents: 2500
Bulk cents: 9000

这里的除法是整数除法，折扣后不足一分的部分会被截去。这不是普遍正确的财务舍入规则，只是函数契约中的具体选择。生产代码应给舍入策略命名并测试边界，而不是让运算符顺序暗中决定结果。

让枚举分支保持穷尽

最后一个程序先把不可信字符串转换为 Access?，再对有限状态做穷尽处理。解析函数需要 else 接住任意文本；路由函数则列出 null 和每个枚举成员，不使用 else。

enum class Access {
    GUEST,
    MEMBER,
    ADMIN,
}

fun parseAccess(raw: String): Access? = when (raw.lowercase()) {
    "guest" -> Access.GUEST
    "member" -> Access.MEMBER
    "admin" -> Access.ADMIN
    else -> null
}

fun homeRoute(access: Access?): String = when (access) {
    null -> "/sign-in"
    Access.GUEST -> "/welcome"
    Access.MEMBER -> "/account"
    Access.ADMIN -> "/admin"
}

fun main() {
    for (raw in listOf("member", "ADMIN", "unknown")) {
        val access = parseAccess(raw)
        println("$raw -> ${homeRoute(access)}")
    }
}

member -> /account
ADMIN -> /admin
unknown -> /sign-in

如果后来加入 SUPPORT，homeRoute 会停止编译，迫使维护者决定新角色的页面。parseAccess 的输入集合是开放的，因此它仍需要默认分支。两个 when 形式相似，但边界契约不同。

陷阱

把 val 当成深度不可变

修复： 同时检查绑定和对象 API。需要快照时创建副本，需要公开只读视图时返回只读接口；如果调用方必须完全相信数据不会变化，应让类型设计本身表达不可变，而不是只把变量改成 val。

依赖隐式数字扩宽

修复： 在语义边界显式调用 toLong()、toDouble() 等转换函数，并在运算开始前选好结果类型。转换到更窄的整数类型可能改变数值，浮点转整数会截去小数部分，因此转换本身也需要测试。

用 !! 消除编译错误

修复： 在接收输入的边界选择策略：用 ?: return 放弃当前操作，用 ?: throw IllegalArgumentException(...) 报告违反契约，或让返回类型继续保留 null。只有外部不变量已经建立、编译器却无法表达时，才考虑局部而有说明的断言。

用 === 比较内容

修复： 值比较使用 ==，只有算法确实关心对象身份时才使用 ===。数组是一个额外边界：数组的 == 不做逐元素比较，需要按目的选择 contentEquals() 或 contentDeepEquals()。

给有限状态加宽泛 else

修复： 对封闭状态逐项列出分支，让编译器检查穷尽性。只有输入集合本来就是开放的，例如任意字符串、整数或外部协议值，才保留 else，并明确未知输入是拒绝、忽略还是降级。

在复杂表达式中隐藏副作用

修复： 表达式只承担一个容易命名的结果。先完成输入验证，再计算值，最后执行副作用；当分支需要多步工作时，用块和局部名称展开，而不是追求最少行数。

延伸阅读

• Kotlin 基础语法概览（官方文档源码）
• Kotlin 数字类型（官方文档源码）
• Kotlin 空安全（官方文档源码）
• Kotlin 条件与循环（官方文档源码）
• Kotlin 函数（官方文档源码）