Kotlin中对象表达式、对象声明、伴生对象

对象表达式（object expression）

对象表达式：在实现使用的地方立即执行

对象声明：第一次访问的时候被初始化，延迟初始化。相当于单例

伴生对象：在相应的类被加载时初始化的，相当于java静态初始化

---

kotlin的对象表达式是为了解决匿名内部类的一些缺陷而产生的

1. 匿名内部类是没有名字的类
2. 匿名内部类一定是继承了某个父类，或是实现了某个接口
3. Java运行时会将该匿名内部类当做它所实现的接口或是所继承的父类来看待

---

对象表达式的格式

object [:若干个父类型,中间用逗号分隔]

//定义接口
interface AInterface {
    fun printFun()
}
//定义抽象类
abstract class BAbstractClass {
    abstract var bAbstract: String
    abstract fun printlnBFuntion()
}

fun main() {
    var aObject = object : AInterface {
        override fun printFun() {
            println("print A interface implement function")
        }
    }
    aObject.printFun()
    println("---------------")
    var bObject = object {
        init {
            println("init B Object")
        }

        fun printFun() {
            println("print B Object function")
        }
    }
    println("---------------")
    var cObject = object : AInterface, BAbstractClass() {
        override fun printFun() {
            println("exe printFun")
        }

        override var bAbstract: String = "bAbstract"


        override fun printlnBFuntion() {
            println("exe printlnBFuntion")
        }
    }
    
    cObject.printFun()
    cObject.printlnBFuntion()
    println(cObject.bAbstract)
}

java中的.class = .javaClass 或者 ::class.java

• 匿名对象只能在局部变量范围内或是被private修饰的成员变量范围内才能被识别出真正的类型

  类中的匿名对象，需要private修饰，才能被类中其他方法调用

  但是方法中的匿名对象，可以直接被方法中直接调用

对象声明

• DeclarationObject类相当于直接声明了对象

  通过打印发现两个对象是相同的

• 通过object关键字用来声明一个对象

  通过object关键字声明，来获得一个对象的单例

fun main() {
    ExpressObject.getName()
    
	var dec1 = DeclarationObject
    var dec2 = DeclarationObject
    
    println(dec1)
    println(dec2)
}

object DeclarationObject{
    fun getName(){
        println("print getName")
    }
}

• Java中的调用

DeclarationObject.INSTANCE.getName();

伴生对象

类内部的对象声明可以用 companion 关键字标记，这样它就与外部类关联在一起，我们就可以直接通过外部类访问到对象的内部元素。

class MyClass {
    companion object Factory {
        fun create(): MyClass = MyClass()
    }
}

val instance = MyClass.create()   // 访问到对象的内部元素

可以省略掉该对象的对象名，然后使用 Companion 替代需要声明的对象名：

class MyClass {
    companion object {
    }
}

val x = MyClass.Companion

注意：一个类里面只能声明一个内部关联对象，即关键字 companion 只能使用一次。

请伴生对象的成员看起来像其他语言的静态成员，但在运行时他们仍然是真实对象的实例成员。例如还可以实现接口：

interface Factory<T> {
    fun create(): T
}


class MyClass {
    companion object : Factory<MyClass> {
        override fun create(): MyClass = MyClass()
    }
}