Kotlin高阶函数

高阶函数即指：将函数用作一个函数的参数或者返回值的函数。

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


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.myTest1(mm: T.() -> Boolean) = mm()

    @JvmStatic
    fun <万能类型> 万能类型.myTest2(mm: 万能类型.(万能类型, 万能类型, 万能类型) -> Boolean) = mm(this, this, this)

    //与上面等价
    @JvmStatic
    fun  T.myTest3(mm: T.(T, T, T) -> Boolean) = mm(this, this, this)

    // testInt1， testInt2， testInt3都是一样的意义，将一个参数泛型设置成为Int后面2个是缩写
    @JvmStatic
    fun  T.testInt1(mm: T.(Int, Int, Int) -> Boolean) = mm(9, 9, 9)

    @JvmStatic
    fun  T.testInt2(mm: T.(Int, Int, Int) -> Boolean) {
        mm(9, 9, 9)
    }

    @JvmStatic
    fun  T.testInt3(mm: T.(Int, Int, Int) -> Boolean) = mm(9, 9, 9)

    //TODO 三个数相乘，三个数相减，三个数相加，三个数相除   通用函数原则
    fun  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)) }
    }