Kotlin第二阶段学习内容详情

Kotlin 第二阶段学习内容详情：函数

本阶段目标是掌握 Kotlin 函数的基本写法，并学会把第一阶段写在 main 函数里的代码拆成可复用的小功能。学完后，你应该能写出判断成绩、计算总价、筛选数字等小函数。

建议用时：2-3 天。

阶段目标

能使用 fun 声明函数。
能定义函数参数和返回值。
能区分有返回值函数和无返回值函数。
能使用默认参数和命名参数。
能写出单表达式函数。
初步理解 Lambda 表达式。
能把重复逻辑封装为函数。

学习前准备

请先确认你已经掌握第一阶段内容：

val 和 var
基本类型
字符串模板
if 和 when
for 和 while
区间

本阶段会大量复用这些基础语法。

第 1 天：函数声明、参数与返回值

1. 为什么需要函数

函数的作用是把一段逻辑封装起来，方便重复使用。

如果不用函数，代码容易重复：

fun main() {
    val score1 = 85
    val result1 = when (score1) {
        in 90..100 -> "优秀"
        in 80..89 -> "良好"
        in 60..79 -> "及格"
        in 0..59 -> "不及格"
        else -> "成绩无效"
    }
    println(result1)

    val score2 = 45
    val result2 = when (score2) {
        in 90..100 -> "优秀"
        in 80..89 -> "良好"
        in 60..79 -> "及格"
        in 0..59 -> "不及格"
        else -> "成绩无效"
    }
    println(result2)
}

封装成函数后更清晰：

fun getGrade(score: Int): String {
    return when (score) {
        in 90..100 -> "优秀"
        in 80..89 -> "良好"
        in 60..79 -> "及格"
        in 0..59 -> "不及格"
        else -> "成绩无效"
    }
}

fun main() {
    println(getGrade(85))
    println(getGrade(45))
}

2. 函数基础语法

Kotlin 使用 fun 声明函数。

fun 函数名(参数名: 参数类型): 返回值类型 {
    return 返回值
}

示例：

fun add(a: Int, b: Int): Int {
    return a + b
}

fun main() {
    val result = add(3, 5)
    println(result)
}

这里：

add 是函数名。
a 和 b 是参数。
Int 是参数类型。
最后一个 Int 是返回值类型。
return a + b 表示返回计算结果。

3. 无返回值函数

如果函数只是执行动作，不需要返回结果，可以不写返回值类型。

fun sayHello(name: String) {
    println("Hello, $name")
}

fun main() {
    sayHello("Kotlin")
}

这类函数的返回值类型其实是 Unit。

下面两种写法等价：

fun sayHello(name: String) {
    println("Hello, $name")
}

fun sayHello(name: String): Unit {
    println("Hello, $name")
}

日常写代码时，通常省略 Unit。

4. 多个参数

多个参数之间用逗号隔开。

fun calculateTotal(price: Int, count: Int): Int {
    return price * count
}

fun main() {
    val total = calculateTotal(20, 3)
    println("总价：$total")
}

5. 返回值必须匹配类型

如果声明返回 Int，就必须返回整数。

错误示例：

fun getAge(): Int {
    return "18" // 错误：返回了 String
}

正确示例：

fun getAge(): Int {
    return 18
}

第 1 天练习

写一个 add(a: Int, b: Int): Int 函数，返回两个数字之和。
写一个 isEven(number: Int): Boolean 函数，判断数字是否为偶数。
写一个 getGrade(score: Int): String 函数，返回成绩等级。
写一个 printUser(name: String, age: Int) 函数，打印用户信息。

参考答案：

fun add(a: Int, b: Int): Int {
    return a + b
}

fun isEven(number: Int): Boolean {
    return number % 2 == 0
}

fun getGrade(score: Int): String {
    return when (score) {
        in 90..100 -> "优秀"
        in 80..89 -> "良好"
        in 60..79 -> "及格"
        in 0..59 -> "不及格"
        else -> "成绩无效"
    }
}

fun printUser(name: String, age: Int) {
    println("姓名：$name，年龄：$age")
}

fun main() {
    println(add(3, 5))
    println(isEven(8))
    println(getGrade(86))
    printUser("小明", 20)
}

第 2 天：默认参数、命名参数与单表达式函数

1. 默认参数

Kotlin 函数参数可以设置默认值。

fun greet(name: String = "Kotlin") {
    println("Hello, $name")
}

fun main() {
    greet()
    greet("Alice")
}

输出：

Hello, Kotlin
Hello, Alice

默认参数适合处理「大多数时候使用默认值，少数时候传入自定义值」的场景。

2. 多个默认参数

fun createUser(name: String, age: Int = 18, city: String = "未知") {
    println("姓名：$name，年龄：$age，城市：$city")
}

fun main() {
    createUser("小明")
    createUser("小红", 20)
    createUser("小刚", 22, "杭州")
}

3. 命名参数

调用函数时，可以写出参数名。

fun createUser(name: String, age: Int, city: String) {
    println("姓名：$name，年龄：$age，城市：$city")
}

fun main() {
    createUser(name = "小明", age = 20, city = "上海")
}

命名参数的好处是代码更清楚，尤其是参数较多时。

4. 命名参数可以调整顺序

fun createUser(name: String, age: Int, city: String) {
    println("姓名：$name，年龄：$age，城市：$city")
}

fun main() {
    createUser(city = "深圳", name = "小明", age = 20)
}

虽然可以调整顺序，但初学时建议保持和函数声明一致，更容易阅读。

5. 默认参数配合命名参数

fun orderDrink(name: String, size: String = "中杯", ice: Boolean = true) {
    println("饮品：$name，规格：$size，是否加冰：$ice")
}

fun main() {
    orderDrink("咖啡")
    orderDrink("奶茶", ice = false)
    orderDrink(name = "果茶", size = "大杯", ice = false)
}

6. 单表达式函数

如果函数只有一行返回逻辑，可以写成单表达式函数。

普通写法：

fun add(a: Int, b: Int): Int {
    return a + b
}

单表达式写法：

fun add(a: Int, b: Int) = a + b

Kotlin 会自动推断返回值类型。

再看几个例子：

fun isEven(number: Int) = number % 2 == 0

fun getMax(a: Int, b: Int) = if (a > b) a else b

fun getGrade(score: Int) = when (score) {
    in 90..100 -> "优秀"
    in 80..89 -> "良好"
    in 60..79 -> "及格"
    in 0..59 -> "不及格"
    else -> "成绩无效"
}

7. 什么时候适合单表达式函数

适合：

逻辑很短。
只有一个返回结果。
代码读起来更清楚。

不适合：

函数里有多步计算。
需要写多个判断和中间变量。
写成一行后反而难读。

第 2 天练习

写一个 greet(name: String = "Kotlin") 函数。
写一个 calculateTotal(price: Int, count: Int = 1) 函数。
用命名参数调用一个有 3 个参数的函数。
把 add、isEven、getMax 改写成单表达式函数。

参考答案：

fun greet(name: String = "Kotlin") {
    println("Hello, $name")
}

fun calculateTotal(price: Int, count: Int = 1) = price * count

fun printBook(title: String, author: String, price: Int) {
    println("书名：$title，作者：$author，价格：$price")
}

fun add(a: Int, b: Int) = a + b

fun isEven(number: Int) = number % 2 == 0

fun getMax(a: Int, b: Int) = if (a > b) a else b

fun main() {
    greet()
    greet("Alice")

    println(calculateTotal(price = 30, count = 2))

    printBook(
        title = "Kotlin 入门",
        author = "匿名作者",
        price = 59
    )

    println(add(1, 2))
    println(isEven(10))
    println(getMax(8, 12))
}

第 3 天：Lambda 表达式入门

1. 什么是 Lambda

Lambda 可以理解为「一小段可以传递的代码」。

普通函数有名字：

fun square(number: Int): Int {
    return number * number
}

Lambda 可以没有名字：

val square = { number: Int -> number * number }

调用方式：

fun main() {
    val square = { number: Int -> number * number }
    println(square(5))
}

2. Lambda 基础结构

{ 参数名: 参数类型 -> 函数体 }

示例：

val add = { a: Int, b: Int -> a + b }

调用：

fun main() {
    val add = { a: Int, b: Int -> a + b }
    println(add(3, 5))
}

3. 没有参数的 Lambda

fun main() {
    val sayHello = { println("Hello, Kotlin") }
    sayHello()
}

4. Lambda 的最后一行就是返回值

Lambda 中最后一行表达式会作为返回值。

fun main() {
    val getGrade = { score: Int ->
        when (score) {
            in 90..100 -> "优秀"
            in 80..89 -> "良好"
            in 60..79 -> "及格"
            in 0..59 -> "不及格"
            else -> "成绩无效"
        }
    }

    println(getGrade(88))
}

5. Lambda 与集合的简单配合

集合会在第五阶段系统学习。这里先看几个常见写法，感受 Lambda 的作用。

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)

    val evenNumbers = numbers.filter { number ->
        number % 2 == 0
    }

    println(evenNumbers)
}

如果 Lambda 只有一个参数，可以使用默认参数名 it。

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)

    val evenNumbers = numbers.filter {
        it % 2 == 0
    }

    println(evenNumbers)
}

6. `map` 示例

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)

    val squares = numbers.map {
        it * it
    }

    println(squares)
}

输出：

[1, 4, 9, 16, 25]

7. 初学 Lambda 的重点

现阶段不需要深入高阶函数，只需要先记住：

Lambda 是一段可以赋值给变量的代码。
Lambda 可以作为参数传给其他函数。
Lambda 最后一行就是返回值。
单参数 Lambda 常用 it。

第 3 天练习

写一个 Lambda，接收一个数字，返回它的平方。
写一个 Lambda，接收两个数字，返回较大的数字。
用 filter 筛选出 1-10 中的偶数。
用 map 把 1-5 转换成它们的平方。

参考答案：

fun main() {
    val square = { number: Int -> number * number }
    println(square(6))

    val max = { a: Int, b: Int ->
        if (a > b) a else b
    }
    println(max(10, 20))

    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    val evenNumbers = numbers.filter {
        it % 2 == 0
    }

    val squares = numbers.map {
        it * it
    }

    println(evenNumbers)
    println(squares)
}

综合练习 1：封装成绩判断

要求：

写一个 getGrade(score: Int): String 函数。
在 main 中调用 3 次，分别传入不同成绩。
输出每个成绩对应的等级。

参考答案：

fun getGrade(score: Int): String {
    return when (score) {
        in 90..100 -> "优秀"
        in 80..89 -> "良好"
        in 60..79 -> "及格"
        in 0..59 -> "不及格"
        else -> "成绩无效"
    }
}

fun main() {
    val score1 = 95
    val score2 = 76
    val score3 = -1

    println("成绩：$score1，等级：${getGrade(score1)}")
    println("成绩：$score2，等级：${getGrade(score2)}")
    println("成绩：$score3，等级：${getGrade(score3)}")
}

综合练习 2：封装价格计算

要求：

写一个 calculateTotal(price: Int, count: Int = 1): Int 函数。
单价乘以数量，返回总价。
在 main 中分别测试默认数量和自定义数量。

参考答案：

fun calculateTotal(price: Int, count: Int = 1): Int {
    return price * count
}

fun main() {
    println(calculateTotal(30))
    println(calculateTotal(30, 4))
    println(calculateTotal(price = 50, count = 2))
}

综合练习 3：封装求和

要求：

写一个 sumFromOneTo(max: Int): Int 函数。
计算 1 到 max 的总和。
如果传入 100，返回 5050。

参考答案：

fun sumFromOneTo(max: Int): Int {
    var sum = 0

    for (i in 1..max) {
        sum += i
    }

    return sum
}

fun main() {
    println(sumFromOneTo(100))
}

综合练习 4：简单计算器

要求：

写一个 calculate(a: Int, b: Int, operator: String): Int 函数。
operator 为 "+" 时返回加法结果。
operator 为 "-" 时返回减法结果。
operator 为 "*" 时返回乘法结果。
operator 为 "/" 时返回除法结果。
其他符号返回 0。

参考答案：

fun calculate(a: Int, b: Int, operator: String): Int {
    return when (operator) {
        "+" -> a + b
        "-" -> a - b
        "*" -> a * b
        "/" -> a / b
        else -> 0
    }
}

fun main() {
    println(calculate(10, 5, "+"))
    println(calculate(10, 5, "-"))
    println(calculate(10, 5, "*"))
    println(calculate(10, 5, "/"))
}

进阶思考：如果 b 是 0，并且 operator 是 "/"，会发生什么？后面学习异常处理时会专门处理这类问题。

本阶段必须掌握的语法清单

完成第二阶段后，请逐项检查。

常见错误

1. 忘记写参数类型

错误写法：

fun add(a, b): Int {
    return a + b
}

正确写法：

fun add(a: Int, b: Int): Int {
    return a + b
}

Kotlin 函数参数必须写类型。

2. 有返回值类型，却没有 `return`

错误写法：

fun add(a: Int, b: Int): Int {
    a + b
}

正确写法：

fun add(a: Int, b: Int): Int {
    return a + b
}

或者写成单表达式函数：

fun add(a: Int, b: Int) = a + b

3. 返回值类型不匹配

错误写法：

fun isEven(number: Int): Boolean {
    return "true"
}

正确写法：

fun isEven(number: Int): Boolean {
    return number % 2 == 0
}

4. 命名参数写错名字

错误写法：

fun createUser(name: String, age: Int) {
    println("$name $age")
}

fun main() {
    createUser(username = "小明", age = 20)
}

正确写法：

fun createUser(name: String, age: Int) {
    println("$name $age")
}

fun main() {
    createUser(name = "小明", age = 20)
}

命名参数必须和函数声明里的参数名一致。

5. 混淆函数和 Lambda 的写法

普通函数：

fun square(number: Int): Int {
    return number * number
}

Lambda：

val square = { number: Int -> number * number }

两者都能完成任务，但写法和使用场景不同。初学阶段先把普通函数学扎实，再逐步熟悉 Lambda。

阶段复盘问题

学完后，用自己的话回答下面的问题：

函数有什么作用？
fun add(a: Int, b: Int): Int 中每一部分分别表示什么？
没有返回值的函数为什么可以省略 Unit？
默认参数解决了什么问题？
命名参数有什么好处？
单表达式函数适合什么场景？
Lambda 和普通函数有什么区别？
Lambda 中的 it 表示什么？
为什么函数参数必须写类型，而普通变量很多时候可以不写类型？
把代码封装成函数后，代码可读性有哪些变化？

下一阶段预告

第三阶段会学习空安全。你会理解 Kotlin 如何减少空指针问题，并掌握下面这些语法：

可空类型：String?
安全调用：?.
Elvis 操作符：?:
非空断言：!!
智能类型转换

空安全是 Kotlin 最重要的特性之一，也是它比 Java 更舒服的地方之一。

posted @ 2026-06-30 11:01 呢哇哦比较阅读(4) 评论(0) 收藏举报

刷新页面返回顶部

茅屋哥

Kotlin第二阶段学习内容详情

Kotlin 第二阶段学习内容详情：函数

阶段目标

学习前准备

第 1 天：函数声明、参数与返回值

1. 为什么需要函数

2. 函数基础语法

3. 无返回值函数

4. 多个参数

5. 返回值必须匹配类型

第 1 天练习

第 2 天：默认参数、命名参数与单表达式函数

1. 默认参数

2. 多个默认参数

3. 命名参数

4. 命名参数可以调整顺序

5. 默认参数配合命名参数

6. 单表达式函数

7. 什么时候适合单表达式函数

第 2 天练习

第 3 天：Lambda 表达式入门

1. 什么是 Lambda

2. Lambda 基础结构

3. 没有参数的 Lambda

4. Lambda 的最后一行就是返回值

5. Lambda 与集合的简单配合

6. map 示例

7. 初学 Lambda 的重点

第 3 天练习

综合练习 1：封装成绩判断

综合练习 2：封装价格计算

综合练习 3：封装求和

综合练习 4：简单计算器

本阶段必须掌握的语法清单

常见错误

1. 忘记写参数类型

2. 有返回值类型，却没有 return

3. 返回值类型不匹配

4. 命名参数写错名字

5. 混淆函数和 Lambda 的写法

阶段复盘问题

下一阶段预告

公告

6. `map` 示例

2. 有返回值类型，却没有 `return`