kotlin 笔记：Object 关键字

一、Object 关键字

kotlin 中的 object 关键字用来创建一个对象，它的使用场景：

• 对象声明
• 伴生对象
• 对象表达式

二、对象声明

对象声明用来创建单例。

与类一样，一个对象的声明也可以包含属性、方法、初始化语句块等声明。唯一不同在于对象没有构造方法（主和从）。因为对象声明在定义的时候就立即创建了，不需要构造函数。

可以在类外部，也可以在类内部生成单例对象，但不能在 fun 中生成单例对象。

实例：

fun main(args: Array<String>) {
    SuperMan.power()
    TheFlash.power()
    BatMan.power()
    compareSpeed(SuperMan, TheFlash, BatMan)
}

abstract class SuperHero(open var energy: Int = 100, open var speed: Int = 100) {
    abstract fun power()
}

object SuperMan : SuperHero() {
    override var speed = 1000
    override fun power() {
        lasing()
    }

    private fun lasing() {
        println(">------------------")
    }
}

object TheFlash : SuperHero() {
    override var speed = 1500
    override fun power() {
        runOnLake()
    }

    private fun runOnLake() {
        println("~~~~~~~~/\\~~~~~~~~~")
    }
}

object BatMan : SuperHero() {
    override var speed = 10
    override fun power() {
        justRich()
    }

    private fun justRich() {
        println("$$$$$$$$$$$$$$$$$$$")
    }
}

object SpeedComparator : Comparator<SuperHero> {
    override fun compare(s1: SuperHero, s2: SuperHero): Int {
        return s1.speed.compareTo(s2.speed)
    }
}

fun compareSpeed(vararg heros: SuperHero) {
    var list = mutableListOf<SuperHero>()
    list.addAll(heros)
    println(list.sortedWith(SpeedComparator))
}

输出：

>------------------
~~~~~~~~/\~~~~~~~~~
$$$$$$$$$$$$$$$$$$$
[BatMan, SuperMan, TheFlash]

三、伴生对象

在类中使用 companion object 关键字修饰的对象。

kotlin 中没有 static 关键字，作为替代，kotlin 中提供包级别函数、对象声明和伴生对象。

java 类中 private 可以在本类中被访问，所以类中的 static 方法可以访问类的私有方法和类对象的私有变量。

• 包级别函数，相当于java中的静态方法，可以访问类的公开方法和类对象的公开变量。

• 伴生对象，相当于java中的静态变量，这个变量是静态内部类的一个对象，其内部的变量可以作为静态变量，其内部的方法可以作为静态方法。它可以访问类的私有方法和类对象的私有变量。这样的特性可以用于工厂方法（构造函数是私有的）。

• 对象声明，相当于单例。

包级别函数和伴生对象一起组成了 java 的静态方法、静态变量。对象声明则是一种特殊的“类与伴生对象合而为一”的对象。

实例：

fun main(args: Array<String>) {
    var bigHouse = House.newBigHouse()
    var smallHouse = House.newSmallHouse()
}

class House private constructor(var width: Int = 100, var height: Int = 6) {
	 // 构造函数是私有的，但伴生对象可以访问
    companion object {
        fun newBigHouse() = House(100, 100)
        fun newSmallHouse() = House(20, 20)
    }
}

3.1 作为普通对象的伴生对象

伴生对象相当于类中的静态内部类的一个对象，它也可以有名称、可以实现接口、可以有扩展函数。

实例（扩展函数）：

fun main(args: Array<String>) {
    var bigHouse = House.newBigHouse()
    var smallHouse = House.newSmallHouse()

    bigHouse.computeArea()
    smallHouse.computeArea()

    House.computeArea()
}

class House private constructor(var length: Int, var width: Int) {

    companion object {
        fun newBigHouse() = House(100, 100)
        fun newSmallHouse() = House(20, 20)
    }
}

// 类的扩展函数作用于类的实例，即一个内部方法
fun House.computeArea() {
    println(this.length * this.width)
}

// 伴生对象的扩展函数作用于伴生对象，即一个静态方法
fun House.Companion.computeArea() {
    println("I can not access private member and method")
}

输出：

10000
400
I can not access private member and method

四、对象表达式

这是 kotlin 中的匿名内部类，与 java 不同，它可以实现多个接口或不实现接口。另外它还可以访问非 final 变量。

实例：

fun main(args: Array<String>) {
    var button = Button()
    var buttonClickCount = 0
    // object 实现了两个接口
    button.clickListener = object : ClickListener, LongClickListener {
        override fun onClick() {
            // onClick 访问了 var 变量（非 final 变量）
            buttonClickCount++
            println("you click me $buttonClickCount Time!")
        }

        override fun onLongClick() {
            println("you long click me!")
        }
    }
    for (i in 1..4) {
        button.beenClick()
    }
}

class Button {
    var clickListener: ClickListener? = null
    fun beenClick() {
        clickListener?.onClick()
    }
}

interface ClickListener {
    fun onClick()
}

interface LongClickListener {
    fun onLongClick()
}

输出：

you click me 1 Time!
you click me 2 Time!
you click me 3 Time!
you click me 4 Time!