# Kotlin使用优化（四）

曾经终败给现在 2022-01-18 20:15 323阅读 0赞

上回我们聊到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的伴生对象的坑，期待吧？

转载于:https://juejin.im/post/5c9a3bb4f265da60c833f57d