Kotlin 中的单例模式（Singleton）与对象声明

在 Kotlin 中，类描述的是一种通用结构，可以多次实例化，也可以用多种方式实例化。但有时我们只需要单个实例，不多不少。单例模式能帮你更好地组织代码，把相关的方法聚合在一起。

单例模式是什么？

单例模式是一种设计模式，保证一个类只有一个实例，并提供全局访问点。这意味着你可以在代码的任何地方获取这个单例类的实例。打个比方，就像大家一起玩棋盘游戏，所有玩家都在同一个“棋盘”上进行操作，这个棋盘就相当于游戏的全局状态。

单例的主要特征：

• 单例类只有一个实例。

• 单例类提供一个全局访问点。

Kotlin 的对象声明（object declaration）

单例模式非常有用，而 Kotlin 为单例提供了专门的语法结构：object 声明。这是一种特殊的类声明，使用关键字 object 创建单例。Kotlin 自动处理所有复杂步骤，你只需要用 object 声明即可，无需手动实现单例模式。

object PlayingField {

    fun getAllPlayers(): Array<Player> {
        /* ... */
    }
    
    fun isPlayerInGame(player: Player): Boolean {
        /* ... */
    }

}

解释：

使用 object 声明时，构造函数不可用，因为 Kotlin 自动完成。你可以通过 PlayingField 直接访问这个单例实例，它在代码任何地方调用都指向同一个对象。

示例：

fun startNewGameTurn() {
    val players = PlayingField.getAllPlayers()
    if (players.size < 2) {
        return println("The game cannot be continued without players")
    }
    for (player in players) {
        nextPlayerTurn(player)
    }
}

fun nextPlayerTurn(player: Player) {
    if (!PlayingField.isPlayerInGame(player)) {
        return println("Current player lost. Next...")
    }
    /* 玩家行动 */
}

嵌套对象（Nested object）

有时候你想创建一个和另一个类相关联的单例。例如，游戏中有 Player 类，代表不同的角色，这些角色有共享的属性，比如默认速度。你如何保存这些共享信息呢？

你可以简单地创建一个单例对象：

object PlayerProperties {
    /* 默认速度，每回合移动7格 */
    val defaultSpeed = 7

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

但如果项目里有许多类似的单例，代码会变得难读。更好的做法是将单例嵌套到相关类中。

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

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

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

Properties 对象作用域是 Player，只能通过 Player.Properties 访问。这种方式让单例和类有明确的关联。

你还可以在外部类中使用嵌套对象的属性：

class Player(val id: Int) {
    object Properties {
        val defaultSpeed = 7
    }
    
    val superSpeed = Properties.defaultSpeed * 2 // 14
}

但反过来是不行的——嵌套对象中不能访问外部类的实例成员：

class Player(val id: Int) {    
    val speed = 7
    object Properties {
        val defaultSpeed = speed // 错误，不能访问外部类实例属性
    }
}

这和其他语言的 static 类似，Kotlin 没有默认的静态成员，但可以用嵌套对象来达到类似效果。

编译时常量（Compile-time constants）

如果某个只读属性永远不会改变，我们称它为常量。可以使用 const 关键字声明编译时常量：

object Languages {
    const val FAVORITE_LANGUAGE = "Kotlin"
}

要求：

• 必须是基本类型或 String。

• 不能有自定义 getter。

• 命名用全大写加下划线（SCREAMING_SNAKE_CASE）。

比如游戏里的默认速度可以写成：

object Properties {
    const val DEFAULT_SPEED = 7
}

访问：

println(Properties.DEFAULT_SPEED) // 输出 7

为什么不都用顶层常量？因为大量无关联的顶层常量会让代码混乱，影响阅读。最好把和某个对象相关的常量放到对应的对象里。

对象与嵌套对象的扩展

你可以在一个类里声明多个对象，比如：

class Player(val id: Int) {
    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.Factory.create(13).id)      // 13

这里的 Factory 是工厂模式，用来创建 Player 实例。你也可以在一个对象内部声明多个对象，用来组织单例数据：

object Game {
    object Properties {
        val maxPlayersCount = 13
        val maxGameDurationInSec = 2400
    }

    object Info {
        val name = "My super game"
    }
}

数据对象（Data object）

普通的对象声明打印会显示类名和哈希码：

object MyObject

fun main() {
    println(MyObject) // MyObject@1f32e575
}

如果用 data 修饰单例对象，会生成更友好的方法：

data object MySingleton

fun main() {
    println(MySingleton) // MySingleton
}

注意，data object 不是数据类，不能复制（没有 copy() 方法），也没有组件函数，因为单例不允许多实例。

总结

Kotlin 中，object 声明是创建单例的标准方式，也可以用嵌套对象关联类本身，而非类的实例。合理使用它们可以让代码结构更清晰，提升可读性和可维护性。