Kotlin语法快速入门-函数（4）

Kotlin语法快速入门-函数（4）

四、函数

1、函数定义

fun 函数名(参数: 类型) ：返回值类型{
    //函数体
    return 返回值
}
1
2
3
4

fun main() {
    a()
}

fun a() {}
1
2
3
4
5

像上述的代码，返回值类型可以省略，函数会自动推导，如果没有返回值，则默认返回Unit（等价于Java中的void）。

加法函数：

fun main() {
    println(sum(1,2))
}

fun sum(a: Int, b: Int): Int {
    return a + b
}
1
2
3
4
5
6
7

可以简写，如果只有一行：

fun sum(a: Int, b: Int): Int = a + b
1

或

fun sum(a: Int, b: Int) = a + b
1

2、infix关键字

infix 是一个关键字，用于定义中缀函数（Infix Functions）。中缀函数是 Kotlin 提供的一项有用的功能，可以使代码更加清晰和易读，尤其是在某些领域特定语言中，它可以改善代码的可读性和表达能力。

fun main() {
    //以下三种写法结果相同。
    println(1.sum(2))
    println(1 sum (2))
    println(1 sum 2)
}
infix fun Int.sum(a: Int) = this + a
1
2
3
4
5
6
7

• 中缀函数必须是成员函数或扩展函数。
• 中缀函数必须只有一个参数。
• 参数不能是可变参数（varargs）。

可以展现多态等面向对象的一些特性，例如：（分别调用不同的同名函数==>多态）

fun main() {
 println(1 sum 2)
 println(1.1F sum 2)
}
infix fun Int.sum(a: Int) = this + a
infix fun Float.sum(a: Int) = this + a
1
2
3
4
5
6

3、参数省略

与js的语法有点像，传参数的时候可以设置默认值，如果传入则覆盖，没有传入则使用默认值。

fun main() {
    println(sum(1))
}
fun sum(a: Int, b: Int = 3) = b + a
1
2
3
4

上述代码没有传入b的值，就取得默认值3

亦可使用b = 1, a = 2来忽略参数顺序：

fun main() {
    println(sum(b = 1, a = 2))
}
fun sum(a: Int, b: Int = 3) = b + a
1
2
3
4

4、函数类型参数

fun main() {
    sum(b = 1, a = 2, c = { println(it) })
}

fun sum(a: Int, b: Int, c: (Int) -> Unit): Int {
    val result = b + a // 计算 a 和 b 的和
    c(result)          // 调用传入的函数 c，传入结果值并执行其逻辑
    return result      // 返回计算结果
}
1
2
3
4
5
6
7
8
9

在 main 函数内部调用了名为 sum 的函数，传入了三个参数：

• 参数 c 是一个类型为 (Int) -> Unit 的函数类型参数。该类型的含义是接收一个 Int 类型的输入参数并返回 Unit 类型（相当于 Java 中的 void）。传入的匿名函数 { println(it) } 实现了这一功能，其中 it 是对传入参数的隐式引用，println 函数用于打印传入的整数到标准输出。

定义了一个名为 sum 的函数，它接受以下三个参数：

• a: Int：一个整数参数。
• b: Int：另一个整数参数。
• c: (Int) -> Unit：一个函数类型参数，如上所述，接收一个整数并返回无具体值（Unit）。

只有函数类型参数的简写：

fun main() {
    sum { //()圆括号可以省略
        println(it)
    }
}

fun sum(c: (Int) -> Unit) { //这里必须是lambda表达式
    c(3)          // 调用传入的函数 c，传入结果值并执行其逻辑
}
1
2
3
4
5
6
7
8
9

5、多参数–vararg

fun main() {
    sum("1", "2", "3")
}

//多参函数
fun sum(vararg list: String) {
    list.forEach {
        println(it)
    }
}
1
2
3
4
5
6
7
8
9
10

上述写法不太友好，换个写法：

fun main() {
    var arr = arrayOf("1", "2", "3")
    sum(*arr) //通过*展开参数
}

//多参函数
fun sum(vararg list: String) {
    list.forEach {
        println(it)
    }
}
1
2
3
4
5
6
7
8
9
10
11

与其他参数混合：（当然，写法不唯一）

fun main() {
    var arr = arrayOf("1", "2", "3")
    sum("1", list = arr)
}

//多参函数
fun sum(a: String, vararg list: String) {
    list.forEach {
        println(it)
    }
}
1
2
3
4
5
6
7
8
9
10
11