类类型（class）

在 TypeScript 中，类（class）是面向对象编程的基础。它们允许你创建具有属性和方法的对象，并支持继承、封装、多态等面向对象的特性。TypeScript 的类是对 ES6 类的扩展，添加了静态类型检查和其他功能。

定义一个简单的类

以下是如何定义一个基本的类：

class Greeter {
  greeting: string;

  constructor(message: string) {
    this.greeting = message;
  }

  greet(): string {
    return "Hello, " + this.greeting;
  }
}

let greeter = new Greeter("world");
console.log(greeter.greet()); // 输出: Hello, world

在这个例子中，Greeter 类有一个 greeting 属性，一个构造函数 (constructor) 用于初始化该属性，以及一个 greet 方法来返回一条问候消息。

公共、私有和受保护的修饰符

TypeScript 提供了三种访问修饰符来控制类成员的可见性：

• 公共（public）：默认情况下所有成员都是公共的，这意味着它们可以在任何地方被访问。
• 私有（private）：只能在声明它的类内部访问。这有助于隐藏实现细节并防止外部代码直接修改类的状态。
• 受保护（protected）：与私有类似，但还可以在子类中访问。

class Person {
  private name: string;
  protected age: number;
  public isMarried: boolean;

  constructor(name: string, age: number, isMarried: boolean) {
    this.name = name;
    this.age = age;
    this.isMarried = isMarried;
  }

  // ...
}

参数属性

在构造函数参数前加上访问修饰符可以自动将参数作为类的成员变量进行初始化：

class Animal {
  constructor(private name: string) {}

  move(distanceInMeters: number = 0) {
    console.log(`${this.name} moved ${distanceInMeters}m.`);
  }
}

继承

你可以使用 extends 关键字让一个类继承另一个类的特性：

class Employee extends Person {
  private department: string;

  constructor(
    name: string,
    age: number,
    isMarried: boolean,
    department: string
  ) {
    super(name, age, isMarried); // 调用父类构造函数
    this.department = department;
  }

  getElevatorPitch() {
    return `Hello, my name is ${this.name} and I work in ${this.department}.`;
  }
}

let howard = new Employee("Howard", 42, false, "Sales");
console.log(howard.getElevatorPitch());
// 注意：不能访问 howard.name 或 howard.age 因为它们是 private 和 protected 的

抽象类

抽象类是用来定义接口和基础功能的类，但它们不能直接实例化。它们通常包含一些需要子类去实现的方法。

abstract class Department {
  constructor(public name: string) {}

  printName(): void {
    console.log("Department name: " + this.name);
  }

  abstract printMeeting(): void; // 必须在派生类中实现
}

class AccountingDepartment extends Department {
  constructor() {
    super("Accounting and Auditing"); // 在派生类的构造函数中必须调用 super()
  }

  printMeeting(): void {
    console.log("The Accounting Department meets each Monday at 10am.");
  }

  generateReports(): void {
    console.log("Generating accounting reports...");
  }
}

let department: Department; // 允许创建一个对抽象类型的引用
department = new AccountingDepartment(); // 实现抽象类的具体类可以被实例化
department.printName();
department.printMeeting();
// department.generateReports(); // 错误: 方法 'generateReports' 在声明类型 'Department' 上不存在

静态属性和方法

静态成员属于类本身而不是类的实例。因此，它们可以通过类名直接访问，而不需要创建类的实例。

class Grid {
  static origin = { x: 0, y: 0 };
  calculateDistanceFromOrigin(point: { x: number; y: number }): number {
    let xDist = point.x - Grid.origin.x;
    let yDist = point.y - Grid.origin.y;
    return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;
  }

  constructor(public scale: number) {}
}

let grid1 = new Grid(1.0); // 1x scale
let grid2 = new Grid(5.0); // 5x scale

console.log(grid1.calculateDistanceFromOrigin({ x: 10, y: 10 }));
console.log(Grid.origin.x); // 访问静态属性

以上就是 TypeScript 中关于类的一些关键概念。通过这些特性，你可以创建结构良好且易于维护的面向对象程序。