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 实例对象, 所以这和静态的结果没什么太大的区别.

Object:

官方描述说定义一个类的同时定义了一个对象. 它就是 java 中的单列.

说说他和 companion 的异同点:

同:

和 companion 一样, 都是一个静态内部类.

异:

它不像 companion 那样和外围内有较大的联系, 比如字段和外围内持有 companion 的引用.
它就是官方说描述的那样, 它就是一个单列, 只是这个类的实例字段是 object 这个类自己持有了.

最后说一下, 在 kotlin 中访问 object 的方法,字段和 companion 的方法和字段的方式几乎是一模一样, 都是通过类名.XX 来访问,

其本质都是通过持有的那个实例对象来访问, 在 java 中访问以下就明白了.