Kotlin使用优化（四）

上回我们聊到Kotlin的属性访问，编译器确实默默帮我们做了很多事情，隐藏的事情越多，潜在开销的可能性就越大，好在，我们通过分析知道了可能的优化点，这一节我们以此为基础做一些延申。

相信大家在使用第三方SDK的时候，都需要在Application里面初始化，它们需要一个Context对象，我们通常声明一个成员变量然后在onCreate方法里面初始它们，但是Kotlin里面对象有Nullable跟NonNull的区别，我们明知道下次在使用这个对象的时候它不可能为空，还是得一遍遍的检查它是否赋值，否则编译器就会发出警告。

Kotlin提供了一个便利的语法糖lateinit，使用它，我们依然可以在onCreate里面初始化对象，同时把对象声明成NonNull。来看个例子：

class Main {
    private lateinit var name: String
    
    fun onCreate() {
        name = "王小明"
  }
}

从字节码来看，这被编译成一个普通的Java字段：

public final class Main {


  // access flags 0x2
  private Ljava/lang/String; name

  // access flags 0x11
  public final onCreate()V
   L0
    LINENUMBER 6 L0
    ALOAD 0
    LDC "\u738b\u5c0f\u660e"
    PUTFIELD Main.name : Ljava/lang/String;
   L1
    LINENUMBER 7 L1
    RETURN
   L2
    LOCALVARIABLE this LMain; L0 L2 0
    MAXSTACK = 2
    MAXLOCALS = 1

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

但是，当我们使用这个name字段的时候：

fun onCreate() {
    name = "王小明"
  print(name)
}

编译器会做额外的检查：

 LINENUMBER 4 L0
    ALOAD 0
    LDC "\u738b\u5c0f\u660e"
    PUTFIELD Main.name : Ljava/lang/String;
   L1
    LINENUMBER 5 L1
    ALOAD 0
    GETFIELD Main.name : Ljava/lang/String;
    DUP
    IFNONNULL L2
    LDC "name"
    INVOKESTATIC kotlin/jvm/internal/Intrinsics.throwUninitializedPropertyAccessException (Ljava/lang/String;)V
   L2
    ASTORE 1
   L3
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ALOAD 1
    INVOKEVIRTUAL java/io/PrintStream.print (Ljava/lang/Object;)V
   L4
   L5
    LINENUMBER 6 L5
    RETURN
   L6
    LOCALVARIABLE this LMain; L0 L6 0
    MAXSTACK = 2
    MAXLOCALS = 2

主要是这里：

 LINENUMBER 5 L1
    ALOAD 0
    GETFIELD Main.name : Ljava/lang/String;
    DUP
    IFNONNULL L2
    LDC "name"
    INVOKESTATIC kotlin/jvm/internal/Intrinsics.throwUninitializedPropertyAccessException (Ljava/lang/String;)V

我们可以看到，每次我们访问这个字段，编译器会检查这个字段是否已经初始化，我们可以减少检查的次数，笨方法就是在使用前把它赋值给一个本地变量：

fun onCreate() {
    name = "王小明"
  val value = name
  print(value)
    print(value)
}

这样编译器只会在我们给value赋值时检查name是否已初始化，我们后来再使用本地变量value也不会有额外的开销：

// access flags 0x11
  public final onCreate()V
   L0
    LINENUMBER 4 L0
    ALOAD 0
    LDC "\u738b\u5c0f\u660e"
    PUTFIELD Main.name : Ljava/lang/String;
   L1
    LINENUMBER 5 L1
    ALOAD 0
    GETFIELD Main.name : Ljava/lang/String;
    DUP
    IFNONNULL L2
    LDC "name"
    INVOKESTATIC kotlin/jvm/internal/Intrinsics.throwUninitializedPropertyAccessException (Ljava/lang/String;)V
   L2
    ASTORE 1
   L3
    LINENUMBER 6 L3
   L4
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ALOAD 1
    INVOKEVIRTUAL java/io/PrintStream.print (Ljava/lang/Object;)V
   L5
   L6
    LINENUMBER 7 L6
   L7
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ALOAD 1
    INVOKEVIRTUAL java/io/PrintStream.print (Ljava/lang/Object;)V
   L8
   L9
    LINENUMBER 8 L9
    RETURN
   L10
    LOCALVARIABLE value Ljava/lang/String; L3 L10 1
    LOCALVARIABLE this LMain; L0 L10 0
    MAXSTACK = 2
    MAXLOCALS = 2

从字节码里就可以看出这一点。

要更优雅一些，我们可以使用also扩展方法这样：

fun onCreate() {
    name = "王小明"
    name.also {  
    
     } 
   }

这样编译器也只会做一次检查，原因不再赘述。

这种使用外部定义的成员的场景比较常见，我们甚至经常会在内部类里面访问外部类的成员。

class Main {
    private var name = "王小明"    
    inner class Inner {
        fun printName() {
            print(name)
        }
    }
}

来看看反编译的Java代码：

public final class Main {
   private String name = "王小明";    // $FF: synthetic method
  public static final void access$setName$p(Main $this, String var1) {
      $this.name = var1;
  }

   public final class Inner {
      public final void printName() {
         String var1 = Main.this.name;
         System.out.print(var1);
  }
   }
}

编译器生成了两个类，还生成了一些特殊的方法让内部类来访问Main类的私有成员，我们也可以看到printName方法最终就是调用这个生成的方法来获取name的值的：

// access flags 0x11
  public final printName()V
   L0
    LINENUMBER 6 L0
    ALOAD 0
    GETFIELD Main$Inner.this$0 : LMain;
    INVOKESTATIC Main.access$getName$p (LMain;)Ljava/lang/String;
    ASTORE 1
   L1
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ALOAD 1
    INVOKEVIRTUAL java/io/PrintStream.print (Ljava/lang/Object;)V
   L2
   L3
    LINENUMBER 7 L3
    RETURN
   L4
    LOCALVARIABLE this LMain$Inner; L0 L4 0
    MAXSTACK = 2
    MAXLOCALS = 2

如果我们把name声明成public呢？

 // access flags 0x2
  private Ljava/lang/String; name
  @Lorg/jetbrains/annotations/NotNull;() // invisible

很遗憾，编译器还是帮我们编译成私有成员，然后生成get，set方法，然后还是调用方法去获取name的值。

 L0
    LINENUMBER 6 L0
    ALOAD 0
    GETFIELD Main$Inner.this$0 : LMain;
    INVOKEVIRTUAL Main.getName ()Ljava/lang/String;
    ASTORE 1

我还不信了，声明成public你还给我直接访问，还要给我生成get，set方法？

于是我又给name加上了@JvmField注解，没错，我总是想搞事情，哈哈

public final class Main {
   @JvmField
   @NotNull  
 public String name = "王小明";   
   public final class Inner {
      public final void printName() {
         String var1 = Main.this.name;
  System.out.print(var1);
  }
   }
}

就结果而言，我是满意的，这下编译器终于不会悄咪咪地给我生成额外的方法了。

今天的故事，到这里差不多就要结束了，下回，我们来说说让Kotlin看起来不那么OOP的伴生对象的坑，期待吧？ 快来关注我吧！