在构建复杂的 TypeScript 应用程序时，我们经常会遇到需要严格控制对象创建方式的场景。你是否想过，如何确保一个类在整个应用中只能存在一个实例？或者，你可能希望定义一个基类，它仅供其他类继承，而不能直接被实例化？
为了解决这些问题，TypeScript 为我们提供了强大的访问修饰符，特别是应用在构造函数上的 INLINECODE0e744f81 和 INLINECODE9785007b。掌握这两者之间的区别，将极大地提升我们代码的健壮性和设计上的灵活性。在这篇文章中，我们将深入探讨私有和受保护构造函数的用法、背后的设计模式以及在实际开发中的最佳实践。
回顾基础：TypeScript 中的构造函数
在我们深入探讨受限构造函数之前，让我们先快速回顾一下构造函数的基本角色。在 TypeScript 中，构造函数是一个特殊的方法，当我们在使用 new 关键字创建类的实例时，它会自动被调用。它的主要职责是初始化对象的属性和设置必要的初始状态。
默认行为：公有构造函数
默认情况下，如果我们没有在构造函数前添加任何访问修饰符，它是 public（公有）的。这意味着，只要类是可见的，任何代码都可以创建它的实例。这在大多数情况下是我们需要的，但对于某些特定的设计模式来说，这种“开放性”可能会导致问题。
示例：默认的公有构造函数
在这个例子中，我们可以自由地从任何位置创建 User 类的实例。
class User {
constructor(public username: string) {
// 初始化用户名
this.username = username;
}
public greet(): void {
console.log(`Hello, I am ${this.username}.`);
}
}
// 在任何地方都可以自由实例化
const user1 = new User(‘Alice‘);
const user2 = new User(‘Bob‘);
user1.greet(); // 输出: Hello, I am Alice.
在这个场景中，INLINECODEdc44d967 类是开放的。任何开发者都可以创建成千上万个 INLINECODE53dc2121 实例。这在大多数情况下没问题，但如果我们需要一个“特殊”的类呢？让我们看看如何改变这种默认行为。
私有构造函数：严格控制实例化
当我们把构造函数标记为 INLINECODE5ecd8711 时，发生了一件有趣的事情：这个类不能在包含它的类的外部被实例化，甚至在它的子类中也不行。这意味着，INLINECODE5ba6d5f4 关键字只能在类的内部静态方法中被使用。
这听起来可能有些受限，但这是实现某些强大设计模式的关键。
场景一：单例模式
单例模式是最经典的私有构造函数应用场景。假设我们在开发一个应用程序，需要一个全局配置管理器。我们希望整个应用中只存在这一个配置管理器实例，以避免配置冲突和资源浪费。私有构造函数在这里就派上用场了。
核心思路：
- 将构造函数设为 INLINECODE93ad0322，防止外部使用 INLINECODEb1babf0c。
- 创建一个静态变量
instance来持有唯一的实例。 - 提供一个静态方法（通常命名为
getInstance）来获取该实例。如果实例不存在，则在内部创建它。
示例：实现单例模式
class AppConfig {
// 1. 静态属性用于保存唯一实例
private static instance: AppConfig;
// 用于演示的配置数据
public settings: { theme: string };
// 2. 私有构造函数阻止外部直接调用 new
private constructor() {
console.log(‘私有构造函数被调用：初始化配置...‘);
this.settings = {
theme: ‘dark‘
};
}
// 3. 提供全局访问点
public static getInstance(): AppConfig {
// 如果实例尚不存在，则创建它
if (!AppConfig.instance) {
AppConfig.instance = new AppConfig();
}
// 返回已存在的实例
return AppConfig.instance;
}
public updateTheme(newTheme: string): void {
this.settings.theme = newTheme;
console.log(`主题已更新为: ${newTheme}`);
}
}
// 尝试直接实例化将会报错
// const config = new AppConfig(); // Error: Constructor of class ‘AppConfig‘ is private
// 只能通过 getInstance 获取实例
const config1 = AppConfig.getInstance();
const config2 = AppConfig.getInstance();
// 验证是否为同一个对象
console.log(config1 === config2); // 输出: true
// 测试功能
config1.updateTheme(‘light‘);
// 输出:
// 私有构造函数被调用：初始化配置... (仅在第一次调用时打印)
// 主题已更新为: light
在这个例子中，无论我们在代码的多少地方调用 AppConfig.getInstance()，我们得到的永远都是同一个对象。这就是私有构造函数的威力。
场景二：静态工具类
另一个常见的用例是创建纯静态工具类。这类类只包含辅助方法（如数学计算、日期格式化等），不需要保存任何实例状态。因此，实例化它们是没有意义的，甚至可能引起混淆。
我们可以使用私有构造函数来明确禁止这种行为，向其他开发者传递出“这个类不应该被实例化”的强烈信号。
示例：日期工具类
class DateUtils {
// 私有构造函数，防止通过 ‘new‘ 创建对象
private constructor() {
throw new Error(‘DateUtils 是一个静态类，不能被实例化。‘);
}
/**
* 格式化日期为 YYYY-MM-DD
*/
public static formatDate(date: Date): string {
const year = date.getFullYear();
const month = String(date.getMonth() + 1).padStart(2, ‘0‘);
const day = String(date.getDate()).padStart(2, ‘0‘);
return `${year}-${month}-${day}`;
}
/**
* 计算两个日期之间的天数差
*/
public static daysBetween(date1: Date, date2: Date): number {
const oneDay = 24 * 60 * 60 * 1000;
return Math.round(Math.abs((date1.getTime() - date2.getTime()) / oneDay));
}
}
// 正确的用法：直接调用静态方法
const today = new Date();
console.log(DateUtils.formatDate(today)); // 输出当前日期，例如 2023-10-27
// 错误的用法（代码将抛出错误）
// const utils = new DateUtils(); // Error: DateUtils 是一个静态类...
在这里，我们在私有构造函数中主动抛出一个错误。这是一个非常有用的防御性编程技巧，它能确保即使在类的内部逻辑发生意外变化时，实例化操作也会被立即阻断。
受保护的构造函数：继承的桥梁
如果说私有构造函数是“完全锁死”，那么受保护（protected）的构造函数就是“半锁半开”。
当一个构造函数被标记为 protected 时，你不能直接在外部实例化这个类，但是你可以继承这个类。这意味着，该类被设计为基类，必须通过子类来使用。
场景：抽象基类
这在定义通用逻辑但不想让基类直接参与实例化的场景中非常有用。例如，你可能有一个 Shape（形状）基类，它知道如何计算面积，但“形状”本身是一个抽象概念，不应该直接被创建。
示例：受保护的构造函数与继承
class Animal {
// protected 构造函数：允许子类通过 super() 调用，
// 但禁止直接 new Animal()
protected constructor(public name: string) {
this.name = name;
}
public move(distanceInMeters: number): void {
console.log(`${this.name} 移动了 ${distanceInMeters} 米.`);
}
// 抽象方法声明：子类必须实现具体的发声方式
public abstract makeSound(): void;
}
// 错误：无法创建 Animal 实例，因为构造函数是受保护的
// const animal = new Animal(‘未知生物‘); // Error
// Dog 类继承自 Animal
class Dog extends Animal {
// 子类构造函数可以调用父类的 protected 构造函数
constructor(name: string) {
super(name);
}
public makeSound(): void {
console.log(‘汪汪!‘);
}
public bark(): void {
console.log(`${this.name} 正在吠叫!`);
}
}
const dog = new Dog(‘旺财‘);
dog.move(10); // 输出: 旺财 移动了 10 米.
dog.bark(); // 输出: 旺财 正在吠叫!
在这个例子中，INLINECODE2dec1f3f 类充当了模版。它包含了共享的逻辑（如 INLINECODE17de6f01），但强制开发者去继承它并创建具体的动物（如 INLINECODE9c6f6071 或 INLINECODEfdc5cd70）。受保护的构造函数确保了这种继承关系的强制执行，防止了模糊不清的 Animal 实例在代码中游荡。
实战技巧与常见陷阱
了解了基本概念后，让我们来看看在实际开发中，如何避免常见的陷阱，并写出更好的代码。
1. 处理单例中的延迟加载
在上面的单例模式示例中，我们在 INLINECODEfc94537b 中进行了 INLINECODEc87ac8a4 判断。这被称为“懒加载”。这意味着实例只有在第一次被请求时才会创建。这对于资源密集型的对象非常有用，可以加快应用的启动速度。
进阶代码示例：更健壮的单例
我们可以使用 TypeScript 的只读属性来确保 instance 引用不会被意外覆盖。
class DatabaseConnection {
private static readonly instance: DatabaseConnection = new DatabaseConnection();
private isConnected: boolean = false;
// 私有构造函数
private constructor() {
console.log(‘建立数据库连接...‘);
}
public static getInstance(): DatabaseConnection {
return DatabaseConnection.instance;
}
public connect(): void {
if (!this.isConnected) {
console.log(‘数据库已连接。‘);
this.isConnected = true;
}
}
}
const db = DatabaseConnection.getInstance();
db.connect();
2. 依赖注入中的考量
虽然在单例模式中私有构造函数很棒，但在现代框架（如 Angular 或 NestJS）中，通常使用依赖注入容器来管理类的生命周期。在这些框架中，我们通常不手动实现单例模式，而是让框架来处理。在这种情况下，使用普通的服务类（默认公有构造函数）配合框架的 @Injectable({ providedIn: ‘root‘ }) 装饰器是更好的选择。理解这一点至关重要：私有构造函数是实现单例的一种语言层手段，而框架提供了更高级的工具层手段。
3. 常见错误：反序列化问题
如果你使用私有构造函数来实现单例，并且你需要将对象序列化（例如转换成 JSON 存储到数据库）然后再反序列化回来，你可能会遇到问题。当你尝试将 JSON 数据转换回对象时，许多反序列化库会尝试调用构造函数。由于它是私有的，操作将会失败。
解决方案： 如果你的单例对象需要序列化，通常需要自定义序列化逻辑，或者确保你序列化的是对象的数据，而不是单例类本身。反序列化时，获取单例实例并更新其状态，而不是创建新对象。
总结：如何选择合适的构造函数
为了帮助你在下次写代码时做出正确的决定，让我们总结一下这三种构造函数的适用场景：
- 公有构造函数 (INLINECODEf873fcec)：这是默认选择。当你希望开发者能够自由创建类的多个实例时使用。例如：INLINECODEc3cdc0f6、INLINECODE6015acaa、INLINECODE44e7a865。
- 私有构造函数 (
private)：
* 当你需要确保只有一个实例存在时（单例模式）。例如：INLINECODE9c12707d、INLINECODE4c63b002。
* 当你创建的类只是一组静态方法的集合，不希望被实例化时。例如：INLINECODEfc1b91ac、INLINECODE7a75770e。
- 受保护构造函数 (
protected)：
* 当你定义了一个基类，它包含子类共享的逻辑，但本身代表的概念太抽象而不应该被直接实例化时。例如：INLINECODE16a1f986、INLINECODEca324719、Component。
通过巧妙地运用 INLINECODEd3ed0068 和 INLINECODEa16802bc 构造函数，我们可以编写出更加安全、逻辑更清晰且更易于维护的 TypeScript 代码。这些修饰符不仅仅是限制，它们更是表达设计意图的强大语言。希望你在未来的项目中能够尝试这些模式！