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函数（官方文档源码）