【每日一个知识点】Kotlin基础语法核心学习笔记

一、写在前面：为什么是Kotlin？

Kotlin 作为 Android 开发的官方首选语言，以其简洁性、安全性和与 Java 的完全互操作性脱颖而出。对于初学者而言，它减少了模板代码，提供了更安全的类型系统，并且学习曲线相对平缓。

本文以"基础语法"为切入点，聚焦变量/函数定义、空安全、条件/循环这四大支柱，为后续深入学习框架和函数调用铺平道路。

二、变量定义：val 与 var 的艺术

1. 核心原则：不变性优先

在 Kotlin 中，变量声明主要有两种方式：

Kotlin 复制代码

// 不可变变量（推荐）：使用 val
val name: String = "Kotlin Learner"
name = "Change Me" // 编译错误：Val cannot be reassigned

// 可变变量：使用 var  
var counter: Int = 0
counter = 1 // 允许重新赋值

最佳实践 ：优先使用 val，它让代码更可预测、更安全，也便于并发编程。

2. 类型推断：让编译器为你工作

Kotlin 拥有强大的类型推断能力，在声明变量时经常可以省略显式类型声明：

Kotlin 复制代码

val message = "Hello, Kotlin!" // 自动推断为 String 类型
val number = 42 // 自动推断为 Int 类型
val pi = 3.14 // 自动推断为 Double 类型

注意：当变量立即被初始化时，类型推断最有效。对于没有初始值的变量，仍需显式声明类型：

复制代码

val result: String // 声明时不初始化
result = calculateResult() // 后续初始化

三、函数定义：简洁而强大

1. 基本函数结构

Kotlin 函数使用 fun 关键字定义：

Kotlin 复制代码

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

// 单表达式函数（更简洁）
fun add(a: Int, b: Int): Int = a + b

// 进一步简化：利用类型推断
fun add(a: Int, b: Int) = a + b

2. 默认参数与命名参数

Kotlin 的函数参数支持默认值，这减少了重载函数的数量：

Kotlin 复制代码

// 默认参数
fun greet(name: String, greeting: String = "Hello") {
    println("$greeting, $name!")
}

// 调用方式
greet("Alice") // 使用默认 greeting: "Hello"
greet("Bob", "Hi") // 提供自定义 greeting

// 命名参数（提高可读性）
greet(name = "Charlie", greeting = "Hey")
greet(greeting = "Hey", name = "Charlie") // 顺序可调换

3. 函数的可见性与作用域

函数可以在文件顶层声明（不需要类），也可以在类、接口或对象内部声明：

Kotlin 复制代码

// 顶层函数：在整个文件中可用
fun topLevelFunction() = println("I'm a top-level function")

class MyClass {
    // 成员函数
    fun memberFunction() = println("I'm a member function")
    
    // 私有函数：仅在类内可用
    private fun privateFunction() = println("Private")
}

四、空安全：Kotlin 的王牌特性

空指针异常（NPE）是 Java 开发者最常见的错误之一，Kotlin 通过类型系统从根本上解决了这个问题。

1. 可空与非空类型

在 Kotlin 中，类型系统明确区分了可以持有 null 的引用和不能持有 null 的引用：

Kotlin 复制代码

var nonNullable: String = "Hello"
nonNullable = null // 编译错误：不能为 null

var nullable: String? = "Hello"  
nullable = null // 允许：类型后加 ? 表示可空

2. 安全调用操作符（?.）

这是处理可空类型最常用的方式：

Kotlin 复制代码

val length: Int? = nullable?.length
// 如果 nullable 不为 null，则返回 length；否则返回 null

3. Elvis 操作符（?:）

提供默认值，避免返回 null：

Kotlin 复制代码

val length = nullable?.length ?: 0
// 如果 nullable 不为 null，返回 length；否则返回 0

4. 非空断言操作符（!!）

将任何值转换为非空类型，如果值为 null 则抛出异常。慎用此操作符：

Kotlin 复制代码

val length = nullable!!.length // 如果 nullable 为 null，抛出 NPE

5. 安全转换（as?）

尝试将值转换为指定类型，如果转换失败则返回 null：

Kotlin 复制代码

val intValue: Int? = value as? Int

五、条件表达式：不只是 if-else

1. 传统 if-else 的增强

在 Kotlin 中，if 是一个表达式（有返回值），而不是语句：

Kotlin 复制代码

// 作为表达式使用
val max = if (a > b) {
    println("Choose a")
    a // 最后一个表达式作为返回值
} else {
    println("Choose b")  
    b // 最后一个表达式作为返回值
}

2. when 表达式：强大的 switch 替代品

when 是 Kotlin 中功能极强的条件表达式：

Kotlin 复制代码

// 基本用法
when (x) {
    1 -> print("x is 1")
    2 -> print("x is 2")
    else -> print("x is neither 1 nor 2")
}

// 多条件匹配
when (x) {
    0, 1 -> print("x is 0 or 1")
    else -> print("otherwise")
}

// 使用任意表达式作为分支条件
when (x) {
    in 1..10 -> print("x is in the range 1-10")
    !in 10..20 -> print("x is outside the range 10-20")
    is String -> print("x is a String")
    else -> print("none of the above")
}

// 作为表达式使用（必须有 else 分支）
val description = when {
    x > 0 -> "Positive"
    x < 0 -> "Negative" 
    else -> "Zero"
}

六、循环控制：迭代的艺术

1. for 循环：简洁而强大

Kotlin 的 for 循环基于迭代器模式，可以遍历任何提供了迭代器的对象：

Kotlin 复制代码

// 遍历范围
for (i in 1..5) print(i) // 输出: 12345（包含 5）
for (i in 1 until 5) print(i) // 输出: 1234（不包含 5）
for (i in 5 downTo 1) print(i) // 输出: 54321
for (i in 1..10 step 2) print(i) // 输出: 1 3 5 7 9

// 遍历集合
val list = listOf("a", "b", "c")
for (item in list) print(item) // 输出: abc

// 带索引遍历
for ((index, value) in list.withIndex()) {
    println("Element at $index is $value")
}

2. while 与 do-while 循环

与大多数语言类似：

Kotlin 复制代码

// while：先判断条件，再执行循环体
var x = 5
while (x > 0) {
    println(x)
    x--
}

// do-while：先执行一次循环体，再判断条件
var y = 0
do {
    println(y)
    y++
} while (y < 5)

3. 循环控制语句

break：终止最内层循环
continue：跳过当前迭代，继续下一次迭代
return：从函数返回

Kotlin 复制代码

// 带标签的 break 和 continue
outer@ for (i in 1..3) {
    inner@ for (j in 1..3) {
        if (i == 2 && j == 2) break@outer // 跳出外层循环
        println("i=$i, j=$j")
    }
}

七、实战示例：综合运用基础语法

让我们通过一个小例子，综合运用今天学到的知识：

Kotlin 复制代码

// 定义一个处理用户信息的函数
fun processUser(name: String?, age: Int?): String {
    // 使用空安全处理可空参数
    val safeName = name ?: "Anonymous"
    val safeAge = age ?: 0
    
    // 使用 when 表达式进行条件判断
    val ageGroup = when {
        safeAge < 0 -> "Invalid age"
        safeAge < 18 -> "Minor"
        safeAge in 18..65 -> "Adult"
        else -> "Senior"
    }
    
    // 构建并返回结果字符串
    return "User: $safeName, Age Group: $ageGroup"
}

// 使用 for 循环和 if 表达式处理列表
fun filterAndProcess(names: List<String?>): List<String> {
    val result = mutableListOf<String>()
    
    for ((index, name) in names.withIndex()) {
        // 使用空安全和条件判断
        val processedName = if (name != null && name.isNotBlank()) {
            "User${index + 1}: $name"
        } else {
            "User${index + 1}: Unknown"
        }
        result.add(processedName)
    }
    
    return result
}

// 测试代码
fun main() {
    // 测试 processUser
    println(processUser("Alice", 25)) // User: Alice, Age Group: Adult
    println(processUser(null, null))  // User: Anonymous, Age Group: Minor
    
    // 测试 filterAndProcess
    val userList = listOf("Alice", null, "Bob", "", "Charlie")
    val processedList = filterAndProcess(userList)
    processedList.forEach { println(it) }
}

八、学习建议与下一步

实践至上 ：在 Kotlin Playground 或 IntelliJ IDEA 中尝试所有示例
渐进学习：每天掌握一个概念，通过小练习巩固
查阅文档 ：遇到问题首先查阅 Kotlin 官方文档
下一步计划：掌握基础语法后，可继续学习集合操作、Lambda 表达式、扩展函数等高级特性

九、总结

Kotlin 的基础语法设计体现了 "简洁而不简单" 的哲学。通过今天的学习，我们掌握了：

变量声明 ：val 与 var 的区别与使用场景
函数定义：从基本结构到高级特性（默认参数、命名参数）
空安全：Kotlin 的王牌特性，从根本上避免 NPE
条件表达式 ：特别是强大的 when 表达式
循环控制：现代化的迭代方式

这些基础是后续学习 Kotlin 高级特性、框架使用和实际项目开发的基石。记住，语法只是工具，真正重要的是如何运用这些工具解决问题。