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注解，可以有多个伴生对象作为静态方法和属性。
对象表达式和声明的区别
对象表达式和对象声明之间的差别：
- 在使用的时候，对象表达式立即被执行（和初始化）
- 当第一次访问的时候，对象声明被初始化
- 当类加载的时候，会初始化伴生对象，与Java的静态初始化是匹配的。
