Kotlin（十一）Kotlin中的Object关键字

  在kotlin中的超类是Any，并没有使用Java中的Object关键字表示超类。

   在Kotlin中Object关键字，另有作用。

1.定义单例类。在一个进程中只有一个类实例。

   这个类，可以用来声明和应用声明周期相关的属性或方法。

object AppConfig {
    //初始化代码块，对象初始化时调用。
    init {
        println("app config init ...")
    }
}
fun main() {
    val app1 = AppConfig
    val app2 = AppConfig
    println(app1)
    println(app2)
}

运行结果：

   可以看到虽然创建了两个对象，AppConfig 初始化代码块，只运行了一次。

   打印两个对象，可以看出，是一样的。也就是说app1和app2是同一个实例。

app config init ...
com.example.kotlin.AppConfig@5594a1b5
com.example.kotlin.AppConfig@5594a1b5

下面是通过show bytecode 反编译后的代码，也就是Kotlin编译后的代码。

init{}对应java中的static{}，并且创建了一个静态对象INSTANCE来保存类实例。

public final class AppConfig {
   @NotNull
   public static final AppConfig INSTANCE;
 
   private AppConfig() {
   }
 
   static {
      AppConfig var0 = new AppConfig();
      INSTANCE = var0;
      String var1 = "app config init ...";
      System.out.println(var1);
   }
}
 
 public static final void main() {
      AppConfig app1 = AppConfig.INSTANCE;
      AppConfig app2 = AppConfig.INSTANCE;
      System.out.println(app1);
      System.out.println(app2);
   }

2.对象表达式

    有时候我们需要调用某个类中的方法，但是有不想创建这个类的子类，因为只调用一次就行。

对于这样只用一次就丢弃的实例。我们可以使用objec:类名，创建匿名的类对象，这种方式就是对象表达式。和Java中的匿名内部类类似，都没有名字。

fun main() {
    val p = object :Person("LiLei"){
        override fun doWork() {
            println("$name,is writing code...")
        }
    }
    p.doWork()
}

3.伴生对象。

当我们需要将一个对象的初始化和一个类实例捆绑在一起时。相伴而生，可以考虑使用伴生对象。

通过 companion object{} ，可以在一个类中，创建一个伴生对象。但是，一个类中只允许存在一个伴生对象。

//父类必须用open修饰，才能够被继承
open class Person(val name: String) {
    //伴生对象，
    companion object {
        var idCard = ""
        //当创建类实例时，会自动调用伴生对象的init代码块
        init {
            idCard = "XXX"
            println("companion init")
        }
        fun getId(): String {
            return idCard
        }
    }
}

fun main() {
    //创建类实例是，会调用伴生对象的init代码块
    val p = Person
    //可以通过类实例，访问伴生对象定义的属性和方法
    println(p.idCard)
    println( p.getId())
}