保姆级 Kotlin 教程：手把手带你从0到1 – wiki基地

作者： /

保姆级 Kotlin 教程：手把手带你从0到1

你好，未来的 Kotlin 大神！

如果你对编程世界充满好奇，或者你是一位希望从 Java 等其他语言转向更现代、更高效工具的开发者，那么你来对地方了。Kotlin，这门由 JetBrains 公司创造、并被 Google 奉为 Android 开发“官方语言”的编程语言，正以其简洁、安全、强大的特性，席卷整个开发界。

这篇文章的目标只有一个：成为你学习 Kotlin 之路上最贴心、最详尽的“保姆”。我们将抛开所有晦涩的术语，用最直白的语言和最丰富的实例，一步一个脚印，带你完成从0到1的蜕变。准备好了吗？让我们开始这段奇妙的旅程吧！

第一章：初见 Kotlin —— 环境搭建与“Hello, World!”

万事开头难，但 Kotlin 的“开头”却异常友好。我们有两种方式来迈出第一步。

方式一：最快体验 – 在线游乐场 (Kotlin Playground)

对于只想快速体验一下 Kotlin 语法的同学，这是最佳选择，无需在本地安装任何软件。

  1. 打开浏览器，访问官方的 Kotlin Playground：play.kotlinlang.org
  2. 你会看到一个简洁的在线代码编辑器。左边是代码输入区，右边是输出区。

  3. 编辑器里已经为你准备好了经典的 “Hello, World!” 代码：

    kotlin
    fun main() {
    println("Hello, world!!!")
    }

  4. 点击右上角的绿色“▶”运行按钮。稍等片刻，你就会在下方的控制台看到输出：Hello, world!!!

恭喜！你已经成功运行了你的第一行 Kotlin 代码。是不是很简单？

方式二：专业之路 – 本地开发环境 (IntelliJ IDEA)

在线游乐场虽好，但终究无法用于开发真实项目。要成为一名真正的开发者，我们需要一个专业的集成开发环境（IDE）。对于 Kotlin 来说，它的“亲爹” JetBrains 公司开发的 IntelliJ IDEA 是不二之选。

  1. 下载并安装 IntelliJ IDEA：

    • 访问 JetBrains 官网：www.jetbrains.com/idea/
    • 下载社区版 (Community Edition)。它是完全免费的，并且对学习和开发 Kotlin 来说功能已经绰绰有余。
    • 根据你的操作系统（Windows, macOS, Linux）下载对应的安装包，然后像安装普通软件一样，一路“下一步”即可。

  2. 创建你的第一个 Kotlin 项目：

    • 打开安装好的 IntelliJ IDEA。
    • 点击 “New Project” (新建项目)。
    • 在左侧的语言列表中，选择 “Kotlin”。
    • 在右侧，给你的项目起个名字，比如 KotlinLearning。项目类型选择 “Console Application” (控制台应用)。
    • 其他的设置（如 JDK、Build system）暂时保持默认即可。点击 “Create” (创建)。

  3. 编写并运行代码：

    • IDEA 会为你生成一个项目结构。在左侧的项目视图中，找到 src/main/kotlin/Main.kt 文件，双击打开它。

    • 你会看到和在线游乐场里一模一样的代码：

      kotlin
      fun main() {
      println("Hello, World!")
      }
      * 代码的 fun main() 这一行左边，你会看到一个绿色的“▶”小箭头。点击它，在弹出的菜单中选择 “Run ‘MainKt'”。
      * 下方的运行窗口会弹出，并显示出 Hello, World!。

至此，你已经搭建好了专业的开发环境，并成功运行了项目。这标志着你已经正式踏入了 Kotlin 开发的大门。

第二章：Kotlin 基础语法 —— 搭建你的知识骨架

现在，让我们来深入了解构成 Kotlin 程序的基石——基础语法。

2.1 变量与常量：数据的容器

在编程中，我们需要地方来存储信息，比如用户的名字、年龄或者计算结果。这就是变量和常量的作用。

  • 常量 (val): 使用 val (value的缩写) 关键字声明。常量一旦被赋值，就不能再改变。把它想象成一块刻在石头上的字，永久不变。

    “`kotlin
    fun main() {
    val name: String = “张三” // 声明一个字符串类型的常量 name，并赋值为 “张三”
    val age: Int = 25 // 声明一个整型的常量 age，并赋值为 25

    // name = "李四" // 这一行会报错！因为 val 声明的常量不能被重新赋值

println("姓名：" + name)
println("年龄：" + age)

    }
    ``
    在 Kotlin 中，我们推荐**优先使用    val`**，这能让你的代码更安全、更易于预测。

  • 变量 (var): 使用 var (variable的缩写) 关键字声明。变量的值在之后可以被修改。把它想象成一块可以随时擦写的白板。

    “`kotlin
    fun main() {
    var score: Int = 90
    println(“初始分数: ” + score)

    score = 95 // 修改 score 的值
println("修改后分数: " + score)

    }
    “`

  • 类型推断 (Type Inference):
    注意到上面的例子中，我们都明确写了类型（如 : String, : Int）。但 Kotlin 非常聪明，大多数情况下，它可以根据你赋的值自动推断出类型。所以，上面的代码可以简化成：

    kotlin
    val name = "张三" // Kotlin 知道 "张三" 是字符串，所以 name 是 String 类型
    val age = 25 // Kotlin 知道 25 是整数，所以 age 是 Int 类型
    var score = 90 // score 会被推断为 Int 类型
    这种特性让代码更加简洁。

2.2 基本数据类型

Kotlin 拥有所有你熟悉的基本数据类型：
* 数字类型：
* Int: 整数 (例如 10, 100)
* Long: 长整数 (用于存储非常大的整数，例如 10000000000L，注意末尾的 L)
* Float: 单精度浮点数 (例如 3.14f，注意末尾的 f)
* Double: 双精度浮点数 (例如 3.1415926)
* 布尔类型：
* Boolean: 只有两个值 true 或 false。
* 字符与字符串类型：
* Char: 单个字符，用单引号括起来 (例如 'A', '1')
* String: 字符串，用双引号括起来 (例如 "你好, Kotlin!")

特别之处：字符串模板
这是一个非常好用的功能，可以让你在字符串中轻松嵌入变量。

“`kotlin
fun main() {
val name = “Kotlin”
val version = 1.9

// 传统拼接方式
println("你好，" + name + "！当前版本是 " + version + "。")

// 使用字符串模板（推荐！）
println("你好，$name！当前版本是 $version。")
// 如果要嵌入表达式，用大括号括起来
println("明年版本可能是 ${version + 0.1}。")

}
输出：
你好，Kotlin！当前版本是 1.9。
你好，Kotlin！当前版本是 1.9。
明年版本可能是 2.0。
“`

2.3 函数：代码的组织者

函数是一段可重复使用的代码块。我们之前一直打交道的 main 就是一个函数。

  • 基本定义： 使用 fun 关键字。

    “`kotlin
    // 一个没有参数，也没有返回值的函数
    fun sayHello() {
    println(“Hello!”)
    }

    // 在 main 函数中调用它
    fun main() {
    sayHello() // 输出: Hello!
    sayHello() // 可以重复调用
    }
    “`

  • 带参数的函数：

    “`kotlin
    // 接收一个 String 类型的参数 name
    fun greet(name: String) {
    println(“你好, $name!”)
    }

    fun main() {
    greet(“Alice”) // 输出: 你好, Alice!
    greet(“Bob”) // 输出: 你好, Bob!
    }
    “`

  • 带返回值的函数：

    “`kotlin
    // 接收两个 Int 参数，并返回一个 Int 结果
    fun add(a: Int, b: Int): Int {
    return a + b
    }

    fun main() {
    val sum = add(5, 3)
    println(“5 + 3 = $sum”) // 输出: 5 + 3 = 8
    }
    “`

  • 单表达式函数 (语法糖):
    如果函数体只有一行代码，可以写得更简洁：

    “`kotlin
    // 上面的 add 函数可以简化为：
    fun add(a: Int, b: Int) = a + b

    fun main() {
    val sum = add(10, 20)
    println(sum) // 输出: 30
    }
    “`

2.4 控制流：让程序“思考”

程序不只是一行行地顺序执行，它需要根据不同的条件做出不同的选择。

  • if-else 条件判断：
    这和大多数语言一样，但 Kotlin 的 if 可以作为表达式使用，即它能返回一个值。

    “`kotlin
    fun main() {
    val score = 85

    val grade: String
if (score >= 90) {
    grade = "优秀"
} else if (score >= 60) {
    grade = "及格"
} else {
    grade = "不及格"
}
println("你的成绩等级是：$grade") // 输出: 你的成绩等级是：及格

// 作为表达式的写法（更简洁，推荐！）
val grade2 = if (score >= 90) {
    "优秀"
} else if (score >= 60) {
    "及格"
} else {
    "不及格"
}
println("你的成绩等级是：$grade2") // 输出: 你的成绩等级是：及格

    }
    “`

  • when 表达式 (超级 switch):
    when 是 Kotlin 中一个非常强大的控制流工具，它比 Java 的 switch 灵活得多。

    “`kotlin
    fun checkValue(x: Any) { // Any 是所有类型的父类，可以接收任何类型
    when (x) {
    1 -> println(“x 是 1”)
    “hello” -> println(“x 是字符串 ‘hello'”)
    is Long -> println(“x 是一个长整型”)
    !is String -> println(“x 不是一个字符串”)
    in 1..10 -> println(“x 在 1 到 10 的范围内”) // 检查范围
    else -> println(“x 是其他东西”)
    }
    }

    fun main() {
    checkValue(1) // 输出: x 是 1
    checkValue(5) // 输出: x 在 1 到 10 的范围内 (注意：when会匹配第一个符合的分支)
    checkValue(“hello”) // 输出: x 是字符串 ‘hello’
    checkValue(100L) // 输出: x 是一个长整型
    checkValue(true) // 输出: x 不是一个字符串
    }
    “`

  • for 循环：
    用于遍历任何可以迭代的对象，比如一个数字范围。

    “`kotlin
    fun main() {
    // 遍历 1 到 5
    println(“遍历 1..5:”)
    for (i in 1..5) {
    print(“$i “) // 输出: 1 2 3 4 5
    }
    println()

    // 倒序遍历
println("遍历 5 downTo 1:")
for (i in 5 downTo 1) {
    print("$i ") // 输出: 5 4 3 2 1
}
println()

// 带步长的遍历
println("遍历 1..10 step 2:")
for (i in 1..10 step 2) {
    print("$i ") // 输出: 1 3 5 7 9
}

    }
    “`

第三章：Kotlin 的王牌特性 —— 空安全 (Null Safety)

这是 Kotlin 最值得称道的特性之一，它旨在从根源上消灭困扰无数 Java 程序员的“空指针异常” (NullPointerException)。

核心思想： 任何变量，默认都不可以是 null。

kotlin
var name: String = "Kotlin"
// name = null // 编译错误！一个非空的 String 变量不能被赋值为 null

那如果我真的需要一个变量可以为 null 怎么办？（比如，用户的中间名可能没有）

很简单，在类型后面加上一个问号 ?，表示这个变量是可空类型 (Nullable Type)。

kotlin
var middleName: String? = "J."
middleName = null // 这是合法的，因为 middleName 被声明为可空

如何安全地使用可空变量？

既然变量可能是 null，直接调用它的方法（如 middleName.length）就可能引发空指针。Kotlin 提供了几种优雅的解决方案：

  1. 安全调用操作符 ?.
    这是最常用的方式。如果变量不为 null，就执行后面的操作；如果为 null，则整个表达式返回 null，而不是抛出异常。

    “`kotlin
    var name: String? = “Alice”
    var name2: String? = null

    println(name?.length) // 输出: 5
    println(name2?.length) // 输出: null (程序不会崩溃)
    “`

  2. Elvis 操作符 ?: (空值合并)
    这个名字来源于猫王(Elvis Presley)的颜文字 ?:)。它的作用是：如果 ?: 左边的表达式不为 null，就返回其值；否则，就返回 ?: 右边的默认值。

    “`kotlin
    val name: String? = null
    val displayName = name ?: “游客” // 如果 name 是 null，就使用 “游客”

    println(“你好, $displayName”) // 输出: 你好, 游客

    val name2: String? = “Bob”
    val displayName2 = name2 ?: “游客”
    println(“你好, $displayName2”) // 输出: 你好, Bob
    “`

  3. 非空断言 !! (不推荐)
    这个操作符告诉编译器：“我向你保证，这个变量此刻绝对不为 null，你放心调用吧！” 如果你错了，程序依然会抛出空指针异常。这相当于放弃了 Kotlin 的空安全保护，应仅在万不得已（比如你100%确定它不为 null）时使用。

    “`kotlin
    val name: String? = “I am not null”
    println(name!!.length) // 正常工作

    val name2: String? = null
    // println(name2!!.length) // 这一行会崩溃！抛出 NullPointerException
    “`

第四章：面向对象初探 —— 类与数据类

Kotlin 是一门完全面向对象的语言。万物皆对象。

4.1 类和对象

类是创建对象的蓝图。比如，“人”是一个类，而具体的“张三”和“李四”就是这个类的实例（对象）。

“`kotlin
// 定义一个简单的 Person 类
// 构造函数直接在类名后定义，属性也直接在里面声明
class Person(val name: String, var age: Int) {
// 类的方法（函数）
fun celebrateBirthday() {
age++ // 年龄增加1
println(“祝 $name 生日快乐！你现在 $age 岁了。”)
}
}

fun main() {
// 创建一个 Person 对象（实例），注意没有 new 关键字
val person1 = Person(“Alice”, 30)

println("${person1.name} 的年龄是 ${person1.age}") // 输出: Alice 的年龄是 30

// 调用对象的方法
person1.celebrateBirthday() // 输出: 祝 Alice 生日快乐！你现在 31 岁了。
println("${person1.name} 的年龄是 ${person1.age}") // 输出: Alice 的年龄是 31

}
“`
Kotlin 的类定义非常简洁，构造函数和属性声明合二为一，大大减少了模板代码。

4.2 数据类 (Data Class)

在开发中，我们经常需要创建一些只用于存储数据的类，比如从服务器API接收到的用户信息。在 Java 中，你需要手动为它编写 equals(), hashCode(), toString(), getter/setter 等大量方法。

在 Kotlin 中，只需一个 data 关键字，编译器就会自动为你生成所有这些！

“`kotlin
// 定义一个数据类
data class User(val id: Int, val username: String, val email: String)

fun main() {
val user1 = User(1, “kotlin_fan”, “[email protected]”)
val user2 = User(1, “kotlin_fan”, “[email protected]”)
val user3 = User(2, “java_dev”, “[email protected]”)

// 1. 自动生成的 toString()，输出非常友好
println(user1) // 输出: User(id=1, username=kotlin_fan, [email protected])

// 2. 自动生成的 equals()，比较的是内容而不是引用
println("user1 equals user2: ${user1 == user2}") // 输出: true
println("user1 equals user3: ${user1 == user3}") // 输出: false

// 3. 自动生成的 copy()，可以方便地创建一个副本并修改部分属性
val updatedUser1 = user1.copy(email = "[email protected]")
println(updatedUser1) // 输出: User(id=1, username=kotlin_fan, [email protected])

}
``data class` 是 Kotlin 提升生产力的又一大利器。

总结与下一步

恭喜你！坚持看到这里，你已经成功地完成了从0到1的跨越。我们一起：

  • 搭建了 Kotlin 的开发环境。
  • 掌握了变量、常量、函数等核心语法。
  • 学会了使用 if, when, for 等控制程序流程。
  • 理解并掌握了 Kotlin 的王牌特性——空安全。
  • 初步了解了如何使用类和数据类来构建程序的模型。

你现在所掌握的知识，已经足够你去阅读和编写一些简单的 Kotlin 程序了。但这仅仅是开始。Kotlin 的世界远比这更广阔。

接下来你可以探索的方向：

  1. 集合操作： 学习 List, Set, Map，以及 Kotlin 强大的集合函数式 API（如 map, filter, forEach），它们能让你以极其优雅的方式处理数据。
  2. 深入面向对象： 学习继承、接口、抽象类、泛型等更高级的 OOP 概念。
  3. 协程 (Coroutines)： 学习 Kotlin 解决异步编程的现代化方案，这在 Android 和后端开发中至关重要。
  4. 平台实践：
    • Android 开发： 用 Kotlin 构建你的第一个安卓 App。
    • 后端开发： 结合 Spring Boot 或 Ktor 框架，用 Kotlin 编写服务器应用。
    • Kotlin Multiplatform (KMP)： 尝试用一套代码逻辑，同时构建 iOS 和 Android 应用。

编程之路，道阻且长，但行则将至。希望这篇“保姆级”教程能为你打下坚实的基础，点燃你对 Kotlin 的热情。现在，打开你的 IntelliJ IDEA，开始创造属于你自己的东西吧！祝你编程愉快！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部