Kotlin 扩展函数与内联函数

Kotlin扩展函数

Kotlin 的扩展函数是 Kotlin 中非常强盛且实用的功能。它答应你为现有的类添加新的方法，而不需要修改其源代码。这意味着你可以在已有的类上“扩展”新的功能，使用起来就像是本来就存在这些方法一样。
扩展函数的基本语法

1. fun 类名.方法名(参数列表): 返回类型 {
2.     // 函数体
3. }

复制代码

我们去看看Kotlin官方为我们实现的扩展函数例子，就拿官方对Float的扩展方法pow()举例，Float类自己并没有实现乘方功能的方法，在没有这个方法之前，我们只能使用Math类的静态方法进行乘方运算：

1. Math.pow(2.0, 2.0）

复制代码

当我们在Kotlin中这样写，编译器会提示我们：

这里告诉我们我们可以用Kotlin的函数如下：

1. 2.0.pow(2.0)
3. //pow函数的实现
4. public actual inline fun Double.pow(x: Double): Double = nativeMath.pow(this, x)

复制代码

我们看到这个pow函数是Kotlin对Double类的扩展。我们也可以自己多现有的类进行扩展，例如我们需要打印字符串的最后一个字符，我们可以对String类进行扩展：

1. fun String.printLastChar() {
2.     println(this[length - 1])
3. }
5. fun main() {
6.         //对扩展函数的调用
7.     "Hello".printLastChar()
8.     //取函数的引用使用invoke进行调用
9.            String::printLastChar.invoke("Hello")
10.            //直接调用函数引用
11.            (String::printLastChar)("Hello")
12. }

复制代码

扩展函数的作用域

扩展函数可以定义在Kotlin文件中，是其不属于任何一个类，其他地方都可以使用，类似于上面的String.printLastChar()方法；另外一种是可以声明在类中:

1. class ExtensionsSample{
3.     fun normalFun(){
4.         "Java".printLastChar()
5.         "Kotlin".printFirstChar()
6.     }
7.        
8.     private fun String.printFirstChar() {
9.         println(this[0])
10.     }
11. }

复制代码

假如扩展函数定义在某个类中，而定义在类中，printFirstChar()方法便是ExtensionsSample类的成员函数，同时又是String类的扩展函数，String类是这个扩展函数的Receiver，定义在类中的扩展函数的作用范围是类及其内部类。在kotlin中也无法通过对象调用定义在其内部的扩展方法，便是限定符是默认的public。
扩展函数的原理

我们对扩展函数所在的文件进行反编译，看其生成的字节码文件反编译的结果如下：

1. public final void printFirstChar(@NotNull String $this$printFirstChar) {
2.    Intrinsics.checkNotNullParameter($this$printFirstChar, "$this$printFirstChar");
3.    char var2 = $this$printFirstChar.charAt(0);
4.    System.out.println(var2);
5. }

复制代码

扩展函数并不是修改原有类的实际代码，它是在编译时通过生成额外的代码来实现的。固然你能通过扩展函数像访问原有方法一样调用新方法，但它们实际上并没有改变原有类的行为。扩展函数只是通过静态解析（编译时确定类型）来实现的。
因此，扩展函数无法真正覆盖或修改类中的已有方法，也不能访问类的私有成员。
Kotlin扩展属性

Kotlin 还支持扩展属性，它可以为类添加属性，但只能是可读属性（即没有 setter 方法），因为扩展属性不能存储实际的数据。

1. val 类名.属性名: 类型
2.     get() = // 计算属性的值

复制代码

1. val String.lastChar: Char
2.     get() = this[this.length - 1]
4. fun main() {
5.     println("HelloWorld".lastChar)
6. }

复制代码

在某些情况下，我们不需要扩展方法，只需要扩展属性即可。
inline

Kotlin官方文档在先容inline关键字中写道使用不当是会有肯定的性能问题的，官方的原话是这样先容：
Using higher-order functions imposes certain runtime penalties: each function is an object, and it captures a closure. A closure is a scope of variables that can be accessed in the body of the function. Memory allocations (both for function objects and classes) and virtual calls introduce runtime overhead.
使用高阶函数会带来一些运行时的服从丧失：每一个函数都是一个对象，并且会捕获一个闭包。 闭包那些在函数体内会访问到的变量的作用域。 内存分配（对于函数对象和类）和假造调用会引入运行时间开销。但是在许多情况下通过内联化 lambda 表达式可以消除这类的开销。

• 使用 inline 修饰的函数，会在调用点处将函数的代码“睁开”（也叫内联），而不是生成一个实际的函数调用。这意味着函数体的代码会直接插入到调用它的地方，这克制了函数调用所带来的栈帧创建和返回的性能开销。
  
• 高阶函数指的是接受另一个函数作为参数的函数。在没有 inline 时，传入的函数会在堆栈上创建一个对象，并通过引用进行调用，这会导致额外的内存分配和垃圾回收。使用 inline 后，传入的函数会直接嵌入到调用点，克制了创建和通报函数对象的开销。
  
• 由于内联函数的代码直接插入到调用的地方，Kotlin 会克制为这些高阶函数（例如 lambda 表达式）分配对象，从而淘汰了内存的斲丧。
  

假如一个高阶函数在循环中被调用，或者在Android中的onDraw方法中调用，高阶函数在实行的过程中就会创建暂时对象，短时间创建大量对象，并且这些对象的生命周期都很短，就会造成内存抖动

1. fun main() {
2.     highOrder(5) {
3.         println(it)
4.         it
5.     }
6. }
8. fun highOrder(number: Int, callBack: (Int) -> Int) {
9.     callBack(number + 1)
10. }

复制代码

我们对上面的文件进行反编译可以发现确实是在实行的时间是通过Function1
这个类来实现我们的高阶函数传入的函数

1. public static final void main() {
2.    highOrder(5, (Function1)null.INSTANCE);
3. }
5. // $FF: synthetic method
6. public static void main(String[] var0) {
7.    main();
8. }
10. public static final void highOrder(int number, @NotNull Function1 callBack) {
11.    Intrinsics.checkNotNullParameter(callBack, "callBack");
12.    callBack.invoke(number + 1);
13. }

复制代码

而我们给高阶函数添加highOrder前面添加关键字inline之后，让他变成内联函数在颠末反编译可以看到：

1. public static final void main() {
2.    int number$iv = 5;
3.    int $i$f$highOrder = false;
4.    int it = number$iv + 1;
5.    int var3 = false;
6.    System.out.println(it);
7. }

复制代码

而这里就是直接把我们传入的lambda表达式具体的实行逻辑直接放到了这里，由此可见inline关键字的主要作用就是淘汰调用栈的深度，并能够优化高阶函数在实行时的性能问题。
noinline

假如不希望内联全部传给内联函数的 lambda 表达式参数都内联，那么可以用 noinline 修饰符标记不希望内联的函数参数：

1. inline fun foo(inlined: () -> Unit, noinline notInlined: () -> Unit) { …… }

复制代码

假设有一种场景，你的高阶函数传入了两个函数参数，你希望其中的一个函数参数以函数引用的方式作为返回值，就可以使用到noinline关键字：

1. inline fun foo(callBack: (Int) -> Int, noinline result: () -> Unit): () -> Unit {
2.     callBack(2)
3.     return result
4. }

复制代码

noinline的作用就是局部的、有指向性的关闭Kotlin的内联优化。
crossinline

我们先来看一段代码：

1. fun main() {
2.     println("This is before of heightFunc")
3.     heightFunc {
4.         return@heightFunc
5.     }
6.     println("This is after of heightFunc")
7. }
9. fun heightFunc(call: () -> Unit) {
10.     call()
11.     println("This is inner of heightFunc")
12. }

复制代码

这样写全部的打印的地方都会实行，而使用inline关键字标记heightFunc函数之后，并且去掉return的标签，那么结果就发生了改变

1. fun main() {
2.     println("This is before of heightFunc")
3.     heightFunc {
4.         return
5.     }
6.     println("This is after of heightFunc")
7. }
9. fun heightFunc(call: () -> Unit) {
10.     call()
11.     println("This is inner of heightFunc")
12. }

复制代码

最终的实行结果为只打印了This is before of heightFunc，我们通过内联函数的优化可以想到其中的原因。
当我们需要在内联函数中心接的调用传入的lambda表达式时，编译器会给我们如下提示：

而我们在表面调用内联函数，在lambda表达式中使用return的时间，是不被答应的，要使用必须加标签体现的指定退出那个函数

所以crossinline的作用就是假如你希望克制 lambda 中的 return 语句影响外部函数的实行，可以使用 crossinline。这块lambda中的return和内联函数结合起来使用具体得多写，编译器会给出提示。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。