TypeScript 抽象类

TypeScript 抽象类

在面向对象编程中，抽象类是连接抽象概念与具体实现的桥梁。本文通过渐进式案例，深入剖析 TypeScript 抽象类的核心特性与应用场景，揭示其如何成为大型项目架构设计的利器。

一、从具体到抽象：编程范式的进化

1. 基础类结构回顾

class Person {
  name: string;
  age: number;
  
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
}

const p1 = new Person('张三', 18);

这种具体类能直接实例化，但当需要为不同角色（教师/学生）添加专属行为时，会面临代码重复和维护困难。

2. 继承的局限性

class Teacher extends Person {
  // 需要重复定义name/age属性
  speak() { /* ... */ }
}

class Student extends Person {
  study() { /* ... */ }
}

直接继承虽然实现代码复用，但无法强制子类实现特定方法，且基础类可能被错误实例化。

二、抽象类：定义蓝图的标准范式

1. 抽象类核心特性

abstract class Person {
  constructor(public name: string, public age: number) {}

  // 抽象方法（无具体实现）
  abstract introduce(): void;

  // 具体方法（可被继承）
  greet() {
    console.log(`你好，我是${this.name}`);
  }
}

• abstract 关键字声明抽象类
• 抽象方法强制子类实现
• 可包含具体方法实现

2. 子类实现规范

class Teacher extends Person {
  introduce() {
    console.log(`我是老师${this.name}，从事教育工作`);
  }

  teach() {
    console.log('正在授课...');
  }
}

class Student extends Person {
  introduce() {
    console.log(`我是学生${this.name}，正在学习`);
  }

  study() {
    console.log('正在自习...');
  }
}

• 必须实现所有抽象方法
• 可扩展专属方法
• 继承父类具体方法

三、抽象类的工程化价值

1. 强制接口规范
当尝试直接实例化抽象类时：

const p = new Person('周杰伦', 38); // 错误：无法创建抽象类的实例

编译器直接阻止错误使用，确保所有角色都是具体实现类。

2. 架构设计优势

• 模板模式：抽象类定义算法骨架（如introduce方法），子类实现具体步骤
• 代码复用：共享通用逻辑（如greet方法），避免重复代码
• 类型安全：通过抽象方法保证子类实现约定行为

3. 与接口的对比选择

特性	抽象类	接口
实现能力	可包含具体实现	仅定义结构
构造器	支持	不支持
多重继承	单继承	多实现
适用场景	共享代码+强制规范	纯类型定义

四、实战案例：教育管理系统

1. 基础抽象类设计

abstract class EducationalRole {
  constructor(
    public id: string,
    public name: string,
    protected roleType: RoleType
  ) {}

  abstract displayInfo(): void;

  getRoleType() {
    return this.roleType;
  }
}

enum RoleType {
  Teacher,
  Student
}

2. 具体角色实现

class UniversityTeacher extends EducationalRole {
  constructor(id: string, name: string, public department: string) {
    super(id, name, RoleType.Teacher);
  }

  displayInfo() {
    console.log(`[教师] 编号：${this.id}，姓名：${this.name}，所属：${this.department}`);
  }

  conductResearch() {
    console.log('正在进行学术研究...');
  }
}

class CollegeStudent extends EducationalRole {
  constructor(
    id: string,
    name: string,
    public studentId: string,
    public major: string
  ) {
    super(id, name, RoleType.Student);
  }

  displayInfo() {
    console.log(`[学生] 学号：${this.studentId}，姓名：${this.name}，专业：${this.major}`);
  }

  attendClass() {
    console.log('正在上课...');
  }
}

3. 统一管理实现

const roles: EducationalRole[] = [
  new UniversityTeacher('T001', '王教授', '计算机学院'),
  new CollegeStudent('S001', '李同学', 'U2020001', '软件工程')
];

roles.forEach(role => {
  role.displayInfo();
  if (role.getRoleType() === RoleType.Teacher) {
    (role as UniversityTeacher).conductResearch();
  }
});

五、最佳实践建议

1. 合理抽象：当多个类需要共享相同属性/方法，且需要强制实现某些行为时使用
2. 层次设计：保持抽象类层次简洁（建议不超过3层）
3. 方法可见性：使用protected修饰需要子类访问的属性/方法
4. 文档注释：为抽象方法和类添加详细注释，明确实现要求
5. 测试策略：重点测试抽象类的具体方法，子类测试关注差异点

结语

抽象类是TypeScript类型系统中的重要工具，它通过"部分实现+强制规范"的模式，在代码复用和设计约束之间找到了完美平衡。在实际开发中，合理运用抽象类可以：

• 提升代码可维护性（强制实现规范）
• 降低系统耦合度（定义清晰接口）
• 加速开发效率（共享通用逻辑）
• 增强类型安全性（编译期检查）

建议开发者在架构设计初期识别可抽象的共同模式，通过抽象类构建可扩展的系统骨架，为后续功能迭代奠定坚实基础。