Kotlin学习笔记14——object关键字

前言

上一篇，我们学习了Kotlin中的泛型，今天继续来学习Kotlin中的object关键字用法。

对象表达式

要创建一个继承自某个（或某些）类型的匿名类的对象，我们会这么写：

editText.addTextChangedListener(object : TextWatcher{
    override fun afterTextChanged(s: Editable?) {
        /*...*/
    }
    override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
        /*...*/
    }
    override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
        /*...*/
    }
})

等同于java代码：

editText.addTextChangedListener(new TextWatcher() {
    @Override
    public void beforeTextChanged(CharSequence s, int start, int count, int after) {
		/*...*/
	}
    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count) {
		/*...*/
	}
    @Override
    public void afterTextChanged(Editable s) {
		/*...*/
	}
});

如果超类型有一个构造函数，则必须传递适当的构造函数参数给它。 多个超类型可以由跟在冒号后面的逗号分隔的列表指定：

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 main(args: Array<String>) {
    val site = object {
        var name: String = "菜鸟教程"
        var url: String = "www.runoob.com"
    }
    println(site.name)
    println(site.url)
}

请注意，匿名对象可以用作只在本地和私有作用域中声明的类型。如果你使用匿名对象作为公有函数的 返回类型或者用作公有属性的类型，那么该函数或属性的实际类型 会是匿名对象声明的超类型，如果你没有声明任何超类型，就会是 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

    editText.addTextChangedListener(object : TextWatcher{
	    override fun afterTextChanged(s: Editable?) {
	        clickCount ++
	    }
	    override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
	        enterCount ++
	    }
	    override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
	        enterCount ++
	    }
	})
    // ……
}

对象声明

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

object DataProviderManager {
    fun registerDataProvider(provider: DataProvider) {
        // ……
    }

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

引用该对象，我们直接使用其名称即可：

DataProviderManager.registerDataProvider(……)

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

var data1 = DataProviderManager
var data2 = DataProviderManager
print("$data1 === $data2")  
//比较两个对象地址，返回true

对象可以有超类型：

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

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

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

class Site {
    var name = "菜鸟教程"
    object DeskTop{
        var url = "www.runoob.com"
        fun showName(){
            print{"desk legs $name"} // 错误，不能访问到外部类的方法和变量
        }
    }
}
fun main(args: Array<String>) {
    var site = Site()
    site.DeskTop.url // 错误，不能通过外部类的实例访问到该对象
    Site.DeskTop.url // 正确
}

用一个简单例子来感受下使用object关键字来实现饿汉式单例：

//Java实现
public class SingletonDemo {
    private static SingletonDemo instance=new SingletonDemo();
    private SingletonDemo(){

    }
    public static SingletonDemo getInstance(){
        return instance;
    }
}
//Kotlin实现
object SingletonDemo

调用：

//Java
SingletonDemo singleObj = SingletonDemo.getInstance();
//Kotlin
var singleObj = SingletonDemo

哈哈，kotlin人狠话不多，就一行代码，只能说干得漂亮。

伴生对象

类内部的对象声明可以用 companion 关键字标记，这样它就与外部类关联在一起，我们就可以直接通过外部类访问到对象的内部元素。类似于java中的静态方法或者静态变量。

class MyClass {
    companion object Factory {
        const val name:String = "Jim"
        fun create(): MyClass = MyClass()
    }
}
val instance = MyClass.create()   // 相当于Java静态方法
val nameStr = Myclass.name    // 相当于Java静态变量

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

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

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

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

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

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

尾巴

今天的学习笔记就先到这里了，下一篇我们将继续学习Kotlin中的委托。
老规矩，喜欢我的文章，欢迎素质三连：点赞，评论，关注，谢谢大家！