如何在含基类构造函数计算的Game类中实现Singleton模式？

开发者阿泽

2026-5-20

嘿，这个问题问得特别实在——单例模式确实是解决你需求的核心方案，而且你考虑到基类构造有计算逻辑的细节，这点真的很关键，很多人刚开始做单例的时候容易忽略这部分。下面我结合常见的面向对象语言场景，给你具体的实现思路和示例：

实现带基类构造逻辑的Game单例

核心思路就是：用单例模式控制Game的实例创建次数，同时保证基类的构造计算逻辑能正常执行——毕竟基类的构造逻辑肯定是初始化必要数据，绝对不能跳过。下面分两种常用场景给你方案：

1. 饿汉式单例（提前初始化）

如果你的Game实例不需要延迟加载（启动时就可以初始化），这种方式最简单，而且天然线程安全（比如Java、C#这类语言里都是如此）。

举个Java的例子，先假设你的基类BaseGame有构造计算逻辑：

public class BaseGame {
    public BaseGame() {
        // 基类构造里的计算逻辑，比如加载配置、计算基础参数
        System.out.println("BaseGame构造：执行初始化计算");
    }
}

然后Game类实现单例：

public class Game extends BaseGame {
    // 提前创建唯一实例，创建时会自动调用基类的构造方法
    private static final Game INSTANCE = new Game();

    // 私有构造，彻底禁止外部调用new Game()
    private Game() {
        // 这里可以写Game自身的构造逻辑，基类构造已经自动执行过了
        System.out.println("Game构造：完成子类初始化");
    }

    // 全局唯一的实例访问入口
    public static Game getInstance() {
        return INSTANCE;
    }

    // 你的业务方法示例
    public void startGame() {
        System.out.println("游戏启动啦！");
    }
}

这种方式下，当Game类被加载时，INSTANCE就会被创建，基类的构造计算逻辑会自动触发。而且因为构造方法是私有的，外部根本没法通过new Game()创建新实例，只能通过Game.getInstance()拿到唯一实例。

2. 懒汉式单例（延迟初始化）

如果Game的初始化成本很高（比如要加载大量资源），希望第一次被使用时才初始化，那就要注意线程安全，同时保证基类构造逻辑正常执行。

还是Java的例子，用线程安全的双重检查锁实现：

public class Game extends BaseGame {
    // volatile关键字保证实例创建的可见性，防止指令重排导致的半初始化问题
    private static volatile Game INSTANCE;

    private Game() {
        // 基类构造会被自动调用，也可以显式写super()，效果一样
        super();
        System.out.println("Game构造：延迟初始化子类逻辑");
    }

    public static Game getInstance() {
        // 双重检查锁，保证线程安全同时避免不必要的锁开销
        if (INSTANCE == null) {
            synchronized (Game.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Game();
                    // 创建实例时，基类的构造计算逻辑已经执行完毕
                }
            }
        }
        return INSTANCE;
    }
}

这种方式下，只有第一次调用getInstance()时才会创建实例，基类的构造计算逻辑会在new Game()时被触发，完全不影响原有逻辑的执行，同时还保证了多线程环境下不会创建多个实例。

关键注意事项

构造方法必须私有：这是单例模式的核心，彻底封死外部通过new创建实例的路径，确保只有内部能创建唯一实例。
基类构造无需特殊修改：不管是饿汉还是懒汉模式，当创建Game实例时，面向对象语言会自动先调用基类的构造方法，所以基类里的计算逻辑会正常执行，不用动基类的代码。
多线程场景要注意线程安全：如果你的项目是多线程环境，懒汉式一定要用双重检查锁+对应语言的线程安全关键字（比如Java的volatile），避免出现多个实例的情况。

调用示例

不管你调用多少次Game.getInstance()，得到的都是同一个实例，而且基类的构造计算逻辑只会执行一次：

public class Main {
    public static void main(String[] args) {
        Game game1 = Game.getInstance();
        Game game2 = Game.getInstance();
        System.out.println(game1 == game2); // 输出true，说明是同一个实例
        game1.startGame();
    }
}

运行结果会是：

BaseGame构造：执行初始化计算
Game构造：完成子类初始化
true
游戏启动啦！

这样就完美实现了你的需求：外部无法通过new Game()创建新实例，只能通过getInstance()获取唯一实例，同时基类的构造计算逻辑也正常执行了。

内容的提问来源于stack exchange，提问作者JetsYanks08

如何在含基类构造函数计算的Game类中实现Singleton模式？

1. 饿汉式单例（提前初始化） #

2. 懒汉式单例（延迟初始化） #

关键注意事项 #

调用示例 #

1. 饿汉式单例（提前初始化）

2. 懒汉式单例（延迟初始化）

关键注意事项

调用示例