TypeScript 中的抽象类

在现代 JavaScript 开发中，TypeScript 引入了类型系统和面向对象编程的特性，使得开发者可以更高效地构建复杂的应用程序。其中，抽象类是一个重要概念。本文将详细探讨 TypeScript 中的抽象类，包括它们的定义、用途和最佳实践。

什么是抽象类？

抽象类是不能被实例化的类，主要用于提供一个基类，供其他类继承。它允许开发者定义一些方法和属性，这些方法和属性可以在子类中被实现或重用。

抽象类的特点不能实例化：抽象类本身不能被直接创建实例。包含抽象方法：可以定义抽象方法，要求子类必须实现这些方法。可以有具体方法：除了抽象方法，抽象类还可以包含具体的方法和属性。封装性：可以使用访问修饰符（如 public、protected 和 private）来控制访问级别。如何定义抽象类

在 TypeScript 中，可以使用 abstract 关键字来定义一个抽象类和其抽象方法。下面是一个简单的示例：

abstract class Animal {
    abstract sound(): string; // 抽象方法
    move(): void {
        console.log("The animal moves.");
    }
}

示例解析继承抽象类

子类可以继承抽象类，并且必须实现所有的抽象方法。下面是一个具体的实现示例：

class Dog extends Animal {
    sound(): string {
        return "Woof!";
    }
}
class Cat extends Animal {
    sound(): string {
        return "Meow!";
    }
}

使用示例

const myDog = new Dog();
console.log(myDog.sound()); // 输出: Woof!
myDog.move(); // 输出: The animal moves.
const myCat = new Cat();
console.log(myCat.sound()); // 输出: Meow!
myCat.move(); // 输出: The animal moves.

抽象类的属性

抽象类不仅可以有方法，还可以定义属性。这使得你可以在子类之间共享状态。

abstract class Vehicle {
    constructor(public color: string) {}
    abstract wheels: number; // 抽象属性
    displayColor(): void {
        console.log(`The color of the vehicle is ${this.color}`);
    }
}
class Car extends Vehicle {
    wheels = 4; // 实现抽象属性
    constructor(color: string) {
        super(color);
    }
}
const myCar = new Car("red");
myCar.displayColor(); // 输出: The color of the vehicle is red
console.log(`Wheels: ${myCar.wheels}`); // 输出: Wheels: 4

构造函数与初始化

抽象类可以定义构造函数，这使得可以在实例化子类之前执行一些初始化逻辑。

abstract class Shape {
    constructor(public area: number) {}
    displayArea(): void {
        console.log(`Area: ${this.area}`);
    }
}
class Circle extends Shape {
    constructor(radius: number) {
        super(Math.PI * radius * radius); // 计算圆的面积
    }
}
const myCircle = new Circle(5);
myCircle.displayArea(); // 输出: Area: 78.53981633974483

多层次继承

抽象类可以形成复杂的继承关系，允许开发者在多个层次上定义和实现方法。

abstract class LivingThing {
    abstract breathe(): void;
}
abstract class Animal extends LivingThing {
    abstract makeSound(): void;
}
class Dog extends Animal {
    breathe(): void {
        console.log("Breathing like a dog.");
    }
    makeSound(): void {
        console.log("Woof!");
    }
}
const myDog = new Dog();
myDog.breathe(); // 输出: Breathing like a dog.
myDog.makeSound(); // 输出: Woof!

访问修饰符

抽象类中的方法和属性可以使用访问修饰符控制其可见性，以支持更好的封装。

abstract class Employee {
    protected salary: number;
    constructor(salary: number) {
        this.salary = salary;
    }
    protected abstract calculateBonus(): number;
}
class Manager extends Employee {
    protected calculateBonus(): number {
        return this.salary * 0.10; // 经理的奖金计算方式
    }
    
    public getBonus(): number { 
        return this.calculateBonus(); // 子类可以访问 protected 方法 
    }
}
const manager = new Manager(50000);
console.log(manager.calculateBonus()); // 这里会报错，因为 calculateBonus 是受保护的。
console.log(manager.getBonus()); // 输出: 5000

创建抽象类的好处代码复用：在抽象类中可以实现一些公用的方法，避免重复代码。提高可维护性：通过强制派生类实现特定方法，可以确保代码的一致性。增强可读性：使用抽象类可以清晰地表达类之间的关系和责任。抽象类与接口的区别

虽然抽象类和接口都可以用来定义方法的契约，但它们在使用上有一些不同：

interface IAnimal {
    makeSound(): void;
}
class Bird implements IAnimal {
    makeSound(): void {
        console.log("Chirp!");
    }
}

最佳实践使用抽象类来实现基本功能：如果一组类有共享的行为和状态，使用抽象类是合适的。避免过度使用抽象类：并不是所有的类都需要成为抽象类。确保你的设计是合理的。清晰的命名：为抽象类和方法使用清晰的命名，以提高代码的可读性。总结

抽象类是 TypeScript 中强大的特性，它允许我们创建通用的基类，为子类提供共享的逻辑和结构。通过使用抽象类，我们可以提高代码的复用性和可维护性。在构建复杂应用程序时，合理运用抽象类可以帮助我们组织代码，提升开发效率。