先来看一个概念。
函数式接口：函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
比如java中的Runnable接口就是函数式接口。
public interface Runnable {
public abstract void run();
}
在项目代码转为使用kotlin时，会存在和java代码互相调用的问题。不知道大家有没有注意到一个细节，kotlin构建java中的函数式接口时，可以转为lambda方式。
java方式：
Runnable runnable = new Runnable() {
@Override
public void run() {
}
};
val runnable = Runnable {
print("runnable")
}
可以看到使用lambda表达式后，对函数式接口来讲，实现方式更加简洁。
我们都知道kotlin代码最终还是会被编译为字节码，那么kotlin中是如何实现lambda表达式的呢？
这得分两种情况：
情况1: lambda表达式内部没有持有外部的非静态变量，方法。
class Lambda{
private var name = "小明" // 外部变量
private fun testLambda(){
var age = 10 // 外部变量
val runnable = Runnable {
print("没有调用外部变量或方法") // 没有调用age或者name变量
}
}
}
查看testLambda方法编译后的字节码
// 获取静态变量 INSTANCE（该INSTANCE实际是Runnable对象的一个实现）
GETSTATIC Lambda$testLambda1$runnable$1.INSTANCE : LLambda$testLambda1$runnable$1;
// 检查 INSTANCE 是否可以转变为Runnbale对象，否则抛出异常
CHECKCAST java/lang/Runnable
// INSTANCE推入操作数栈
ASTORE 1
翻译成java代码就会类似于这样：
public class Lambda {
private String name = "小明";
private static Object INSTANCE = new Runnable() {
@Override
public void run() {
System.out.println("没有调用外部类的成员变量");
}
};
private void testLambda1() {
Runnable runnable = (Runnable)INSTANCE;
}
}
可以看到这种情况下lambda表达式实际上被转换为静态成员变量。
情况二：lambda表达式内部持有外部的非静态变量，方法。
class Lambda {
private var name = "小明"
private fun testLambda2() {
val runnable = Runnable {
print(name)
}
}
}
反编译为java代码：
private final void testLambda2() {
Runnable runnable = (Runnable)(new Runnable() {
public final void run() {
String var1 = Lambda.this.name;
System.out.print(var1);
}
});
}
可以看到lambda表达式是采用匿名内部类的方式来实现的。
那么以上两种方式有什么不同呢？
我们都知道java中匿名内部类都会隐式持有外部类的引用（即使不需要引用外部类的变量），当匿名内部类中有耗时操作时，容易造成内存泄露。
像kotlin这样的实现，在情况一的时候，lambda内部没有持有外部类的引用，不会有任何内存泄露的风险。
以上就是kotlin调用java时，lambda的实现方式。
kotlin中Functions.kt中定义了从Function0到Function22一共23个接口，每个接口有且仅有一个invoke方法，Function后边的数字代表invoke方法有几个入参，当kotlin中自定义的lambda表达式在编译的时候，会被替换为对应的接口实现。
比如：
val lambda: (() -> Unit) = {
}
由于没有参数，所以实际上会被编译为
Function0 lambda = new Function0{
public void invoke(){
}
}
当然了，编译规则也会像调用java中的函数式接口时一样，仅当需要持有this对象时才会编译为匿名内部类。
