Kotlin学习笔记（十一）【对象表达式】

Kotlin 对象表达式和对象声明

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

对象表达式

通过对象表达式实现一个匿名内部类的对象用于方法的参数中：

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

            }
        })

对象可以继承于某个基类，或者实现其他接口:

fun main(args: Array<String>) {
    val a = object : A(1), B {
        override fun b() {

        }
    }
}

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

interface B {
    fun b()
}

如果超类型有一个构造函数，则必须传递参数给它。多个超类型和接口可以用逗号分隔。

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

fun main(args: Array<String>) {
    val person = object {
        val name = "qfxl"
        val age = 25
    }

    println("nams is ${person.name} age is ${person.age}")
}

打印结果
nams is qfxl age is 25

请注意，匿名对象可以用作只在本地和私有作用域中声明的类型。如果你使用匿名对象作为公有函数的 返回类型或者用作公有属性的类型，那么该函数或属性的实际类型 会是匿名对象声明的超类型，如果你没有声明任何超类型，就会是 Any。在匿名对象 中添加的成员将无法访问。

class A {
    //私有函数，所以其返回类型是匿名对象类型
    private fun b() = object {
        val name = "qfxl"
    }

    //公有函数，所以其返回类型是 Any
    fun c() = object {
        val name = "qfxl"
    }

    fun test() {
        b().name //正常访问
        c().name //无法访问到（类型变成了Any）
    }
}

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

        var index = 0
        btn.setOnClickListener(object : View.OnClickListener {
            override fun onClick(v: View?) {
                index++
            }
        })

对象声明

Kotlin 使用 object 关键字来声明一个对象。
Kotlin 中我们可以方便的通过对象声明来获得一个单例。

fun main(args: Array<String>) {
    //直接引用
    MySubscriber.addSubscriber(Subscriber())
}

object MySubscriber {
    val subscribers = ArrayList<Subscriber>()
    fun addSubscriber(subscriber: Subscriber) {
        subscribers.add(subscriber)
    }

    val allSubscribers: ArrayList<Subscriber>
        get() = subscribers
}

class Subscriber

当然你也可以定义一个变量来获取获取这个对象，当时当你定义两个不同的变量来获取这个对象时，你会发现你并不能得到两个不同的变量。也就是说通过这种方式，我们获得一个单例。

fun main(args: Array<String>) {
    val a = MySubscriber
    a.addSubscriber(Subscriber())
    val b = MySubscriber
    println("b's subscribers length = ${b.allSubscribers.size}")
}

打印结果
b’s subscribers length = 1

再来一个实例：

fun main(args: Array<String>) {
    val p1 = Person
    p1.name = "qfxl"
    val p2 = Person
    println("p2 name is ${p2.name}")
}

object Person {
    var name = ""
    var age = 0
}

输出结果
p2 name is qfxl

对象可以有超类型：

object MyClickListener : ClickListener{
    override fun click() {

    }
}
interface ClickListener {
    fun click()
}

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

fun main(args: Array<String>) {
    val p = Person()
    p.Qfxl.name //错误！不能通过外部类的实例访问到该对象
    Person.Qfxl.name //正确
}

class Person {
    object Qfxl {
        val name = "qfxl"
    }
}

伴生对象

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

fun main(args: Array<String>) {
    val instance = Sample.create()
}

class Sample {
    companion object {
        fun create() : Sample = Sample()
    }
}

注意：一个类里面只能声明一个内部关联对象，即关键字 companion 只能使用一次。
请伴生对象的成员看起来像其他语言的静态成员，但在运行时他们仍然是真实对象的实例成员。例如还可以实现接口：

fun main(args: Array<String>) {
    val instance = Sample.create()
}

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

class Sample {
    companion object : Factory<Sample>{
        override fun create(): Sample {
            return Sample()
        }
    }
}

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

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

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