Kotlin 基础语法（原汁原味中文版）
本文汇总了 Kotlin 核心基础语法元素及示例，每个章节末尾附有相关主题的详细说明链接。你也可以通过 JetBrains Academy 提供的免费 Kotlin Core 课程，系统学习所有 Kotlin 核心知识。
（注：文档翻译部分由 AI 完成）
一、包定义与导入
包声明必须放在源文件的顶部：
kotlin
package my.demo // 包声明（需置于文件最顶部）
import kotlin.text.* // 导入 kotlin.text 包下所有内容
// 后续代码...重点记忆：
-
包名与文件系统目录无需强制匹配，源文件可自由存放；
-
import 支持通配符 * 导入包下所有成员，也可使用 as 定义别名（如 import kotlin.text.StringBuilder as SB）。
二、程序入口点
Kotlin 应用的入口点是 main 函数：
kotlin
// 无参数主函数（最常用形式）
fun main() {
println("Hello world!") // 输出：Hello world!
}另一种支持接收可变数量字符串参数的形式：
kotlin
// 接收字符串数组参数的主函数
fun main(args: Array<String>) {
println(args.contentToString()) // 输出传入的命令行参数，例如：[arg1, arg2]
}重点记忆：
-
无参数 main 函数是 Kotlin 1.3+ 推荐写法，简洁高效；
-
命令行参数通过 Array 接收，contentToString() 用于友好打印数组内容。
三、标准输出打印
-
print：打印参数到标准输出，不换行；
-
println：打印参数后追加换行符，后续输出自动换行。
kotlin
// print 示例（无换行）
print("Hello ")
print("world!") // 输出结果：Hello world!（一行显示）
// println 示例（自动换行）
println("\nHello world!") // 输出：Hello world!（单独一行）
println(42) // 输出：42（单独一行）重点记忆：
-
字符串拼接可直接用 +，或用字符串模板（后续章节详解）；
-
println 支持所有基本类型（Int、Double 等）和对象的打印。
四、标准输入读取
readln() 函数读取用户输入的整行内容，返回字符串类型。可结合打印函数实现"请求输入-展示结果"的交互：
kotlin
// 提示用户输入
println("请输入任意单词：")
// 读取输入并存储（示例输入：Happiness）
val yourWord = readln()
// 展示输入结果
print("你输入的单词是：")
print(yourWord) // 输出：你输入的单词是：Happiness重点记忆：
-
readln() 会阻塞程序直到用户输入并按下回车；
-
若需读取其他类型（如 Int、Double），需配合类型转换（如 readln().toInt()）。
五、函数
函数是 Kotlin 中代码复用的核心单元，支持多种简洁写法：
1. 完整声明（带参数和返回值类型）
kotlin
// 两个 Int 参数，返回 Int 类型
fun sum(a: Int, b: Int): Int {
return a + b // 显式返回
}
// 调用函数
fun main() {
println(sum(3, 5)) // 输出：8
}2. 表达式函数（返回类型自动推断）
函数体为单一表达式时，可省略 {} 和 return，直接用 = 连接：
kotlin
// 省略返回类型，编译器自动推断为 Int
fun sum(a: Int, b: Int) = a + b
fun main() {
println(sum(4, 6)) // 输出：10
}3. 无返回值函数（Unit 类型）
无实际返回值时，返回类型为 Unit（可省略）：
kotlin
// 显式声明 Unit 返回类型
fun printSum(a: Int, b: Int): Unit {
println("${a} + ${b} 的和是 ${a + b}")
}
// 省略 Unit（推荐写法）
fun printSum2(a: Int, b: Int) {
println("${a} + ${b} 的和是 ${a + b}")
}
fun main() {
printSum(2, 3) // 输出：2 + 3 的和是 5
printSum2(5, 7) // 输出：5 + 7 的和是 12
}重点记忆：
-
函数参数格式为「参数名: 类型」，与 Java 相反；
-
表达式函数仅适用于单一表达式场景，复杂逻辑仍需用代码块 {}；
-
Unit 类似 Java 的 void，但 Unit 是实际类型（可用于泛型）。
六、变量
Kotlin 变量声明必须用 val 或 var 关键字，明确区分"不可变"和"可变"：
1. 不可变变量（val）
用 val 声明的变量只能赋值一次（类似 Java 的 final），线程安全，优先使用：
kotlin
// 声明并初始化 Int 类型变量 x（显式指定类型）
val x: Int = 5
// x = 6 // 编译错误：val 变量不可重新赋值
// 省略类型，编译器自动推断为 Int
val y = 10
fun main() {
println(x) // 输出：5
println(y) // 输出：10
}2. 可变变量（var）
用 var 声明的变量可多次赋值，需谨慎使用（避免线程安全问题）：
kotlin
// 声明并初始化 Int 类型变量 x
var x: Int = 5
x += 1 // 允许重新赋值（x 变为 6）
// 省略类型，自动推断为 Int
var z = 3
z = z * 2 // z 变为 6
fun main() {
println(x) // 输出：6
println(z) // 输出：6
}3. 变量初始化规则
-
声明时直接初始化：可省略类型（编译器自动推断）；
-
延迟初始化：需显式指定类型，且必须在使用前赋值。
kotlin
// 声明时初始化（推荐）
val a = 10 // 自动推断为 Int
val b = "Kotlin" // 自动推断为 String
// 延迟初始化（需指定类型）
val c: Int
c = 3 // 必须在使用前赋值
fun main() {
println(a) // 输出：10
println(c) // 输出：3
}4. 顶层变量
变量可声明在函数外部（顶层），作用域覆盖整个文件：
kotlin
// 顶层不可变变量（常量）
val PI = 3.14
// 顶层可变变量
var x = 0
// 函数中可直接访问顶层变量
fun incrementX() {
x += 1 // 修改顶层变量
}
fun main() {
println("x = $x, PI = $PI") // 输出：x = 0, PI = 3.14
incrementX()
println("x = $x, PI = $PI") // 输出：x = 1, PI = 3.14
}重点记忆：
-
优先使用 val（不可变），仅在确实需要修改时用 var；
-
延迟初始化的变量必须显式指定类型，否则编译器无法推断；
-
顶层变量会在首次访问时初始化，无需手动创建实例。
七、类与实例创建
Kotlin 中用 class 关键字定义类，语法简洁，默认提供构造函数：
1. 简单类声明
kotlin
// 空类（无属性和方法）
class Shape2. 带属性的类
属性可直接声明在类名后（主构造函数参数），或在类体中声明：
kotlin
// 主构造函数参数直接声明为属性（val 不可变，var 可变）
class Rectangle(val height: Double, val length: Double) {
// 类体中声明的属性（自动计算周长）
val perimeter = (height + length) * 2
}3. 创建实例与访问属性
无需 new 关键字，直接调用构造函数即可创建实例：
kotlin
class Rectangle(val height: Double, val length: Double) {
val perimeter = (height + length) * 2
}
fun main() {
// 创建 Rectangle 实例（无 new 关键字）
val rectangle = Rectangle(5.0, 2.0)
// 访问属性（直接用 . 语法）
println("矩形周长：${rectangle.perimeter}") // 输出：矩形周长：14.0
}4. 类的继承
-
类默认是 final（不可继承），需用 open 关键字标记为可继承；
-
继承用冒号 : 表示，需显式调用父类构造函数（空构造函数用 ()）。
kotlin
// 用 open 标记可继承的父类
open class Shape
// Rectangle 继承自 Shape，调用父类空构造函数
class Rectangle(val height: Double, val length: Double) : Shape() {
val perimeter = (height + length) * 2
}重点记忆：
-
主构造函数参数加 val/var 会自动成为类的属性，否则仅为构造函数参数；
-
类默认不可继承（final），必须用 open 显式允许继承；
-
创建实例无需 new 关键字，语法更简洁。
八、注释
Kotlin 支持单行注释、多行注释，且多行注释可嵌套：
1. 单行注释（//）
kotlin
// 这是单行注释（从 // 到行尾）
val x = 10 // 行尾注释：声明并初始化 x 为 102. 多行注释（/* */）
kotlin
/* 这是
多行注释
（可跨多行）*/
val y = 203. 嵌套多行注释
kotlin
/* 外层注释开始
/* 内层嵌套注释 */
外层注释结束 */
val z = 30重点记忆：
-
多行注释支持嵌套是 Kotlin 相比 Java 的优势，便于临时注释大块代码；
-
文档注释使用 /** */（如函数文档），支持 Markdown 格式，详见官方文档。
详见：Documenting Kotlin Code（官方文档）
九、字符串模板
字符串模板允许在字符串中直接嵌入变量或表达式，用 $ 标记，无需拼接：
1. 嵌入变量
kotlin
var a = 1
// $a 直接嵌入变量 a 的值
val s1 = "a 的值是 $a" // 结果："a 的值是 1"
a = 2
// 嵌入变量并修改
val s2 = "${s1.replace("是", "原来是")}，现在是 $a" // 结果："a 的值原来是 1，现在是 2"
fun main() {
println(s1) // 输出：a 的值是 1
println(s2) // 输出：a 的值原来是 1，现在是 2
}2. 嵌入表达式
复杂表达式需用 ${} 包裹：
kotlin
val x = 3
val y = 5
// 嵌入算术表达式
val sumStr = "$x + $y = ${x + y}" // 结果："3 + 5 = 8"
// 嵌入函数调用
val upperStr = " Kotlin ".trim().uppercase() // 结果："KOTLIN"
fun main() {
println(sumStr) // 输出：3 + 5 = 8
println(upperStr) // 输出：KOTLIN
}重点记忆：
-
单个变量可直接用 <math xmlns="http://www.w3.org/1998/Math/MathML"> 变量名，表达式必须用 变量名，表达式必须用 </math>变量名，表达式必须用{表达式}；
-
模板支持任意合法 Kotlin 表达式（函数调用、算术运算、字符串操作等）；
-
相比字符串拼接（+），模板更简洁、可读性更高。
十、条件表达式
Kotlin 中的 if 不仅是语句，还可作为表达式返回值，替代 Java 的三元运算符：
1. 传统条件语句
kotlin
// 函数返回两个数中的较大值（语句形式）
fun maxOf(a: Int, b: Int): Int {
if (a > b) {
return a
} else {
return b
}
}
fun main() {
println(maxOf(4, 7)) // 输出：7
}2. 条件表达式（推荐）
if 作为表达式，直接返回结果，可省略 return：
kotlin
// 一行实现：if 表达式返回较大值
fun maxOf(a: Int, b: Int) = if (a > b) a else b
fun main() {
println(maxOf(9, 3)) // 输出：9
}重点记忆：
-
条件表达式必须包含 else 分支（否则编译错误），确保所有路径都有返回值；
-
复杂逻辑可嵌套 if-else，但建议用 when 表达式替代（后续章节）；
-
可替代 Java 的 a > b ? a : b 三元运算符，语法更统一。
十一、for 循环
Kotlin 的 for 循环支持迭代区间、集合、数组等，语法简洁灵活：
1. 迭代集合/数组
直接遍历元素：
kotlin
val items = listOf("apple", "banana", "kiwifruit")
fun main() {
// 遍历集合中的每个元素
for (item in items) {
println(item) // 输出：apple、banana、kiwifruit
}
}2. 迭代索引与元素
用 indices 获取索引，或 withIndex() 同时获取索引和元素：
kotlin
val items = listOf("apple", "banana", "kiwifruit")
fun main() {
// 方式1：通过 indices 遍历索引
for (index in items.indices) {
println("索引 $index 的元素是：${items[index]}")
}
// 方式2：通过 withIndex() 同时获取索引和元素（推荐）
for ((index, item) in items.withIndex()) {
println("索引 $index 的元素是：$item")
}
}3. 迭代区间
kotlin
fun main() {
// 遍历 1 到 5（闭区间，包含 5）
for (x in 1..5) {
print(x) // 输出：12345
}
println()
// 遍历 1 到 10，步长为 2
for (x in 1..10 step 2) {
print(x) // 输出：13579
}
}重点记忆：
-
for (item in 集合) 是最常用的遍历方式，简洁高效；
-
indices 返回集合的索引区间（如列表 [0,1,2]）；
-
withIndex() 返回包含索引和元素的 Pair，适合需要索引的场景。
十二、while 循环
while 循环是前置条件循环（先判断条件，再执行循环体），可能一次都不执行；do-while 是后置条件循环（先执行循环体，再判断条件），至少执行一次：
1. while 循环
kotlin
val items = listOf("apple", "banana", "kiwifruit")
var index = 0
fun main() {
// 前置条件：index < 集合长度时执行
while (index < items.size) {
println("索引 $index 的元素是：${items[index]}")
index++ // 索引自增（避免死循环）
}
// 输出：索引 0 的元素是：apple、索引 1 的元素是：banana、索引 2 的元素是：kiwifruit
}2. do-while 循环
kotlin
var count = 0
fun main() {
// 后置条件：先执行循环体，再判断条件
do {
println("count = $count")
count++
} while (count < 3)
// 输出：count = 0、count = 1、count = 2（至少执行一次）
}重点记忆：
-
while 适合"条件不满足则不执行"的场景，do-while 适合"至少执行一次"的场景（如用户输入验证）；
-
循环体内必须有修改条件的逻辑（如 index++），否则会导致死循环。
十三、when 表达式
when 是 Kotlin 中强大的条件分支结构，替代 Java 的 switch，支持多条件匹配、类型匹配等：
1. 基本用法（值匹配）
kotlin
// 根据 obj 的值返回对应的描述
fun describe(obj: Any): String =
when (obj) {
1 -> "整数：一" // 匹配值为 1
"Hello" -> "字符串：问候" // 匹配值为 "Hello"
is Long -> "类型：长整数" // 匹配类型为 Long
!is String -> "类型：非字符串" // 匹配类型不是 String
else -> "未知类型" // 默认分支（必须包含，除非覆盖所有可能）
}
fun main() {
println(describe(1)) // 输出：整数：一
println(describe("Hello")) // 输出：字符串：问候
println(describe(100L)) // 输出：类型：长整数
println(describe(3.14)) // 输出：类型：非字符串
println(describe("Kotlin")) // 输出：未知类型
}2. 区间与集合匹配
kotlin
fun judgeScore(score: Int): String =
when (score) {
in 90..100 -> "优秀" // 匹配 90-100 区间
in 80..89 -> "良好" // 匹配 80-89 区间
in 60..79 -> "及格" // 匹配 60-79 区间
0..59 -> "不及格" // 匹配 0-59 区间
else -> "无效分数"
}
fun main() {
println(judgeScore(95)) // 输出：优秀
println(judgeScore(72)) // 输出：及格
println(judgeScore(105)) // 输出：无效分数
}重点记忆：
-
when 可作为表达式（返回值）或语句（无返回值）；
-
分支用 -> 分隔，无需 break（自动跳出）；
-
支持值匹配、类型匹配、区间匹配、集合匹配等，功能远强于 switch；
-
若 when 作为表达式，必须包含 else 分支（除非覆盖所有可能情况，如密封类）。
详见：when expressions and statements（官方文档）
十四、区间（Ranges）
区间是 Kotlin 中表示"连续值集合"的语法糖，常用 .. 创建，配合 in/!in 检查包含关系，或用于循环：
1. 检查值是否在区间内
kotlin
val x = 10
val y = 9
fun main() {
// 检查 x 是否在 1 到 y+1 区间内（y+1=10，闭区间包含 10）
if (x in 1..y+1) {
println("x 符合区间要求") // 输出：x 符合区间要求
}
}2. 检查值是否在区间外
kotlin
val list = listOf("a", "b", "c")
fun main() {
// 检查 -1 是否不在 0 到列表最后一个索引的区间内
if (-1 !in 0..list.lastIndex) {
println("-1 超出区间") // 输出：-1 超出区间
}
// 检查列表长度是否不在索引区间内（列表索引 0-2，长度 3）
if (list.size !in list.indices) {
println("列表长度超出有效索引区间") // 输出：列表长度超出有效索引区间
}
}3. 迭代区间与步长
kotlin
fun main() {
// 1. 正序闭区间（包含首尾）
print("正序闭区间 1-5：")
for (x in 1..5) {
print(x) // 输出：12345
}
// 2. 正序区间+步长（step 指定递增幅度）
print("\n步长为 2 的 1-10 区间：")
for (x in 1..10 step 2) {
print(x) // 输出：13579
}
// 3. 逆序区间（downTo 表示从大到小）
print("\n逆序区间 5-1：")
for (x in 5 downTo 1) {
print(x) // 输出：54321
}
// 4. 逆序区间+步长
print("\n步长为 3 的逆序区间 9-0：")
for (x in 9 downTo 0 step 3) {
print(x) // 输出：9630
}
// 5. 半开区间（until 表示包含起点，不包含终点）
print("\n半开区间 1 until 5：")
for (x in 1 until 5) {
print(x) // 输出：1234（不包含 5）
}
}4. 区间的本质与常见类型
Kotlin 中的区间本质是实现了 ClosedRange 接口的对象，常见类型包括：
-
数值区间 ：如
IntRange（Int 类型区间）、LongRange（Long 类型区间）、DoubleRange（Double 类型区间），是最常用的区间类型； -
字符区间 ：基于字符的 Unicode 编码排序，如
'a'..'z'表示所有小写英文字母区间； -
自定义区间 ：通过实现
ClosedRange接口，可定义符合业务需求的自定义区间。
kotlin
fun main() {
// 字符区间示例
print("小写英文字母区间：")
for (c in 'a'..'f') {
print(c) // 输出：abcdef
}
// Double 区间示例（主要用于判断包含关系，不适合迭代）
val doubleRange = 1.5..3.5
println("\n2.0 是否在 1.5-3.5 区间内：${2.0 in doubleRange}") // 输出：true
println("4.0 是否在 1.5-3.5 区间内：${4.0 in doubleRange}") // 输出：false
}
kotlin
fun main() {
// 字符区间示例
print("小写英文字母区间：")
for (c in 'a'..'f') {
print(c) // 输出：abcdef
}
// Double 区间示例（主要用于判断包含关系，不适合迭代）
val doubleRange = 1.5..3.5
println("\n2.0 是否在 1.5-3.5 区间内：${2.0 in doubleRange}") // 输出：true
println("4.0 是否在 1.5-3.5 区间内：${4.0 in doubleRange}") // 输出：false
}重点记忆：
-
闭区间用
..创建（包含首尾），半开区间用until创建（包含起点，不包含终点）； -
逆序区间必须用
downTo关键字，不可直接写5..1（会生成空区间）； -
步长
step可用于正序和逆序区间，值必须为正整数； -
Double 区间因精度问题，仅适合用
in/!in检查包含关系，不建议用于迭代。
详见：Ranges（官方文档）
十五、空安全（Null Safety）
空安全是 Kotlin 核心特性之一，通过编译期检查避免空指针异常（NullPointerException），核心是区分"可空类型"和"非空类型"：
1. 可空类型与非空类型
默认情况下，Kotlin 变量为非空类型 ，不可赋值为 null；若需允许赋值为 null，需在类型后加 ? 声明为可空类型：
kotlin
// 非空类型（默认）：不可赋值为 null
val str: String = "Kotlin"
// str = null // 编译错误：非空类型不能赋值为 null
// 可空类型（加 ?）：可赋值为 null 或非空值
val nullableStr: String? = "Hello"
nullableStr = null // 合法：可空类型允许赋值为 null
fun main() {
println(nullableStr) // 输出：null
}2. 安全调用运算符（?.）
访问可空类型的属性或方法时，直接用 . 会编译错误，需用 ?. 实现"安全调用"------若对象为 null，表达式直接返回 null，不执行后续调用：`
2. 安全调用运算符（?.）
访问可空类型的属性或方法时，直接用 . 会编译错误，需用 ?. 实现"安全调用"------若对象为 null，表达式直接返回 null，不执行后续调用：`
kotlin
// 可空字符串变量（可能为 null）
val nullableStr: String? = "Kotlin"
val nullStr: String? = null
fun main() {
// 安全调用长度属性：若变量为 null，返回 null
val length1 = nullableStr?.length // 结果：6（非空，正常获取长度）
val length2 = nullStr?.length // 结果：null（为空，直接返回 null）
println("length1 = $length1, length2 = $length2") // 输出：length1 = 6, length2 = null
}3. Elvis 运算符（?:）
配合安全调用使用，用于指定"可空表达式为 null 时的默认值"，语法为 可空表达式 ?: 默认值：
kotlin
val nullableStr: String? = null
val anotherStr: String? = "Kotlin"
fun main() {
// 若 nullableStr 为 null，返回默认值 "默认字符串"；否则返回自身
val safeStr = nullableStr ?: "默认字符串"
// 若 anotherStr 为 null，返回默认值 "默认字符串"；否则返回自身
val safeStr2 = anotherStr ?: "默认字符串"
println(safeStr) // 输出：默认字符串
println(safeStr2) // 输出：Kotlin
}4. 非空断言运算符（!!）
强制将可空类型转换为非空类型，若对象实际为 null，会抛出 NullPointerException，谨慎使用：
kotlin
val nullableStr: String? = "Kotlin"
val nullStr: String? = null
fun main() {
// 非空断言：确认 nullableStr 非空，强制转换为非空类型
val str1 = nullableStr!!
println(str1.length) // 输出：6（正常执行）
// 非空断言：nullStr 实际为 null，抛出空指针异常
val str2 = nullStr!! // 运行时错误：NullPointerException
println(str2.length)
}5. 安全类型转换（as?）
普通类型转换（as）若失败会抛出 ClassCastException，安全类型转换（as?）失败时返回 null，配合 Elvis 运算符更安全：
kotlin
val obj1: Any = "Kotlin"
val obj2: Any = 100
fun main() {
// 安全类型转换：若转换为 String 成功则返回 String，否则返回 null
val str1 = obj1 as? String ?: "转换失败"
val str2 = obj2 as? String ?: "转换失败"
println(str1) // 输出：Kotlin（转换成功）
println(str2) // 输出：转换失败（转换失败，返回默认值）
}重点记忆：
-
可空类型必须显式加
?，非空类型默认不可赋值为 null，从源头减少空指针； -
优先使用
?.和?:组合实现安全调用与默认值，避免使用!!；` -
!!仅在确认变量非空时使用（如初始化后永不改变的变量），否则会引发运行时异常； -
类型转换优先用
as?配合?:，替代as减少类型转换异常。
十六、类型别名（Type Aliases）
类型别名为现有类型定义简短名称，简化复杂类型的使用，尤其适用于泛型、嵌套类等场景：
1. 基本用法
用 typealias 关键字声明，语法为 typealias 别名 = 原始类型：
kotli
// 为 String 类型定义别名 MyString（实际意义不大，仅作示例）
typealias MyString = String
// 为 Map<String, Int> 定义别名 StringToIntMap（简化复杂泛型）
typealias StringToIntMap = Map<String, Int>
// 为函数类型定义别名 Calculator（简化函数类型声明）
typealias Calculator = (Int, Int) -> Int
fun main() {
// 使用别名 MyString 声明变量
val str: MyString = "Kotlin"
// 使用别名 StringToIntMap 声明集合
val scoreMap: StringToIntMap = mapOf("Alice" to 95, "Bob" to 88)
// 使用别名 Calculator 声明函数变量
val add: Calculator = { a, b -> a + b }
println(str) // 输出：Kotlin
println(scoreMap) // 输出：{Alice=95, Bob=88}
println(add(3, 5)) // 输出：8
}2. 适用场景：嵌套类简化
嵌套类的完整名称较长时，类型别名可简化调用：
kotlin
class User {
// 嵌套类
class Profile(val name: String, val age: Int)
}
// 为嵌套类 User.Profile 定义别名 UserProfile
typealias UserProfile = User.Profile
fun main() {
// 原写法：User.Profile
val profile1 = User.Profile("Alice", 25)
// 别名写法：UserProfile（更简洁）
val profile2 = UserProfile("Bob", 23)
println(profile1.name) // 输出：Alice
println(profile2.age) // 输出：23
}重点记忆：
-
类型别名仅为"别名"，不创建新类型，原始类型与别名可完全互通；
-
主要用于简化复杂类型（如泛型、函数类型、嵌套类），避免重复书写冗长类型；
-
别名作用域：顶层声明的别名作用域为整个文件，类内部声明的别名仅作用于类内部。
十七、整体记忆小技巧
Kotlin 基础语法知识点较多，结合其"简洁、安全"的设计核心，可通过以下小技巧快速记忆关键内容，提升学习效率：
若有 Java 基础，通过"异同比对"可快速区分易混点，重点记忆 Kotlin 特有语法：
| 语法场景 | Java 写法 | Kotlin 写法（核心差异） |
|---|---|---|
| 变量声明 | int a = 5; final int b = 5; | var a = 5; val b = 5;（用 var/val 区分可变/不可变） |
| 函数定义 | public int sum(int a, int b) { return a+b; } | fun sum(a: Int, b: Int) = a + b（参数"名:型"，表达式函数） |
| 条件分支 | switch(a) { case 1: ... break; default: ... } | when(a) { 1 -> ...; else -> ... }（无需 break，支持多类型匹配） |
| 空值处理 | String s = null; if(s != null) { s.length(); } | val s: String? = null; s?.length（可空类型+安全调用） |
关键字口诀记忆法：提炼高频关键字
将高频核心关键字按功能分类，编成口诀或短句，降低记忆负担：
-
变量与函数："val 不可变，var 可变；fun 定义函数，= 简化单表达式"；
-
空安全："? 可空，?. 安全调，?: 给默认，!! 强制非空要谨慎"；
-
循环与分支："for 遍历用 in，逆序 downTo 加 step；when 替代 switch，类型区间都能配"；
-
类与继承："class 定义类，open 才允许继承；构造参数加 val/var，直接变属性"。
易错点对比记忆：规避常见陷阱
整理易混淆、易出错的语法点，重点标记差异：
常见易错点对比：
-
❌ 错误：
val a; a = 5（延迟初始化未指定类型）→ ✅ 正确：val a: Int; a = 5； -
❌ 错误：
for (x in 5..1)（逆序用 .. 生成空区间）→ ✅ 正确：for (x in 5 downTo 1)； -
❌ 错误：
class Son : Father（继承未调用父类构造）→ ✅ 正确：class Son : Father()； -
❌ 错误：
val s: String = null（非空类型赋值 null）→ ✅ 正确：val s: String? = null。
记忆核心：先掌握"高频实用语法"（如 var/val、函数、字符串模板、for/when），再攻克"特色语法"（如空安全、区间），结合实例练习强化记忆，避免死记硬背。
十八、总结：Kotlin 基础语法核心特点
Kotlin 基础语法围绕"简洁、安全、高效"设计，核心特点可总结为：
-
简洁性：表达式函数、类型自动推断、无 new 关键字、字符串模板等，减少样板代码；
-
安全性：空安全机制（可空类型、安全调用）、默认非空变量，从编译期避免空指针；
-
灵活性：when 表达式替代 switch、区间语法糖、for 循环多场景适配，语法更灵活；
-
兼容性：完全兼容 Java，可直接调用 Java 类库，同时支持 Java 调用 Kotlin 代码。
掌握以上基础语法后，可进一步学习 Kotlin 进阶特性（如协程、扩展函数、密封类等），逐步提升开发效率
- 兼容性：完全兼容 Java，可直接调用 Java 类库，同时支持 Java 调用 Kotlin 代码。