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

---

伴生对象（Companion object）

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

class Player(val id: Int) {companion object Properties {/* 默认玩家速度 - 每回合移动 7 格 */val defaultSpeed = 7fun calcMovePenalty(cell: Int): Int {/* 计算移动速度的惩罚 */}}
}/* 输出 7 */
println(Player.Properties.defaultSpeed)

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

---

省略伴生对象名字

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

class Player(val id: Int) {companion object {val defaultSpeed = 7fun calcMovePenalty(cell: Int): Int {/* 计算移动惩罚 */}}
}/* 输出 7 */
println(Player.defaultSpeed)

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

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

---

伴生对象与外部类

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

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

---

同名属性的遮蔽（Shadowing）

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

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

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

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

---

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

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

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

---

伴生对象的限制

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

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

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

class Player(val id: Int) {companion object Properties {val defaultSpeed = 7fun 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 = 4fun createSound(): String = "WUF-WUF"}
}/* 输出 WUF-WUF */
println(Dog.createSound())

---

总结

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

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

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

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

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