阅读 434
Kotlin学习笔记(六)对象表达式与对象声明

Kotlin学习笔记(六)对象表达式与对象声明

前言 本文章只是用于记录学习,所以部分地方如果有错误或者理解不对的地方,麻烦请指正。

Kotlin 学习笔记(五)

  Java中,不管是为了实现接口,或者是抽象类,我们总是习惯使用匿名内部类。最熟悉的例子,莫过于对单击事件的监听.

btn.setOnClickListener(new OnClickListener{
    // 处理单击事件逻辑
});
复制代码

  Kotlin没有匿名内部类,恰巧其用object一个简单的关键字,解决了这一个问题,我们一起来学习下。

对象表达式

对象表达式更倾向于表达式这一点,针对 java 中点击事件的使用,我们演示下再kotlin 中如何编写

btn.setOnClickListener(object : OnClickListener{
});
复制代码

  对象表达式内的代码可以访问创建这个对象的代码范围内的变量,与Java不同的是,被访问的变量不需要被限制为final变量(挺爽的)。

var a = 10

val listener = object {
    fun doClick() {
        println("a:$a")
    }

}

listener.doClick() // 打印 a:10
复制代码

  当然我们也可以只是用对象

val adHoc = object {
    var x: Int = 0
    var y: Int = 0
}

print(adHoc.x + adHoc.y)
复制代码

  接下来我们看一下 对象在继承实现方面的使用

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

interface B {……}

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

  如果超类型有一个构造函数,则必须传递参数给它。多个超类型和接口可以用逗号分隔。

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

2. 对象声明

  所谓的对象声明,我们可以理解为 java 中的单例模式。

object Site {
    var url:String = ""
    val name: String = "ymc"
}
fun main(args: Array<String>) {
    var s1 =  Site
    var s2 = Site
    s1.url = "www.google.com"
    println(s1.url)
    println(s2.url)
}
复制代码

输出结果

www.google.com
www.google.com
复制代码

  可以看到,object 指向的对象是同一个。

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

class ObjectDemo {
    var objName = "菜鸟教程"
     object DeskTop{
        var url = "www.runoob.com"
        fun showName(){
            print{"desk legs $objName"} // 错误,不能访问到外部类的方法和变量
        }
    }
}

fun main(args: Array<String>) {
	ObjectDemo.DeskTop.url  //只能通过类名 访问到,而不能通过实例
    val obj = ObjectDemo()
    obj.objName    // 通过实例 不能访问到 ObjectDemo 对象
}
复制代码

3. 伴生对象

  类内部的对象声明可以用 companion 关键字标记,这样它就与外部类关联在一起,我们就可以直接通过外部类访问到对象的内部元素。当然我们也可以省略对象的对象名,使用 Companion 来代替

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

val instance = MyClass.create()   // 访问到对象的内部元素

--------------------------
// 也可以这样写
class MyClass {
    companion object {
    }
}

val x = MyClass.Companion  //直接使用 companion 代替
复制代码

**注意:**一个类里面只能声明一个内部关联对象,即关键字 companion 只能使用一次。

请伴生对象的成员看起来像其他语言的静态成员,但在运行时他们仍然是真实对象的实例成员。例如还可以实现接口:

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


class MyClass {
    companion object : Factory<MyClass> {
        override fun create() : MyClass{
            return MyClass()
        }
    }
}
复制代码

Kotlin 学习笔记(七)

文章分类
Android
文章标签