kotlin函数类型

一函数类型定义

1 定义

函数类型就是 (Int, Int) -> Int
函数类型其实就是将函数的 “参数类型” 和 “返回值类型” 抽象出来

2 示例：

(Int, Int) -> Int 表示接收两个 Int 参数并返回 Int 的函数类型；
(String) -> Unit 表示接收 String 参数且无返回值的函数类型空。

3 函数类型定义（补充）

基本形式：
- (Int, Int) -> Int 表示接收两个 Int 参数并返回 Int 的函数类型。
- (String) -> Unit 表示接收 String 参数但无返回值的函数类型（Unit 表示无返回值）。
特殊情况：
- 无参数的函数：() -> String（无参数，返回 String）。
- 返回值是函数的函数类型：(Int) -> (Int) -> Int（接收 Int，返回一个 (Int) -> Int 类型的函数）。
- 可空的函数类型：((Int, Int) -> Int)?（函数类型可为 null）。

函数类型的变量：

val sum: (Int, Int) -> Int = { a, b -> a + b }
val printMessage: (String) -> Unit = { message -> println(message) }

二 Lambda 表达式

1 语法结构

{ 参数列表 -> 函数体 }

2 示例

示例：{ x: Int, y: Int -> x + y }
{a1:Int,b1:Int->a1+b1}

3 Lambda 表达式（补充）

省略参数类型（Kotlin 可以类型推导）：

val sum = { a: Int, b: Int -> a + b } // 显式声明参数类型
val sum2: (Int, Int) -> Int = { a, b -> a + b } // 省略参数类型

单个参数时，使用 it（当 Lambda 只有一个参数时，it 代表该参数）：

val square: (Int) -> Int = { it * it }  // `it` 代表传入的参数
println(square(5)) // 输出 25

Lambda 作为参数传递：

fun operate(a: Int, b: Int, op: (Int, Int) -> Int): Int {return op(a, b)
}val result = operate(3, 4) { x, y -> x * y }
println(result) // 输出 12

Lambda 作为函数返回值：

fun getOperator(): (Int, Int) -> Int {return { x, y -> x + y }
}val add = getOperator()
println(add(10, 5)) // 输出 15

三、高阶函数

高阶函数 指的是 接受函数类型作为参数或返回值的函数。
示例：

fun highOrderFunction(operation: (Int, Int) -> Int): Int {return operation(10, 20)
}val result = highOrderFunction { a, b -> a + b }
println(result) // 输出 30

总结

函数类型的特殊情况（无参数、返回值是函数、可空类型）。
Lambda 表达式的简化写法（省略参数类型、it 关键字）。
Lambda 作为参数和返回值。
高阶函数（函数可以接收 Lambda 作为参数）。

四函数体

在 Kotlin 中，函数体（Function Body） 是定义函数具体行为的代码块，即 {} 大括号中的内容。它包含了函数要执行的逻辑和操作，具体分为两种形式：

1. 代码块函数体（Block Body）

当函数需要执行多行逻辑时使用，必须显式声明返回值（如果有返回值）。

// 完整函数体（包含 return）
fun add(a: Int, b: Int): Int {val sum = a + breturn sum
}// 无返回值的函数（Unit 可省略）
fun printMessage(message: String) {println("Message: $message")
}

2. 单表达式函数体（Single-Expression Body）

当函数可以通过单个表达式完成时，可省略 {} 并用 = 直接返回结果，编译器会自动推导返回值类型。

// 等价于代码块函数体，但更简洁
fun add(a: Int, b: Int) = a + b// 配合 when 表达式
fun getTypeName(type: Int) = when(type) {1 -> "A/C"2 -> "Heater"else -> "Unknown"
}

关键区别

特性	代码块函数体	单表达式函数体
语法	用 `{}` 包裹	用 `=` 连接表达式
返回值	必须显式 `return`	自动返回表达式结果
类型推导	需显式声明返回值类型	可省略返回值类型声明
适用场景	多行逻辑、复杂操作	简单计算、条件判断

注意事项

• 类型推导限制：单表达式函数体仅在逻辑简单时可自动推导类型，复杂逻辑仍需显式声明。
• 作用域：代码块函数体中定义的变量（如示例中的 sum）仅在函数体内可见。
• 空函数体：无实际操作的函数可以留空 {}，但需声明返回类型为 Unit（可省略）。

如果在 Android 开发中遇到函数体相关的具体问题（如事件回调的 lambda 简化写法等），可以进一步探讨！

五省略参数列表情况

在 Kotlin 中，当 Lambda 表达式只有一个参数时，可以省略参数列表，直接使用 it 关键字来引用这个唯一的参数。

你的代码：

val square: (Int) -> Int = { it * it }

实际上等价于：

val square: (Int) -> Int = { x -> x * x }

这里 x 是 Lambda 的唯一参数。

为什么可以省略参数列表？

原因：
Kotlin 允许在 只有一个参数 的 Lambda 表达式中，使用 it 作为默认参数名称，省略显式声明。

规则：

如果 Lambda 只有一个参数，就可以用 it 代替参数列表：

val printMessage: (String) -> Unit = { println(it) }
printMessage("Hello")  // 输出 Hello

相当于：

val printMessage: (String) -> Unit = { message -> println(message) }

如果 Lambda 有多个参数，就必须显式声明参数列表：
```
val sum: (Int, Int) -> Int = { a, b -> a + b } // 必须写参数名
```
不能写成 { it + it }，因为 Kotlin 无法知道 it 代表哪一个参数。

示例：省略参数 vs 显式参数

// 只有一个参数，使用 it
val double: (Int) -> Int = { it * 2 }  
println(double(5)) // 输出 10// 两个参数，必须显式声明
val add: (Int, Int) -> Int = { a, b -> a + b }
println(add(3, 4)) // 输出 7