Kotlin学习_对象表达式和声明（Object Expressions and Declarations）

2017年的Google I/O大会上谷歌宣布Kotlin正式成为Android的官方语言。

下面我们来继续学习Kotlin中的对象表达式和声明(Object Expressions and Declarations)的相关知识。

对象表达式和声明(Object Expressions and Declarations)

在写代码的时候，会创建一个对当前类做轻微修改的对象，而不用重新声明一个子类，Kotlin 中用对象表达式和声明来解决这个问题。

对象表达式(Object expressions)

在Android里面，我们对一些点击事件的监听的时候，会使用到匿名内部类

fab.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG).setAction("Action", null).show();
    }
});

而在Kotlin中，就用对象表达式来替换匿名内部类，是这样子来写的

fab.setOnClickListener(
            object : View.OnClickListener {
                override fun onClick(v: View?) {
                    
                } 
            })
// 上面可以使用Lambdas简写成
// fab.setOnClickListener( View.OnClickListener { })

如果父类有构造函数，则必须传递相应的构造函数。多个父类可以用逗号隔开，写在冒号后面

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

interface B {...}

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

当只需要一个对象just an object，没有父类的情况下

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

就像Java的匿名内部类一样，对象表达式中的代码可以访问封闭范围的变量。

fun countClicks(window: JComponent) {
    var clickCount = 0 // 如果是Java的话这里要加上final
    var enterCount = 0 // 这里也是

    window.addMouseListener(object : MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) {
            clickCount++
        }

        override fun mouseEntered(e: MouseEvent) {
            enterCount++
        }
    })
    // ...
}

与Java不同，封闭范围的变量不需要声明为final

对象声明(Object declarations)

在写项目的时候，一般会将常量统一写到一个类里面，然后设置静态变量，由于在Kotlin中不存在静态变量，所有就有对象声明的存在，对象声明比较常用的地方就是在这里，对象声明用Objcet关键字表示。

object Constant {
    /**
     * baseUrl
     */
    val REQUEST_BASE_URL = "http://gank.io/api/"

    /**
     * all | Android | iOS | 休息视频 | 福利 | 拓展资源 | 前端 | 瞎推荐 | App
     */
    val ALL = "all"
    val ANDROID = "Android"
    val IOS = "iOS"
    val WELFARE = "福利"
    val REST_VIDEO = "休息视频"
    val EXPAND_RESOURCES = "拓展资源"
    val WEB = "前端"
    val RECOMMEND = "瞎推荐"
    val APP = "App"
}

Kotlin声明单例模式特别简单，如果在Java中声明

public class Singleton {
    private static Singleton instance = null;

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

在Kotlin中声明

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

在名字面前加object关键字，这样子的声明叫做对象声明，对象声明不算是表达式。

由于对象声明不算是表达式，所以不能直接赋值给变量。

如果要引用对象，我们直接使用其名称：

DataProviderManager.registerDataProvider(...)

这样的对象可以有父类

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

对象声明不可以是局部的(比如不可以直接在函数内部声明)，但可以在其它对象的声明或非内部类中使用。

伴生对象(Companion Objects)

一个类可以设置对象声明，那么在类的内部可不可以使用对象声明呢，答案是可以的，使用companion关键字声明，这样子的对象称为伴生对象(Companion Objects)。

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

伴生对象的成员可以通过类名做限定词直接使用

val instance = MyClass.create()

在使用了 companion 关键字时，可以省略伴生对象的名字

class MyClass {
    companion object {
    }
}

val x = MyClass.Companion

伴生对象的成员可以看着是静态变量，但是与静态变量还是有区别的，比如在运行时它们任然是真正对象的成员实例，比如可以实现接口等

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


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

如果在JVM上使用@JvmStatic注解，可以有多个伴生对象作为静态方法和属性。

声明静态方法

使用@JvmStatic在对象声明和伴生对象上面声明静态方法

// 伴生对象
class Foo() {
    companion object {
        @JvmStatic
        fun test() {

        }
    }
}
// 对象声明
object Constant {
    
    @JvmStatic
    fun test() {

    }
}

生成的内容

Java调用的时候

public class TestClass {

    public void get() {
        Constant.test();
        Foo.test();
    }

}

对象表达式和声明的区别

对象表达式和对象声明之间的差别：

• 在使用的时候，对象表达式立即被执行（和初始化）
• 当第一次访问的时候，对象声明被初始化
• 当类加载的时候，会初始化伴生对象，与Java的静态初始化是匹配的。