你说你会用Companion object?恐怕不是!

初次接触Kotlin的时候,觉得这才是一门真正的OOP语言,就连基本类型,它也是一个类。后来遇到了一些在Java里面用静态成员实现很方便的场景,完全的OOP让我无所适从,于是我找到了(Companion object)伴生对象。

使用方法大概如下:

class Main private constructor(){
    private var id: Int? = null   
    companion object {
        var previousId = -1    
        fun newInstance(): Main {
            val instance = Main()
            instance.id = previousId++
        }
    }

    fun main(args: Array) {
        val main = Main.newInstance()
        print((Main.previousId)
    }
}
复制代码

这是一个工厂方法,用起来还是跟Java的静态成员很相似的,但是我们得记住了,这些字段其实是其他对象的成员。(不用说,编译器又偷偷地帮我们做了一些事)

乍一看好像没什么问题,我们Java代码也是这么写的,读者们可能要问我了,怎么就只知道伴生对象就不行了,不就这点儿用法吗?

别急,我们来扒一扒字节码:

 // access flags 0x8
  static ()V
    NEW Main$Companion
    DUP
    ACONST_NULL
    INVOKESPECIAL Main$Companion. (Lkotlin/jvm/internal/DefaultConstructorMarker;)V
    PUTSTATIC Main.Companion : LMain$Companion;
   L0
    LINENUMBER 5 L0
    ICONST_M1
    PUTSTATIC Main.previousId : I
    RETURN
    MAXSTACK = 3
    MAXLOCALS = 0

复制代码

我们看到这一段,Main类在加载的时候,创建了一个Main$Companion类的对象,这也就证实了,伴生对象确实是一个对象,我们当成主类静态成员使用的那些成员,都是这个对象的成员。

那我们来看看编译器给我们生成的这个类的字节码:

 // access flags 0x2
  private ()V
   L0
    LINENUMBER 4 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object. ()V
    RETURN
   L1
    LOCALVARIABLE this LMain$Companion; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1001
  public synthetic (Lkotlin/jvm/internal/DefaultConstructorMarker;)V
   L0
    LINENUMBER 4 L0
    ALOAD 0
    INVOKESPECIAL Main$Companion. ()V
    RETURN
   L1
    LOCALVARIABLE this LMain$Companion; L0 L1 0
    LOCALVARIABLE $constructor_marker Lkotlin/jvm/internal/DefaultConstructorMarker; L0 L1 1
    MAXSTACK = 1
    MAXLOCALS = 2
复制代码

我们可以看到,除了默认的构造函数,编译器还给它合成了一个新的构造函数。

此外它还生成了get,set方法来访问previousId字段,给对象成员生成get,set函数,这也都是正常的。


  // access flags 0x11
  public final getPreviousId()I
   L0
    LINENUMBER 5 L0
    INVOKESTATIC Main.access$getPreviousId$cp ()I
    IRETURN
   L1
    LOCALVARIABLE this LMain$Companion; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x11
  public final setPreviousId(I)V
    // annotable parameter count: 1 (visible)
    // annotable parameter count: 1 (invisible)
   L0
    LINENUMBER 5 L0
    ILOAD 1
    INVOKESTATIC Main.access$setPreviousId$cp (I)V
    RETURN
   L1
    LOCALVARIABLE this LMain$Companion; L0 L1 0
    LOCALVARIABLE  I L0 L1 1
    MAXSTACK = 1
    MAXLOCALS = 2
复制代码

等等!怎么还有INVOKESTATIC 指令!我定睛一看,怎么又去调用Main的静态方法了,回过头去看Main的字节码,果然,有这样的方法:

 // access flags 0x1019
  public final static synthetic access$getPreviousId$cp()I
   L0
    LINENUMBER 1 L0
    GETSTATIC Main.previousId : I
    IRETURN
   L1
    MAXSTACK = 1
    MAXLOCALS = 0

  // access flags 0x1019
  public final static synthetic access$setPreviousId$cp(I)V
   L0
    LINENUMBER 1 L0
    ILOAD 0
    PUTSTATIC Main.previousId : I
    RETURN
   L1
    LOCALVARIABLE  I L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1
复制代码

难受了,一通OOP的操作下来,各种方法调用,最后居然还是给Main生成了静态成员,而且还生成了方法来访问id:

// access flags 0x1019
  public final static synthetic access$getId$p(LMain;)Ljava/lang/Integer;
   L0
    LINENUMBER 1 L0
    ALOAD 0
    GETFIELD Main.id : Ljava/lang/Integer;
    ARETURN
   L1
    LOCALVARIABLE $this LMain; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1019
  public final static synthetic access$setId$p(LMain;Ljava/lang/Integer;)V
   L0
    LINENUMBER 1 L0
    ALOAD 0
    ALOAD 1
    PUTFIELD Main.id : Ljava/lang/Integer;
    RETURN
   L1
    LOCALVARIABLE $this LMain; L0 L1 0
    LOCALVARIABLE  Ljava/lang/Integer; L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2
复制代码

我就想实现一个基本的工厂方法,有必要给我生成这么多方法吗?我肯定闲不住的,我又开始捣鼓了:previousId是个静态成员,那就想办法让它成为一个真正的静态成员,newInstance方法本意也是一个静态的创建对象的方法。

@file:JvmName("Main")

@JvmField 
var previousId = -1  
 
class Main private constructor() {
    private var id: Int? = null   
    
    companion object {

        @JvmStatic
 fun newInstance(): Main {
            val instance = Main()
            instance.id = previousId++
        }
    }

    fun main(args: Array) {
        val main = Main.newInstance()
        print((previousId)
    }
}
复制代码

我在之前已经跟大家讨论过顶级成员配合@JvmField的效果,@file:JvmName通知编译器所有顶级成员都放到Main这个类下,我们就再也不用承受编译器给我们生成那么多额外方法的开销了,而@JvmStatic,会让编译器直接把newInstance方法编译成一个静态方法。

这时候再来看生成的字节码:

 // access flags 0x1001
  public synthetic (Lkotlin/jvm/internal/DefaultConstructorMarker;)V
   L0
    LINENUMBER 9 L0
    ALOAD 0
    INVOKESPECIAL Main$Companion. ()V
    RETURN
   L1
    LOCALVARIABLE this LMain$Companion; L0 L1 0
    LOCALVARIABLE $constructor_marker Lkotlin/jvm/internal/DefaultConstructorMarker; L0 L1 1
    MAXSTACK = 1
    MAXLOCALS = 2
复制代码

除了Main$Companion类这个生成的构造函数,编译器已经不会给我们生成那些弯弯绕绕的方法了,完美!

我们来做一下总结,其实就是避免在伴生对象中定义成员变量,而改在文件中定义顶级变量,而且可以把伴生对象中的函数都用@JvmStatic来修饰,使它变成一个真正的静态函数。

下次,我们再来扒扒Kotlin一个独特的类Range

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

你可能感兴趣的:(你说你会用Companion object?恐怕不是!)