抽象类是什么

在TypeScript的面向对象编程体系中，抽象类是一个至关重要但又容易被误解的概念。它既不像普通类那样可以直接实例化，也不像接口那样纯粹定义契约。本文将深入探讨TypeScript抽象类的核心概念、使用场景和实现细节，帮助前端开发者深入理解这一重要特性。

什么是抽象类？

基本定义

抽象类是一种特殊的类，它不能被直接实例化，只能被其他类继承。抽象类的主要目的是为派生类提供基类和公共实现，同时定义必须由派生类实现的抽象成员。

typescript 复制代码 
// 声明一个抽象类
abstract class Animal {
  // 抽象属性
  abstract name: string;
  
  // 抽象方法
  abstract makeSound(): void;
  
  // 具体方法
  move(distance: number = 0): void {
    console.log(`${this.name} moved ${distance}m.`);
  }
}

与普通类的区别

特性 普通类 抽象类
实例化 可以直接实例化 不能直接实例化
抽象成员 不能包含抽象成员 可以包含抽象成员
继承 可以被继承 必须被继承才能使用
用途 创建具体对象 作为基类提供通用实现

抽象成员详解

抽象方法

抽象方法只有声明没有实现，必须在派生类中实现：

typescript 复制代码 
abstract class Department {
  constructor(public name: string) {}
  
  // 抽象方法
  abstract printMeeting(): void;
  
  // 具体方法
  printName(): void {
    console.log("Department name: " + this.name);
  }
}

class AccountingDepartment extends Department {
  constructor() {
    super("Accounting and Auditing");
  }
  
  // 必须实现抽象方法
  printMeeting(): void {
    console.log("The Accounting Department meets each Monday at 10am.");
  }
  
  generateReports(): void {
    console.log("Generating accounting reports...");
  }
}

抽象属性

抽象属性也必须在派生类中实现：

typescript 复制代码 
abstract class Vehicle {
  // 抽象属性
  abstract wheels: number;
  abstract brand: string;
  
  // 具体属性
  color: string = "white";
  
  displayInfo(): void {
    console.log(`This is a ${this.color} ${this.brand} with ${this.wheels} wheels`);
  }
}

class Car extends Vehicle {
  // 实现抽象属性
  wheels: number = 4;
  brand: string = "Toyota";
  
  // 可以添加额外属性
  model: string = "Camry";
}

抽象类的构造函数

抽象类可以有构造函数，虽然不能直接实例化，但派生类可以通过super()调用父类的构造函数：

typescript 复制代码 
abstract class Person {
  constructor(
    public firstName: string,
    public lastName: string
  ) {}
  
  abstract getFullName(): string;
}

class Employee extends Person {
  constructor(
    firstName: string,
    lastName: string,
    public jobTitle: string
  ) {
    super(firstName, lastName); // 调用抽象类的构造函数
  }
  
  getFullName(): string {
    return `${this.firstName} ${this.lastName}`;
  }
}

访问修饰符与抽象类

抽象类支持所有TypeScript访问修饰符：

typescript 复制代码 
abstract class Example {
  // 公共抽象方法
  public abstract publicMethod(): void;
  
  // 受保护抽象方法
  protected abstract protectedMethod(): void;
  
  // 私有具体方法（只能在抽象类内部访问）
  private privateMethod(): void {
    console.log("Private method");
  }
  
  // 受保护的具体方法
  protected commonLogic(): void {
    this.privateMethod();
    console.log("Common logic executed");
  }
}

class ConcreteExample extends Example {
  // 必须实现公共抽象方法
  public publicMethod(): void {
    console.log("Public method implementation");
  }
  
  // 必须实现受保护抽象方法
  protected protectedMethod(): void {
    this.commonLogic(); // 可以访问父类的受保护方法
    console.log("Protected method implementation");
  }
}

抽象类与接口的对比

相似之处

抽象类和接口都定义了必须由实现类遵循的契约，但它们在实现方式上有所不同：

typescript 复制代码 
// 使用接口
interface ClockInterface {
  currentTime: Date;
  setTime(d: Date): void;
}

// 使用抽象类
abstract class ClockAbstract {
  abstract currentTime: Date;
  abstract setTime(d: Date): void;
  
  // 抽象类可以提供具体实现
  getTime(): string {
    return this.currentTime.toLocaleTimeString();
  }
}

主要区别

特性 接口 抽象类
实现 只有声明，无实现 可以包含具体实现
成员类型 所有成员都是抽象的 可以混合抽象和具体成员
多继承 一个类可以实现多个接口 一个类只能继承一个抽象类
构造函数 不能有构造函数 可以有构造函数
访问修饰符 所有成员都是public的 支持所有访问修饰符

实际应用场景

1. 框架基类

抽象类常用于框架设计中，提供基础功能同时强制子类实现特定方法：

typescript 复制代码 
abstract class Component {
  // 抽象方法，子类必须实现渲染逻辑
  abstract render(): HTMLElement;
  
  // 具体方法，提供通用功能
  mount(container: HTMLElement): void {
    const element = this.render();
    container.appendChild(element);
  }
  
  // 钩子方法，子类可以选择性重写
  onMount(): void {
    // 默认空实现
  }
}

class ButtonComponent extends Component {
  constructor(public text: string) {
    super();
  }
  
  render(): HTMLElement {
    const button = document.createElement("button");
    button.textContent = this.text;
    return button;
  }
  
  // 重写钩子方法
  onMount(): void {
    console.log("Button component mounted");
  }
}

2. 模板方法模式

抽象类非常适合实现模板方法模式，定义算法骨架：

typescript 复制代码 
abstract class DataProcessor {
  // 模板方法，定义处理流程
  process(): void {
    this.validateData();
    this.transformData();
    this.saveData();
    this.cleanup();
  }
  
  // 具体方法
  private validateData(): void {
    console.log("Validating data...");
  }
  
  // 抽象方法，子类必须实现
  protected abstract transformData(): void;
  
  // 钩子方法，子类可以选择性重写
  protected saveData(): void {
    console.log("Saving data to default location...");
  }
  
  protected cleanup(): void {
    console.log("Cleaning up resources...");
  }
}

class CSVProcessor extends DataProcessor {
  protected transformData(): void {
    console.log("Transforming CSV data...");
  }
  
  protected saveData(): void {
    console.log("Saving data to CSV file...");
  }
}

class JSONProcessor extends DataProcessor {
  protected transformData(): void {
    console.log("Transforming JSON data...");
  }
}

3. 多层级继承

抽象类可以形成多层级继承结构：

typescript 复制代码 
abstract class Shape {
  abstract getArea(): number;
  abstract getPerimeter(): number;
  
  displayInfo(): void {
    console.log(`Area: ${this.getArea()}, Perimeter: ${this.getPerimeter()}`);
  }
}

abstract class Polygon extends Shape {
  abstract getSides(): number;
}

class Rectangle extends Polygon {
  constructor(public width: number, public height: number) {
    super();
  }
  
  getArea(): number {
    return this.width * this.height;
  }
  
  getPerimeter(): number {
    return 2 * (this.width + this.height);
  }
  
  getSides(): number {
    return 4;
  }
}

最佳实践与注意事项

1. 合理使用抽象类

  • 当需要提供通用实现时使用抽象类
  • 当需要强制子类实现特定方法时使用抽象类
  • 当预期会有多个相关类共享行为时使用抽象类

2. 避免过度使用

  • 如果所有方法都是抽象的，考虑使用接口代替
  • 避免创建过于复杂的继承层次结构
  • 优先使用组合而非继承，除非确实需要"is-a"关系

3. 设计原则

遵循依赖倒置原则：高层模块不应该依赖低层模块，二者都应该依赖抽象。

typescript 复制代码 
// 不好的做法：直接依赖具体类
class PaymentService {
  processPayment(creditCardProcessor: CreditCardProcessor) {
    // 处理支付
  }
}

// 好的做法：依赖抽象
abstract class PaymentProcessor {
  abstract process(amount: number): boolean;
}

class PaymentService {
  processPayment(processor: PaymentProcessor, amount: number) {
    return processor.process(amount);
  }
}

常见面试问题

1. 抽象类和接口有什么区别？

这是最常见的面试问题。关键区别在于：

  • 抽象类可以包含实现，接口只能包含声明
  • 类可以实现多个接口，但只能继承一个抽象类
  • 抽象类可以有构造函数和访问修饰符，接口不能

2. 什么时候应该使用抽象类而不是接口？

当需要为派生类提供一些默认实现，同时要求它们实现特定方法时，应该使用抽象类。如果只是定义契约而没有共享实现，应该使用接口。

3. 抽象类能被实例化吗？

不能。尝试实例化抽象类会导致编译错误。

4. 抽象类必须包含抽象方法吗？

不一定。抽象类可以不包含任何抽象方法，但仍然不能被实例化。

总结

TypeScript中的抽象类是面向对象编程的重要工具，它：

  • 提供了一种定义不能直接实例化的基类的方式
  • 允许混合抽象成员和具体实现
  • 支持模板方法模式等设计模式
  • 强制派生类遵循特定契约

正确使用抽象类可以提高代码的可维护性、可扩展性和重用性。理解抽象类的特性和适用场景，对于编写高质量的TypeScript代码至关重要。

通过本文的深入讲解，希望您对TypeScript抽象类有了更全面的理解，能够在实际项目中灵活运用这一强大特性。