第3章 TypeScript中的面向对象编程

在软件开发的世界里，面向对象编程（Object-Oriented Programming, OOP）是一种广泛使用的编程范式，它通过将数据（属性）和操作这些数据的方法（函数）封装在对象中来组织代码。TypeScript，作为JavaScript的一个超集，不仅继承了JavaScript的动态类型和灵活性，还通过引入静态类型系统和类、接口等概念，极大地增强了面向对象编程的能力。本章将深入探讨TypeScript中面向对象编程的核心概念，包括类、继承、封装、多态以及接口等。

3.1 类的基本概念

在TypeScript中，类（Class）是面向对象编程的基础。类是一种蓝图，用于创建具有相同属性和方法的对象。通过类，我们可以定义对象的结构，包括其属性和方法。

class Person {
    name: string;
    age: number;
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }
    greet(): void {
        console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
    }
}
const person1 = new Person('Alice', 30);
person1.greet(); // 输出: Hello, my name is Alice and I am 30 years old.

在上面的例子中，Person类有两个属性：name和age，以及一个构造函数constructor用于初始化这些属性。此外，还定义了一个方法greet用于输出问候语。通过new关键字，我们可以创建Person类的实例person1，并调用其方法。

3.2 访问修饰符

TypeScript支持三种访问修饰符：public（默认，公开的）、protected（受保护的）和private（私有的），用于控制类成员的访问级别。

• Public：成员可以在任何地方被访问。
• Protected：成员只能在类内部及其子类中被访问。
• Private：成员只能在类内部被访问。

class Animal {
    private name: string;
    constructor(name: string) {
        this.name = name;
    }
    protected speak(): void {
        console.log(`${this.name} makes a sound.`);
    }
    public getName(): string {
        return this.name;
    }
}
class Dog extends Animal {
    bark(): void {
        this.speak(); // 可以访问受保护的成员
        console.log('Woof!');
    }
}
const dog = new Dog('Buddy');
dog.bark(); // 输出: Buddy makes a sound. Woof!
// dog.name; // 错误：'name' 是私有的，不能在类外部访问

3.3 继承

继承是面向对象编程中的一个核心概念，它允许我们基于一个类（父类）来创建另一个类（子类），子类会继承父类的属性和方法，并可以添加新的属性或重写父类的方法。

class Vehicle {
    move(): void {
        console.log('The vehicle is moving.');
    }
}
class Car extends Vehicle {
    constructor(public brand: string) {
        super(); // 调用父类的构造函数
    }
    move(): void {
        console.log(`${this.brand} is moving.`);
    }
}
const myCar = new Car('Toyota');
myCar.move(); // 输出: Toyota is moving.

在上面的例子中，Car类继承自Vehicle类，并重写了move方法以包含品牌信息。注意，在子类的构造函数中，我们需要通过super()调用父类的构造函数（如果父类有构造函数的话）。

3.4 封装

封装是面向对象编程的三大特性之一（封装、继承、多态），它指的是将数据（属性）和操作这些数据的方法（函数）组合在一起，形成一个独立的单元（即对象）。通过封装，我们可以隐藏对象的内部实现细节，只对外暴露有限的接口供外部使用。

在TypeScript中，通过访问修饰符（如private和protected）可以很容易地实现封装。

3.5 多态

多态（Polymorphism）是面向对象编程的又一重要特性，它允许我们以统一的接口处理不同类型的对象。在TypeScript中，多态通常通过继承和方法重写来实现。

class Shape {
    draw(): void {
        console.log('Drawing a shape.');
    }
}
class Circle extends Shape {
    draw(): void {
        console.log('Drawing a circle.');
    }
}
class Rectangle extends Shape {
    draw(): void {
        console.log('Drawing a rectangle.');
    }
}
function drawShape(shape: Shape): void {
    shape.draw();
}
const circle = new Circle();
const rectangle = new Rectangle();
drawShape(circle); // 输出: Drawing a circle.
drawShape(rectangle); // 输出: Drawing a rectangle.

在这个例子中，drawShape函数接受一个Shape类型的参数，并调用其draw方法。由于Circle和Rectangle都继承自Shape并重写了draw方法，因此它们都可以作为drawShape的参数，这体现了多态性。

3.6 接口

接口（Interface）在TypeScript中扮演着非常重要的角色，它是对对象形状的描述。接口可以定义对象的结构，包括对象应该包含哪些属性以及这些属性的类型。接口还可以定义对象可以执行的方法及其参数和返回值的类型。

interface IPerson {
    name: string;
    age: number;
    greet(message?: string): void;
}
class Employee implements IPerson {
    name: string;
    age: number;
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }
    greet(message: string = 'Hello'): void {
        console.log(`${message}, my name is ${this.name} and I am an employee.`);
    }
}
const employee: IPerson = new Employee('Bob', 25);
employee.greet('Good morning'); // 输出: Good morning, my name is Bob and I am an employee.

在上面的例子中，IPerson接口定义了name、age属性和greet方法。Employee类实现了IPerson接口，这意味着它必须包含接口中定义的所有属性和方法。此外，我们还展示了如何使用接口作为类型注解来创建变量。

3.7 抽象类

抽象类（Abstract Class）是一种特殊的类，它不能被实例化，只能被其他类继承。抽象类通常用于定义一组接口，这些接口由子类实现。在TypeScript中，使用abstract关键字来定义抽象类和抽象方法。

abstract class Animal {
    abstract makeSound(): void;
    move(): void {
        console.log('The animal is moving.');
    }
}
class Dog extends Animal {
    makeSound(): void {
        console.log('Woof!');
    }
}
// const myAnimal = new Animal(); // 错误：不能实例化抽象类
const myDog = new Dog();
myDog.makeSound(); // 输出: Woof!
myDog.move(); // 输出: The animal is moving.

在上面的例子中，Animal是一个抽象类，它定义了一个抽象方法makeSound和一个普通方法move。Dog类继承自Animal并实现了makeSound方法。注意，我们不能直接实例化抽象类Animal。

结语

通过本章的学习，我们深入了解了TypeScript中面向对象编程的核心概念，包括类、继承、封装、多态、接口以及抽象类等。这些概念是构建复杂、可维护软件系统的基石。掌握它们将使你能够更有效地利用TypeScript的强大功能来开发高质量的Web应用程序。