TypeScript 中的类与对象：继承与多态

在 TypeScript 中，类与对象是面向对象编程的核心概念。继承与多态是面向对象编程的两个重要特性，它们使得代码更加灵活、可重用和易于维护。在本节中，我们将深入探讨 TypeScript 中的继承与多态，提供详细的示例代码，并讨论每个概念的优缺点和注意事项。

1. 继承

1.1 概念

继承是面向对象编程中的一种机制，允许一个类（子类）继承另一个类（父类）的属性和方法。通过继承，子类可以重用父类的代码，同时可以扩展或修改父类的行为。

1.2 示例代码

// 定义一个父类 Animal
class Animal {
    constructor(public name: string) {}

    makeSound(): void {
        console.log(`${this.name} makes a sound.`);
    }
}

// 定义一个子类 Dog 继承自 Animal
class Dog extends Animal {
    makeSound(): void {
        console.log(`${this.name} barks.`);
    }
}

// 定义另一个子类 Cat 继承自 Animal
class Cat extends Animal {
    makeSound(): void {
        console.log(`${this.name} meows.`);
    }
}

// 使用子类
const dog = new Dog("Buddy");
dog.makeSound(); // 输出: Buddy barks.

const cat = new Cat("Whiskers");
cat.makeSound(); // 输出: Whiskers meows.

1.3 优点

代码重用：子类可以重用父类的代码，减少重复代码的编写。
逻辑组织：通过继承，可以将相关的类组织在一起，形成清晰的层次结构。
扩展性：子类可以扩展父类的功能，增加新的属性和方法。

1.4 缺点

复杂性：过度使用继承可能导致类层次结构复杂，难以理解和维护。
紧耦合：子类与父类之间的紧密耦合可能导致父类的修改影响到所有子类。

1.5 注意事项

尽量使用组合而非继承来实现代码复用，特别是在复杂的系统中。
关注类的单一职责原则，确保每个类只负责一项功能。

2. 多态

2.1 概念

多态是指不同类的对象可以通过相同的接口进行操作。多态允许我们使用父类的引用来指向子类的对象，从而实现动态绑定。这样，程序在运行时可以根据对象的实际类型来调用相应的方法。

2.2 示例代码

// 定义一个函数，接受 Animal 类型的参数
function makeAnimalSound(animal: Animal): void {
    animal.makeSound();
}

// 使用多态
const animals: Animal[] = [new Dog("Buddy"), new Cat("Whiskers")];

for (const animal of animals) {
    makeAnimalSound(animal);
}
// 输出:
// Buddy barks.
// Whiskers meows.

2.3 优点

灵活性：多态使得代码更加灵活，可以在运行时决定调用哪个方法。
可扩展性：可以轻松添加新的子类，而不需要修改现有的代码。
简化代码：通过统一的接口，可以简化代码的编写和维护。

2.4 缺点

性能开销：多态可能引入一定的性能开销，因为需要在运行时进行类型检查和方法查找。
调试困难：由于方法的调用在运行时决定，可能会导致调试时难以追踪问题。

2.5 注意事项

确保接口的设计清晰，避免过度复杂的多态实现。
在使用多态时，注意类型安全，确保传入的对象符合预期的接口。

3. 结合继承与多态的示例

下面是一个结合继承与多态的完整示例，展示如何使用这两个特性来构建一个简单的图形绘制程序。

// 定义一个父类 Shape
abstract class Shape {
    constructor(public color: string) {}

    abstract area(): number; // 抽象方法，子类必须实现
    abstract draw(): void; // 抽象方法，子类必须实现
}

// 定义一个子类 Circle 继承自 Shape
class Circle extends Shape {
    constructor(public radius: number, color: string) {
        super(color);
    }

    area(): number {
        return Math.PI * this.radius * this.radius;
    }

    draw(): void {
        console.log(`Drawing a ${this.color} circle with radius ${this.radius}`);
    }
}

// 定义另一个子类 Rectangle 继承自 Shape
class Rectangle extends Shape {
    constructor(public width: number, public height: number, color: string) {
        super(color);
    }

    area(): number {
        return this.width * this.height;
    }

    draw(): void {
        console.log(`Drawing a ${this.color} rectangle with width ${this.width} and height ${this.height}`);
    }
}

// 使用多态
const shapes: Shape[] = [
    new Circle(5, "red"),
    new Rectangle(10, 20, "blue"),
];

for (const shape of shapes) {
    shape.draw();
    console.log(`Area: ${shape.area()}`);
}
// 输出:
// Drawing a red circle with radius 5
// Area: 78.53981633974483
// Drawing a blue rectangle with width 10 and height 20
// Area: 200

结论

在 TypeScript 中，继承与多态是构建灵活、可扩展和可维护代码的重要工具。通过合理使用这两个特性，可以有效地组织代码，减少重复，提高代码的可读性和可维护性。然而，开发者在使用时也需谨慎，避免过度复杂化类层次结构和接口设计。希望本教程能帮助你更深入地理解 TypeScript 中的继承与多态，并在实际开发中灵活运用。