封装和多态

1. 封装

1.1 理论解释

封装是面向对象编程（OOP）中的一个核心概念，它指的是将对象的状态（属性）和行为（方法）捆绑在一起，并隐藏对象的内部实现细节。通过封装，我们可以控制对象的访问权限，防止外部代码直接修改对象的内部状态，从而提高代码的安全性和可维护性。

在 JavaScript 中，封装通常通过以下方式实现：

• 使用 private 关键字（ES6 中没有原生的 private 关键字，但可以通过约定或闭包来模拟）。
• 使用闭包来隐藏私有变量。
• 使用 get 和 set 方法来控制对属性的访问。

1.2 代码示例

class Person {
    constructor(name, age) {
        this._name = name; // 使用下划线约定表示私有属性
        this._age = age;
    }

    // Getter 方法
    get name() {
        return this._name;
    }

    // Setter 方法
    set name(newName) {
        if (typeof newName === 'string') {
            this._name = newName;
        } else {
            console.error('Name must be a string');
        }
    }

    get age() {
        return this._age;
    }

    set age(newAge) {
        if (typeof newAge === 'number' && newAge >= 0) {
            this._age = newAge;
        } else {
            console.error('Age must be a non-negative number');
        }
    }

    introduce() {
        console.log(`Hello, my name is ${this._name} and I am ${this._age} years old.`);
    }
}

const person = new Person('Alice', 30);
console.log(person.name); // 输出: Alice
person.name = 'Bob';
console.log(person.name); // 输出: Bob
person.age = -5; // 输出: Age must be a non-negative number

1.3 实践练习

1. 创建一个 BankAccount 类，包含 balance 属性。使用 get 和 set 方法来控制对 balance 的访问。确保 balance 不能被设置为负数。
2. 实现一个 deposit 方法，允许用户存入金额。
3. 实现一个 withdraw 方法，允许用户取款，但确保余额不会变为负数。

2. 多态

2.1 理论解释

多态是面向对象编程中的另一个重要概念，它允许不同的对象对同一消息做出不同的响应。多态性可以通过继承和方法重写（覆盖）来实现。在 JavaScript 中，多态性可以通过以下方式实现：

• 方法重写（覆盖）：子类可以重写父类的方法，以提供不同的实现。
• 方法重载：JavaScript 不支持方法重载，但可以通过传递不同的参数来模拟。

2.2 代码示例

class Animal {
    makeSound() {
        console.log('Some generic animal sound');
    }
}

class Dog extends Animal {
    makeSound() {
        console.log('Woof!');
    }
}

class Cat extends Animal {
    makeSound() {
        console.log('Meow!');
    }
}

function animalSound(animal) {
    animal.makeSound();
}

const dog = new Dog();
const cat = new Cat();

animalSound(dog); // 输出: Woof!
animalSound(cat); // 输出: Meow!

2.3 实践练习

1. 创建一个 Shape 类，包含一个 draw 方法，输出“Drawing a shape”。
2. 创建 Circle 和 Square 类，继承自 Shape，并重写 draw 方法，分别输出“Drawing a circle”和“Drawing a square”。
3. 编写一个函数 drawShape，接受一个 Shape 对象作为参数，并调用其 draw 方法。
4. 创建 Circle 和 Square 的实例，并调用 drawShape 函数，观察输出结果。

3. 总结

封装和多态是面向对象编程中的两个重要概念。封装通过隐藏对象的内部状态和实现细节，提高了代码的安全性和可维护性。多态则允许不同的对象对同一消息做出不同的响应，增强了代码的灵活性和可扩展性。通过理解和实践这两个概念，你将能够编写出更加健壮和灵活的 JavaScript 代码。

4. 进一步学习

• 深入学习 JavaScript 中的原型和原型链，理解它们与封装和多态的关系。
• 探索 JavaScript 中的高阶函数、函数组合和纯函数，这些概念与多态性密切相关。
• 学习如何使用 Symbol 和 WeakMap 来实现真正的私有属性。

通过不断实践和学习，你将能够更好地掌握这些高级编程概念，并在实际项目中灵活运用它们。