Kotlin笔记高阶函数（七）
Kotlin笔记数据类型（一）
Kotlin笔记字符串（二）
Kotlin笔记运算符（三）
Kotlin笔记函数（四）
Kotlin笔记面向对象（五）
Kotlin笔记继承、抽象类、接口（六）
文章目录
一、高阶函数
一个函数可以作为另一个函数的参数，或者返回值，那么这个函数就是“高阶函数”
2、函数类型
Kotlin中每一个函数都有一个类型，称为“函数类型”，函数类型作为一种数据类型与数
据类型在使用场景没有区别
//定义计算长方形面积函数
//函数类型(Double, Double) -> Double
fun rectangleArea(width: Double, height: Double): Double {
①
return width * height
}
//定义计算三角形面积函数
//函数类型(Double, Double) -> Double
fun triangleArea(bottom: Double, height: Double) = 0.5 * bottom * height ②
fun sayHello() {
//函数类型()->Unit ③
print("Hello, World")
}
fun main(args: Array<String>) {
val getArea: (Double, Double) -> Double = ::triangleArea ④
//调用函数
val area = getArea(50.0, 40.0) ⑤
print(area) //1000.0
}
3、函数字面量
函数类型可以声明的变量，那么函数类型变量能够接收什么的数据呢？即函数字面量如何
表示的问题，函数字面量可以有三种表示：
- 函数引用。引用到一个已经定义好的，有名字的函数。它可以作为函数字面量。
- 匿名函数。没有名字的函数，即匿名函数，它也可以作为函数字面量。
- Lambda表达式。Lambda表达式是一种匿名函数，可以作为函数字面量。
fun calculate(opr: Char): (Int, Int) -> Int {
//加法函数
fun add(a: Int, b: Int): Int {
return a + b
}
//减法函数
fun sub(a: Int, b: Int): Int {
return a - b
}
val result: (Int, Int) -> Int =
when (opr) {
'+' -> ::add ①
'-' -> ::sub ②
'*' -> {
//乘法匿名函数
fun(a: Int, b: Int): Int {
return (a * b)
}
}
else -> {
a, b -> (a / b) } //除法Lambda表达式 ④
}
return result
}
fun main(args: Array<String>) {
val f1 = calculate('+') ⑤
println(f1(10, 5)) //调用f1变量 ⑥
val f2 = calculate('-')
println(f2(10, 5))
val f3 = calculate('*')
println(f3(10, 5))
val f4 = calculate('/')
println(f4(10, 5))
}
4、函数作为返回值
fun main(args: Array<String>) {
var funName=getFunWithType(2)
println(funName(1,3))
}
fun getFunWithType(type:Int):(Int,Int)->Int{
var functionType:(Int,Int)->Int
when(type){
1-> functionType=fun (a:Int,b:Int):Int=a+b
else -> functionType={
a,b->a-b}
}
return functionType
}
5、函数作为参数
fun main(args: Array<String>) {
var funName=getFunWithType(2)
println(operterFun(funName,4,5))
}
fun operterFun(funName:(Int,Int)->Int,a: Int,b: Int):Int{
return funName(a,b)
}
fun getFunWithType(type:Int):(Int,Int)->Int{
var functionType:(Int,Int)->Int
when(type){
1-> functionType=fun (a:Int,b:Int):Int=a+b
else -> functionType={
a,b->a-b}
}
return functionType
}
二、Lambda表达式
1、Lambda表达式标准语法
{ 参数列表 -> Lambda体 }
Lambda表达式的参数列表与函数的参数列表形式类似，但是Lambda表达式参数列
表前后没有小括号。箭头符号将参数列表与Lambda体分隔开，Lambda表达式不需要声明
返回类型。Lambda表达式可以有返回值，如果没有return语句Lambda体的最后一个表
达式就是Lambda表达式的返回值，如果有return语句返回值是return语句后面的表达
式。
fun main(args: Array<String>) {
var funLa={
a:Int,b:Int-> a+b}
println(funLa(2,4))
}
2、Lambda表达式 简化写法
{a:Int,b:Int-> a+b} 可以简化成
{ a, b -> a + b }
尾随Lambda 如果一个函数的最后一个参数是Lambda表达式，那么这个Lambda表达
式可以放在函数括号之后。
fun main(args: Array<String>) {
//正常调用
// operterFun(2,3,{a,b->a+b})
//尾随写法
operterFun(2,3){
a,b->
a+b
}
}
fun operterFun(a: Int,b: Int,funName:(Int,Int)->Int):Int{
return funName(a,b)
}
如果Lambda表达式的参数只有一个，并且能够根据上下文环境推导出它的数据类
型，那么这个参数声明可以省略，在Lambda体中使用隐式参数it替代Lambda表达
式的参数
fun main(args: Array<String>) {
operterLa("zyb"){
println(it)}
}
fun operterLa(name:String,funName: (String)->Unit){
funName(name)
}
3、Lambda表达式与return语句
Lambda表达式体中也可以使用return语句，它会使程序跳出Lambda表达式体
fun main(args: Array<String>) {
println(sum(1,2,3,10,3)) //9
val add = label@ {
val a = 1
val b = 2
return@label 10
a + b
}
//调用Lambda表达式add
println(add()) //10
}
//累加求和函数
fun sum(vararg num: Int): Int {
var total = 0
num.forEach {
// if (it == 10) return -1 //返回最近的函数 ②
if (it == 10) return@forEach//返回Lambda表达式函数 ③
total += it
}
return total
}
三、闭包与捕获变量
闭包（closure）是一种特殊的函数，它可以访问函数体之外的变量，这个变量和函数一
同存在，即使已经离开了它的原始作用域也不例外。这种特殊函数一般是局部函数、匿名
函数或Lambda表达式
fun makeArray(): (Int) -> Int {
①
var ary = 0 ②
//局部函数捕获变量
fun add(element: Int): Int {
③
ary += element ④
return ary ⑤
}
return ::add ⑥
}
fun main(args: Array<String>) {
val f1 = makeArray() ⑦
println("---f1---")
println(f1(10))//累加ary变量，输出结果是10
println(f1(20))//累加ary变量，输出结果是30
}
四、内联函数
在高阶函数中参数如果是函数类型，则可以接收Lambda表达式，而Lambda表达式在编译
时被编译称为一个匿名类，每次调用函数时都会创建一个对象，如果这种被函数反复调用
则创建很多对象，会带来运行时额外开销。为了解决次问题，在Kotlin中可以将这种函数
声明为内联函数。
提示 内联函数在编译时不会生成函数调用代码，而是用函数体中实际代码替换每次
调用函数
1、内联函数定义
使用关键字 inline
inline fun calculatePrint(funN: (Int, Int) -> Int) {
①
println("${funN(10, 5)}")
}
fun main(args: Array<String>) {
calculatePrint {
a, b -> a + b } ②
calculatePrint {
a, b -> a - b } ③
}
2、使用let函数
在Kotlin中一个函数参数被声明为非空类型时，也可以接收可空类型的参数，但是如果实
际参数如果真的为空，可能会导致比较严重的问题。因此需要在参数传递之前判断可空参
数是否为非空
fun main(args: Array<String>) {
sayNameLength(null)
}
fun sayNameLength(name:String?){
// if (name!=null){
// println(name.length)
// }
name?.let {
println(it.length) }
}
2、使用with和apply函数
有时候需要对一个对象设置多个属性，或调用多个函数时，可以使用with或apply函数。
与let函数类似Kotlin中所有对象都可以使用这两个函数
with 返回表达式的最后一句，apply 返回的是一个对象
fun main(args: Array<String>) {
//sayNameLength(null)
var name=StringBuilder(0)
var stringBuilder2=name.apply{
append("hello")
append(" ")
append("world")
}
var stringBuilder3= with(name){
this.append("\n")
this.append("My name is ")
this.append("zyb")
"我是with"
}
println(name)
println(stringBuilder2)
println(stringBuilder3)
## hello world
## My name is zyb
## hello world
## My name is zyb
## 我是with
}