Kotlin学习(八): 对象表达式和声明(Object Expressions and Declarations)

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

Kotlin学习(八): 对象表达式和声明(Object Expressions and Declarations)_第1张图片
Kotlin

下面我们来继续学习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
        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 {
    fun create(): T
}


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

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

对象表达式和声明的区别

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

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

你可能感兴趣的:(Kotlin学习(八): 对象表达式和声明(Object Expressions and Declarations))