1
(Type1, Type2, ...) -> Type
2
// 例如
3
(Int) -> Int
4

5
// 所以才有了这样的函数
6
fun test(a: Int, f: (Int) -> Int): Int {
7
    return f(a)
8
}

1
fun main(args: Array<String>) {
2
    // 引用函数
3
    println(test(1, 2, ::add))
4
    // 匿名函数
5
    val add = fun(a: Int, b: Int): Int {
6
        return a + b
7
    }
8
    println(test(3, 4, add))
9
    // lambda表达式
10
    println(test(5, 6, { a, b -> a + b }))// lambda作为最后一个参数可以提到括号外
11
    println(test(5, 6) { a, b -> a + b })
12
}
13

14
fun test(a: Int, b: Int, f: (Int, Int) -> Int): Int {
15
    return f(a, b)
16
}
17

18
fun add(a: Int, b: Int): Int {
19
    return a + b
20
}

1
{ () -> R }

1
{ T.() -> R }

1
fun fun1(f: (Int) -> Unit) {
2
    f(1)
3
}
4

5
fun fun2(f: (Int) -> Unit) {
6
    f(2)
7
}
8

9
// 使用typealias
10
typealias intFun = (Int) -> Unit
11

12
fun fun3(f: intFun) {
13
    f(3)
14
}
15

16
fun fun4(f: intFun) {
17
    f(4)
18
}
19

20
fun main(args: Array<String>) {
21
    fun1 { println(it) }
22
    fun2 { println(it) }
23
    fun3 { println(it) }
24
    fun4 { println(it) }
25
}

1
interface ICallback {
2
    fun onSuccess(msg: String)
3

4
    fun onFail(msg: String)
5
}
6

7
class TestCallback {
8

9
    var myCallback: ICallback? = null
10

11
    fun setCallback(callback: ICallback) {
12
        myCallback = callback
13
    }
14

15
    fun init() {
16
        myCallback?.onSuccess("success message")
17
    }
18
}
19

20
fun main(args: Array<String>) {
21
    val testCallback = TestCallback()
22
    testCallback.setCallback(object : ICallback {
23
        override fun onSuccess(msg: String) {
24
            println("success $msg")
25
        }
26

27
        override fun onFail(msg: String) {
28
            println("fail $msg")
29
        }
30
    })
31
    testCallback.init()
32
}

1
class TestCallback {
2
    var mySuccessCallback: (String) -> Unit? = {}
3
    var myFailCallback: (String) -> Unit? = {}
4

5
    fun setCallback(successCallback: (String) -> Unit, failCallback: (String) -> Unit) {
6
        mySuccessCallback = successCallback
7
        myFailCallback = failCallback
8
    }
9

10
    fun init() {
11
        mySuccessCallback("success message")
12
        myFailCallback("fail message")
13
    }
14
}
15

16
fun main(args: Array<String>) {
17
    val testCallback = TestCallback()
18
    testCallback.setCallback({ println("success $it") }, { println("fail $it") })
19
    testCallback.init()
20
}

1
class LambdaTest {
2

3
    companion object {
4
        // 相当于 static 成员
5
        private fun Int.toBoolean(predicate: (Int) -> Boolean) = predicate(this)
6

7
        private fun testStaticLambda() {
8
            val x = 1;
9
            val y = 2;
10
            val b = 1.toBoolean {
11
                // 引用局部变量 x 和 y
12
                println("$x and $y")
13
                it % 2 == 0
14
            }
15
            println(b)
16
        }
17
    }
18

19
    private var x = 1;
20

21
    private fun testNonStaticLambda() {
22
        //非static
23
        val y = 2;
24
        val b = 1.toBoolean {
25
            // 引用实例变量 x 和局部变量 y
26
            println("$x and $y")
27
            it % 2 == 0
28
        }
29
        println(b)
30
    }
31
}

1
// LambdaTest$Companion.class
2
public final class LambdaTest$Companion {
3
    private final boolean toBoolean(int $this$intToBoolean, Function1<? super Integer, Boolean> predicate) {
4
        return predicate.invoke($this$intToBoolean); // AutoBox
5
    }
6

7
    private final void testStaticLambda() {
8
        int x = 1;
9
        int y = 2;
10
        // lambda 表达式编译为 Function1 接口的匿名类
11
        boolean b = toBoolean(1, (Function1) new LambdaTest$Companion$testStaticLambda$b$1(x, y));
12
        System.out.println(b);
13
    }
14

15
    public static final boolean access$toBoolean(LambdaTest$Companion $this, int $this$access_u24toBoolean, Function1 predicate) {
16
        return $this.toBoolean($this$access_u24toBoolean, (Function1<? super Integer, Boolean>)predicate);
17
    }
18

19
    private LambdaTest$Companion() {}
20
    public LambdaTest$Companion(DefaultConstructorMarker $constructor_marker) {
21
        this();
22
    }
23
}

1
// LambdaTest$Companion$testStaticLambda$b$1.class
2
static final class LambdaTest$Companion$testStaticLambda$b$1
3
        extends Lambda implements Function1<Integer, Boolean> {
4
    final int $x;
5
    final int $y;
6

7
    public final boolean invoke(int it) {
8
        String string = this.$x + " and " + this.$y;
9
        System.out.println((Object)string);
10
        return it % 2 == 0;
11
    }
12

13
  // 引用的局部变量作为内部 final 属性传入
14
    LambdaTest$Companion$testStaticLambda$b$1(int n, int n2) {
15
        this.$x = n;
16
        this.$y = n2;
17
        super(1);
18
    }
19
}

1
// LambdaTest$testNonStaticLambda$b$1.class
2
static final class LambdaTest$testNonStaticLambda$b$1
3
extends Lambda
4
implements Function1<Integer, Boolean> {
5
    final LambdaTest this$0; // 实例对象的引用，注意哦，某些场景会内存泄露！！！
6
    final int $y; // 局部变量
7

8
    public final boolean invoke(int it) {
9
        String string = this.this$0.x + " and " + this.$y;
10
        boolean bl = false;
11
        System.out.println((Object)string);
12
        return it % 2 == 0;
13
    }
14

15
    LambdaTest$testNonStaticLambda$b$1(LambdaTest lambdaTest, int n) {
16
        this.this$0 = lambdaTest;
17
        this.$y = n;
18
        super(1);
19
    }
20
}

1
    var num = 0
2
    val result = myForEach(fruits) {
3
        println("#$num: $it")
4
    }
5
    println(num)

1
    Ref.IntRef intRef = new Ref.IntRef();
2
    intRef.element = 0; // 包装在引用对象的 element 字段中
3
    String result2 = myForEach(fruits, new Function1<String, Unit>((Ref.IntRef)num) {});
4
    System.out.println(intRef.element);