Kotlin 用对象表达式和对象声明来实现创建一个 对某个类做了轻微改动 的类的对象，且不需要去声明一个新的子类。

对象表达式和对象声明之间的语义差异

对象表达式和对象声明之间有一个重要的语义差别：

• 对象表达式是在使用他们的地方立即执行的
• 对象声明是在第一次被访问到时延迟初始化的
• 伴生对象的初始化是在相应的类被加载（解析）时，与 Java 静态初始化器的语义相匹配

对象表达式

通过对象表达式实现一个匿名内部类的对象用于方法的参数中，其实就是类似java中的new接口{}。

btnOperator.setOnClickListener(object : View.OnClickListener{
            override fun onClick(v: View?) {

            }
        })

简化后

btnOperator.setOnClickListener { }

对象可以继承于某个基类，或者实现其他接口:
如果超类型有一个构造函数，则必须传递参数给它。多个超类型和接口可以用逗号分隔。

open class A(x: Int) {
    open val y: Int = x
}
interface B 
val cc: A = object : A(1),B {
    override val y = 15
}

通过对象表达式可以越过类的定义直接得到一个对象：

        val site = object {
            var name: String = "zhongjh"
            var gender: String = "男"
        }
        println(site.name)
        println(site.gender)

私有函数和公有函数创建对象

请注意，匿名对象可以用作只在本地和私有作用域中声明的类型。如果你没有声明任何超类型，就会是 Any。在匿名对象 中添加的成员将无法访问。

    // 私有函数，所以其返回类型是匿名对象类型
    private fun foo() = object {
        val x: String = "x"
        val y: String = "y"
    }

    // 这个跟上一个是差不多一样的哦
    private val foo = object {
        val x: String = "x"
        val y: String = "y"
    }

    // 公有函数，所以其返回类型是 Any
    fun publicFoo() = object {
        val x: String = "x"
    }

        val x1 = foo().x        // 没问题
        val y1 = foo().y        // 没问题
        val x2 = publicFoo()  // val x2 = publicFoo().x 错误：未能解析的引用“x”
        val x3 = foo.x

在对象表达中可以方便的访问到作用域中的其他变量:

var clickCount = 0

btnOperator.setOnClickListener {
    clickCount++;
}

对象声明

Kotlin 使用 object 关键字来声明一个对象。
Kotlin 中我们可以方便的通过对象声明来获得一个单例。是的，都是同一个数据，让我们看看下面两个例子

    object DataProviderManager {
        const val name = "name"
        fun registerDataProvider() {
        }
    }
        DataProviderManager.registerDataProvider()
        DataProviderManager.name

    object Site {
        var url:String = ""
        val name: String = "zhongjh"
    }
        val s1 = Site
        val s2 = Site
        s1.url = "www.zhongjh.com"
        tvContent.append("${s1.url}\n")
        tvContent.append("${s2.url}\n")

可以看到，都是同个对象

所以他们分别输出的结果都是一样：

结果

对象声明有以下两点不能访问：

• 内部对象不能直接访问到外部类的方法和变量。
• 对象声明后不能通过外部类的实例访问到该对象，而只能通过类名来访问。

    class ZhongJH {
        var name = "zhongjh"
        object DeskTop{
            var url = "www.zhongjh.com"
            fun showName(){
//                print{"desk legs $name"} // 错误，不能访问到外部类的方法和变量
            }
        }
    }

        var zhongjh = ZhongJH()
//        zhongjh.DeskTop.url  // 错误，不能通过外部类的实例访问到该对象
        ZhongJH.DeskTop.url  // 正确

伴生对象

类内部的对象声明可以用 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()
    }
}

对象表达式和对象声明之间的语义差异

对象表达式和对象声明之间有一个重要的语义差别：

• 对象表达式是在使用他们的地方立即执行的
• 对象声明是在第一次被访问到时延迟初始化的
• 伴生对象的初始化是在相应的类被加载（解析）时，与 Java 静态初始化器的语义相匹配