Kotlin中的object理解

一、 object用作对象声明

最简单的对象声明

object Single{

}

转成java，可以看出（1）一个简单的单例模式，（2）构造函数是private

public final class Single {
   @NotNull
   public static final Single INSTANCE;

   private Single() {
   }

   static {
      Single var0 = new Single();
      INSTANCE = var0;
   }

稍复杂的对象声明

object Single{
    var a = 1
    fun execute(){
        
    }
}

转换成java，可以看出（1）a变量是私有静态成员变量（2）声明了两个非静态的函数用来读写a变量（3）execute函数并没有变成静态函数

public final class Single {
   private static int a;
   @NotNull
   public static final Single INSTANCE;

   public final int getA() {
      return a;
   }

   public final void setA(int var1) {
      a = var1;
   }

   public final void execute() {
   }

   private Single() {
   }

   static {
      Single var0 = new Single();
      INSTANCE = var0;
      a = 1;
   }
}

Kotlin中的具体使用

Single.a = 2;
Single.execute()

Java中的具体使用

Single.INSTANCE.setA(2)；
Single.INSTANCE.getA();
Single.INSTANCE.execute();

总结

object用作对象声明时

1.自动变为一个饿汉单例模式

2.生成读写变量的函数去读写其中的私有静态变量

@JvmField和@JvmStatic

object用作对象声明，，@JvmField和@JvmStatic可以简化其在Java中的使用

object Single{
    @JvmField
    var abc = 1;
    
    @JvmStatic
    var efg = 3;
    

    @JvmStatic
    fun feelTheWorld(){}
}

转化为Java代码

public final class Single {
   @JvmField
   public static int abc;
   private static int efg;
   @NotNull
   public static final Single INSTANCE;

   /** @deprecated */
   // $FF: synthetic method
   @JvmStatic
   public static void getEfg$annotations() {
   }

   public static final int getEfg() {
      return efg;
   }

   public static final void setEfg(int var0) {
      efg = var0;
   }

   @JvmStatic
   public static final void feelTheWorld() {
   }

   private Single() {
   }

   static {
      Single var0 = new Single();
      INSTANCE = var0;
      abc = 1;
      efg = 3;
   }
}

Java中的使用

Single.abc = 2;
Single.feelTheWorld();

@JvmField将原来的私有静态变量变为公有静态的变量（可以比较一下使用JvmField和不使用的Java代码的区别），另外，它不能修饰本身为私有的变量

@JvmStatic只能用在object和companion object声明内，一般用于修饰方法，使方法变成真正的静态方法；如果修饰变量不会消除变量的getter与setter方法，但会使getter与setter方法和变量都变成静态

最后总结一下其中成员变量的在Java中的体现

object Single1{
        var a = 1;//私有静态变量，公有非静态setter，getter
        val b = 2;//私有静态变量，公有静非态getter，final修饰
        private var c = 3;//私有静态变量，木有setter,getter
        private val d = 4;//私有静态变量，木有setter，getter，final修饰
        @JvmStatic
        var e = 5 //私有静态变量，公有静态setter,getter
        @JvmStatic
        val f = 6 //私有静态变量，公有静态getter，final修饰
        @JvmField
        var g = 7 //公有静态变量，木有setter，getter
        @JvmField
        val h = 8//公有静态变量，木有setter，getter，final修饰

    }

二、 类的内部使用object对象声明

简单比较一下类内部使用object和companion object的区别，发现

1..类内部可以有多个object声明，但是companion object声明只能有一个

2..object一定要取名，但是companion object可以不取名，默认为Companion。对于companion object取不取名，这个在Java使用中会有感觉，而Kotlin使用中无感

下面用kotlin代码实际比较一下，成员变量，成员函数相关

class TestManager3{
    object Single{
        var a1 = 1
        @JvmField
        var b1 = 1
        fun seeTheWorld1(){}
        @JvmStatic
        fun feelTheWorld1(){}
    }

    companion object{
        var a2 = 1
        @JvmField
        var b2 = 1
        fun seeTheWorld2(){}
        @JvmStatic
        fun feelTheWorld2(){}
    }
}

在Java中的体现

public final class TestManager3 {
   private static int a2 = 1;
   @JvmField
   public static int b2 = 1;
   @NotNull
   public static final Companion Companion = new Companion((DefaultConstructorMarker)null);

   @JvmStatic
   public static final void feelTheWorld2() {
      Companion.feelTheWorld2();
   }
  
   public static final class Single {
      private static int a1;
      @JvmField
      public static int b1;
      @NotNull
      public static final Single INSTANCE;

      public final int getA1() {
         return a1;
      }

      public final void setA1(int var1) {
         a1 = var1;
      }

      public final void seeTheWorld1() {
      }

      @JvmStatic
      public static final void feelTheWorld1() {
      }

      private Single() {
      }

      static {
         Single var0 = new Single();
         INSTANCE = var0;
         a1 = 1;
         b1 = 1;
      }
   }
  
   public static final class Companion {
      public final int getA2() {
         return TestManager3.a2;
      }

      public final void setA2(int var1) {
         TestManager3.a2 = var1;
      }

      public final void seeTheWorld2() {
      }

      @JvmStatic
      public final void feelTheWorld2() {
      }

      private Companion() {
      }

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

Kotlin中的使用

TestManager3.Single.a1=2
TestManager3.Single.b1=2
TestManager3.Single.seeTheWorld1()
TestManager3.Single.feelTheWorld1()
TestManager3.a2 = 2
TestManager3.b2 = 3
TestManager3.seeTheWorld2()
TestManager3.feelTheWorld2()

Java中的使用

TestManager3.Single.INSTANCE.setA1(2);
TestManager3.Single.b1 = 2;
TestManager3.Single.feelTheWorld1();
TestManager3.Single.INSTANCE.seeTheWorld1();
TestManager3.Companion.setA2(2);
TestManager3.b2 = 2;//java转kotlin项目静态变量使用这种
TestManager3.feelTheWorld2();
TestManager3.Companion.seeTheWorld2();

object用作内部类声明，和之前相比并没有变化

companion object用作内部类声明的话，有几点需要注意

1.定义的变量，会变成外部类的私有静态变量

2.定义的变量加上@JvmField修饰，会变成外部类的公有静态变量

3.定义的方法加上@JvmStatic修饰，会变成外部类的公有静态方法