Kotlin 中 object 和 companion 的理解

首先, 这两个东东最终都会是 java 中的静态内部类, 然后说下不同的地方:

首先看看 kotlin 的代码:

class Test {

    companion object C {
        val cachePool: ExecutorService = Executors.newCachedThreadPool() // 注意此处的 val

        private var i = 0 // 注意此处的私有

        fun cMethod() {

        }
    }

    object o {
        val demo = 0

    }
}

看看生成的 java 的字节码:

  public final class Test {
        @NotNull
        private static final ExecutorService cachePool; // Companion 中定义的
        private static int i; // Companion 中定义的
        public static final Test.C C = new Test.C((DefaultConstructorMarker)null); // Companion 的实例对象

        static {
            ExecutorService var10000 = Executors.newCachedThreadPool();
            Intrinsics.checkExpressionValueIsNotNull(var10000,
                    "Executors.newCachedThreadPool()");
            cachePool = var10000;
        }

        public static final class C {
            @NotNull
            public final ExecutorService getCachePool() { // get 方法
                return Test.cachePool;
            }

            public final void cMethod() {
            }

            private C() {
            }

// $FF: synthetic method
            public C(DefaultConstructorMarker $constructor_marker) {
                this();
            }
        }

        public static final class o {
            private static final int demo = 0;
            public static final Test.o INSTANCE;

            public final int getDemo() {
                return demo;
            }

            static {
                Test.o var0 = new Test.o();
                INSTANCE = var0;
            }
        }
    }

看到上面的字节码, 可以得到如下结论:

Companion:
官方描述到这是 伴生 对象, companion 本身也是伴侣的意思.  我们看到 java 的字节码, 的确如此, 外围内会持有 companion 对象的一个静态常年字段, 伴随着外围类 的加载而诞生.

关于在 compain 中定义的变量的理解:

companion 中定义的变量通通都会在 外围类 定义成一个 私有 静态字段.
如果变量为 val ,  那么 对应的 java 便是 static final.
变量为 private , 也就意味着 companion 中 不会为这个变量生成对应的访问方法,
我们可以看到, 其实 companion 就是个 空壳子, 字段不会位于 companion 类中,  只有方法会定义在 companion 内部.
此外我们还看到 companion 中的方法都不是静态方法, 其实我们访问任何 companion 中的字段都是通过 外围类持有的 companion 实例对象来访问的, 方法也是如此, 而且 companion 的构造方法也是 private 的.

总结: companion 其实和 java 中的静态方法和字段很像, 只是我们访问这些字段和方法时需要通过 companion 实例对象来绕一下, 而外围类永远只会持有一个 companion 实例对象, 所以这和静态的结果没什么太大的区别.

实例:

class MyClass7 {
    companion object {
        val myClassField1: Int = 1
        var myClassField2 = "this is myClassField2"
        fun companionFun1() {
            println("this is 1st companion function.")
            foo()
        }
        fun companionFun2() {
            println("this is 2st companion function.")
            companionFun1()
        }
    }
    fun MyClass7.Companion.foo() {
        println("伴随对象的扩展函数(内部)")
    }
    fun test2() {
        MyClass7.foo()
    }
    init {
        test2()
    }
}
val MyClass7.Companion.no: Int
    get() = 10
fun MyClass7.Companion.foo() {
    println("foo 伴随对象外部扩展函数")
}
println("no:${MyClass7.no}")
println("field1:${MyClass7.myClassField1}")
println("field2:${MyClass7.myClassField2}")
MyClass7.foo()
MyClass7.companionFun2()

结果:

no:10
field1:1
field2:this is myClassField2
foo 伴随对象外部扩展函数
this is 2st companion function.
this is 1st companion function.
foo 伴随对象外部扩展函数