本文收录于 kotlin入门潜修专题系列，欢迎学习交流。

创作不易，如有转载，还请备注。

内联方法

在学习c/c++语言的时候，会了解到inline（内联）方法。java中并没有inline方法，而kotlin提供了该功能，这是有别于java的一个地方。kotlin中使用inline关键字来修饰内联方法。

什么是inline方法？使用inline修饰的方法和普通方法有什么区别？这背后的原理是什么？这就是本篇文章要阐述的内容。

先来看下没有使用inline修饰的方法，如下所示：

class Test {
//定义了一个普通的方法m1，该方法打印语句hello world
    fun m1() {
        println("hello world")
    }
//测试方法test，仅仅调用m1
    fun test() {
        m1()
    }
}

上面代码就是一个普通的代码调用，来看看其背后的字节码实现（这里主要来看下test方法的实现）：

  public final test()V
   L0
    LINENUMBER 13 L0
    ALOAD 0
//注意这里，编译器会通过字节码指令INVOKEVIRTUAL
//来完成方法m1的调用
    INVOKEVIRTUAL Test.m1 ()V
   L1
    LINENUMBER 15 L1
    RETURN
   L2
    LOCALVARIABLE this LTest; L0 L2 0
    MAXSTACK = 1
    MAXLOCALS = 1

上面注释已经说明了普通方法的调用流程，即会通过字节码指令完成方法的调用，那么inline方法会有什么不同呢？看个inline方法的示例：

class Test {
//此时方法m1就是内联方法，使用了inline关键字修饰
    inline fun m1() {
        println("hello world")
    }
//测试方法
    fun test() {
        m1()
    }
}

上述代码仅仅将方法m1使用了inline关键字来修饰，其他什么都没有变，来看看其背后对应的字节码：

  public final test()V
   L0
    LINENUMBER 13 L0
    ALOAD 0
    ASTORE 1
   L1
    LINENUMBER 101 L1
    LDC "hello world"//注意这里
    ASTORE 2
   L2
//同样也注意这里
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ALOAD 2
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/Object;)V
   L3
   L4
    LINENUMBER 102 L4
    NOP
  //省略部分字节码

从字节码可以发现，inline方法被直接编译到了调用处，是作为调用方法的一部分来实现的，而不是通过方法调用来完成的，这就是inline方法和普通方法的区别！

那么，为什么要这么做呢？答案是显而易见的，因为方法调用是有性能开销的，而inline方法刚好可以将方法调用编译到自己的方法体实现中，故节省了很多开销。

如果，你觉得方法开销不必在意的话，那么就来看下面一段代码：

class Test {
//方法m0接收了一个方法类型作为参数
    fun m0(checkStr: (str: String) -> String) {
        val str1 = "test str"
        println(checkStr(str1))
    }
    fun test() {
        m0({ "test2" })
    }
}

如果看过kotlin入门潜修之进阶篇—高阶方法和lambda表达式
这篇文章，一定对上面的代码不陌生，这就是kotlin中的高阶方法！在kotlin入门潜修之进阶篇—高阶方法和lambda表达式原理
这篇文章中，我们曾分析过，方法类型实际上最终都是以对象的形式存在的，kotlin会为lambda表达式生成一个新类，并通过该类的实例完成方法的入参及执行。所以这中间存在着一些内存方面的开销，如果有很多这种语句，那么这个开销将会变的非常之大。

下面我们将m0方法改成inline方法进行实现，源代码如下所示：

class Test {
//m0方法使用了inline关键字来修饰，表示m0是个内联方法
    inline fun m0(checkStr: (str: String) -> String) {
        val str1 = "test str"
        println(checkStr(str1))
    }
    fun test() {
        m0({ "test2" })
    }
}

上面代码将m0标注为了inline方法，来看下其背后对应的字节码，如下所示：

// ================Test.class =================
// class version 50.0 (50)
// access flags 0x31
public final class Test {
  // access flags 0x11
  // signature (Lkotlin/jvm/functions/Function1<-Ljava/lang/String;Ljava/lang/String;>;)V
  // declaration: void m0(kotlin.jvm.functions.Function1<? super java.lang.String, java.lang.String>)
  public final m0(Lkotlin/jvm/functions/Function1;)V
    @Lorg/jetbrains/annotations/NotNull;() // invisible, parameter 0
   L0
    ALOAD 1
    LDC "checkStr"
    INVOKESTATIC kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull (Ljava/lang/Object;Ljava/lang/String;)V
   L1
    LINENUMBER 3 L1
    LDC "test str"
    ASTORE 3
   L2
    LINENUMBER 4 L2
    ALOAD 1
    ALOAD 3
    INVOKEINTERFACE kotlin/jvm/functions/Function1.invoke (Ljava/lang/Object;)Ljava/lang/Object;
    ASTORE 4
   L3
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ALOAD 4
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/Object;)V
   L4
   L5
    LINENUMBER 5 L5
    RETURN
   L6
    LOCALVARIABLE str1 Ljava/lang/String; L2 L6 3
    LOCALVARIABLE this LTest; L0 L6 0
    LOCALVARIABLE checkStr Lkotlin/jvm/functions/Function1; L0 L6 1
    LOCALVARIABLE $i$f$m0 I L0 L6 2
    MAXSTACK = 2
    MAXLOCALS = 5

  // access flags 0x11
  public final test()V
   L0
    LINENUMBER 8 L0
    ALOAD 0
    ASTORE 1
   L1
    LINENUMBER 95 L1
    LDC "test str"
    ASTORE 2
   L2
    LINENUMBER 96 L2
    ALOAD 2
    ASTORE 3
   L3
    LINENUMBER 8 L3
    LDC "test2"
   L4
   L5
    ASTORE 3
   L6
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ALOAD 3
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/Object;)V
   L7
   L8
    LINENUMBER 97 L8
    NOP
   L9
    LINENUMBER 9 L9
    RETURN
   L10
    LOCALVARIABLE it Ljava/lang/String; L3 L5 3
    LOCALVARIABLE $i$a$1$m0 I L3 L5 4
    LOCALVARIABLE str1$iv Ljava/lang/String; L2 L9 2
    LOCALVARIABLE this_$iv LTest; L1 L9 1
    LOCALVARIABLE $i$f$m0 I L1 L9 5
    LOCALVARIABLE this LTest; L0 L10 0
    MAXSTACK = 2
    MAXLOCALS = 6

  // access flags 0x1
  public <init>()V
   L0
    LINENUMBER 1 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    RETURN
   L1
    LOCALVARIABLE this LTest; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1
}

没错，上面就是生成的全部字节码！通过字节码可以发现以下两点：

1. kotlin不再为lambda表达式生成一个新类。
2. m0方法的实现会被编译到其调用处（即test方法）中。

由此可见，inline方法会节省掉使用lambda或者匿名方法时所带来的内存开销。这就是inline方法背后的优势。

noinline

当inline作用于方法时，会同时对方法本身以及传入的lambda起作用，换句话说，inline方法和lambda都会被编译到方法的调用处（可以见上例），那么如果我们只需要一部分方法被内联该如果做呢？这就是noinline关键字的作用！使用noinline关键字表明其修饰的部分不需要内联到调用处，如下所示：

//代码同上个例子基本一致
class Test {
//唯一不一样的地方就是我们使用noinline修饰了m0方法
//的类型入参
    inline fun m0(noinline checkStr: (str: String) -> String) {
        val str1 = "test str"
        println(checkStr(str1))
    }
//测试方法
    fun test() {
        m0({ "test2" })
    }
}

那么这么写以后，kotlin会怎么处理呢？通过查看字节码可知，kotlin会忽略加在方法开头的inline修饰符，而照例为传入的lambda表达式生成了一个新类！但是m0方法体中的实现却被内联到了test方法中，字节码摘录如下：

//test方法对应的字节码
  public final test()V
   L0
    LINENUMBER 8 L0
    ALOAD 0
    ASTORE 1
    GETSTATIC Test$test$1.INSTANCE : LTest$test$1;
    CHECKCAST kotlin/jvm/functions/Function1
    ASTORE 2
   L1
    LINENUMBER 95 L1
    LDC "test str"//由此可知，m0方法体中代码被内联到了此处
    ASTORE 3
   L2
    LINENUMBER 96 L2
    ALOAD 2
    ALOAD 3
//这里，可以看出，是通过方法调用来完成lambda表达式功能的
    INVOKEINTERFACE kotlin/jvm/functions/Function1.invoke (Ljava/lang/Object;)Ljava/lang/Object;
    ASTORE 4
   L3
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ALOAD 4
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/Object;)V
   L4
//下面是kotlin为lambda表达式生成的新类
final class Test$test$1 extends kotlin/jvm/internal/Lambda  implements kotlin/jvm/functions/Function1  {
//省略了类中的内容
}

非局部返回（Non-local returns）

先来看个例子：

//定义了一个高阶方法m0，该方法接收一个方法类型
    fun m0(param: () -> Unit) {
    }
//测试方法
    fun test() {
//调用m0方法
        m0 {
            return// !!!错误，编译不通过!
        }
    }

上述代码将会编译不通过！原因是return一般会结束方法，表示方法执行完成，而lambda表达式则无法结束方法，也就是不能在lambda表达式中使用return语句。那么如果我们想要结束lambda的执行该如何做呢？那就是使用label机制，如下所示：

    fun test() {
        m0 {
            return@m0//通过隐式的label返回
        }
    }

隐式的label就是不给m0指定label标识，而是通过默认的方法名m0进行返回。需要注意，上面的return@m0是一个整体，不能有任何空格。使用label后就可以从lambda中返回，然后继续执行方法体下面的语句。

那么如果不使用label还有什么办法吗？有，使用inline方法即可，如下所示：

//将m0标识为了inline方法
    inline fun m0(param: () -> Unit) {
    }
//测试方法
    fun test() {
        m0 {
            return//正确！
        }
    }

为什么inline方法可以运行return呢？这是正是因为inline方法是会被编译到调用处的方法体中，所以可以使用return。但这也同时意味着，return语句会直接结束掉整个方法的执行，而不会再执行后面的语句。

这也是使用return@label和使用inline return的区别：前者仅仅是从当前label作用域返回，后者则会返回整个方法。

使用inline方法返回的这种形式，就被称为非局部返回。其定义为：位于lambda表达式内，但是可以通过return直接结束其所属方法的执行。

inline修饰的方法都可以用作非局部返回。kotlin标准库中有很多inline方法，如最常用的forEach方法。这些方法都可以用在非局部返回场景中。

//kotlin库定义的forEach方法，是个inline方法
public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit {
    for (element in this) action(element)
}

举个forEach非局部返回的使用场景：比如我们需要实现遇到偶数就结束方法运行的功能，如下所示：

    fun test() {
        listOf(1, 2, 3).forEach {
            if (it % 2 == 0) {//当遇到偶数时就直接返回
                println(it)
                return
            }
            println(it)
        }
    }

上面代码会打印1 2。即当遇到偶数时就直接返回了整个方法。如果forEach不是inline方法，则无法这么使用。

crossinline

来看一个例子：

//定义了一个inline高阶方法m0，接收一个方法类型作为入参
    inline fun m0(checkStr: () -> Unit) {
        object : Runnable {
            override fun run() {
                checkStr()//!!!编译错误
            }
        }.run()
    }

上面代码的场景是这样的：我们不是在inline方法体中直接使用lambda表达式，而是在其方法体内部的匿名对象中使用了lambda表达式。这种场景编译器会报错，不允许这么做！其实想想也是有道理的，因为如果允许checkStr非局部返回的话，那么就会直接结束整个run方法，这可能会带来难以预料的错误。针对这种情况kotlin提供了一个关键字crossinline，使用crossinline修饰的lambda表达式可以应用于方法体的任何地方，如下所示：

    inline fun m0(crossinline  checkStr: () -> Unit) {
        object : Runnable {
            override fun run() {
//由于checkStr被使用了crossinline关键字修饰
//所以可以这么用
                checkStr()
                println("end")
            }
        }.run()
    }

具体化类型参数（Reified type parameters）

kotlin中也有反射，kotlin允许使用反射来访问类型信息，示例如下：

//根据类型获取对应的值，如果匹配我们的类型则返回对应类型的默认值
fun <T> getIntDefValByType(clazz: Class<T>): T? {
    val defVal = 0//Int的默认值为0
    if (clazz.isInstance(defVal)) {//如果传入的是Int则返回defVal
        return defVal as T?
    }
    return null//如果不是Int则返回null
}
//测试方法main
fun main(args: Array<String>) {
    println(getIntDefValByType(Int::class.javaObjectType))//打印 0
    println(getIntDefValByType(String::class.javaObjectType))//打印null
}

上面方法的功能是根据获取Int类型的默认值，如果是类型匹配则返回其默认值0，否则返回null。::class表示获取kotlin中的类型信息，而::class.javaObjectType表示获取java对应的类型信息（也可以使用::class.java，但是::class.java无法返回包裹类型对应的类型信息，而javaObjectType可以），这个方法不具有实际意义，但是说明kotlin支持使用反射来进行类型校验。

上述代码虽然能完成功能，但是使用起来不太优雅，我们还要传入具体的类型，那么有没有更优雅的使用方法？当然有，这就是使用reified关键字。示例如下：

//方法需要使用inline修饰，加上了reified 关键字，
//此时方法不需要Class类型的入参
inline fun <reified T> getIntDefValByType2(): T? {
    val defVal = 0
    if (defVal is T) {//在这里判断是否是T类型即可
        return defVal
    }
    return null
}
//测试方法main
fun main(args: Array<String>) {
    println(getIntDefValByType2<Int>())//打印 0
    println(getIntDefValByType2<String>())//打印 null
}

上面就是reified的用法，其对应的调用形式就显得相对优雅些。最后需要注意的是，reified关键字只能用于inline方法中！

那么reified背后的原理是什么？为什么我们使用reified就无法进行类型判断？

对于泛型，前面kotlin入门潜修之类和对象篇—泛型及其原理这篇文章已经阐述的很详细：kotlin中的泛型同java一样，都会在运行期进行类型擦除，所以我们使用"is T"这种方法来判断类型的时候是不可能的，因为运行时根本就不存在所谓的T类型。那么reified关键字背后又做了什么？

我们来看下reified的背后的字节码实现，首先先把源代码粘贴出来，如下所示：

//要分析的源代码
inline fun <reified T> getIntDefValByType2(): T? {
    val defVal = 0
    if (defVal is T) {
        return defVal
    }
    return null
}
//测试代码
fun main(args: Array<String>) {
    getIntDefValByType2<Int>()//该语句符合getIntDefValByType2所需类型Int（defVal类型）
    getIntDefValByType2<String>()//该语句不符合getIntDefValByType2所需的类型Int（defVal类型）

在来看下其对应的字节码，这里摘录重点的一部分，如下所示：

//这里只摘录了main方法中对应的一部分代码，
    LINENUMBER 121 L9
    ILOAD 1
    INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
    INSTANCEOF java/lang/String
    IFEQ L10

上面字节码摘录了main方法对应的字节码，其实main方法总共就两句源代码，一句是getIntDefValByType2<Int>()，一句是getIntDefValByType2<String>()。因为getIntDefValByType2方法是inline的，所以getIntDefValByType2的实现会被编译到main方法当中。但是通过字节码发现，getIntDefValByType2<String>()语句会加上一句类型判断，即上面粘贴出来的字节码：INSTANCEOF java/lang/String。而getIntDefValByType2<Int>却没有对应的字节码语句。这说明了什么？

是时候总结下reified背后的原理了。reified实际上是作用在编译期间的，由于reified必须用于inline方法中，而对于inline方法实际上是编译到当前代码的调用处，所以在编译的时候编译器就能根据defVal来确认其对应的具体类型了。当T被传入多个类型时（比如Int、String等等），kotlin就会在编译的时候插入INSTANCEOF字节码指令进行类型判断，INSTANCEOF指令会检测是否是指定类的实例，在本例中，如果是则返回defVal，否则返回null。而在INSTANCEOF判断之前，还有一句字节码指令： INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
这句指令表示将Int的值转为java下的Integer类型，并获取其值，这样才有后面INSTANCEOF指令的判断。

内联属性（inline properties）

从kotlin1.1之后，inline关键字可以用于没有后备字段的属性上，如下所示：

class Test {
    val t0: Int = 2//正确，普通的常量（变量定义）
    val t1: Int//正确，可以使用inline修饰get
        inline get() = 1

    var t2: Int//正确
        inline get() = 1
        set(value) {}

    var t3: Int//正确
        inline get() = 3
        inline set(value) {}

    var t4: Int//正确
        get() = 1
        set(value) {}

    var t5: Int//!!!错误，这里显示使用了field字段
        inline get() = 3
        inline set(value) {
            field = value
        }

    inline val t6 = 1//!!!错误，这里默认使用了field字段
    inline var t7 = 2//!!!错误，这里默认使用了field字段

    inline var t8: Int//!!!正确，我们复写了get和set，就没有了field字段
        get() = 1
        set(value) {}
}

上述代码比较容易理解，只需要记住只要有field字段就无法使用inline关键字即可。关于什么时候有field字段，什么时候没有，可记住一句话：只有使用默认的getter(setter)以及显示使用field字段的时候，后备字段才会存在。具体可参见另一篇文章：kotlin入门潜修之类和对象篇—属性和字段

那么inline属性有什么作用？答案是显而易见的：inline属性同inline方法一样会被编译器编译到其调用处，避免了一些开销。

公有内联方法的限制

使用inline方法会有一个潜在的问题，那就是当一个模块调用其他模块的公有inline方法时，由于inline方法会被编译到调用处，所以可能会存在其他模块方法变更，而当前模块没有重新编译的问题。这种问题主要是使用了非公有的inline方法引起的（即公有的inline方法调用了非公有的inline方法），所以kotlin就限制公有的inline方法不能调用非公有的inline方法。如下所示：

//私有inline方法
    private inline fun m0() {}
//默认为public的共有inline方法
    inline fun m1() {}
//internal inline方法
    internal fun m2() {}
//使用@PublishedApi修饰的internal inline方法
    @PublishedApi
    internal fun m3() {}
//测试方法
    inline fun test() {
        m0()//错误，public inline方法无法调用private inline方法
        m1()//正确，public inline方法可以调用public inline方法
        m2()//错误，public inline方法无法调用internal inline方法
        m3()//正确，public inline方法可以调用使用@PublishedApi注解标注的internal inline方法，具体见下面解释。
    }

这里所说的非公有的inline方法是指使用private和internal修饰的方法。而对于internal修饰的方法，如果用户使用了@PublishedApi注解进行了标识，则可以被public inline方法使用，因为使用@PublishedApi注解标识的方法，同public修饰的inline方法一样,编译器会在编译的时候会进行检查。