Kotlin伴生对象

你已经知道如何为类创建单例对象（singleton）。不过，在很多情况下，你只需要为某个类维护一个单例，这时候使用类的完整名字会显得冗长。比如，你可能只需要存储一个公共的属性。这种情况下，可以用 Kotlin 的另一个特性 —— companion object（伴生对象）。

伴生对象（Companion object）

在一个类内部，可以声明一个用 companion 关键字标记的对象：

class Player(val id: Int) {
    companion object Properties {
        /* 默认玩家速度 - 每回合移动 7 格 */
        val defaultSpeed = 7

        fun calcMovePenalty(cell: Int): Int {
            /* 计算移动速度的惩罚 */
        }
    }
}

/* 输出 7 */
println(Player.Properties.defaultSpeed)

解释：
伴生对象是绑定在外部类上的单例，必须通过外部类访问它。它表明该对象与外部类有紧密联系。比如，可以把所有玩家的默认速度存在 Player 类的伴生对象里。每个 Player 实例都会持有伴生对象的引用，访问时都会得到这个唯一实例。

省略伴生对象名字

我们也可以不给伴生对象命名，这样访问时更加简洁：

class Player(val id: Int) {
    companion object {
        val defaultSpeed = 7

        fun calcMovePenalty(cell: Int): Int {
            /* 计算移动惩罚 */
        }
    }
}

/* 输出 7 */
println(Player.defaultSpeed)

解释：
省略名字后，仍然可以通过外部类直接访问伴生对象的成员。如果需要，也可以用默认名字 Companion 访问：

/* 依然输出 7 */
println(Player.Companion.defaultSpeed)

伴生对象与外部类

伴生对象与外部类联系非常紧密。在外部类中，可以直接使用伴生对象的属性和方法：

class Deck {
    companion object {
        val size = 10
        val height = 2
        fun volume(bottom: Int, height: Int) = bottom * height
    }

    val square = size * size             // 100
    val volume = volume(square, height)  // 200
}

同名属性的遮蔽（Shadowing）

如果外部类中有与伴生对象同名的属性，会“遮蔽”伴生对象的同名属性：

class Deck {
    companion object {
        val size = 10
    }
    val size = 2
    val square = size * size // 4，使用的是外部类的 size
}

如果想访问伴生对象的 size，需要明确使用伴生对象的名字：

class Deck {
    companion object {
        val size = 10
    }
    val size = 2
    val square = Companion.size * Companion.size // 100
}

伴生对象不能访问外部类实例成员

和嵌套对象类似，伴生对象不能访问外部类的实例属性和方法：

class Deck() {
    val size = 2
    object Properties {
        val defaultSize = size // 错误，无法访问外部类的实例变量
    }
}

伴生对象的限制

• 每个类最多只能有一个伴生对象，即使起不同名字也不行：

class BadClass {
    companion object Properties {
    }

    companion object Factory {
    }
}
// 编译错误：每个类只能有一个伴生对象

• 可以有一个伴生对象，同时拥有多个嵌套对象：

class Player(val id: Int) {
    companion object Properties {
        val defaultSpeed = 7

        fun calcMovePenalty(cell: Int): Int {
            // ...
        }
    }

    object Factory {
        fun create(playerId: Int): Player {
            return Player(playerId)
        }
    }
}

println(Player.Properties.defaultSpeed) // 7
println(Player.defaultSpeed)             // 7
println(Player.Factory.create(13).id)   // 13

• 伴生对象不能定义在另一个单例对象或伴生对象内部，因为这会违反全局访问的原则：

object OuterSingleton {
    companion object InnerSingleton { // 编译错误，伴生对象不能嵌套在对象中
    }
}

与其他语言的对比

如果你来自其他语言，可能会觉得伴生对象有点陌生。它类似于 Java 或 C++ 中的 static 成员，static 表示成员属于类本身，而不是实例。比如，Java 中：

class Dog {
    public static int numOfPaws = 4;

    public static String createSound() {
        return "WUF-WUF";
    }
}

/* 输出 WUF-WUF */
System.out.println(Dog.createSound());

Kotlin 没有 static 关键字，推荐用伴生对象来实现类似功能：

class Dog {
    companion object {
        val numOfPaws: Int = 4
        fun createSound(): String = "WUF-WUF"
    }
}

/* 输出 WUF-WUF */
println(Dog.createSound())

总结

• 伴生对象是和类紧密关联的单例对象。

• 它是组织类级别数据和方法的好方式。

• 在外部类中可以直接访问伴生对象的成员，反之则不行。

• 每个类只能有一个伴生对象。

• 它是 Kotlin 中实现类静态成员的推荐做法。