高阶函数即指:将函数用作一个函数的参数或者返回值的函数。
demo
private fun testHightLevel() {
MoreFun.loginEngine("helloo", "kotlin") {
if (it) {
println("登录成功")
} else {
println("登录失败")
}
}
//输出结果: 登录失败
999.myTest1 {
this
false
}
false.myTest1 {
this
false
}
testLambda().myTest1 {
this
false
}
999.myTest3() { t1, t2, t3 ->
this
println(t1 == this)
false
}
false.myTest3 { t1, t2, t3 ->
this
false
}
testLambda().myTest3 { t1, t2, t3 ->
this
false
}
val sum1 = sum(1, 2, 3) { v1, v2, v3 ->
v1 + v2 + v3
}
println("三个数相加结果是:$sum1")
val sum2 = sum(3, 2, 3) { v1, v2, v3 ->
v1 * v2 * v3
}
println("三个数相乘结果是:$sum2")
val sum3 = sum(24, 2, 3) { v1, v2, v3 ->
v1 / v2 / v3
}
println("三个数相除结果是:$sum3")
val sum4 = sum(1, 2, 3) { v1, v2, v3 ->
v1 - v2 - v3
}
println("三个数相减结果是:$sum4")
}
MoreFun.kt
package com.example.plugintest.ui.home
/**
* @author: admin
* created on: 2022/5/22 23:15
* description:
*/
object MoreFun {
@JvmStatic
fun loginEngine(username: String, password: String, responseResult: (Boolean) -> Unit) {
val DB_USER_NAME = "hello"
val DB_USER_PASS = "kotlin"
if (username == DB_USER_NAME && password == DB_USER_PASS) {
//TODO 其他逻辑的处理
//....
responseResult(true)
} else {
//TODO 其他逻辑的处理
//....
responseResult(false)
}
}
//泛型T == 万能类型,下面的函数万能类型.myTest是让所有类型的函数可以使用下面的函数
//mm是一个lambda函数的名称
//万能类型.() :这个lambda函数会持有this == 万能类型本身
// mm()调用lambda
@JvmStatic
fun <万能类型> 万能类型.myTest(mm: 万能类型.() -> Boolean) = mm()
//与上面等价
@JvmStatic
fun <T> T.myTest1(mm: T.() -> Boolean) = mm()
@JvmStatic
fun <万能类型> 万能类型.myTest2(mm: 万能类型.(万能类型, 万能类型, 万能类型) -> Boolean) = mm(this, this, this)
//与上面等价
@JvmStatic
fun <T> T.myTest3(mm: T.(T, T, T) -> Boolean) = mm(this, this, this)
// testInt1, testInt2, testInt3都是一样的意义,将一个参数泛型设置成为Int后面2个是缩写
@JvmStatic
fun <T> T.testInt1(mm: T.(Int, Int, Int) -> Boolean) = mm(9, 9, 9)
@JvmStatic
fun <T> T.testInt2(mm: T.(Int, Int, Int) -> Boolean) {
mm(9, 9, 9)
}
@JvmStatic
fun <T> T.testInt3(mm: T.(Int, Int, Int) -> Boolean) = mm(9, 9, 9)
//TODO 三个数相乘,三个数相减,三个数相加,三个数相除 通用函数原则
fun <R> sum(
n1: Int, n2: Int, n3: Int,
lambda: (Int, Int, Int) -> R?
) = lambda(n1, n2, n3)
}
ex2:
private fun testHighLevel2() {
//如果函数的最后一个参数是lambda,那么作为相应参数传入的lambda表达式可以放在括号外
convert(30.0, { c: Double -> c * 1.8 + 32 }) //方式1
convert(30.0) { c: Double -> c * 1.8 + 32 } //方式2
convert(30.0) { it * 1.8 + 32 } //方式3,当个参数可以使用it代替参数符号
//输出结果: 摄氏度30.0 is convert to 华氏度:86.0
//函数只有一个参数,而该参数是一个lamdda,调用函数的时候可以省略括号
convert1() { it * 1.8 + 32 }
//输出结果: 摄氏度30.0 is convert to 华氏度:86.0
//
val tem: Double = getConversion("tem")(30.0)
println("温度是:$tem")
//输出结果: 温度是:86.0
convert2(30.0, getConversion("tem"))
//输出结果: 30.0 is convert to :86.0
convert2(1000.0, getConversion("kg to g"))
//输出结果: 1000.0 is convert to :1.0
convert2(500.0, getConversion("g to catties"))
//输出结果: 500.0 is convert to :1.0
val toGrams: (Double) -> Double = { x: Double -> x * 1000.0 } // kg到g
val toGatties: (Double) -> Double = { x: Double -> x / 500.0 } // g到斤
val combineNum: (Double) -> Double = combine(toGrams, toGatties)
val result: Double = combineNum(1.0)
println("result==$result")
//输出结果: result==2.0
}
//第一个参数是Double,第二个参数是lambda使用lambda作为参数是高阶函数,高阶函数返回类型是Double
fun convert(
x: Double,
converter: (Double) -> Double
): Double {
//调用converter的lambda,并将结果返回给result
val result: Double = converter(x)
println("摄氏度$x is convert to 华氏度:$result")
return result
}
//convert1只有一个参数,而且是lambda
fun convert1(
converter: (Double) -> Double
): Double {
//调用converter的lambda,并将结果返回给result
val result: Double = converter(30.0)
println("摄氏度30.0 is convert to 华氏度:$result")
return result
}
//第一个参数是Double,第二个参数是lambda
fun convert2(
x: Double,
converter: (Double) -> Double
): Double {
//调用converter的lambda,并将结果返回给result
val result: Double = converter(x)
println("$x is convert to :$result")
return result
}
//参数是String,函数的返回是lambda
fun getConversion(str: String): (Double) -> Double {
if (str == "tem") {
return { it * 1.8 + 32 }
} else if (str == "kg to g") {
return { it / 1000 }
} else if (str == "g to catties") {
return { it / 500 }
} else {
return { it }
}
}
//创建一个Combine合并的函数,该函数有2个lambda,方法的返回也是lambda
fun combine(
lambda: (Double) -> Double,
lambda2: (Double) -> Double
): (Double) -> Double {
return { x: Double -> lambda2(lambda(x)) }
}