Kotlin基础学习（九）—— object 关键字

Kotlin 中 object 关键字的使用场景主要有三种：

• 对象声明（object declaration）：定义单例的一种方式
• 伴生对象（companion object）：通过类名来访问伴生对象中的成员
• 对象表达式（object expression）：替代 Java 的匿名内部类

一、对象声明

• Kotlin 中对象声明将 类声明 与 该类的单一实例声明 结合到了一起。不同于普通类的实例，对象声明在定义的时候就创建了实例
• 对象声明中不允许包含构造方法（主构造方法 & 从构造方法）
• 对象声明同样可以继承自类和接口

对象声明的例子：

object UserManager {
    fun saveUser(){}
}

// 反编译出的Java代码
public final class UserManager {
   public static final UserManager INSTANCE;

   public final void saveUser() {
   }

   private UserManager() {
   }

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

在kotlin和java代码中，它们的调用方式有点差别：

kotlin代码调用：UserManager.saveUser()

java代码调用：UserManager.INSTANCE.saveUser();

Java实现单例模式 与 Kotlin实现单例模式 的对比：

（1）饿汉模式

//java 饿汉模式
public class Singleton{
    private final static Singleton INSTANCE = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

//Kotlin 饿汉模式
//关键字 “object” 定义单例，类加载时实例化对象，Singleton既是类名也是对象名，是饿汉模式的单例实现
object Singleton

（2）懒汉模式

//java   定义一个使用private的构造方法，并且用静态字段来持有这个类仅有的实例 懒汉模式
public class Singleton{
    private static Singleton instance;
    private Singleton(){}
    public static synchronized Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

//Kotlin 懒汉模式
class Singleton private constructor(){  //主构造方法
    companion object{  //伴生对象
        private var instance:Singleton ?= null
        	get(){
                if(field == null){
                    field = Singleton()
                }
                return field
            }
        fun get():Singleton{
            return instance!!
        }
    }
}

二、伴生对象

Kotlin 中的类不能拥有静态成员，即在 Kotlin 中是没有 static 关键字的，所以 Kotlin 中没有静态方法和静态成员。在kotlin中想要表达这种概念（直接通过类名来调用其成员），可使用 包级别函数（顶层函数） 和 伴生对象

• 大多数情况下，推荐使用顶层函数来替代 Java 的静态方法，但是顶层函数不能访问类的 private 成员（包括 private 构造方法），这时使用伴生对象
• companion object 关键字定义的伴生对象，可以直接通过容器类名称来访问这个对象的方法和属性，不需要显式地指明对象的名称。类似于Java中的静态方法调用。
• 伴生对象可以有名称（命名伴生对象），可以实现一个接口，可以有扩展函数或属性

（1）伴生对象语法形式：

class ClassName {
    // 伴生对象名可以省略，默认为Companion
    companion object 伴生对象名 {
        // define field and method
    }
}

伴生对象实例解析以及在kotlin和java代码中的调用：

class App {
    companion object {
        fun getAppContext() {}
    }
}

// 反编译出的Java代码
public final class App {
   public static final App.Companion Companion = new App.Companion((DefaultConstructorMarker)null);

   public static final class Companion {
      public final void getAppContext() {
      }

      private Companion() {
      }

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

与对象声明类似，它们在kotlin和java代码中的调用方式也有点差别：

kotlin代码调用：App.getAppContext()

java代码调用：App.Companion.getAppContext();

（2）命名伴生对象

class A{
    companion object B{  //命名伴生对象
        fun bar(){
            println("Compainon object called")
        }
    }
}
fun main(args:Array<String>){
    A.bar()   //通过包含伴生对象的类的名字来引用伴生对象
    A.B.bar()
}

如果省略伴生对象的名字，默认的名字将会分配为 Companion，会在伴生对象扩展中使用。

class A{
    companion object{  
        fun bar(){
            println("Compainon object called")
        }
    }
}
fun main(args:Array<String>){
    A.bar()   //通过包含伴生对象的类的名字来引用伴生对象
    A.Companion.bar()  //未命名时，可通过Companion引用伴生对象
}

（3）在伴生对象中实现接口

interface F{
    fun price()
}
class A{
    companion object: F{
        override fun price() {
            println("A:::F:::price")
        }
    }
}
fun fun22(f:F){
    f.price()
}
fun main(args:Array<String>){
    fun22(A) //可将包含伴生对象的类的名字当作实现了该接口的对象实例
}

（4）伴生对象扩展

class A{
    companion object{
    }
}
fun A.Companion.bar(){
    println("Compainon object called")
}
fun main(args:Array<String>){
    A.bar()   //通过包含伴生对象的类的名字来引用伴生对象
    A.Companion.bar()  //未命名时，可通过Companion引用伴生对象
}

三、对象表达式

对象表达式常用来作为匿名内部类的实现

与对象声明不同，匿名对象不是单例的，每次对象表达式被执行都会创建一个新的对象实例

Java 和 Kotlin 匿名内部类的区别：

//Java  使用匿名对象来实现事件监听器
button.setOnClickListener(new OnClickListener(){  //相当于实现了一个接口的匿名类
    @Override
    public void onClick(View v){
        ... ...
    }
})

//Kotlin 
button.setOnClickListener(object:OnClickListener{
        override fun onClick(v:View){
            ... ...
        }
    }
)

• 与Java匿名内部类只能扩展一个类 或 实现一个接口 不同，Kotlin的匿名对象可以实现多个接口或者不实现接口
• 与Java的匿名类一样，在对象表达式中的代码可以访问创建它的函数中的变量，Java的访问被限制在 final 变量，Kotlin的匿名类访问并没有被限制在 final 变量。

四、扩展

有这样一个疑问，在对象声明和伴生对象中，java代码调用总会跟上INSTANCE或者Companion，直观上感觉不太友好，能不能像kotlin代码那样可以直接调用？

答案肯定是可以的。需要使用kotlin自带的注解： @JvmStatic 或者 @JvmField ，这样就可以和kotlin调用保持一致。

@JvmStatic既可以修饰属性，也可以修饰方法；而@JvmField只能修饰属性

参考：
《Kotlin实战》
Kotlin：object关键字总结