KotLin 相关文档

官方在线Reference
kotlin-docs.pdf
Kotlin for android Developers 中文翻译
Kotlin开发工具集成，相关平台支持指南
Kotlin开源项目与Libraries
Kotlin开源项目、资源、书籍及课程搜索平台
Google’s sample projects written in Kotlin
Kotlin and Android

object表达式(匿名对象)

a. 上一节，介绍了如下，用object来 声明一个匿名内部类：

addAdapter(object : MouseAdapter {
    override fun mouseClicked(e: MouseEvent) {
        // ...
    }
    override fun mouseEntered(e: MouseEvent) {
        // ...
    }
})

b. 这里用的object:是继承语义，所以其之后可以跟一个或多个类(接口)

如，还继承了类 ： open class Comb(val x:Int) ：

addAdapter(object : MouseAdapter, Comb(33) {…} )

c. 再比如，有时想将一个局部变量声明为一个对象，但又不是一般的内部类：

fun foo() {
    val adHoc = object {
        var x: Int = 0
        var y: Int = 0
    }
    print(adHoc.x + adHoc.y)
}

d. 在函数表达式中，使用object创建匿名对象，需要注意该函数表达式的可访问性声明，是否是public的：

class BO {
    private fun test2()= object {
        val x = 77
    }
    fun test3() = object {
        val x = 88
    }

    fun bar() {
        val x2 = test2().x // worked
//      val x3 = test3().x // ERROR: Unresolved reference 'x'
    }
}

上例，public 修饰的函数， 内部的公共成员 无法被访问
 

e. kotlin 匿名对象中 访问外面的局部变量时，不需要final 关键字

fun countClicks(window: JComponent) {
    var clickCount = 0
    var enterCount = 0
    window.addMouseListener(object : MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) {
            clickCount++
        }
        override fun mouseEntered(e: MouseEvent) { 
            enterCount++
        }
    })
}

object 声明一个类

a. 如下，以object来声明一个类时，表示这是一个单例类

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

b. 可以继承一个基类

object DefaultListener : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) {
        // ...
        }
    override fun mouseEntered(e: MouseEvent) {
        // ...
    }
}

c. 不能嵌套在一个函数内

fun cc() {
    object AA {} //error
}

d. 可嵌套在一个object 声明的类中

object Outer {
    object Internal
}

e. 可嵌套在一个非inner class中 (inner class 即java中的 成员内部类)
也就是说，可嵌套在一个静态内部类中：

class Outer {
//    inner class Internal {
//        object Inter //error
//    }

    class Internal {
        object Inter
    }
}

f. 可用在companion关键字后， 可见 companion类 是一个非 inner class

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

g. companion object可以有自己的静态方法和属性

interface Factory<T> { 
    fun create(): T
}
class MyClass {
    companion object : Factory<MyClass> {
        override fun create(): MyClass = MyClass()
    }
}

object表达式和object声明的不同语义

含object 的函数表达式， 是被立即执行且初始化的 (初始化一个匿名对象)

object 声明一个类，是 initialized lazily， 在首次被访问时，才初始化

companion object，这是一个静态内部类，即在类加载时就会被初始化，与java中 静态块 “static {}” 语义相匹配