kotlin基础5：重要的object关键字

一、通过object:实现对象表达式，从而 使用匿名类的对象

fun main(args: Array<String>) {
    var str = "123456"
    setOnMyTouchListener(object : OnMyTouchListener {
        override fun onTouch() {
            kotlin.io.println("onTouch...")
            kotlin.io.println("访问外部属性：$str")
        }

    })
}

interface OnMyTouchListener {
    fun onTouch()
}


fun setOnMyTouchListener(onMyTouchListener: OnMyTouchListener) {
    onMyTouchListener.onTouch()
}

运行结果：

二、通过object:实现对象表达式，从而实现使用匿名类的对象的时候实现一个或多个接口或者继承一个父类

这种场景在java中是无法实现的

kotlin的对象表达式可以做到

fun main(args: Array<String>) {
    var son: Parent = object : Parent(10), Eat, Sleep {   //son: Parent Parent、Eat、 Sleep其中一种类型

        override fun sleep() {
            print("sleep...")
        }

        override fun eat() {
            print("eat...")
        }

    }
    son.eat()    //编译错误，因为son指定为了Parent 类型，无法调用Eat的eat方法
    son.sleep() //编译错误，因为son指定为了Parent 类型，无法调用Sleep的sleep方法

}


interface Sleep {
    fun sleep()
}

interface Eat {
    fun eat()
}

虽然kotlin支持这种写法，但是却只能指定一种类型，无法调用多个接口的方法，所以笔者也不清楚这种写法的应用场景在哪里。

三：通过object实现对象表达式，直接得到一个对象：

fun main(args: Array<String>) {
    val phone = object {
        var name: String = "phone"
        var price: Int = 2999
    }
    kotlin.io.println(phone.name)
    kotlin.io.println(phone.price)

}

运行结果：

但是需要注意，通过object得到的对象如果用作公有函数的 返回类型或者用作一个类的公有属性,那么该对象的实际类型会是匿名对象声明的超类型，如果没有声明任何父类型，那么该对象的实际类型就是 Any，那么该类型除了 Any的属性外都会访问不到

class Test{
    var Obj1 = object{
        val x: String = "x"
    }
    private var Obj2 = object{
        val x: String = "x"
    }

    private fun getObj1() = object{
        val x: String = "x"
    }

     fun getObj2() = object{
        val x: String = "x"
    }

    fun bar() {
        val x1 = getObj1().x        // 可以访问
        val x2 = getObj2().x  //访问不到
        Obj1.x  //访问不到
        Obj2.x   // 可以访问
    }

}

四、object修饰对象的类名（对象声明）获得单例对象

object Ball{
    var name:String = "default ball name"
}

fun main(args: Array<String>) {
    var ball_1 = Ball
    var ball_2 = Ball
    kotlin.io.println("直接通过Ball获取属性值：${Ball.name} ")
    kotlin.io.println(" ball_1和ball_2是同一个对象吗 ${ball_1 === ball_2}")
}

运行结果：

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

class Person {
    var name = "Person"

    object InnerObj{
        var str = "123456"
        fun showName(){
            print{"desk legs $name"} // 编译报错，不能访问到外部类的方法和变量
        }
    }
}
fun main(args: Array<String>) {
    var person = Person()
    person.InnerObj.str // 编译报错，不能通过外部类的实例访问到该对象
    Person.InnerObj.str // 可以访问
}

五、companion object（伴生对象）实现java中访问静态成员的场景

Kotlin文件一里的代码：

class Person {
    var name = "Person"

    companion object{
        var age = 0
    }
    
}

Kotlin文件二里调用：

var aaa = Person.age

java文件里调用：

Person.Companion.getAge();