kotlin入门潜修之进阶篇—高阶方法和lambda表达式原理

最新推荐文章于 2023-03-14 13:41:59 发布

寒潇2018

最新推荐文章于 2023-03-14 13:41:59 发布

阅读量284

点赞数

本文链接：https://blog.csdn.net/lv1317039693/article/details/103167095

版权

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

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

写在前面

疑者,觉悟之机也。一番觉悟,一番长进。——与君共勉。

高阶方法及lambda表达式原理

照例，先看下我们要分析的源代码片段。如下所示：

class Test {
//定义了一个高阶方法m0
    fun m0(checkStr: () -> String) {
        checkStr()
    }
//测试方法，用于测试m0
    fun test(){
        m0 {  -> "return a str" }//采用lambda表达式实例化方法类型
    }
}

一个最简单的高阶方法及lambda表达式的示例，来看下对应的字节码，照例先全部粘贴下:

public final class Test {


  // access flags 0x11
  // signature (Lkotlin/jvm/functions/Function0<Ljava/lang/String;>;)V
  // declaration: void m0(kotlin.jvm.functions.Function0<java.lang.String>)
  public final m0(Lkotlin/jvm/functions/Function0;)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
    ALOAD 1
    INVOKEINTERFACE kotlin/jvm/functions/Function0.invoke ()Ljava/lang/Object;
    POP
   L2
    LINENUMBER 4 L2
    RETURN
   L3
    LOCALVARIABLE this LTest; L0 L3 0
    LOCALVARIABLE checkStr Lkotlin/jvm/functions/Function0; L0 L3 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x11
  public final test()V
   L0
    LINENUMBER 7 L0
    ALOAD 0
    GETSTATIC Test$test$1.INSTANCE : LTest$test$1;
    CHECKCAST kotlin/jvm/functions/Function0
    INVOKEVIRTUAL Test.m0 (Lkotlin/jvm/functions/Function0;)V
   L1
    LINENUMBER 8 L1
    RETURN
   L2
    LOCALVARIABLE this LTest; L0 L2 0
    MAXSTACK = 2
    MAXLOCALS = 1

  // 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
  // access flags 0x18
  final static INNERCLASS Test$test$1 null null
  // compiled from: Main.kt
}


// ================Test$test$1.class =================
// class version 50.0 (50)
// access flags 0x30
// signature Lkotlin/jvm/internal/Lambda;Lkotlin/jvm/functions/Function0<Ljava/lang/String;>;
// declaration: Test$test$1 extends kotlin.jvm.internal.Lambda implements kotlin.jvm.functions.Function0<java.lang.String>
final class Test$test$1 extends kotlin/jvm/internal/Lambda  implements kotlin/jvm/functions/Function0  {


  // access flags 0x1041
  public synthetic bridge invoke()Ljava/lang/Object;
   L0
    LINENUMBER 1 L0
    ALOAD 0
    INVOKEVIRTUAL Test$test$1.invoke ()Ljava/lang/String;
    ARETURN
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x11
  public final invoke()Ljava/lang/String;
  @Lorg/jetbrains/annotations/NotNull;() // invisible
   L0
    LINENUMBER 7 L0
    LDC "return a str"
   L1
    ARETURN
   L2
    LOCALVARIABLE this LTest$test$1; L0 L2 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x0
  <init>()V
    ALOAD 0
    ICONST_0
    INVOKESPECIAL kotlin/jvm/internal/Lambda.<init> (I)V
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 1

  // access flags 0x19
  public final static LTest$test$1; INSTANCE

  // access flags 0x8
  static <clinit>()V
    NEW Test$test$1
    DUP
    INVOKESPECIAL Test$test$1.<init> ()V
    PUTSTATIC Test$test$1.INSTANCE : LTest$test$1;
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 0
  OUTERCLASS Test test ()V
  // access flags 0x18
  final static INNERCLASS Test$test$1 null null
  // compiled from: Main.kt
}

字节码比较长，这里照例分割成几个部分来进行阐述。

高阶方法中的方法类型实际上会被编译成Function类型，在本例中的类型就是Function0，其对应的字节码如下所示：

  public final m0(Lkotlin/jvm/functions/Function0;)V

这就是kotlin中对方法类型的处理，那么是所有的方法类型都会被编译成Function0吗？当然不是，kotlin会根据方法类型的参数个数来做相应的处理，比如现在方法类型有1个入参，则就会被编译成Function1类型，有2个入参就会被编译成Function2类型，一次类推。下面我粘贴一个有两个入参的字节码编译案例：

//源代码m0，其入参是有两个参数的方法类型
    fun m0(checkStr: (str1:String, str2:String) -> String) {
    }
//编译后对应的字节码，从中可知，
//两个参数的方法类型被编译成了Function2类型
  public final m0(Lkotlin/jvm/functions/Function2;)V

事实上，我们不从字节码的角度也能发现这个规律，kotlin所有的方法类型都会被处理成Function家族类型，只不过参数个数不同，对应的具体的Function类型不同而已，这个可以通过kotlin.jvm.functions包下的接口定义得到确认，如下所示：

package kotlin.jvm.functions

/** A function that takes 0 arguments. */
public interface Function0<out R> : Function<R> {
    /** Invokes the function. */
    public operator fun invoke(): R
}
/** A function that takes 1 argument. */
public interface Function1<in P1, out R> : Function<R> {
    /** Invokes the function with the specified argument. */
    public operator fun invoke(p1: P1): R
}
/** A function that takes 2 arguments. */
public interface Function2<in P1, in P2, out R> : Function<R> {
    /** Invokes the function with the specified arguments. */
    public operator fun invoke(p1: P1, p2: P2): R
}
//中间省略n个Function类型
.........................................................
.........................................................
//第21个参数对应的Function类型
/** A function that takes 21 arguments. */
public interface Function21<in P1, in P2, in P3, in P4, in P5, in P6, in P7, in P8, in P9, in P10, in P11, in P12, in P13, in P14, in P15, in P16, in P17, in P18, in P19, in P20, in P21, out R> : Function<R> {
    /** Invokes the function with the specified arguments. */
    public operator fun invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, p15: P15, p16: P16, p17: P17, p18: P18, p19: P19, p20: P20, p21: P21): R
}
/** A function that takes 22 arguments. */
public interface Function22<in P1, in P2, in P3, in P4, in P5, in P6, in P7, in P8, in P9, in P10, in P11, in P12, in P13, in P14, in P15, in P16, in P17, in P18, in P19, in P20, in P21, in P22, out R> : Function<R> {
    /** Invokes the function with the specified arguments. */
    public operator fun invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, p15: P15, p16: P16, p17: P17, p18: P18, p19: P19, p20: P20, p21: P21, p22: P22): R
}

由上面的代码可知，kotlin最多支持定义有22个入参的方法类型。这些方法都有一个共同的Function<R>，Function<R>代表的正是方法类型。除此之外，每个方法类型都提供了一个包含有对应参数个数的invoke操作符。

在m0方法中调用传入的方法类型实例的时候，实际上就是通过方法的invoke来完成调用的，对应的字节码摘录如下：

   L1
    LINENUMBER 3 L1
    ALOAD 1
    INVOKEINTERFACE 
kotlin/jvm/functions/Function0.invoke ()Ljava/lang/Object;
    POP
   L2

有上述代码可知，kotlin最终是通过Function0.invoke ()来完成了checkStr方法的调用。

kotlin会为lambda表达式生成一个新类，类名为自己所处的类名（Test）+ 所处的方法名（test）+ 数字（从1开始，有多个则依次递增）。该类继承了Lambda类并实现了对应的Function接口。字节码如下所示：

//生成的新类继承了Lambda类，并实现了Function0接口
final class Test$test$2 extends kotlin/jvm/internal/Lambda  implements kotlin/jvm/functions/Function0  {

Lambda类实际上没有什么东西，就是提供了lambda参数数量的入口：getArity。而Function0正是我们上面提到的有invoke入口的接口。

当调用方法m0的时候，传入的lambda实例，实际上就是通过上述生成的新类实例完成的。而且实际调用的时候也正是通过上述生成的新类的invoke方法完成调用的，对应的字节码如下所示：

//test方法对应的字节码
// access flags 0x11
  public final test()V
   L0
    LINENUMBER 7 L0
    ALOAD 0
//这里实际上是调用了生成类LTest$test$1的实例
    GETSTATIC Test$test$1.INSTANCE : LTest$test$1;
    CHECKCAST kotlin/jvm/functions/Function0
    INVOKEVIRTUAL Test.m0 (Lkotlin/jvm/functions/Function0;)V//将LTest$test$1实例传入方法m0
   L1

步骤4中提到的INSTANCE，实际上是kotlin为lambda表达式生成的新类、提供了一个单例对象。该单例对象是在该类的类构造方法中完成初始化的，如下所示：

//本例中Test$test$1的成员属性INSTANCE
  public final static LTest$test$1; INSTANCE
//Test$test$1的类构造方法
  static <clinit>()V
    NEW Test$test$1
    DUP
//这里调用了类的实例构造方法，即生成了一个Test$test$1对象
    INVOKESPECIAL Test$test$1.<init> ()V
//这里完成了对INSTANCE的赋值，其值正式上面生成的新对象
    PUTSTATIC Test$test$1.INSTANCE : LTest$test$1;
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 0

在kotlin为我们生成的Test$test$1类中的invoke方法中，正式完成了方法实例对应的实现，如下所示：

//这里就是invoke的实现，lambda表达式实例对应的实现
//就是在这里。
  public final invoke()Ljava/lang/String;
  @Lorg/jetbrains/annotations/NotNull;() // invisible
   L0
    LINENUMBER 7 L0
    LDC "return a str"
   L1
    ARETURN
   L2
    LOCALVARIABLE this LTest$test$1; L0 L2 0
    MAXSTACK = 1
    MAXLOCALS = 1

至此，高阶方法与lambda背后的原理产生完毕。下面看下匿名方法的实现原理。

匿名方法背后的原理

我们将上述代码的调用改成匿名方法的实现，如下所示：

//将m0方法的调用改成传入匿名方法实例方式
    fun test() {
        m0(fun(): String { return "return a str" })
    }

通过查看对应的字节码发现，匿名方法和lambda表达式对应的字节码完全一样，重要的字节码摘录如下所示：

//同样生成了一个新类，同lambda表达式一致
final class Test$test$1 extends kotlin/jvm/internal/Lambda  implements kotlin/jvm/functions/Function0  {
// 也提供了一个单例实现
public final static LTest$test$1; INSTANCE
//匿名方法的实现也在invoke完成
 public final invoke()Ljava/lang/String;
  @Lorg/jetbrains/annotations/NotNull;() // invisible
   L0
    LINENUMBER 7 L0
    LDC "return a str"
    ARETURN
   L1
    LOCALVARIABLE this LTest$test$1; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1
//等等...

上面省略了一些分析，最终总结一句话，匿名方法和lambda表达式实现一致。

闭包的访问原理

在上篇高阶方法及lambda表达式中，我们提到了闭包的概念，那么为什么lambda表达式和匿名方法能够自由访问外部作用域中的成员呢？本小节来分析下原因。
首先附上我们要分析的源代码：

class Test {
//为了更能说服问题，这里提供了一个private的私有属性
    private val str:String = "test"
    fun m0(checkStr: () -> String) {
    }
//测试方法，这里完成了对外部作用域的访问，即$str
    fun test() {
        m0(fun(): String { return "return a $str" })
    }
}

上述代码生成的字节码这里不再全部粘贴，直接捡重点的来看下：

kotlin编译器会为私有是成员str生成一个公有的访问方法，对应字节码如下所示：

//位于Test类中，由编译器为我们自动生成的访问str的共有方法
  public final static synthetic access$getStr$p(LTest;)Ljava/lang/String;
  @Lorg/jetbrains/annotations/NotNull;() // invisible
   L0
    LINENUMBER 1 L0
    ALOAD 0
    GETFIELD Test.str : Ljava/lang/String;
    ARETURN
   L1
    LOCALVARIABLE $this LTest; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

在生成的新类中，会持有Test类的引用，并在实例构造方法中将传入的Test类对象赋值给了Test$test$1.this$0，对应字节码如下所示：

//位于生成的Test$test$1类中
  <init>(LTest;)V
    ALOAD 0
    ALOAD 1
//这里实际上将传入的Test对象赋值给了Test$test$1.this$0
    PUTFIELD Test$test$1.this$0 : LTest;
    ALOAD 0
    ICONST_0
    INVOKESPECIAL kotlin/jvm/internal/Lambda.<init> (I)V
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 2

步骤2中的Test对象，实际上是在test方法调用的时候生成的，对应的字节码如下所示：

//test方法对应的字节码
  public final test()V
   L0
    LINENUMBER 7 L0
    ALOAD 0
    NEW Test$test$1//生成一个新的Test$test$1对象
    DUP
    ALOAD 0
//这句字节码表示传入了Test对象this
    INVOKESPECIAL Test$test$1.<init> (LTest;)V
    CHECKCAST kotlin/jvm/functions/Function0
    INVOKEVIRTUAL Test.m0 (Lkotlin/jvm/functions/Function0;)V

kotlin正式通过上述三个步骤完成了对闭包环境下的访问，因为方法体实现都在新生成类中的invoke中，所以其对应的字节码如下所示：

  public final invoke()Ljava/lang/String;
  @Lorg/jetbrains/annotations/NotNull;() // invisible
   L0
    LINENUMBER 7 L0
    NEW java/lang/StringBuilder
    DUP
    INVOKESPECIAL java/lang/StringBuilder.<init> ()V
    LDC "return a "
    INVOKEVIRTUAL java/lang/StringBuilder.append (Ljava/lang/String;)Ljava/lang/StringBuilder;
    ALOAD 0
    GETFIELD Test$test$1.this$0 : LTest;
//这里完成了对str的访问
    INVOKESTATIC Test.access$getStr$p (LTest;)Ljava/lang/String;
    INVOKEVIRTUAL java/lang/StringBuilder.append (Ljava/lang/String;)Ljava/lang/StringBuilder;
    INVOKEVIRTUAL java/lang/StringBuilder.toString ()Ljava/lang/String;
    ARETURN

上面代码最主要有两句，这里再次摘录如下：

//获取Test$test$1.this$0实例
GETFIELD Test$test$1.this$0 : LTest;
//这里通过生成的共有方法access$getStr$p 完成了对str的访问
    INVOKESTATIC Test.access$getStr$p (LTest;)Ljava/lang/String;

至此，高阶方法相关的原理分析完毕。

寒潇2018

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
kotlin入门潜修之进阶篇—高阶方法和lambda表达式原理

本文收录于 kotlin入门潜修专题系列，欢迎学习交流。创作不易，如有转载，还请备注。写在前面疑者,觉悟之机也。一番觉悟,一番长进。——与君共勉。高阶方法及lambda表达式原理照例，先看下我们要分析的源代码片段。如下所示：class Test {//定义了一个高阶方法m0 fun m0(checkStr: () -> String) { ...
复制链接

扫一扫