注：编码工具为IntelliJ

目录

匿名函数入门示例

函数类型和隐式返回

定义函数类型变量的两种方式

方式一：

方式二：

函数类型作为函数参数

非内联函数

内联函数

函数引用

函数类型作为函数的返回值

匿名函数入门示例

fun main() {
    val len = "KimuraTakuya".count { it == 'a' }
    println(len)
}

输出：

3

        示例中的{it == 'a'}就是一个匿名函数。

        匿名函数只有参数列表和函数体，没有函数名。

        匿名函数可以作为另一个函数的实际参数或者返回值。

        匿名函数==lambda表达式。

函数类型和隐式返回

        Kotlin中可以定义函数类型的变量，该变量可以作为函数使用，通过()或者invoke()调用。

        隐式返回：函数类型的实现即匿名函数中的返回值不能用return关键字修饰，函数体的最后一句的执行结果即为返回值。

package step_two

fun main() {
    // ()->Int 是函数类型
    // 等号后{}中的内容是函数的实现
    val f: ()->Int = {
        println("in Anonymous func")
        18
    }
    println(f())
    println(f.invoke())
}

输出：

in Anonymous func
18
in Anonymous func
18

定义函数类型变量的两种方式

方式一：

package step_two

fun main() {
    val func: (Int, Int) -> Int = {a, b -> a + b}
    println(func(12, 11))
}

输出：

23

方式二：

package step_two

fun main() {
    val func = { a: Int, b: Int -> a + b }
    println(func(12, 11))
}

输出：

23

        方式二，编译器会根据匿名函数体的最后一句执行结果推断返回值类型。

函数类型作为函数参数

        类似于Java中的回调接口。

非内联函数

        反编译为Java代码显示，将作为函数参数的函数定义成了一个对象，效率低。

package step_two

fun main() {
    login("abc", "123"){
        msg, code -> println("login result: msg = $msg, code = $code")
    }
}

fun login(user: String, pwd: String, result:(String, Int) -> Unit){
    if("abc" == user && "123" == pwd)
    {
        result("success", 200);
    }else{
        result("failure", 400);
    }
}

输出：

login result: msg = success, code = 200

反编译后的Java代码：

package step_two;

import kotlin.metadata;
import kotlin.jvm.functions.Function2;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;

@metadata(
   mv = {1, 5, 1},
   k = 2,
   d1 = {"u0000u001cnu0000nu0002u0010u0002nu0000nu0002u0010u000enu0002bu0002nu0002u0018u0002nu0002u0010bnu0002bu0002u001a0u0010u0000u001au00020u00012u0006u0010u0002u001au00020u00032u0006u0010u0004u001au00020u00032u0018u0010u0005u001au0014u0012u0004u0012u00020u0003u0012u0004u0012u00020u0007u0012u0004u0012u00020u00010u0006u001au0006u0010bu001au00020u0001¨u0006t"},
   d2 = {"login", "", "user", "", "pwd", "result", "Lkotlin/Function2;", "", "main", "kt"}
)
public final class FuncAsFuncParamKt {
   public static final void main() {
      login("abc", "123", (Function2)null.INSTANCE);
   }

   // $FF: synthetic method
   public static void main(String[] var0) {
      main();
   }

   public static final void login(@NotNull String user, @NotNull String pwd, @NotNull Function2 result) {
      Intrinsics.checkNotNullParameter(user, "user");
      Intrinsics.checkNotNullParameter(pwd, "pwd");
      Intrinsics.checkNotNullParameter(result, "result");
      if (Intrinsics.areEqual("abc", user) && Intrinsics.areEqual("123", pwd)) {
         result.invoke("success", 200);
      } else {
         result.invoke("failure", 400);
      }

   }
}

内联函数

        用inline关键字修饰的函数。当函数参数中含有函数时，将该函数定义为内联函数，反编译为Java代码后显示将内联函数的实现直接拷贝到了函数调用处，减少了函数的入栈出栈，效率高。

package step_two

fun main() {
    login("abc", "123"){
        msg, code -> println("login result: msg = $msg, code = $code")
    }
}

inline fun login(user: String, pwd: String, result:(String, Int) -> Unit){
    if("abc" == user && "123" == pwd)
    {
        result("success", 200);
    }else{
        result("failure", 400);
    }
}

输出：

login result: msg = success, code = 200

反编译后的Java代码：

package step_two;

import kotlin.metadata;
import kotlin.jvm.functions.Function2;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;

@metadata(
   mv = {1, 5, 1},
   k = 2,
   d1 = {"u0000u001cnu0000nu0002u0010u0002nu0000nu0002u0010u000enu0002bu0002nu0002u0018u0002nu0002u0010bnu0002bu0002u001a6u0010u0000u001au00020u00012u0006u0010u0002u001au00020u00032u0006u0010u0004u001au00020u00032u0018u0010u0005u001au0014u0012u0004u0012u00020u0003u0012u0004u0012u00020u0007u0012u0004u0012u00020u00010u0006Hu0086bøu0001u0000u001au0006u0010bu001au00020u0001u0082u0002u0007nu0005bu009920u0001¨u0006t"},
   d2 = {"login", "", "user", "", "pwd", "result", "Lkotlin/Function2;", "", "main", "kt"}
)
public final class FuncAsFuncParamKt {
   public static final void main() {
      String user$iv = "abc";
      String pwd$iv = "123";
      int $i$f$login = false;
      short code;
      String msg;
      boolean var5;
      String var6;
      boolean var7;
      if (Intrinsics.areEqual("abc", user$iv) && Intrinsics.areEqual("123", pwd$iv)) {
         code = 200;
         msg = "success";
         var5 = false;
         var6 = "login result: msg = " + msg + ", code = " + code;
         var7 = false;
         System.out.println(var6);
      } else {
         code = 400;
         msg = "failure";
         var5 = false;
         var6 = "login result: msg = " + msg + ", code = " + code;
         var7 = false;
         System.out.println(var6);
      }

   }

   // $FF: synthetic method
   public static void main(String[] var0) {
      main();
   }

   public static final void login(@NotNull String user, @NotNull String pwd, @NotNull Function2 result) {
      int $i$f$login = 0;
      Intrinsics.checkNotNullParameter(user, "user");
      Intrinsics.checkNotNullParameter(pwd, "pwd");
      Intrinsics.checkNotNullParameter(result, "result");
      if (Intrinsics.areEqual("abc", user) && Intrinsics.areEqual("123", pwd)) {
         result.invoke("success", 200);
      } else {
         result.invoke("failure", 400);
      }

   }
}

函数引用

        用::函数名的形式，可以引用一个现有的符合条件的函数作为另一个函数实际参数。

package step_two

fun plus(a: Int, b: Int) {
    println("a + b = ${a + b}")
}

fun minus(a: Int, b: Int){
    println("a - b = ${a - b}")
}

fun calc(a: Int, b: Int, cal: (Int, Int) -> Unit) {
    cal(a, b)
}

fun main() {
    calc(99, 13, ::plus)
    val method = ::minus
    calc(10000, 1, method)
}

输出：

a + b = 112
a - b = 9999

函数类型作为函数的返回值

package step_two

fun main() {
    generateFunc("hello anonymous function")("this is another func")
}

fun generateFunc(msg: String): (String) -> Unit {
    println(msg)
    return { str: String -> println(str) }
}

输出：

hello anonymous function
this is another func