一、内联函数原理
使用高阶函数为开发带来了便利，但同时也产生了一些性能上的损失，官方是这样描述这个问题：
使用高阶函数会带来一些运行时的效率损失：每一个函数都是一个对象，并且会捕获一个闭包。 即那些在函数体内会访问到的变量。 内存分配（对于函数对象和类）和虚拟调用会引入运行时间开销，但是通过内联化 Lambda 表达式可以消除这类的开销。
为了解决这个问题，可以使用内联函数，用inline修饰的函数就是内联函数，inline修饰符影响函数本身和传给它的 Lambda 表达式，所有这些都将内联到调用处，即编译器会把调用这个函数的地方用这个函数的方法体进行替换，而不是创建一个函数对象并生成一个调用。
接下来用代码验证这个说法，先定义一个普通的高阶函数，然后调用两次：
fun calculate(a: Int, b: Int, cal: (Int, Int) -> String) {
println(cal(a, b))
}
fun main(args: Array<String>) {
calculate(3, 7) { a, b ->
"$a + $b = ${a + b}"
}
calculate(3, 7) { a, b ->
"$a * $b = ${a * b}"
}
}
// 输出
3 + 7 = 10
3 * 7 = 21
这样其实是看不出什么问题的，Kotlin 文件编译后会生成对应的 class 文件，所以我们将 class 文件反编译成 Java 文件后再看。如果使用Android Studio或者IntelliJ IDEA，可以按照如下方式查看 Kotlin 文件对应反编译后的 Java 文件：
- 打开目标 Kotlin 文件
- 查看 Kotlin 文件字节码：Tools –> Kotlin –> Show Kotlin ByteCode
- 在 kotlin 文件字节码页面中点击左上角的 decompile 按钮，就会生成对应的 Java 文件
我们来看上边代码对应的 Java 代码：
虽然不是正常的 Java 代码，但不妨碍我们分析流程，可以看出，编译器创建了两个 Lambda 的实例，并进行了两次
calculate函数调用。
那如果将calculate声明为内联函数呢：
inline fun calculate(a: Int, b: Int, cal: (Int, Int) -> String) {
println(cal(a, b))
}
我们再看最终的 Java 文件：
即编译器会把调用这个函数的地方用这个函数的方法体进行替换，这样验证了之前的说法。
需要注意的是， 内联函数提高代码性能的同时也会导致代码量的增加，所以应避免内联函数过大。
二、禁用内联（noinline）
如果一个内联函数可以接收多个 Lambda 表达式作为参数，默认这些 Lambda 表达式都会被内内联到调用处，如果需要某个 Lambda 表达式不被内联，可以使用noinline修饰对应的函数参数：
inline fun calculate(a: Int, b: Int, noinline title: () -> Unit, cal: (Int, Int) -> String) {
title()
println(cal(a, b))
}
fun main(args: Array<String>) {
calculate(3, 7, { println("开始计算") }) { a, b ->
"$a * $b = ${a * b}"
}
}
// 输出
开始计算
3 * 7 = 21
title对应的 Lambda 确实没有被内联，看图：
一个内联函数没有可内联的函数参数并且没有具体化的类型参数，编译器会有警告，因为这样并不能带来什么好处，如果你不愿去掉内联修饰，可以使用@Suppress("NOTHING_TO_INLINE") 注解关闭这个警告。
三、非局部返回
我们知道默认情况下，在高阶函数中，要显式的退出（返回）一个 Lambda 表达式，需要使用 return@标签的语法，不能使用裸return，但这样也不能使高阶函数和包含高阶函数的函数退出。例如：
fun message(block: () -> Unit) {
block()
println("-----")
}
fun test() {
message {
println("Hello")
return@message
}
println("World")
}
fun main(args: Array<String>) {
test()
}
// 输出
Hello
-----
World
但如果把 Lambda 表达式作为参数传递给一个内联函数，就可以在 Lambda 表达式中正常的使用return语句了，并且会使该内联函数和包含该内联函数的函数退出（返回），这种操作就是非局部返回。例如：
inline fun message(block: () -> Unit) {
block()
println("-----")
}
fun test() {
message {
println("Hello")
return
}
println("World")
}
fun main(args: Array<String>) {
test()
}
// 输出
Hello
注意，由于非局部返回的原因，这里只输出了Hello。
在使用了非局部返回后，Lambda 表达式中return的返回值受调用该内联函数的函数的返回值类型影响。例如：
fun test(): Boolean {
message {
println("Hello")
return false
}
println("World")
return true
}
四、禁用非局部返回（crossinline）
从前边已经知道，通过内联函数可以使 Lambda表达式实现非局部返回，但是，如果一个内联函数的函数类型参数被crossinline修饰，则对应传入的 Lambda表达式将不能非局部返回了，只能局部返回了。还是用之前的例子修改：
inline fun message(crossinline block: () -> Unit) {
block()
println("-----")
}
fun test() {
message {
println("Hello")
return@message
}
println("World")
}
fun main(args: Array<String>) {
test()
}
// 输出
Hello
-----
World
通过crossinline可以禁用掉非局部返回，但有什么意义呢？这其实是有实际的场景需求的，看个例子：
interface Calculator {
fun calculate(a: Int, b: Int): Int
}
inline fun test(block: (Int, Int) -> Int) {
val c = object : Calculator {
override fun calculate(a: Int, b: Int): Int = block(a, b)
}
c.calculate(3, 7)
}
首先定义一个Calculator计算接口，然后在内联函数test中创建Calculator的一个对象表达式，重写calculate方法时，我们让calculate的函数体是test函数的block参数，当block是 Lambda表达式时，由于非局部返回的原因，导致calculate函数的返回值不是预期的，进而发生异常，为了避免这种情况的发生，所以就有必要使用crossinline来禁用非局部返回，来保证calculate的返回值类型是安全的。
上边的代码会有这样一个错误提示：
Can't inline 'block' here: it may contain non-local returns. Add 'crossinline' modifier to parameter declaration 'block'
使用crossinline后就正常了：
inline fun test(crossinline block: (Int, Int) -> Int) {
val c = object : Calculator {
override fun calculate(a: Int, b: Int): Int = block(a, b)
}
c.calculate(3, 7)
}
五、具体化的类型参数（reified）
对于一个泛型函数，如果需要访问泛型参数的类型，但由于泛型类型被擦除的原因，可能无法直接访问，但通过反射还是可以做到的，例如：
fun <T> test(param: Any, clazz: Class<T>) {
if (clazz.isInstance(param)) {
println("参数类型匹配")
} else {
println("参数类型不匹配")
}
}
fun main(args: Array<String>) {
test("Hello World", String::class.java)
test(666, String::class.java)
}
// 输出
参数类型匹配
参数类型不匹配
功能虽然实现了，但是不够优雅，Kotlin 中有更好的办法来实现这样的功能。
在内联函数中支持具体化的参数类型，即用reified来修饰需要具体化的参数类型，这样我们用reified来修饰泛型的参数类型，以达到我们的目的：
inline fun <reified T> test(param: Any) {
if (param is T) {
println("参数类型匹配")
} else {
println("参数类型不匹配")
}
}
调用的过程也变得简单了：
fun main(args: Array<String>) {
test<String>("Hello World")
test<String>(666)
}
