1、闭包

闭包：函数式编程，函数可以作为方法的返回值，也可以作为方法的参数，lambda表达式

fun test(): () -> Unit {
    var a = 10

    // 此处方法的返回值就是闭包
    return {
        println(a)
        a++
    }
}

fun main() {
    val result = test()
    result()         // 10
    result()         // 11
    result.invoke()  // 12
}

2、高阶函数

/**
 * 普通函数
 */
fun add(a: Int, b: Int): Int {
    return a + b
}

/**
 * 普通函数
 */
fun sub(a: Int, b: Int): Int {
    return a - b
}

/**
 * 高阶函数
 * 需要两个 Int 参数和一个函数类型的参数
 */
fun cecl(a: Int, b: Int, block: (Int, Int) -> Int): Int {
    //return block(a, b)
    return block.invoke(a, b)
}

fun main() {
    val a = 10
    val b = 20
    var sum = add(a, b)
    var result = sub(a, b)
    println(sum)    // 30
    println(result) // -10

    // :: 表示函数的引用，类似于C/C++里的函数指针
    sum = cecl(a, b, ::add)
    println(sum)    // 30
    result = cecl(a, b, ::sub)
    println(result) // -10
}

3、lambda表达式

/**
 * 高阶函数
 * 需要两个 Int 参数和一个函数类型的参数
 */
fun lambda(a: Int, b: Int, block: (Int, Int) -> Int): Int {
    //return block(a, b)
    return block.invoke(a, b)
}

fun lambda2(a: Int, block: (Int, Int) -> Int, b: Int): Int {
    //return block(a, b)
    return block.invoke(a, b)
}

fun main() {
    val a = 10
    val b = 20


    // 1、匿名函数即 lambda 表达式
    val sum = lambda(a, b, { m, n ->
        m + n
    })
    println(sum)    // 30


    // 2、lambda 表达式去括号：当函数最后一个参数为 lambda 表达式时，可以放到括号外面ß
    val result = lambda(a, b) { m, n ->
        m - n
    }
    println(result) // -10

    val l3 = lambda2(a, { m, n ->
        m + n
    }, b)
    println(l3);


    // 3、无参 lambda 表达式
    {
        println("无参 lambda 表达式")
    }();

    {
        println("无参 lambda 表达式")
    }.invoke()


    // 4、有参 lambda 表达式
    val r1 = { a: Int, b: Int ->
        println("有参 lambda 表达式")
        a + b
    }(10, 20)
    println(r1) // 30

    val r2 = { a: Int, b: Int ->
        println("有参 lambda 表达式")
        a - b
    }?.invoke(10, 20)
    println(r2) // -10
}