Kotlin 对象表达式和对象声明

2017-09-27 本文已影响0人郎官人

有时候，我们需要对某个类进行轻微的改动（比如重写或实现某个方法等），而又不用再显示声明新的子类，这时候，我们是怎么处理的呢?

Java 中提供了匿名内部类来应对这种情况

Kotlin 中则采用对象表达式和对象声明来解决.

对象表达式

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

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

即：

object:TypeClass(){
    ....
}

对象可以继承于某个基类，或者实现其他接口,如果父类有一个构造函数，则必须传递适当的构造函数参数给它。多个超类型和接口可以用逗号分隔：

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)
}

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

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

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

与Java 一样，Kotlin 在对象表达中也可以方便的访问到作用域中的其他变量，唯一的区别是Java需要对局部变量进行 final 修饰，Kotlin则不必：

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++
        }
    })
    // ……
}

对象声明

在上面的示例中，我们已经发现在Kotlin中是通过关键字 object 来声明一个对象，下面我们来创建一个单例：

package com.talent.kotlin.example

object SingleTonExample {
    
}

你没看错，声明一个单例就是这么简单.那么在字节码中它被编绎成什么样了呢?用jd-gui查看如下：

public final class SingleTonExample
{
  public static final SingleTonExample INSTANCE;

  //类的加载最后一步是初始化,即对类的静态变量和静态代码块执行初始化工作, 这里的静态代码块获取一个Singleton()对象, 并赋值给INSTANCE静态变量
  static
  {
    new SingleTonExample();
  }
  private SingleTonExample()
  {
    INSTANCE = (SingleTonExample)this;
  }
}

看吧!就是java中的写法。

现在我们添加一个方法，再来访问：

package com.talent.kotlin.example

object SingleTonExample {

    fun handleMessage(msg:String){
        print("receive message:$msg")
    }
}

调用：

fun doMain(){
    SingleTonExample.handleMessage("msg")
}

当然你也可以能过定义一个变量来调用它，像下面这样：

fun doMain(){
    var single  = SingleTonExample
    single.handleMessage("msg")
}

那么还有没有其它的单例方式呢？当然是有的：

通过伴生对象(下面会讲伴生对象这个概念)

package com.talent.kotlin.example

class SingleTonExample private constructor(){

    companion object {
        val instance = SingleTonExample()
    }

    fun handleMessage(msg:String){
        print("receive message:$msg")
    }
    //调用
    fun call(){
        SingleTonExample.instance.handleMessage("msg")
    }
}

懒汉式的单例实现方法(有没有想起Java的饿汉式，懒汉式?)

package com.talent.kotlin.example

class SingleTonExample private constructor(){

    private object Holder{
        val single = SingleTonExample()
    }

    companion object {
       val instance :SingleTonExample by lazy { Holder.single }
    }

    fun handleMessage(msg:String){
        print("receive message:$msg")
    }
    //调用
    fun call(){
        SingleTonExample.instance.handleMessage("msg")
    }
}

同样地，单例可以有超类的：

package com.talent.kotlin.example

object SingleTonExample:Functions("singleto") {

    fun handleMessage(msg:String){
        print("receive message:$msg")
    }
}

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

class Site {
    var name = "site"
    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 // 正确
}

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

伴生对象

其实我们在扩展一节中，讲到伴生对象扩展时就提到过“伴生对象”这个词。

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

伴生对象的成员看起来像其他语言的静态成员，但在运行时他们仍然是真实对象的实例成员

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

如你所见，使用 companion 关键字来声明伴生对象，其中伴生对象的名称（上文中的“Factory”）是可以省略的，缺省情奖品下名称为 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()
    }
}

这里我们同样看一下，上述代码在字节码中变成了什么样：

  public static abstract interface Factory<T>
  {
    public abstract T create();
  }
  
  public static final class MyClass
  {
    public static final Companion Companion = new Companion(null);
    
    public static final class Companion
      implements CompainC.Factory<CompainC.MyClass>
    {
      @NotNull
      public CompainC.MyClass create()
      {
        return new CompainC.MyClass();
      }
    }
  }

这里我们发现，Kotlin中好像没有静态方法或静态属性?实质上只是用创建一个静态对象达到了类似的效果。

语义差异

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

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

Kotlin 对象表达式和对象声明

对象表达式

对象声明

伴生对象

语义差异

猜你喜欢

热点阅读