Kotlin快速入门系列9

Kotlin对象表达式和对象声明

对象表达式

有时，我们想要创建一个对当前类有些许修改的对象同时又不想重新声明一个子类。如果是Java，可以用匿名内部类的概念来解决这个问题。kotlin的对象表达式和对象声明就是为了实现这一点(创建一个对某个类做了轻微改动的类的对象，且不需要去声明一个新的子类)。

对象表达式的格式：

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

例如下例常见的，通过对象表达式实现的将一个匿名内部类的对象用于方法的参数中：

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

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

fun main(args: Array) {
    val site = object {
        var tips: String = "谷歌大法好"
        var url: String = "www.Google.com"
    }
    println(site.tips)
    println(site.url)
}

对应的控制台输出为：

如果超类有构造器，则需要传入合适的参数。多个超类在冒号之后使用逗号分隔，大抵格式如下：

open class BaseA(x: Int){
    public open val num: Int = x
}

interface InterfaceB {...}

val ab: A = object : BaseA(1) , InterfaceB{
    override val num = 15
}

用作类型的匿名对象，只能在局部和私有声明中。如果使用匿名对象作为public函数的返回值，或public属性的类型，则函数或属性的实际类型实际为匿名类的超类或Any（未声明任何超类）。匿名对象添加的成员不能被访问。下面是一个官网的例子：

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

    // Public函数，返回类型为Any
    fun publicFoo() = object {
        val x: String = "FOO"
    }

    fun bar() {
        val x1: String = foo().x  // 有效
        val x2: String = publicFoo().x // 提示错误：无法引用x
    }
}

对象声明

在Kotlin中，使用 object 关键字来声明一个(单例)对象。这点跟Java是完全不一样的，在Java中，必须先有类，然后才能new出该类的对象并生成实例，也就是声明类和创建对象是两个分开的步骤，并有先后次序。在Kotlin中，我们可以使用object关键字在声明定义一个类的同时创建出一个对象，这就是所谓的对象声明。

使用方法极其简单，在 object 关键字后跟⼀个名称即可，这样就直接声明了一个单例对象。

object DataProviderManager {
    fun registerDataProvider(provider: DataProvider) {
// ……
    }
    val allDataProviders: Collection
        get() = // ……
}

要引⽤该对象，直接使⽤其名称即可：

DataProviderManager.registerDataProvider(……)

注意这里是单例，当你定义两个不同的变量来获取这个对象时，你会发现你并不能得到两个不同的变量，如下例我们只对一个对象实例进行了属性更改，但打印两个对象实例都会得到更改的属性：

object WebSite {
    var url:String = ""
    val web: String = "谷歌大法好"
}
fun main(args: Array) {
    var s1 = WebSite
    var s2 = WebSite
    s1.url = "www.Google.com"
    println(s1.url)
    println(s2.url)
}

对应的控制台输出为：

与对象表达式不同的是，当对象声明在另一个类的内部时，这个对象并不能通过外部类的实例访问到该对象，而只能通过类名来访问，同样该对象也不能直接访问到外部类的方法和变量。

object WebSite {
    var web = "谷歌大法好"
    object DeskTop{
        var url = "www.Google.com"
        fun showName(){
            print{"desk legs $web"} // 错误，不能访问到外部类的方法和变量，打印结果为：Function0
        }
    }
}
fun main(args: Array) {
    var site = WebSite
    site.DeskTop.url // 提示错误，不能通过外部类的实例访问到该对象
    WebSite.DeskTop.url // 调用方式正确
}

伴生对象 

跟Java不同，在kotlin中，类是没有static方法的。多数情况下，Kotlin推荐的做法是使用包级别的函数作为静态方法。这里就引申除了另外一个关键字，companion。

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

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

val instance = DemoClass.create()   // 变量可直接访问到对象的内部元素

我们可以直接省略掉该对象的对象名，然后使用 companion 替代需要声明的对象名：

class DemoClass {
    companion object {
    }
}

val instance = DemoClass.Companion

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

伴生对象的成员看起来像其他语言的静态成员，但在运行时他们仍然是真实对象的实例成员。在 JVM 平台，如果使⽤ @JvmStatic 注解，你可以将伴⽣对象的成员⽣成为真正的静态⽅法和字段。

差异性

最后总结下，对象表达式和对象声明之间有一个重要的语义差别：

· 对象表达式是在使用他们的地方立即执行的；

· 对象声明是在第一次被访问到时延迟初始化的；

· 伴生对象的初始化是在相应的类被加载（解析）时，与 Java 静态初始化器的语义相匹配。