Kotlin基础篇：关键字object的使用，对象声明、伴生对象、对象表达式

前言

在学习object关键字的使用场景前，我们要先了解下object的核心理念：object关键字定义一个类并同时创建一个实例。

• 对象声明

定义单例

object UserInfoInstance {
    var name: String = ""
    var address: String = ""
    var vipLevel: Int = 0

    fun isVip() = vipLevel > 0
}

UserInfoInstance.isVip()

在Kotlin中写一个饿汉式的单例十分的简单，我们只需要在类名前加上object关键字即可。

注意：一个对象声明可以包含属性、方法等，但绝对不可以有构造方法，因为对象声明在定义的时候就已经创建了实例了，不需要构造方法了。

• 伴生对象

前面的文章我们说过Koltin中是没有static关键字的，所以当我们想在没有类实例的前提下访问类中方法的话，我们推荐大家使用顶层函数，顶层函数可以满足绝大数需要使用静态方法的场景，但顶层函数有个限制就是：它不能访问类的private成员，那么针对这种情况，伴生对象就是我们更好的选择了，伴生对象的使用也很简单，在类名前加上companion object即可。

//Java
class X {
    private static int level;

    static boolean isVip() {
        return level > 0;
    }
}
X.isVip()

//Kotlin
class X {
    companion object {
        private var level = 0
        fun isVip() = level > 0
    }
}
X.isVip()

伴生对象也可以指明它的名字，不过一般可以不用声明，使用默认分配的Companion即可

class X {
    companion object A{
        private var level = 0
        fun isVip() = level > 0
    }
}

• 对象表达式

object不仅可以声明单例，也可以声明匿名对象，用来替代Java中匿名类的使用。

class Z {
    fun z(x: X) {
    }
}

abstract class X {
    abstract fun a()

    abstract fun b()
}

Z().z(object : X() {
    override fun a() {
    }
    override fun b() {
    }
})

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

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

val z = object {
    var name: String = ""
    var age = 0
    
    fun test(){
        
    }
}
z.name  z.test() //报错，因为没有在本地或者私有作用域中声明

//私有作用域中声明
private val z = object {
    var name: String = ""
    var age = 0
    
    fun test(){
        
    }
}
z.name  z.test() //可以调用匿名对象中成员


//本地声明
fun foo() {
    val adHoc = object {
        var x: Int = 0
        var y: Int = 0
    }
    print(adHoc.x + adHoc.y)
}


//匿名对象实现类和接口
abstract class W {
    abstract fun w()
}
interface Y {
    fun y()
}
private val z = object :W(),Y{  //此处用，分隔。实现多接口的话，后面接着，分隔就可以了
    var name: String = ""
    var age = 0
    fun test(){
    }
    override fun w() {
    }
    override fun y() {
    }
}

这里不要忘记我们上面提到匿名对象的本地或私有的限制。

还有一种情况我们需要使用object关键字，那就是当我们需要声明一个类的对象，并且重写这个类的某些方法的时候，（eg：activity中创建一个handler对象）为什么这个时候也要使用object呢？仔细想想...
Bigo，就是因为我么重写类的方法的时候，相当于是定义了这个类的子类，但是我们并没有用一个实体类来接收它，所以呢，它是个匿名类。还记得吗？object的核心理念：object关键字定义一个类并同时创建一个实例。所以这就是为什么使用object的原因了

对象表达式和对象声明之间的语义差异

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

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

以上就是object的用法了，希望可以帮助你们加深一些object相关的理解，溜了溜了~