kotlin学习之对象

kotlin的对象

对象表达式和对象声明

官方说明

有时候，我们需要创建一个对某个类做了轻微改动的类的对象，而不用为之显式声明新的子类。 Kotlin 用对象表达式和对象声明处理这种情况。

简单的说,对象表达式就是匿名类和内部类在kotlin里的使用说明,对象声明就是静态类,和静态属性的说明

对象表达式

创建某个类型的匿名类对象,必须使用object关键字

window.addMouseListener(object : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) { /*……*/ }

    override fun mouseEntered(e: MouseEvent) { /*……*/ }
})

要实现多个超类的匿名对象可以使用逗号分隔

	var a = object : View.OnTouchListener, View.OnDragListener {
		override fun onTouch(v: View?, event: MotionEvent?): Boolean {
			TODO("Not yet implemented")
		}

		override fun onDrag(v: View?, event: DragEvent?): Boolean {
			TODO("Not yet implemented")
		}

	}

如果这个类型有构造函数,那我们必须要传递适当的构造函数给它

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

interface B { /*……*/ }

val ab: A = object : A(1), B {
    override val y = 15
}

任何时候，如果我们只需要“一个对象而已”，并不需要特殊超类型，那么我们可以简单地写：

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

匿名对象的作用域

匿名对象只作用于本地和私有作用域的声明类型,不能作为公有函数或者属性的类型,如果使用则会返回他的超类,如果没有超类则返回any,在匿名对象里添加的成员将无法访问

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

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

    fun bar() {
        val x1 = foo().x        // 没问题
        val x2 = publicFoo().x  // 错误：未能解析的引用“x”
    }
}

对象表达式中的代码可以访问来自包含它的作用域的变量。

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 DataProviderManager {
    fun registerDataProvider(provider: DataProvider) {
        // ……
    }

    val allDataProviders: Collection<DataProvider>
        get() = // ……
}

//如需引用该对象，我们直接使用其名称即可：
DataProviderManager.registerDataProvider(……)

这样称为对象声明,在object关键字后跟一个名称,像声明属性一样,对象声明不是表达式,所以不可以在赋值语句的右边

//错误示范
var a = object DataProviderManager {
    fun registerDataProvider(provider: DataProvider) {
        // ……
    }

    val allDataProviders: Collection<DataProvider>
        get() = // ……
}

单例对象可以有超类型

object DefaultListener : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) { …… }

    override fun mouseEntered(e: MouseEvent) { …… }
}

：对象声明不能在局部作用域（即直接嵌套在函数内部），但是它们可以嵌套到其他对象声明或非内部类中。

伴生对象

类内部的伴生对象可以用companion关键字标记,实现类似于静态属性

class MyClass {
    companion object Factory {
        fun create(): MyClass = MyClass()
    }
}
//该伴生对象的成员可通过只使用类名作为限定符来调用：
val instance = MyClass.create()

可以省略伴生对象的名称，在这种情况下将使用名称Companion：

class MyClass {
    companion object { }
}

val x = MyClass.Companion

其自身所用的类的名称（不是另一个名称的限定符）可用作对该类的伴生对象 （无论是否具名）的引用：

class MyClass1 {
    companion object Named {
		    var i= 8
	}
}

val x = MyClass1 //这样代表的是这个类的伴生类可以调用伴生对象 可以使用 x.i
val x = MyClass1()//这样代表的是这个类的实例对象象 不可以使用 x.i

class MyClass2 {
    companion object { 
		    var i= 8
	}
}
val y = MyClass2

请注意，即使伴生对象的成员看起来像其他语言的静态成员，在运行时他们仍然是真实对象的实例成员，而且，例如还可以实现接口：

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

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

val f: Factory<MyClass> = MyClass