TypeScript的类的结构

在 TypeScript 中，类（class）的结构与 JavaScript 类似，但通过引入了类型系统，TypeScript 为类的成员（属性和方法）提供了额外的类型信息和静态检查。下面是 TypeScript 中类的结构及其特性详细介绍：

1. 类的基本结构

一个 TypeScript 类的基本结构与 JavaScript 类非常相似，但可以包括类型注解、访问修饰符等。

typescriptCopy Code

class Person {
  // 类的属性
  name: string;
  age: number;

  // 构造函数
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  // 类的方法
  greet(): string {
    return `Hello, my name is ${this.name} and I am ${this.age} years old.`;
  }
}

2. 类型注解

在 TypeScript 中，你可以给类的属性和方法提供类型注解，以确保属性和方法的数据类型是正确的。

• 属性：可以指定每个类属性的类型（如 string, number, boolean 等）。
• 方法：可以为方法的返回值提供类型注解。

例如：

typescriptCopy Code

class Person {
  name: string;  // 属性类型是 string
  age: number;   // 属性类型是 number

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

  greet(): string {  // 方法返回值类型是 string
    return `Hello, my name is ${this.name} and I am ${this.age} years old.`;
  }
}

3. 构造函数

构造函数用于初始化类的实例。在 TypeScript 中，构造函数的参数可以添加类型注解。如果构造函数的参数前面添加了 public、private 或 protected 修饰符，TypeScript 会自动为这些参数生成相应的类属性。

例如：

typescriptCopy Code

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

上面的代码实际上等同于：

typescriptCopy Code

class Person {
  name: string;
  private age: number;

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

4. 访问修饰符

TypeScript 提供了三种访问修饰符，用于控制类的成员（属性和方法）的可访问性：

• public：公开的，类的外部可以访问（默认修饰符）。
• private：私有的，只有类内部可以访问。
• protected：受保护的，类内部和子类可以访问。

typescriptCopy Code

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

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

  public greet(): string {
    return `Hello, my name is ${this.name}`;
  }

  private calculateAgeInMonths(): number {
    return this.age * 12;
  }

  protected getJob(): string {
    return this.job;
  }
}

const person = new Person("John", 30, "Engineer");
console.log(person.greet());  // 可以访问公共方法
console.log(person.getJob()); // 错误，无法访问受保护的方法

5. 继承

TypeScript 支持类的继承，可以通过 extends 关键字来扩展父类。子类会继承父类的所有公共和受保护的成员，但不能继承私有成员。

typescriptCopy Code

class Employee extends Person {
  private employeeId: number;

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

  getEmployeeDetails(): string {
    return `Employee ID: ${this.employeeId}, Name: ${this.name}, Job: ${this.getJob()}`;
  }
}

const employee = new Employee("Jane", 28, "Developer", 1234);
console.log(employee.getEmployeeDetails());  // 可以访问父类的公共和受保护成员

6. 静态成员

静态成员属于类本身，而不是类的实例。通过 static 关键字定义静态成员，静态方法和属性无法通过实例访问，只能通过类来访问。

typescriptCopy Code

class Calculator {
  static PI: number = 3.14;

  static calculateCircleArea(radius: number): number {
    return Calculator.PI * radius * radius;
  }
}

console.log(Calculator.PI);  // 访问静态属性
console.log(Calculator.calculateCircleArea(5));  // 访问静态方法

7. 抽象类

抽象类是不能被实例化的类，它通常作为其他类的基类，用于定义一个公共的接口。抽象类可以包含抽象方法，抽象方法是没有实现的方法，必须在子类中实现。

typescriptCopy Code

abstract class Animal {
  abstract makeSound(): void;  // 抽象方法，子类必须实现

  move(): void {
    console.log("The animal is moving");
  }
}

class Dog extends Animal {
  makeSound(): void {
    console.log("Woof!");
  }
}

const dog = new Dog();
dog.makeSound();  // 输出: Woof!
dog.move();       // 输出: The animal is moving

8. getter 和 setter

TypeScript 支持在类中定义 getter 和 setter 方法，用来控制对类属性的访问。通过 get 和 set 关键字可以定义这些方法。

typescriptCopy Code

class Rectangle {
  private _width: number;
  private _height: number;

  constructor(width: number, height: number) {
    this._width = width;
    this._height = height;
  }

  get area(): number {
    return this._width * this._height;
  }

  set width(value: number) {
    if (value <= 0) {
      throw new Error("Width must be positive");
    }
    this._width = value;
  }

  set height(value: number) {
    if (value <= 0) {
      throw new Error("Height must be positive");
    }
    this._height = value;
  }
}

const rect = new Rectangle(10, 20);
console.log(rect.area);  // 使用 getter 输出面积
rect.width = 15;         // 使用 setter 修改宽度
console.log(rect.area);  // 使用 getter 输出新的面积

9. 类的接口实现

TypeScript 支持类实现接口，接口定义了类应该具备哪些方法和属性，类必须实现接口中的所有方法和属性。

typescriptCopy Code

interface Shape {
  area(): number;
}

class Circle implements Shape {
  constructor(public radius: number) {}

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

const circle = new Circle(5);
console.log(circle.area());  // 输出圆的面积

总结

TypeScript 的类结构提供了更多的类型安全、方法和属性的访问控制、以及面向对象编程（OOP）常见的概念，如继承、抽象类和接口等。通过类型注解、访问修饰符、静态成员等特性，TypeScript 类的结构更适合大规模的应用开发，能有效提高代码的可维护性和可读性。