在Kotlin中，函数类型如 () -> Unit 或 (Int, String) -> Boolean 实际上是一些特殊的接口。它们定义了一个 invoke 方法。
举例来说，对于一个无参数和无返回值（Unit）的函数类型 () -> Unit，其实现的接口是这样的：
interface Function0<out R> : Function<R> {
public operator fun invoke(): R
}
对于下边这段代码：
var method01 : (() -> Unit)?= null
fun main() {
"Derry".shows()
"2353453".shows()
if (method01 != null) {
method01()
}
method01?.invoke() // 调用函数
}
它反编译之后的内容是：
public final class Lambda00Kt {
@Nullable
private static Function0 method01;
@Nullable
public static final Function0 getMethod01() {
return method01;
}
public static final void setMethod01(@Nullable Function0 var0) {
method01 = var0;
}
public static final void main() {
Lambda01Kt.shows("Derry");
Lambda01Kt.shows("2353453");
if (method01 != null) {
method01.invoke();
}
Function0 var10000 = method01;
if (var10000 != null) {
Unit var0 = (Unit)var10000.invoke();
}
}
// $FF: synthetic method
public static void main(String[] var0) {
main();
}
}
可见无论是()还是invoke，最终的调用都是Function0的invoke函数。当你声明一个 () -> Unit 类型的变量并赋予一个函数或者lambda表达式，你实际上是创建了一个 Function0<Unit> 类型的对象，这个对象有一个 invoke 方法。
在 Kotlin 中，invoke 是一个特殊的操作符函数。如果类型定义了 invoke 操作符函数，那么该类型的实例可以通过在实例名后面跟 () 来调用 invoke 函数。这就是为什么你可以通过 () 来 “调用” 函数类型的实例，例如 method01()。
这就是为什么 () 和 invoke() 在这种情况下等价的原因：它们实际上都是调用了 invoke 方法。
但是要注意，这只对那些定义了 invoke 操作符函数的类型适用。并不是所有的 Kotlin 类型都定义了 invoke 操作符函数，对于那些没有定义 invoke 操作符函数的类型，是不能通过 () 来 “调用” 实例的。
带有拓展函数的lambda
fun main() {
"Derry".shows()
"2353453".shows()
val method20 : Int.(Int) -> String = { "两数相加的结果是:${this + it}" }
println(1.method20(100))
println(method20(1, 100))
println(method20.invoke(10,200000))
}
反编译之后的代码：
public final class Lambda00Kt {
public static final void main() {
Lambda01Kt.shows("Derry");
Lambda01Kt.shows("2353453");
Function2 method20 = (Function2)null.INSTANCE;
Object var1 = method20.invoke(1, 100);
System.out.println(var1);
var1 = method20.invoke(1, 100);
System.out.println(var1);
var1 = method20.invoke(10, 200000);
System.out.println(var1);
}
// $FF: synthetic method
public static void main(String[] var0) {
main();
}
}
可见，最终的调用，还是通过invoke函数来进行实现。
函数返回一个函数
fun s04() : () -> Boolean = { true } // () -> Boolean
在 Kotlin 中，函数是不可变的。一旦函数被定义，其实现就不能改变。不能像修改变量那样去修改函数的实现。
如果你想改变 s04 的实现，需要重新定义一个新的 s04 函数，覆盖原有的函数定义。在 Kotlin 中，这可以通过使用不同的上下文（例如不同的类或文件）来实现。然而，对于同一个上下文，不能有两个同名的函数，因此不能直接重写 s04。
但是，如果是在某个类中定义 s04，你可以使用 open/override 机制来实现重写。下面是一个例子：
open class A {
open fun s04(): () -> Boolean = { true }
}
class B : A() {
override fun s04(): () -> Boolean = { false } // 重写 s04 的实现
}
在上面的例子中，B 类重写了 A 类中的 s04 函数。但请注意，需要使用 open 关键字来标记想要重写的函数，以明确表示该函数可以被重写。
如果只是想改变 s04 返回的函数，你可以将 s04 定义为一个变量，然后修改这个变量的值：
var s04: () -> Boolean = { true } // 初始化为返回 true 的函数
s04 = { false } // 然后修改为返回 false 的函数
在上面的代码中，s04 是一个变量，其类型是 () -> Boolean。你可以修改 s04 的值，从而改变 s04 返回的函数。
函数调用函数
fun s04() : (CharSequence) -> Boolean = { true } // () -> Boolean 函数返回一个函数
println(s04()("11111"))
s04()?.invoke("11111") // 该方式也可以。
在代码中，s04 是一个函数，这个函数返回另一个函数，这个返回的函数接受一个 CharSequence 参数，并返回一个 Boolean 值。
fun s04() : (CharSequence) -> Boolean = { true } 这一行定义了 s04 函数。它没有参数，返回类型是 (CharSequence) -> Boolean，也就是一个函数类型，这个函数类型接受一个 CharSequence 参数并返回一个 Boolean 值。{ true } 是函数体，它返回的是一个lambda表达式，这个lambda表达式总是返回 true。
所以，当调用 s04() 时，会得到一个函数，这个函数接受一个 CharSequence 参数并返回一个 Boolean 值。
然后，可以对这个函数再次调用，传入一个 CharSequence 参数。这就是为什么可以写 s04()("11111")，因为 s04() 返回的是一个函数，然后又调用了这个函数，传入了 "11111" 作为参数。
println(s04()("11111")) 这一行的意思是：调用 s04 函数得到一个新的函数，然后调用这个新的函数，传入 "11111" 作为参数，并打印这个函数调用的结果。因为 s04 返回的函数总是返回 true，所以这行代码最终会打印 true。
函数被定义之后就不能修改他的定义了，所以如果用以下的写法，是错误的：
fun s04() : (() -> Boolean ) ? = null// () -> Boolean 函数返回一个函数
s04 = { true }
但可以这么写：
var s04 : (() -> Boolean)? = null
或者这样写：// val s04:Function1<Unit, Boolean> ?= null
s04 = { true }
下边这个是一个错误的示例，这种方式很不好，不要这么写：
val methodX1 :(String)->Int = fun(str) : Int {
return (str.length)
}
一些区别：
// fun aa{} 与 var aa={}有啥区别
fun aa() {}
var aa2 = {}
// aa就是一个函数，实打实的函数
// aa2 是接收一个匿名函数的变量而已，这个变量 可以执行这个匿名函数
// 共同点：他们现象是一样的
var aa3 = aa2 // 都属于函数引用的概念
var aa4 = ::aa // 实打实的函数 变成 函数引用 所以可以传递赋值 给另外一个变量
函数的函数的函数的函数的嵌套示例，这也是kotlin的lambda的精髓所在：
例1：
var k01 : ((String)->(CharSequence)->(Long)->(Short)->(Float)->Int)? = null
k01 = {
{
{
{
{
1
}
}
}
}
}
例2：
fun show(n1:Int, lambda:(Int, Int)->Unit, n2:Int) = lambda(n1, n2)
// 调用 show 函数，并传入一个 lambda，该 lambda 打印两个参数的和
show(5, { a, b -> println(a + b) }, 3)
