Kotlin object

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/mengks1987/article/details/83902165

Kotlin 中的object是个非常神奇的关键字，他可以干很多事情：

1、匿名内部类

Java中我们这样写：

view.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

            }
        });

或者：

 Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
        }
    };

Kotlin中这样写

view.setOnClickListener(object :View.OnClickListener{
            override fun onClick(v: View?) {
                
            }
        })

val handler = object : Handler(){
        override fun handleMessage(msg: Message?) {
            super.handleMessage(msg)
        }
    }

2、单例模式

object Single {
    fun add(){}
}

上面就是Kotlin的单例模式了，调用：
Java：

Single.INSTANCE.add();

Kotlin:

 Single.add()

这里需要注意的是Java中调用的时候加了一个 INSTANCE 。
下面我们看看编译成Java代码Single是如果实现的，如果不知道如何将Kotlin代码变为Java代码请看：Kotlin 入门 。

我们发现这是典型的饿汉式单例模式。这种单例模式在类加载的时候就进行了实例化，没有懒加载机制，如果项目没有用到这个类就会造成内存浪费。

3、类内部的静态类

class ObjectDemo {
    object Demo1{
        fun add(){}
    }
}

Demo1是静态内部类，对应的Java：

public final class ObjectDemo {
 
   public static final class Demo1 {
      public static final ObjectDemo.Demo1 INSTANCE;

      public final void add() {
      }

      static {
         ObjectDemo.Demo1 var0 = new ObjectDemo.Demo1();
         INSTANCE = var0;
      }
   }
}

4、companion object

class ObjectDemo {


    fun test(){
        add()
        var s= name
    }

    companion object {
        val name = ""
        fun add(){}
    }

}

转为Java：

扫描二维码关注公众号，回复： 4258626 查看本文章

public final class ObjectDemo {
   @NotNull
   private static final String name = "";
   public static final ObjectDemo.Companion Companion = new ObjectDemo.Companion((DefaultConstructorMarker)null);

   public final void test() {
      Companion.add();
      String s = name;
   }
   public static final class Companion {
      @NotNull
      public final String getName() {
         return ObjectDemo.name;
      }

      public final void add() {
      }

      private Companion() {
      }

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

我们发现其实就是在类内部生成了一个静态类 Companion，由于Kotlin中没有static关键字，所以定义静态属性的时候使用companion object,如下：

companion object {
        const val TAG = "ObjectDemo"
    }