TypeScript访问修饰符：public, private, protected详解-CFANZ编程社区

在TypeScript中，类是面向对象编程的重要组成部分。为了更好地控制类成员（属性和方法）的可见性和可访问性，TypeScript引入了访问修饰符的概念。本文将深入探讨public、private和protected三个访问修饰符的作用，并通过解决一个具体的技术痛点来帮助开发者更深刻地理解它们的使用场景。

什么是访问修饰符？

访问修饰符是用来定义类成员（属性或方法）的访问级别的关键字。TypeScript提供了三种主要的访问修饰符：

public：默认值，表示该成员可以被任何地方访问。
private：表示该成员只能在定义它的类内部访问。
protected：表示该成员只能在定义它的类及其子类中访问。

这些修饰符的存在是为了帮助开发者实现封装，从而提高代码的安全性和可维护性。

public修饰符

public是最简单的访问修饰符，也是TypeScript中的默认设置。如果一个类成员没有显式地指定访问修饰符，那么它就是public的。这意味着这个成员可以在任何地方被访问，无论是从类的外部还是从继承的子类中。

尽管public提供了最大的灵活性，但它也带来了潜在的风险。因为任何地方都可以修改或调用public成员，这可能会导致代码的不可预测行为。因此，在设计类时，应该谨慎考虑哪些成员需要暴露给外部。

class Person {
    public name: string;

    constructor(name: string) {
        this.name = name;
    }

    public sayHello() {
        console.log(`Hello, my name is ${this.name}`);
    }
}

const person = new Person(Alice);
person.sayHello(); // 输出: Hello, my name is Alice

在这个例子中，name属性和sayHello方法都是public的，所以我们可以直接从类的外部访问它们。

private修饰符

private修饰符限制了类成员的访问范围，使其只能在定义它的类内部被访问。这种限制有助于保护数据不被外部随意修改，从而增强了类的封装性。

假设我们有一个BankAccount类，其中包含账户余额。如果我们希望只有类本身能够修改余额，而外部只能查询余额，那么可以将余额属性设为private。

class BankAccount {
    private balance: number;

    constructor(balance: number) {
        this.balance = balance;
    }

    public getBalance(): number {
        return this.balance;
    }

    public deposit(amount: number): void {
        if (amount > 0) {
            this.balance += amount;
        }
    }

    public withdraw(amount: number): void {
        if (amount > 0 && amount <= this.balance) {
            this.balance -= amount;
        }
    }
}

const account = new BankAccount(100);
console.log(account.getBalance()); // 输出: 100
account.deposit(50);
console.log(account.getBalance()); // 输出: 150
// account.balance = 200; // 错误: 'balance' 是私有的

在这个例子中，balance属性是private的，所以无法从类的外部直接访问或修改它。这样可以确保余额只通过受控的方法进行更改。

protected修饰符

protected修饰符与private类似，但它允许子类访问被标记为protected的成员。这种修饰符非常适合用于定义那些仅应在类及其子类中使用的成员。

例如，假设我们有一个Animal类，其中包含一个move方法。我们希望所有子类都能访问这个方法，但不允许类的外部直接调用它。

class Animal {
    protected move(distanceInMeters: number): void {
        console.log(`Moving ${distanceInMeters}m.`);
    }
}

class Dog extends Animal {
    bark(): void {
        console.log('Woof! Woof!');
    }

    run(speed: number): void {
        this.move(speed * 10); // 子类可以访问父类的protected方法
    }
}

const dog = new Dog();
dog.bark(); // 输出: Woof! Woof!
dog.run(5); // 输出: Moving 50m.
// dog.move(10); // 错误: 'move' 是受保护的

在这个例子中，move方法被标记为protected，所以只有Dog类及其父类Animal可以访问它。外部代码无法直接调用move方法。

技术痛点：如何合理使用访问修饰符？

在实际开发中，很多开发者会遇到一个问题：到底应该选择哪种访问修饰符？答案取决于具体的业务需求和设计目标。以下是一些指导原则：

尽量减少public成员的数量：过多的public成员会导致类的接口变得复杂且难以维护。尽量将类的内部细节隐藏起来，只暴露必要的接口。
使用private保护敏感数据：对于那些不应该被外部直接访问的数据，使用private修饰符。这可以帮助你控制数据的完整性和一致性。
利用protected实现继承机制：如果你希望某些成员只能在类及其子类中使用，那么protected是一个很好的选择。它可以促进代码的复用，同时保持一定的封装性。
考虑未来的扩展性：在设计类时，要考虑到未来可能的变化。如果某个成员将来可能会被子类重写或扩展，那么将其设为protected可能是更明智的选择。

通过合理使用访问修饰符，你可以构建出更加健壮和易于维护的代码库。记住，封装是面向对象编程的核心原则之一，而访问修饰符正是实现这一原则的重要工具。