7.Kotlin伴生对象及其字节码内幕详解

1.类与接口

• 示例代码

interface A {

    fun method() {
        println("A")
    }
}

open class B {
    open fun method() {
        println("B")
    }
}

class C : A, B() {
    override fun method() {
        super.method()
    }
}

fun main(args: Array) {
    var c = C()
    c.method()
}

• 运行结果

A

2.抽象类

• 示例代码

open class BaseClass {
    open fun method() {

    }
}

abstract class ChildClass : BaseClass() {
    override abstract fun method()
}

3.对象声明

object declaration,对象声明

• 示例代码

object MyObject {
    fun method() {
        println("method")
    }
}

fun main(args: Array) {
    MyObject.method()
}

• 运行结果

method

4.伴生对象

companion object,拌生对象。
1）在Kotlin中，与Java不同的是，类是没有static方法的。
2）在大多数情况下，Kotlin推荐的做法是使用包级别的函数来作为静态方法。
3）Kotlin会将包级别的函数当作静态方法来看待。

1）如果不提供伴生对象的名字，那么编译器会提供一个默认的名字。
2）注意：虽然伴生对象的成员看起来像是Java中的静态成员，但在运行期，他们依旧是真实对象的实例成员。
3）在JVM上，可以将伴生对象的成员真正生成为类的静态方法与属性，这是通过@JcmStatic注解来实现的。
4）伴生对象在编译后会生成一个静态内部类。

• 示例代码

class MyTest {
    companion object MyObject {

        var a: Int = 100
      
        fun method() {
            println("method invoked!")
        }

    }
}

• 反编译结果

➜ kotlin_lecture javap com.leofight.kotlin.MyTest
Compiled from "HelloKotlin19.kt"
public final class com.leofight.kotlin.MyTest {
  public static final com.leofight.kotlin.MyTest$MyObject MyObject;
  public com.leofight.kotlin.MyTest();
  static {};
  public static final int access$getA$cp();
  public static final void access$setA$cp(int);
}
➜  kotlin_lecture javap -c com.leofight.kotlin.MyTest
Compiled from "HelloKotlin19.kt"
public final class com.leofight.kotlin.MyTest {
  public static final com.leofight.kotlin.MyTest$MyObject MyObject;

  public com.leofight.kotlin.MyTest();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."":()V
       4: return

  static {};
    Code:
       0: new           #37                 // class com/leofight/kotlin/MyTest$MyObject
       3: dup
       4: aconst_null
       5: invokespecial #40                 // Method com/leofight/kotlin/MyTest$MyObject."":(Lkotlin/jvm/internal/DefaultConstructorMarker;)V
       8: putstatic     #42                 // Field MyObject:Lcom/leofight/kotlin/MyTest$MyObject;
      11: bipush        100
      13: putstatic     #19                 // Field a:I
      16: return

  public static final int access$getA$cp();
    Code:
       0: getstatic     #19                 // Field a:I
       3: ireturn

  public static final void access$setA$cp(int);
    Code:
       0: iload_0
       1: putstatic     #19                 // Field a:I
       4: return
}

• 示例代码

class MyTest {
    companion object MyObject {

        var a: Int = 100
        @JvmStatic
        fun method() {
            println("method invoked!")
        }

    }
}

• 反编译结果

➜  kotlin_lecture javap com.leofight.kotlin.MyTest   
Compiled from "HelloKotlin19.kt"
public final class com.leofight.kotlin.MyTest {
  public static final com.leofight.kotlin.MyTest$MyObject MyObject;
  public com.leofight.kotlin.MyTest();
  static {};
  public static final int access$getA$cp();
  public static final void access$setA$cp(int);
  public static final void method();
}
➜  kotlin_lecture javap -c com.leofight.kotlin.MyTest
Compiled from "HelloKotlin19.kt"
public final class com.leofight.kotlin.MyTest {
  public static final com.leofight.kotlin.MyTest$MyObject MyObject;

  public com.leofight.kotlin.MyTest();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."":()V
       4: return

  static {};
    Code:
       0: new           #41                 // class com/leofight/kotlin/MyTest$MyObject
       3: dup
       4: aconst_null
       5: invokespecial #46                 // Method com/leofight/kotlin/MyTest$MyObject."":(Lkotlin/jvm/internal/DefaultConstructorMarker;)V
       8: putstatic     #39                 // Field MyObject:Lcom/leofight/kotlin/MyTest$MyObject;
      11: bipush        100
      13: putstatic     #19                 // Field a:I
      16: return

  public static final int access$getA$cp();
    Code:
       0: getstatic     #19                 // Field a:I
       3: ireturn

  public static final void access$setA$cp(int);
    Code:
       0: iload_0
       1: putstatic     #19                 // Field a:I
       4: return

  public static final void method();
    Code:
       0: getstatic     #39                 // Field MyObject:Lcom/leofight/kotlin/MyTest$MyObject;
       3: invokevirtual #43                 // Method com/leofight/kotlin/MyTest$MyObject.method:()V
       6: return
}

• 示例代码

//object declaration,对象声明

object MyObject {
    fun method() {
        println("method")
    }
}

fun main(args: Array) {
    MyObject.method()

    println("-----------")

    MyTest.MyObject.method()

    println("-----------")

    println(MyTest.a)
    MyTest.method()//类似静态方法，Kotlin中没有静态方法

    println("----------")

    val v = MyTest.MyObject
    println(v.javaClass)

    D.foo()
    D.bar()

    D.Companion.bar()
    D.Companion.foo()
}

//companion object,拌生对象
//在Kotlin中，与Java不同的是，类是没有static方法的。
//在大多数情况下，Kotlin推荐的做法是使用包级别的函数来作为静态方法。
//Kotlin会将包级别的函数当作静态方法来看待。

//如果不提供伴生对象的名字，那么编译器会提供一个默认的名字
//注意：虽然伴生对象的成员看起来像是Java中的静态成员，但在运行期，他们依旧是真实对象的实例成员。
//在JVM上，可以将伴生对象的成员真正生成为类的静态方法与属性，这是通过@JcmStatic注解来实现的。
//伴生对象在编译后会生成一个静态内部类。


class MyTest {
    companion object MyObject {

        var a: Int = 100
        @JvmStatic
        fun method() {
            println("method invoked!")
        }

    }
}

class D {
    companion object {
        @JvmStatic
        fun foo() {

        }

        fun bar() {

        }
    }
}

• 运行结果

method
-----------
method invoked!
-----------
100
method invoked!
----------
class com.leofight.kotlin.MyTest$MyObject