Kotlin高阶探索-Lambda

在Kotlin中，函数类型如 () -> Unit 或 (Int, String) -> Boolean 实际上是一些特殊的接口。它们定义了一个 invoke 方法。举例来说，对于一个无参数和无返回值（Unit）的函数类型 () -> Unit，其实现的接口是这样的：

kotlin 复制代码

interface Function0<out R> : Function<R> {
    public operator fun invoke(): R
}

对于下边这段代码：

kotlin 复制代码

var method01 : (() -> Unit)?= null
fun main() {
    "Derry".shows()
    "2353453".shows()
    if (method01 != null) {
        method01()
    }
    method01?.invoke() // 调用函数
}

它反编译之后的内容是：

java 复制代码

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

kotlin 复制代码

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))
}

反编译之后的代码：

arduino 复制代码

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函数来进行实现。
函数返回一个函数

kotlin 复制代码

fun s04() : () -> Boolean = { true } // () -> Boolean

在 Kotlin 中，函数是不可变的。一旦函数被定义，其实现就不能改变。不能像修改变量那样去修改函数的实现。

如果你想改变 s04 的实现，需要重新定义一个新的 s04 函数，覆盖原有的函数定义。在 Kotlin 中，这可以通过使用不同的上下文（例如不同的类或文件）来实现。然而，对于同一个上下文，不能有两个同名的函数，因此不能直接重写 s04。

但是，如果是在某个类中定义 s04，你可以使用 open/override 机制来实现重写。下面是一个例子：

kotlin 复制代码

open class A {
    open fun s04(): () -> Boolean = { true }
}

class B : A() {
    override fun s04(): () -> Boolean = { false } // 重写 s04 的实现
}

在上面的例子中，B 类重写了 A 类中的 s04 函数。但请注意，需要使用 open 关键字来标记想要重写的函数，以明确表示该函数可以被重写。如果只是想改变 s04 返回的函数，你可以将 s04 定义为一个变量，然后修改这个变量的值：

kotlin 复制代码

var s04: () -> Boolean = { true } // 初始化为返回 true 的函数
s04 = { false } // 然后修改为返回 false 的函数

在上面的代码中，s04 是一个变量，其类型是 () -> Boolean。你可以修改 s04 的值，从而改变 s04 返回的函数。

函数调用函数

kotlin 复制代码

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。

函数被定义之后就不能修改他的定义了，所以如果用以下的写法，是错误的：

kotlin 复制代码

fun s04() : (() -> Boolean ) ? = null// () -> Boolean 函数返回一个函数
s04 = { true }

但可以这么写：

javascript 复制代码

var s04 : (() -> Boolean)? = null
或者这样写：// val s04:Function1<Unit, Boolean> ?= null
s04 = { true }

下边这个是一个错误的示例，这种方式很不好，不要这么写：

kotlin 复制代码

val methodX1 :(String)->Int = fun(str) : Int {
    return (str.length)
}

一些区别：

kotlin 复制代码

// fun aa{} 与 var aa={}有啥区别
fun aa() {}
var aa2 = {}
// aa就是一个函数，实打实的函数
// aa2 是接收一个匿名函数的变量而已，这个变量 可以执行这个匿名函数
// 共同点：他们现象是一样的
var aa3 = aa2 // 都属于函数引用的概念
var aa4 = ::aa // 实打实的函数 变成 函数引用 所以可以传递赋值 给另外一个变量

函数的函数的函数的函数的嵌套示例，这也是kotlin的lambda的精髓所在：

例1：

kotlin 复制代码

var k01 : ((String)->(CharSequence)->(Long)->(Short)->(Float)->Int)? = null
k01 = {
    {
        {
            {
                {
                    1
                }
            }
        }
    }
}

例2：

kotlin 复制代码

fun show(n1:Int, lambda:(Int, Int)->Unit, n2:Int) = lambda(n1, n2)

// 调用 show 函数，并传入一个 lambda，该 lambda 打印两个参数的和
show(5, { a, b -> println(a + b) }, 3)