面试题：TypeScript类访问修饰符对大型项目代码可维护性的影响

1. public 修饰符对可维护性的影响

理解与修改代码：public 是默认的访问修饰符，意味着类的属性和方法可以在类的内部、子类以及类的实例外部被访问。在团队协作开发中，开发人员可以方便地在任何地方访问和修改这些成员，这对于快速理解和调试代码有一定帮助。例如，在一个简单的用户信息类中：

class User {
    public name: string;
    public age: number;
    public constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }
    public getInfo() {
        return `Name: ${this.name}, Age: ${this.age}`;
    }
}

const user = new User('John', 30);
console.log(user.getInfo()); // 开发人员可以直接通过实例访问public方法

代码重构：在代码重构时，如果某个 public 成员的功能需要改变，可能影响到所有依赖它的地方，包括类外部的调用代码。例如，如果要修改 getInfo 方法的返回格式，就需要检查并更新所有调用 getInfo 的地方，这可能会增加重构的成本。
模块扩展：在模块扩展方面，public 成员使得其他模块可以轻松地继承该类并使用或重写这些 public 成员。例如：

class AdminUser extends User {
    public role: string;
    public constructor(name: string, age: number, role: string) {
        super(name, age);
        this.role = role;
    }
    public getInfo() {
        return `Name: ${this.name}, Age: ${this.age}, Role: ${this.role}`;
    }
}

2. private 修饰符对可维护性的影响

理解与修改代码：private 修饰的属性和方法只能在类的内部访问，外部无法直接访问和修改。这使得代码的内部实现细节对外部隐藏，提高了代码的封装性。在团队协作中，开发人员不能随意从外部修改这些成员，只能通过类提供的公共接口来间接操作。例如：

class BankAccount {
    private balance: number;
    public constructor(initialBalance: number) {
        this.balance = initialBalance;
    }
    public deposit(amount: number) {
        if (amount > 0) {
            this.balance += amount;
        }
    }
    public withdraw(amount: number) {
        if (amount > 0 && amount <= this.balance) {
            this.balance -= amount;
        }
    }
    public getBalance() {
        return this.balance;
    }
}

const account = new BankAccount(1000);
// account.balance = -100; // 报错，无法从外部访问private属性
account.deposit(500);
console.log(account.getBalance());

代码重构：在重构时，只要类的公共接口不变，private 成员的内部实现可以自由改变，而不会影响到类外部的代码。例如，BankAccount 类内部对 balance 的存储方式可以从简单的数字改为更复杂的货币对象表示，只要 deposit、withdraw 和 getBalance 方法的接口不变，外部代码无需修改，降低了重构风险。
模块扩展：子类不能访问父类的 private 成员，这限制了子类对父类内部实现的直接访问，使得继承体系更加清晰，避免了子类意外修改父类的内部状态。

3. protected 修饰符对可维护性的影响

理解与修改代码：protected 修饰的属性和方法可以在类的内部以及子类中访问，但不能在类的实例外部访问。在团队协作开发中，这意味着子类开发人员可以根据需要访问和修改这些成员，同时对外部隐藏了这些细节。例如：

class Animal {
    protected name: string;
    public constructor(name: string) {
        this.name = name;
    }
    protected makeSound() {
        console.log(`${this.name} makes a sound`);
    }
}

class Dog extends Animal {
    public bark() {
        this.makeSound();
        console.log(`${this.name} barks`);
    }
}

const dog = new Dog('Buddy');
// dog.makeSound(); // 报错，无法从外部访问protected方法
dog.bark();

代码重构：类似于 private，只要类的公共接口不变，protected 成员的内部实现可以在不影响外部代码的情况下进行重构。同时，由于子类可以访问 protected 成员，当对父类进行重构时，需要考虑对子类的影响。例如，如果修改了 Animal 类中 makeSound 方法的实现，需要检查 Dog 类等子类的行为是否受到影响。
模块扩展：protected 修饰符使得子类可以基于父类的 protected 成员进行功能扩展，同时保持对外部的封装。例如，Dog 类可以基于 Animal 类的 protected 属性和方法实现更具体的行为。

星途面试题库

面试题：TypeScript类访问修饰符对大型项目代码可维护性的影响

知识考点

面试题答案

1. public 修饰符对可维护性的影响

2. private 修饰符对可维护性的影响

3. protected 修饰符对可维护性的影响