Kotlin面向对象之对象表达式与声明（Object Expre

有时候，我们需要创建一个类被部分修改的对象，而不需要明确地声明一个新的子类。Java用匿名内部类来处理这种情况。Kotlin则用对象表达式和对象声明略微概括了这个概念。

对象表达式（Object expressions）

要创建一个继承某种类型（或类型s）的匿名类的对象，我们可以这样写：

window.addMouseListener(object : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) {
        // ...
    }

    override fun mouseEntered(e: MouseEvent) {
        // ...
    }
})

如果基类具有构造函数，则必须传递适当的构造函数参数。 冒号后可以用逗号将基类分隔：

open class A(x: Int) {
    public open val y: Int = x
}

interface B {...}

val ab: A = object : A(1), B {
    override val y = 15
}

如果我们需要“只是一个对象”，没有任何重要的基类，我们可以简单地写：

fun foo() {
    val adHoc = object {
        var x: Int = 0
        var y: Int = 0
    }
    print(adHoc.x + adHoc.y)
}

注意到，匿名对象仅可以被用作本地类型和私有声明。如果你使用一个匿名对象作为一个公有函数的返回类型，或公有属性的类型，函数或属性的真实类型将是匿名对象的基类类型，如果没有声明任何超类型，则匿名对象的类型将是"Any"。在匿名对象中添加的成员将无法访问。

class C {
    // Private function, so the return type is the anonymous object type
    private fun foo() = object {
        val x: String = "x"
    }

    // Public function, so the return type is Any
    fun publicFoo() = object {
        val x: String = "x"
    }

    fun bar() {
        val x1 = foo().x        // Works
        val x2 = publicFoo().x  // ERROR: Unresolved reference 'x'
    }
}

就像Java中的匿名内部类对象的表达式，对象表达式的代码可以访问表达式之外的变量。（不像Java，是不受限制的final变量）。

fun countClicks(window: JComponent) {
    var clickCount = 0
    var enterCount = 0

    window.addMouseListener(object : MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) {
            clickCount++
        }

        override fun mouseEntered(e: MouseEvent) {
            enterCount++
        }
    })
    // ...
}

对象声明（Object declarations）

单例是一个非常有用的模式。Kotlin让声明单例更加的容易：

object DataProviderManager {
    fun registerDataProvider(provider: DataProvider) {
        // ...
    }

    val allDataProviders: Collection<DataProvider>
        get() = // ...
}

这被称作对象声明，且其名字始终跟随object关键字。就像变量声明一样，对象声明不是一个表达式，不能在赋值语句的右侧使用。

为了引用这个对象，我们直接使用它的名字：

DataProviderManager.registerDataProvider(...)

如此对象也可以拥有基类：

object DefaultListener : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) {
        // ...
    }

    override fun mouseEntered(e: MouseEvent) {
        // ...
    }
}

注意：对象声明不是本地的（即直接嵌套在函数内），它们可以嵌套到其他对象声明或非内部类中。

伴生对象（Companion Objects）

在一个类内部的对象声明可以被companion关键字标记：

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

伴生对象的成员可以通过简单的类名作为限定符来调用：

val instance = MyClass.create()

伴生对象的名称可以省略，此时该对象的名称可以使用Companion代替：

class MyClass {
    companion object {
    }
}

val x = MyClass.Companion

注意，尽管伴生对象的成员看起来像其他语言里的static成员，运行时他们仍然是真实对象的实例成员，并且它们可以实现接口：

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


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

但是，在JVM上，如果使用@JvmStatic注解，则可以将伴生对象作为实际静态方法和字段生成。

对象表达式和声明的语义区别（Semantic difference between object expressions and declarations）

对象表达式和对象声明之间存在一个重要的语义差异：

1. 对象表达式在使用它们的地方被立即初始化并执行
2. 对象声明则是懒初始化，只有第一次引用它们的时候
3. 当对应得类被加载（解析）时，伴生对象被初始化，和Java中的static初始化一致。