学 Kotlin 时，很多人不是不会写语法，而是总在“这个词到底是不是保留字、能不能拿来当名字、为什么这里必须这样写”这些细节上反复卡住。本文按官方分类把 77 个关键字拆成三组，并配上简短示例和使用提示，帮助你快速分清哪些是始终保留、哪些看上下文、哪些主要负责修饰声明，后续查表和写代码都会更稳。
硬关键字：始终保留，不能直接拿来命名
硬关键字是 Kotlin 中最严格的一组。它们无条件保留，不能直接作为变量名、函数名或类名使用。实际开发里，最容易混淆的是流程控制、类型判断、对象声明和空安全相关词汇，这些关键字往往决定了一段代码的基本语义。
类型转换、类型判断与空值相关关键字
这一组经常一起出现，尤其是在处理 Any、可空类型和分支判断时。
as：强制类型转换，失败会抛异常；导入时也能起别名。as?：安全类型转换，失败返回null。is/!is：类型检查与反向类型检查。null：空引用常量。in/!in：判断元素是否位于区间或集合中；in还可用于泛型逆变。
val num = anyObj as Int
val str = anyObj as? String ?: "默认值"
val value: Any = "Kotlin"
if (value is String) println(value.length)
if (value !is Int) println("不是整数")
val s: String? = null
if (5 in 1..10) {}
if (3 !in 5..10) println("不在区间")
class Box<in T>如果你不确定转换一定成功，优先考虑 as?，再配合 Elvis 操作思路处理默认值，这比直接强转更安全。
流程控制与分支表达式
Kotlin 的流程关键字覆盖了条件判断、循环和跳转控制。其中 if 和 when 都不只是语句，也可以直接作为表达式返回值。
if/else：条件分支，可直接产出结果。when：更灵活的分支表达式。for、while、do：迭代与循环。break、continue：中断循环或跳过当前轮次。return：返回函数结果。
val result = if (score >= 60) "及格" else "不及格"
val max = if (a > b) a else b
val grade = when (score) {
100 -> "满分"
in 90..99 -> "优秀"
else -> "及格"
}
for (i in 1..5) println(i)
for ((idx, item) in list.withIndex()) {}
var i = 0
while (i < 3) {
println(i)
i++
}
var j = 0
do {
println(j)
j++
} while (j < 2)
for (i in 1..5) {
if (i == 3) continue
println(i)
}
loop@ for (i in 1..3) {
break@loop
}和 Java 不同，Kotlin 更鼓励把分支直接写成表达式，因此 if、when 的返回值能力值得优先掌握。
声明、对象与基本结构
这组关键字定义了文件、类、函数、接口、变量和对象，是写 Kotlin 代码时最常见的基础词汇。
package、class、interface、funobject：可用于单例、伴生对象、匿名对象。val/var：只读变量与可变变量。this/super：当前对象与父类引用。typealias：类型别名。
package com.example.kotlin.keywords
class Person(val name: String) {
fun sayHello() = println("Hi")
fun intro() = println("我是$this.name")
}
interface Flyable {
fun fly()
}
class Bird : Flyable {
override fun fly() {}
}
object Singleton {
val app = "Kotlin"
}
class A {
companion object {}
}
val age = 25
var count = 0
count += 1
typealias StringList = List<String>val 并不等于绝对不可变，它表示“引用不可重新赋值”；而 object 则是 Kotlin 中非常高频的语言级单例方案。
布尔值与异常处理
剩下这组关键字数量不多，但基本都和运行时行为直接相关。
true/false：布尔字面量。try、throw：异常处理和主动抛错。
val isSuccess = true
val isFail = false
if (isSuccess) println("完成")
if (!isFail) println("成功")
try {
10 / 0
} catch (e: ArithmeticException) {
println(e.message)
}
fun checkAge(age: Int) {
if (age < 0) throw IllegalArgumentException("年龄非法")
}这里需要顺带记住一点：catch 和 finally 在 Kotlin 中被归入软关键字，它们虽然常和 try 一起写，但分类上并不相同。
软关键字：只有在特定上下文里才生效
软关键字不会像硬关键字那样无条件占用名字。只有放进特定语法位置时，它们才会被编译器识别成关键字；离开对应上下文，它们通常可以当作普通标识符使用。这也是 Kotlin 在可读性和兼容性之间做出的平衡。
委托、构造与访问器相关
这一类常见于类定义和属性定义，是日常编码中最容易遇到的软关键字。
by：接口委托或属性委托。constructor：主构造函数或次构造函数声明。init：初始化代码块。get/set：自定义属性访问器。field：属性幕后字段，常在 setter/getter 或注解目标中出现。
class User(p: Printer) : Printer by p
var name: String by Delegate()
class Car constructor(val brand: String)
class Person(val name: String) {
init {
println("初始化:$name")
}
}
var isAdult: Boolean
get() = age >= 18
var score: Int = 0
set(value) {
field = if (value in 0..100) value else 0
}如果你刚接触 Kotlin，by 和 field 往往是第一批“看起来不熟、但项目里很常见”的词。前者常用来减少模板代码，后者则是写自定义访问器时的关键。
异常处理与导入语法
这一组虽然不多，但出现频率很高。
catch：捕获异常。finally：无论异常与否都会执行的收尾块。import：导入类型或函数。
try {
10 / 0
} catch (e: ArithmeticException) {
println("除零异常")
} finally {
file.close()
}
import java.util.ArrayList它们之所以被列为软关键字，是因为编译器只会在对应语法结构里把它们识别成关键字，而不是像 class、fun 那样始终保留。
注解目标、泛型约束与平台相关场景
这一组更偏进阶，平时不一定每天都会写到，但一旦碰上注解、多平台或 Kotlin/JS，就很难绕开。
delegate、file、param、property、receiver、setparam：注解目标。where：给泛型追加约束。dynamic：Kotlin/JS 中的动态类型。
@delegate:MyAnnotation
val name: String by Delegate()
@field:Nullable
var age: Int = 0
@file:JvmName("MyFile")
package com.example
fun test(@param:NotNull name: String) {}
@property:Deprecated
var age2: Int = 0
fun @receiver:NotNull String.printLen() = println(length)
var age3: Int = 0
set(@setparam:Min(0) value) {
field = value
}
fun <T> printInfo(t: T) where T : CharSequence, T : Comparable<T> {
println(t.length)
}
val jsObj: dynamic = js("{}")
jsObj.name = "Kotlin"其中 where 很适合用来把复杂的泛型限制写得更清楚；而一长串注解目标关键字则主要服务于框架和平台互操作场景。
修饰符关键字：决定可见性、继承关系与能力边界
修饰符关键字主要用来修饰类、函数、属性或泛型参数。它们控制的不是“这段代码是什么”，而是“这段代码能被谁访问、能否继承、会以什么方式工作”。理解这组关键字，往往比单纯记住写法更重要。
可见性与继承控制
这部分最直接，关系到模块边界、封装和扩展能力。
public、private、protected、internal：可见性控制。open、final、abstract、override：继承与重写控制。
public class PublicClass {
public fun pubFun() {}
}
private val PWD = "123456"
abstract class Shape {
abstract fun area(): Double
}
open class Animal {
open fun eat() {}
}
class Dog : Animal() {
override fun eat() {
super.eat()
}
}
final class FinalClass {
final fun noOverride() {}
}
internal class Module {
internal fun f() {}
}
protected val secret = "秘"Kotlin 的类默认是 final，这一点和很多面向对象语言不同。只有显式写上 open，类和成员才允许被继承或覆盖。
数据建模与对象组织
当你在定义常量、数据结构或有限状态时，这组修饰符很常见。
data：数据类。enum：枚举类。sealed：密封类，适合有限分支建模。annotation：注解类。companion：伴生对象。const：编译期常量。inner：内部类。lateinit：延迟初始化的var属性。
data class User(val id: Int, val name: String)
enum class Season { SPRING, SUMMER }
sealed class Result
class Success : Result()
@Target(AnnotationTarget.CLASS)
annotation class MyAnnotation
class A {
companion object {
val info = "伴生"
fun show() = println(info)
}
}
const val MAX = 100
class Outer {
inner class Inner {}
}
lateinit var email: Stringdata、enum、sealed 这三者都和“建模”有关，但适用场景不同：前者偏数据承载，中间偏固定枚举值，后者偏受控分支结构。
泛型、函数能力与调用形式
这一组更偏语言高级特性，通常和性能、DSL、泛型表达力有关。
inline、noinline、crossinline：内联函数及 Lambda 行为控制。reified：实化内联泛型。infix：中缀函数。operator：操作符重载。vararg：可变参数。tailrec：尾递归优化。out：泛型协变。suspend：挂起函数。
inline fun measureTime(action: () -> Unit) {
action()
}
inline fun test(
inlineAction: () -> Unit,
noinline noInlineAction: () -> Unit
) {}
inline fun test2(crossinline action: () -> Unit) {
action()
}
inline fun <reified T> isType(v: Any) = v is T
infix fun Int.add(n: Int) = this + n
operator fun plus(p: Point) = Point(x + p.x)
fun sum(vararg nums: Int): Int = nums.sum()
tailrec fun factorial(n: Int, r: Int = 1): Int {
if (n <= 1) return r
return factorial(n - 1, n * r)
}
class Box<out T>(val data: T)
suspend fun fetch(): String {
return "data"
}如果只是日常业务开发，最先要熟悉的通常是 vararg、inline、suspend；而 reified、crossinline、out 等更适合在理解泛型和高阶函数后再深入。
多平台与外部实现
这部分关键字出现频率相对较低，但在 Kotlin Multiplatform 或与外部平台互操作时非常关键。
expect/actual：多平台声明与实际实现。external：声明实现来自 Kotlin 之外，例如 JavaScript 或本地平台。
expect fun getPlatform(): String
actual fun getPlatform() = "Android"
expect class PlatformFile(path: String)
external fun callJs(): String这三个词虽然平时不一定常见，但只要项目跨平台，它们就会成为理解代码结构的入口。
怎么记这 77 个 Kotlin 关键字更高效
如果只按字母顺序硬背，记忆成本很高，也不容易形成语法判断。更实用的方式是先抓住分类边界：
- 硬关键字 28 个：始终保留，不能作标识符。
- 软关键字 17 个：只在特定语境下生效。
- 修饰符关键字 32 个：主要用于修饰声明，决定可见性、继承、泛型和执行方式。
真正写代码时，可以按问题反查：遇到命名报错，先看是不是硬关键字；遇到注解目标、委托或泛型限制，优先想到软关键字；遇到访问范围、继承关系、协程、内联和数据建模，再回到修饰符关键字。这种记法比单纯背表更接近真实开发场景。
把这 77 个关键字分门别类搞清楚后，Kotlin 的核心语法轮廓也就基本搭起来了。后面无论是读源码、写业务逻辑，还是处理泛型、多平台和协程相关代码，判断都会更快。
