通过下面的方式可以创建继承自某种(或某些)匿名类的对象：

    如果父类有构造函数，则必须传递相应的构造参数。多个父类可以用逗号隔开，跟在冒号后面：

    2.     public open val y: Int = x
    3. }
    5. interface B { ... }
    7. val ab = object : A(1), B {
    8.     override val y = 14
    9. }

    有时候我们只是需要一个没有父类的对象，我们可以这样写：

    1.     var x: Int = 0
    2.     var y: Int = 0
    3. }
    5. print(adHoc.x + adHoc.y)

    像 java 的匿名内部类一样，对象表达式可以访问闭合范围内的变量 (和 java 不一样的是，这些变量不用是 final 修饰的)

    是一种很有用的模式，Kotln 中声明它很方便：

    1. object DataProviderManager {
    2.     fun registerDataProvider(provider: DataProvider) {
    3.         // ...
    4.     }
    6.     val allDataProviders: Collection<DataProvider>
    7.         get() = // ...
    8. }

    想要访问这个类，直接通过名字来使用这个类：

      这样类型的对象可以有父类型：

      注意：对象声明不可以是局部的(比如不可以直接在函数内部声明)，但可以在其它对象的声明或非内部类中进行内嵌入

      在类声明内部可以用 companion 关键字标记对象声明：

      1. class MyClass {
      2.     companion object Factory {
      4.     }
      5. }

      伴随对象的成员可以通过类名做限定词直接使用：

      1. val instance = MyClass.create()

      注意，尽管伴随对象的成员很像其它语言中的静态成员，但在运行时它们任然是真正对象的成员实例，比如可以实现接口：

      1. interface Factory<T> {
      2.     fun create(): T
      3. }
      5. class MyClass {
      6.     companion object : Factory<MyClass> {
      7.         override fun create(): MyClass = MyClass()

      如果你在 JVM 上使用 @JvmStatic 注解，你可以有多个伴随对象生成为真实的静态方法和属性。参看 。

      他俩之间只有一个特别重要的区别：