kotlin inline函数

代码中如果有大量重复的lambda表达式，代码会生成很多临时的无用对象，可以使用inline修饰方法，这样当方法在编译时就会拆解方法的调用为语句的调用，进而减少创建不必要的对象。如果过度使用inline管关键字，会使代码块变得很庞大，查找问题很麻烦，所以inline一般用来修饰高阶函数.

例如：加入inline 下面的onlyif方法在编译的时候就变成了语句的调用，进而减少临时变量的产生

inline fun onlyif(isDebug: Boolean, block: () -> Unit){
    if (isDebug) block()
}
public static final void onlyif(boolean isDebug,Function0<Unit> block){
    if(isDebug){
        block.invoke();
    }
}
public static final void main(String[] args){
    boolean isDebug = true;
    if(isDebug){
        String str = "打印日志";
        System.out.println(str);
    }
}

inline crossinline noinline

inline修饰方法，crossinline、noinline修饰lambda参数

1.在kotlin中，函数内部lambda是不允许中断外部函数执行的(如果有return检查期会报错)。
2.inline修饰的lambda可以中断外部函数调用（lambda中含有return不会报错，其实就是在编译时把lambda的代码拷贝到父函数中，并且return后面的代码都被删除掉了，包括父函数的代码）。
3.crossinline不允许inline的lambda中断外部函数执行（其实参数加入这个修饰符后，如果lambda中有return的话直会报错，所以说不能中断，编译就通不过）。
4.noinline 拒绝内联(防止lambda转成语句，一般修饰返回值是lambda的时候)。

inline 相当于编译的时候将lambda的内容生成语句，但是如果内容中有return的时候直接返回外部方法，如果说不想返回外部方法，就要在lambda参数前面加上crossinline修饰符，这样如果在lambda中有return就就会报错，已到达不在lambda中断外部方法的目的。
匿名函数里的返回值只能返回他自己并不能返回他的外部函数（匿名函数是没有inline修饰的）

最后可以理解inline是代码设计的一种语法糖

例子：

没有内联检查期报错
val runnable = Runnable {
    println("runnable")
}
fun main(args: Array<String>) {
    test0 {
        println("hello00")
        return// -------------------检查期报错----------------------
        println("hello01")
    }
    test1 {
        println("hello10")
        return@test1
        println("hello11")
    }
    test2({
        println("hello")
    }, runnable::run)
}
 fun test0(l: () -> Unit) {// -------------------没有 inline  修饰----------------------
    l.invoke()
    println("hello00nei")
    return
}
inline fun test1(crossinline l: () -> Unit) {
    l.invoke()
    println("hello11nei")
    return
}
inline fun test2(l0: () -> Unit, noinline l1: () -> Unit): () -> Unit {
    l0.invoke()
    l1.invoke()
    println("test2")
    return l1
}

正常输出打印结果
val runnable = Runnable {
    println("runnable")
}
fun main(args: Array<String>) {
    test0 {
        println("hello00")
        return@test0
        println("hello01")
    }
    test1 {
        println("hello10")
        return@test1
        println("hello11")
    }
    test2({
        println("hello")
    }, runnable::run)
}
inline fun test0(l: () -> Unit) {
    l.invoke()
    println("hello00nei")
    return
}
inline fun test1(crossinline l: () -> Unit) {
    l.invoke()
    println("hello11nei")
    return
}
inline fun test2(l0: () -> Unit, noinline l1: () -> Unit): () -> Unit {
    l0.invoke()
    l1.invoke()
    println("test2")
    return l1
}

执行结果
hello00
hello00nei
hello10
hello11nei
hello
runnable
test2

内联函数lambda中有return
val runnable = Runnable {
    println("runnable")
}
fun main(args: Array<String>) {
    test0 {
        println("hello00")
        return   ------------- 这之后的代码在class中根本就没有
        println("hello01")
    }
    test1 {
        println("hello10")
        return@test1
        println("hello11")
    }
    test2({
        println("hello")
    }, runnable::run)
}
inline fun test0(l: () -> Unit) {
    l.invoke()
    println("hello00nei")
    return
}
inline fun test1(crossinline l: () -> Unit) {
    l.invoke()
    println("hello11nei")
    return
}
inline fun test2(l0: () -> Unit, noinline l1: () -> Unit): () -> Unit {
    l0.invoke()
    l1.invoke()
    println("test2")
    return l1
}

执行结果
hello00

crossinline 修饰lambda有return 报错
val runnable = Runnable {
    println("runnable")
}
fun main(args: Array<String>) {
    test0 {
        println("hello00")
        return
        println("hello01")
    }
    test1 {
        println("hello10")
        return// -------------------检查期报错----------------------
        println("hello11")
    }
    test2({
        println("hello")
    }, runnable::run)
}
inline fun test0(l: () -> Unit) {
    l.invoke()
    println("hello00nei")
    return
}
inline fun test1(crossinline l: () -> Unit) {// -------------------crossinline 修饰----------------------
    l.invoke()
    println("hello11nei")
    return
}
inline fun test2(l0: () -> Unit, noinline l1: () -> Unit): () -> Unit {
    l0.invoke()
    l1.invoke()
    println("test2")
    return l1
}