一 函数类型定义

1 定义

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

2 示例 ：

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

3 函数类型定义（补充）

1. 基本形式：

   • (Int, Int) -> Int 表示接收两个 Int 参数并返回 Int 的函数类型。
   • (String) -> Unit 表示接收 String 参数但无返回值的函数类型（Unit 表示无返回值）。

2. 特殊情况：

   • 无参数的函数：() -> String（无参数，返回 String）。
   • 返回值是函数的函数类型：(Int) -> (Int) -> Int（接收 Int，返回一个 (Int) -> Int 类型的函数）。
   • 可空的函数类型：((Int, Int) -> Int)?（函数类型可为 null）。

3. 函数类型的变量：

   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 表达式（补充）

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

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

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

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

3. 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
   

4. 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

---

总结

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

四 函数体

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

---

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

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

// 完整函数体（包含 return）
fun add(a: Int, b: Int): Int {
    val sum = a + b
    return 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 作为默认参数名称，省略显式声明。

规则：

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

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

   相当于：

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

2. 如果 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

结论：
✅ it 适用于单参数 Lambda，当 Lambda 只有一个参数时，可以省略参数列表，直接用 it 代替。
❌ 多参数 Lambda 不适用 it，必须显式定义参数列表。

这样写代码更简洁，减少不必要的参数命名，让 Lambda 表达式更加直观！