Kotlin for android学习七：对象表达式与对象声明

前言

kotlin官网和kotlin教程学习教程的笔记。

背景

有时我们需要创建一个对象, 这个对象在某个类的基础上略做修改, 但又不希望仅仅为了这一点点修改就明 确地声明一个新类. Java 通过 匿名内部类(anonymous inner class) 来解决这种问题. Kotlin 使用 对象表达 式(object expression) 和 对象声明(object declaration), 对这个概念略做了一点泛化.

一、对象表达式

类似匿名内部类
1. 通过对象表达式实现一个匿名内部类的对象用于方法的参数中

 recyclerview.addOnScrollListener(object :RecyclerView.OnScrollListener(){
})

textView.setOnClickListener(object :View.OnClickListener{
   override fun onClick(p0: View?) {
   }
})

**2.对象可以继承于某个基类，或者实现其他接口 **

open class A {}
interface B {}

 val ab = object : A(), B {}

如果, 我们 “只需要对象”, 而不需要继承任何有价值的基类

val ab = object{
            val a=0
            val b=1
        }
 println(ab.a + ab.b)

3. 注意

匿名对象可以用作只在本地和私有作用域中声明的类型。如果你使用匿名对象作为公有函数的返回类型或者用作公有属性的类型，那么该函数或属性的实际类型会是匿名对象声明的超类型，如果你没有声明任何超类型，就会是 Any。在匿名对象中添加的成员将无法访问。

class User {
   //私有函数，所以其返回类型是匿名对象类型
   private fun foo() = object {
       val x = "x"
   }

   //公有函数，所以其返回类型是 Any
   fun pfoo() = object {
       val x = "px"
   }

   //返回类型是Any，则无法访问匿名对象中的成员
   private fun afoo(): Any = object {
       val x = "x"
   }

   fun check() {
       val x1 = foo().x //ok
       val x2 = pfoo().x //unresolved 错误
       val x3=afoo().x //unresolved 错误
   }
}

二、对象声明

类似单例

1. Kotlin中使用object关键字来声明一个对象，因此可以方便的声明一个单例：

object Site {
    var url: String = ""
    val name: String = ""
    fun foo() {}
}

fun main(args: Array<String>) {
    val s1 = Site
    val s2 = Site
    s1.url = "www.kotlin.com"
    println(s1.url) // 输出 www.kotlin.com
    println(s2.url) // 输出 www.kotlin.com
}

2. 当对象声明在一个类的内部

class User {
    val name = "user"
    object Site {
        var url: String = ""
        fun foo() {
            val c = name //错误，不能访问到外部类的方法和变量
        }
    }
}

fun main(args: Array<String>) {
    var s1 = User.Site //ok
    var s2 = User().Site //错误，不能通过外部里的实例访问到该对象
}

三、同伴对象

还记得扩展函数与扩展属性这一节中，我们引入了同伴对象么？这里在详细的说明一下，顺便知识回顾

 class User { 
   companion object { //同伴对象
        fun foo(){  }
   }
}
User.Companion.create() //默认命名的调用
User.create() //可以忽略名称调用

当然我们也可以给同伴对象命名

class User {
    companion object Factory{
        fun create():User= User()
    }
}
User.Factory.create() //命名后的调用
User.create() //忽略名称的调用

注意, 虽然同伴对象的成员看起来很像其他语言中的类的静态成员(static member), 但在运行时期, 这些成员仍然是真实对象的实例的成员, 它们与静态成员是不同的

例如, 它可以实现接口:

interface B{
    fun create():User
}
class User {
    companion object :B{
        override fun create():User= User()
    }
}

   User.create()

四、对象表达式与对象声明在语义上的区别

• 对象声明是 延迟(lazily) 初始化的, 只会在首次访问时才会初始化
• 对象表达式则会在使用处 立即 执行(并且初始化)

参考资料

菜鸟教程