TypeScript 中的类与对象：修饰符（public, private, protected）

在 TypeScript 中，类是面向对象编程的核心概念之一。类允许我们创建对象，并定义对象的属性和方法。为了控制类的成员（属性和方法）的可访问性，TypeScript 提供了三种访问修饰符：public、private 和 protected。在本教程中，我们将详细探讨这三种修饰符的用法、优缺点以及注意事项。

1. public 修饰符

定义与用法

public 是 TypeScript 中的默认修饰符。使用 public 修饰符声明的属性和方法可以在类的内部和外部访问。

示例代码

class Person {
    public name: string;
    public age: number;

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

    public greet(): void {
        console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
    }
}

const person = new Person("Alice", 30);
person.greet(); // 输出: Hello, my name is Alice and I am 30 years old.
console.log(person.name); // 输出: Alice

优点

• 易于使用：public 修饰符是默认的，使用起来非常简单。
• 灵活性：可以在类的外部自由访问和修改属性。

缺点

• 封装性差：由于 public 属性和方法可以被外部访问，可能导致不必要的依赖和错误的使用。

注意事项

• 在设计类时，尽量避免将所有属性和方法都设为 public，以保持良好的封装性。

2. private 修饰符

定义与用法

private 修饰符用于声明只能在类的内部访问的属性和方法。外部无法直接访问这些成员。

示例代码

class BankAccount {
    private balance: number;

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

    public deposit(amount: number): void {
        if (amount > 0) {
            this.balance += amount;
            console.log(`Deposited: ${amount}. New balance: ${this.balance}`);
        } else {
            console.log("Deposit amount must be positive.");
        }
    }

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

const account = new BankAccount(100);
account.deposit(50); // 输出: Deposited: 50. New balance: 150
console.log(account.getBalance()); // 输出: 150
// console.log(account.balance); // 错误: Property 'balance' is private and only accessible within class 'BankAccount'.

优点

• 封装性强：private 成员只能在类内部访问，保护了类的内部状态，避免外部代码对其进行不当操作。
• 易于维护：可以在不影响外部代码的情况下修改类的内部实现。

缺点

• 访问限制：外部无法直接访问 private 成员，可能导致某些操作变得复杂。

注意事项

• 在需要保护类的内部状态时，使用 private 修饰符是一个好习惯。
• 通过公共方法（如 getter 和 setter）来访问和修改 private 属性，可以提供更好的控制。

3. protected 修饰符

定义与用法

protected 修饰符与 private 类似，但它允许在子类中访问。也就是说，protected 成员可以在类内部和子类中访问，但不能在类的外部访问。

示例代码

class Animal {
    protected species: string;

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

class Dog extends Animal {
    public bark(): void {
        console.log(`Woof! I am a ${this.species}.`);
    }
}

const dog = new Dog("Dog");
dog.bark(); // 输出: Woof! I am a Dog.
// console.log(dog.species); // 错误: Property 'species' is protected and only accessible within class 'Animal' and its subclasses.

优点

• 继承支持：protected 成员可以在子类中访问，允许子类扩展父类的功能。
• 封装性：与 private 类似，protected 成员也保护了类的内部状态。

缺点

• 访问限制：外部无法访问 protected 成员，可能导致某些操作变得复杂。

注意事项

• 使用 protected 修饰符时，确保子类需要访问父类的成员。
• 适当使用 protected 可以提高代码的可重用性和可维护性。

总结

在 TypeScript 中，public、private 和 protected 修饰符为类的成员提供了不同级别的访问控制。选择合适的修饰符可以帮助我们实现良好的封装性和代码维护性。

• public：适用于需要被外部访问的成员，但要注意封装性。
• private：适用于需要保护的内部状态，提供良好的封装性。
• protected：适用于需要在子类中访问的成员，支持继承。

在设计类时，合理使用这些修饰符可以提高代码的可读性、可维护性和安全性。希望本教程能帮助你更好地理解 TypeScript 中的类与对象的修饰符。