Kotlin 是一种现代、静态类型的编程语言，由 JetBrains 开发，旨在提高开发者的生产力。它与 Java 完全兼容，但语法更简洁、更安全，并支持函数式编程特性。Kotlin 广泛应用于 Android 开发、后端服务和多平台项目中。本教程将通过 10 个实用案例，从基础语法到高级技巧，帮助你快速掌握 Kotlin 的核心概念。每个案例都包含详细的代码示例和解释，确保你能逐步理解和应用这些知识。无论你是编程新手还是有经验的开发者，这些实例都能让你从入门走向精通。
案例 1: 变量声明与基本数据类型（入门基础）
Kotlin 的变量声明使用
val
（不可变）和
var
（可变）关键字，这比 Java 的
final
更直观。基本数据类型包括
Int
、
Double
、
String
等，它们是对象，但 Kotlin 会自动优化为原始类型以提高性能。
主题句
：通过声明变量并进行基本运算，你可以快速熟悉 Kotlin 的类型系统和空安全特性。
支持细节
：
val
用于只读变量，一旦赋值不可更改。
var
用于可变变量。
Kotlin 支持类型推断，无需显式指定类型。
字符串模板允许在字符串中嵌入变量。
完整代码示例
：
fun main() {
// 使用 val 声明不可变变量
val name: String = “Alice” // 显式指定类型
val age = 25 // 类型推断为 Int
val height = 175.5 // 类型推断为 Double
// 使用 var 声明可变变量
var score = 90
score = 95 // 可以修改
// 字符串模板
val message = “姓名: $name, 年龄: $age, 成绩: $score”
println(message)
// 基本运算
val total = age + score // Int + Int
val average = (age + height) / 2 // 混合类型，Kotlin 会自动提升为 Double
println(“总分: $total, 平均值: $average”)
// 空安全：声明可为空的变量
var nullableName: String? = null // ? 表示可为空
if (nullableName != null) {
println(“名字长度: ${nullableName.length}”)
} else {
println(“名字为空”)
}
}
解释
：
运行此代码，你会看到输出如 “姓名: Alice, 年龄: 25, 成绩: 95”，展示了变量的使用和字符串模板。
空安全检查避免了 NullPointerException，这是 Kotlin 的核心优势。
这个案例帮助你理解 Kotlin 的简洁性和安全性，从这里开始构建你的第一个 Kotlin 程序。
案例 2: 条件表达式与控制流（逻辑判断）
Kotlin 的条件语句使用
if
和
when
，其中
when
是增强版的 switch，支持模式匹配。
if
可以作为表达式返回值。
主题句
：掌握条件表达式能让你编写更简洁的逻辑代码，避免冗长的 if-else 链。
支持细节
：
if
作为表达式：可以直接赋值给变量。
when
支持范围、类型检查和多个条件。
控制流还包括
for
循环和
while
循环。
完整代码示例
：
fun main() {
val score = 85
// if 作为表达式
val grade = if (score >= 90) “A” else if (score >= 80) “B” else “C”
println(“成绩等级: $grade”)
// when 表达式
val dayOfWeek = 3
val dayName = when (dayOfWeek) {
1 -> “星期一”
2 -> “星期二”
3 -> “星期三”
4 -> “星期四”
5 -> “星期五”
6 -> “星期六”
7 -> “星期日”
else -> “无效”
}
println(“今天是: $dayName”)
// when 与类型检查
val anyValue: Any = “Hello”
val result = when (anyValue) {
is String -> “字符串，长度: ${anyValue.length}”
is Int -> “整数: $anyValue”
else -> “其他类型”
}
println(result)
// for 循环
for (i in 1..5) { // 范围操作符
print(“$i “)
}
println()
// while 循环
var count = 0
while (count < 3) {
print("Kotlin ")
count++
}
}
解释
：
输出示例：成绩等级 B，今天是星期三，字符串长度 5，然后是 “1 2 3 4 5 Kotlin Kotlin Kotlin”。
when
的类型检查（
is String
）类似于模式匹配，使代码更具可读性。
这个案例展示了 Kotlin 如何通过表达式减少样板代码，提高开发效率。
案例 3: 函数定义与默认参数（代码复用）
Kotlin 的函数使用
fun
关键字定义，支持默认参数、命名参数和单表达式函数，这大大简化了方法签名。
主题句
：通过定义带默认参数的函数，你可以创建更灵活的 API，减少重载需求。
支持细节
：
默认参数：在参数后指定默认值。
命名参数：调用时指定参数名。
单表达式函数：使用
=
简写返回值。
扩展函数：为现有类添加新方法。
完整代码示例
：
// 普通函数
fun greet(name: String, greeting: String = "Hello"): String {
return "$greeting, $name!"
}
// 单表达式函数
fun add(a: Int, b: Int) = a + b
// 扩展函数：为 String 类添加方法
fun String.repeat(times: Int): String {
return this.repeat(times)
}
fun main() {
// 调用函数
println(greet("Bob")) // 使用默认参数
println(greet("Charlie", greeting = "Hi")) // 命名参数
// 单表达式
val sum = add(10, 20)
println("和: $sum")
// 扩展函数
val repeated = "Kotlin".repeat(3)
println(repeated) // 输出: KotlinKotlinKotlin
}
解释
：
输出： “Hello, Bob!”, “Hi, Charlie!”, “和: 30”, “KotlinKotlinKotlin”。
默认参数避免了多个
greet
重载，命名参数提高可读性。
扩展函数让你无需修改原类即可添加功能，这是 Kotlin 函数式编程的入门。
案例 4: 集合操作（List、Set、Map）
Kotlin 的集合框架是不可变和可变的，支持丰富的扩展函数如
filter
、
map
和
forEach
。
主题句
：使用集合操作可以高效处理数据，结合函数式编程风格。
支持细节
：
List：有序，可重复。
Set：无序，不重复。
Map：键值对。
扩展函数：
filter
过滤、
map
转换、
forEach
遍历。
完整代码示例
：
fun main() {
// List
val numbers = listOf(1, 2, 3, 4, 5)
val evenNumbers = numbers.filter { it % 2 == 0 } // it 是隐式参数
println("偶数: $evenNumbers") // [2, 4]
// Set
val uniqueNumbers = setOf(1, 2, 2, 3, 3)
println("唯一数字: $uniqueNumbers") // [1, 2, 3]
// Map
val map = mapOf("Alice" to 25, "Bob" to 30)
map.forEach { (key, value) -> println(“$key: $value”) }
// 可变集合
val mutableList = mutableListOf(10, 20)
mutableList.add(30)
mutableList.removeAt(0)
println(“可变列表: $mutableList”) // [20, 30]
// 链式操作
val result = numbers
.filter { it > 2 }
.map { it * 2 }
.joinToString(“, “)
println(“链式结果: $result”) // 6, 8, 10
}
解释
：
输出展示了过滤、映射和遍历。
Lambda 表达式
{ it -> … }
简化了操作。
链式操作体现了 Kotlin 的流畅 API 设计，适合数据处理管道。
案例 5: 类与对象（面向对象基础）
Kotlin 的类默认是
public
，支持主构造函数、次构造函数和属性。
主题句
：定义类可以封装数据和行为，Kotlin 自动生成 getter/setter。
支持细节
：
主构造函数：在类头中定义。
属性：
val
或
var
，自动生成访问器。
继承：使用
open
关键字。
完整代码示例
：
open class Person(val name: String, var age: Int) {
// 次构造函数
constructor(name: String) : this(name, 0)
fun introduce(): String {
return “我叫 $name，今年 $age 岁”
}
open fun celebrateBirthday() {
age++
println(“$name 现在 $age 岁了”)
}
}
class Employee(name: String, age: Int, val salary: Int) : Person(name, age) {
override fun celebrateBirthday() {
super.celebrateBirthday()
println(“加薪！新薪水: ${salary * 1.1}”)
}
}
fun main() {
val person = Person(“Alice”, 25)
println(person.introduce())
person.celebrateBirthday()
val employee = Employee(“Bob”, 30, 5000)
employee.celebrateBirthday()
}
解释
：
输出：介绍和生日庆祝，展示了继承和重写。
自动生成的 getter 如
person.name
，无需手动编写。
这个案例教你如何用 Kotlin 构建对象模型，比 Java 更简洁。
案例 6: 数据类与密封类（数据建模）
数据类自动生成
equals
、
hashCode
、
toString
和
copy
方法。密封类用于受限继承。
主题句
：数据类简化 POJO，密封类处理状态机。
支持细节
：
数据类：
data class
。
密封类：
sealed class
，所有子类必须在同一文件中。
解构：从数据类提取属性。
完整代码示例
：
data class User(val id: Int, val name: String, val email: String)
sealed class Result {
data class Success(val data: String) : Result()
data class Error(val message: String) : Result()
}
fun main() {
// 数据类
val user1 = User(1, “Alice”, “alice@example.com”)
val user2 = User(1, “Alice”, “alice@example.com”)
println(user1 == user2) // true，自动生成 equals
println(user1) // User(id=1, name=Alice, email=alice@example.com)
// 解构
val (id, name, email) = user1
println(“ID: $id, Name: $name”)
// 密封类处理
val result: Result = Result.Success(“数据加载成功”)
val message = when (result) {
is Result.Success -> “成功: ${result.data}”
is Result.Error -> “错误: ${result.message}”
}
println(message)
// copy 方法
val updatedUser = user1.copy(email = “new@example.com”)
println(updatedUser)
}
解释
：
输出显示了相等性检查、解构和模式匹配。
密封类确保
when
覆盖所有情况，提高类型安全。
这些类适合表示纯数据或状态，减少 boilerplate。
案例 7: 空安全与 Elvis 操作符（避免崩溃）
Kotlin 的类型系统强制处理 null，使用
?
、
!!
、
?:
等操作符。
主题句
：空安全机制让你编写健壮代码，无需担心运行时异常。
支持细节
：
可空类型：
String?
。
安全调用：
?.
。
Elvis 操作符：
?:
提供默认值。
非空断言：
!!
（慎用）。
完整代码示例
：
fun findUser(id: Int): String? {
return if (id == 1) “Alice” else null
}
fun main() {
val user = findUser(1)
val user2 = findUser(2)
// 安全调用
println(“用户1长度: ${user?.length ?: “未找到”}”) // 5
println(“用户2长度: ${user2?.length ?: “未找到”}”) // 未找到
// Elvis 操作符
val name = user ?: “默认用户”
println(“名字: $name”)
// 链式安全调用
val email = user?.let { “$it@example.com” } ?: “no-email”
println(email)
// !! 断言（会抛异常如果 null）
try {
val unsafe = user2!!.length // NullPointerException
} catch (e: NullPointerException) {
println(“捕获异常: ${e.message}”)
}
}
解释
：
输出：处理 null 而不崩溃。
?:
是 Elvis 操作符，提供默认值。
这个案例强调 Kotlin 的 null 安全，减少 90% 的空指针错误。
案例 8: Lambda 与高阶函数（函数式编程）
Lambda 是匿名函数，高阶函数接受或返回函数。
主题句
：Lambda 让代码更简洁，高阶函数支持函数作为一等公民。
支持细节
：
Lambda 语法：
{ params -> body }
。
高阶函数：如
filter
内部使用 lambda。
with、apply 等作用域函数。
完整代码示例
：
// 高阶函数
fun operate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
return operation(a, b)
}
fun main() {
// Lambda 作为参数
val sum = operate(5, 3) { x, y -> x + y }
val product = operate(5, 3) { x, y -> x * y }
println(“和: $sum, 积: $product”)
// 集合中的 Lambda
val list = listOf(1, 2, 3, 4)
val doubled = list.map { it * 2 }
println(“加倍: $doubled”)
// 作用域函数 with
val builder = StringBuilder()
with(builder) {
append(“Hello”)
append(” “)
append(“Kotlin”)
}
println(builder.toString()) // Hello Kotlin
// apply
val person = Person(“Charlie”, 0).apply {
age = 28
introduce()
}
}
解释
：
输出展示了灵活的函数组合。
Lambda 减少了匿名类的使用。
这个案例引入函数式思维，提升代码表达力。
案例 9: 协程基础（异步编程）
协程是 Kotlin 的轻量级线程，使用
launch
和
async
处理异步任务。
主题句
：协程简化异步代码，避免回调地狱。
支持细节
：
作用域：
GlobalScope
或自定义作用域。
挂起函数：
suspend
。
async
返回
Deferred
。
完整代码示例
：
import kotlinx.coroutines.*
fun main() = runBlocking { // 阻塞当前线程直到协程完成
println(“开始异步任务”)
// launch 启动协程
val job = launch {
delay(1000) // 模拟延迟
println(“任务1 完成”)
}
// async 返回结果
val deferred = async {
delay(500)
“任务2 结果”
}
job.join() // 等待 job 完成
val result = deferred.await() // 等待 async 结果
println(result)
// 多个协程
val jobs = List(5) { i ->
launch {
delay(100L * i)
println(“协程 $i”)
}
}
jobs.forEach { it.join() }
}
解释
：
输出：按顺序显示异步结果，如 “开始异步任务” -> “任务2 结果” -> “任务1 完成” -> 协程 0-4。
runBlocking
桥接协程和主线程。
协程比线程更高效，适合网络请求或 UI 更新。
案例 10: 泛型与类型安全（高级技巧）
泛型允许编写可重用代码，支持类型参数。
主题句
：泛型确保类型安全，避免运行时转换错误。
支持细节
：
泛型类/函数：
class Box
。
约束：
where
或上界
T : Comparable
。
星投影：
*
用于未知类型。
完整代码示例
：
// 泛型类
class Box
fun printValue() = println(“值: $value”)
}
// 泛型函数
fun
// 带约束的泛型
fun
fun main() {
// 使用泛型类
val intBox = Box(42)
val stringBox = Box(“Hello”)
intBox.printValue()
stringBox.printValue()
// 泛型函数
val swapped = swap(10, 20)
println(“交换: $swapped”)
// 约束
val maxInt = max(5, 10)
val maxString = max(“Apple”, “Banana”)
println(“最大值: $maxInt, $maxString”)
// 星投影
val boxes: List
boxes.forEach { it.printValue() }
}
解释
：
输出：值 42, 值 Hello, 交换 (20, 10), 最大值 10 和 Banana。
泛型防止了类型错误，如不能将 String 放入 Int Box。
这个案例展示了 Kotlin 的类型系统强大，适合构建通用库。
通过这 10 个案例，你已经覆盖了 Kotlin 的核心语法和开发技巧。从变量到协程，这些实例提供了实际代码，帮助你实践和掌握。建议在 IntelliJ IDEA 中运行这些代码，并尝试修改以加深理解。继续探索 Kotlin 的生态系统，如 Android 开发或 Spring Boot 集成，你将真正精通这门语言。