有时候，我们需要创建一个类被部分修改的对象，而不需要明确地声明一个新的子类。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）
对象表达式和对象声明之间存在一个重要的语义差异：
- 对象表达式在使用它们的地方被立即初始化并执行
- 对象声明则是懒初始化，只有第一次引用它们的时候
- 当对应得类被加载（解析）时，伴生对象被初始化，和Java中的static初始化一致。
