kotlin(对比) : 普通方法/匿名函数/lambda/闭包 与 invoke

测试一：

fun main(args: Array<String>) {
    //以下执行结果一样
    println(ordinaryMethod(1, 5))
    println("------------------------")
    println(anonymousFunction1(1, 5))
    println(anonymousFunction1.invoke(1, 5))
    println("------------------------")
    println(anonymousFunction2(1, 5))
    println(anonymousFunction2.invoke(1, 5))
    println("------------------------")
    println(lambda1(1, 5))
    println(lambda1.invoke(1, 5))
    println("------------------------")
    println(lambda2(1, 5))
    println(lambda2.invoke(1, 5))
}

// 源方法
fun ordinaryMethod(a: Int, b: Int): Int {
    return a + b
}



//匿名函数（有fun，没名字）
val anonymousFunction1: (Int, Int) -> Int = fun(a: Int, b: Int) = a + b
//或者
val anonymousFunction2 = fun(a: Int, b: Int) = a + b



// lambda(有大括号)
val lambda1: (Int, Int) -> Int = { a, b -> a + b }
// 或者
val lambda2 = { a: Int, b: Int -> a + b }

测试二：

fun main(args: Array<String>) {
    //先计算3，5乘法的积，在计算与10的和
    // 调用
    println(method1(10, method2(3, 5)))

    println(method3(10, { num1: Int, num2: Int -> num1 * num2 }))
    //或
    println(method3(10) { num1: Int, num2: Int -> num1 * num2 })

    println(method4(10, { a, b -> a * b }))
    //或
    println(method4(10) { a, b -> a * b })
}


private fun method1(a: Int, b: Int): Int {
    return a + b
}

private fun method2(num1: Int, num2: Int): Int {
    return num1 * num2
}

// method 带 lambda
fun method3(a: Int, b: (num1: Int, num2: Int) -> Int): Int {
    return a + b.invoke(3, 5)
}

// method 带 lambda
fun method4(a: Int, b: (num1: Int, num2: Int) -> Int): Int =
    a + b.invoke(3, 5)

测试三

/*
* 闭包：函数中包含函数，外函数可访问内函数的变量
* */
fun main(args: Array<String>) {
    val test = method(3)
    println(test())            //7
    println(test.invoke())     //8
    println(test())            //9
    println(test.invoke())     //10
    println(test())            //11
}

/**
 * 闭包，即是函数中包含函数，
 * 这里的函数我们可以包含（Lambda表达式，匿名函数，局部函数，对象表达式）。
 * 参数 b
 * 返回 匿名函数
 */
fun method(b: Int): () -> Int {
    var a = 3
    return fun(): Int {
        a++
        return a + b
    }
}

闭包就是能够读取其他函数内部变量的函数。
作用
● 一个是前面提到的可以读取函数内部的变量
● 另一个就是让这些变量的值始终保持在内存中