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 靜態初始化器的語義相匹配