TypeScript 类
最后修改时间：2025年3月3日
TypeScript 中的类提供了定义对象蓝图的方式。它们支持继承、封装和多态。本教程将通过实际示例探讨类语法、构造函数、访问修饰符和高级模式。
基本类语法
TypeScript 中的类使用 class 关键字定义。它可以包含属性、方法和构造函数。
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.`;
}
}
const person = new Person("Alice", 30);
console.log(person.greet()); // Output: Hello, my name is Alice and I am 30 years old.
Person 类具有 name 和 age 属性，用于初始化它们的构造函数，以及一个 greet 方法。
继承
TypeScript 使用 extends 关键字支持继承。子类继承父类的属性和方法。
class Employee extends Person {
employeeId: number;
constructor(name: string, age: number, employeeId: number) {
super(name, age);
this.employeeId = employeeId;
}
displayId(): string {
return `Employee ID: ${this.employeeId}`;
}
}
const employee = new Employee("Bob", 25, 12345);
console.log(employee.greet()); // Output: Hello, my name is Bob and I am 25 years old.
console.log(employee.displayId()); // Output: Employee ID: 12345
Employee 类扩展了 Person 类，并添加了新的 employeeId 属性和 displayId 方法。
访问修饰符
TypeScript 提供了 public、private 和 protected 等访问修饰符来控制属性和方法的可见性。
class BankAccount {
private balance: number;
constructor(initialBalance: number) {
this.balance = initialBalance;
}
deposit(amount: number): void {
this.balance += amount;
}
getBalance(): number {
return this.balance;
}
}
const account = new BankAccount(1000);
account.deposit(500);
console.log(account.getBalance()); // Output: 1500
balance 属性是私有的，只能在类内部访问。deposit 和 getBalance 等公共方法提供了受控访问。
只读属性
标记为 readonly 的属性只能在初始化时赋值，之后不能修改。
class Car {
readonly make: string;
readonly model: string;
constructor(make: string, model: string) {
this.make = make;
this.model = model;
}
}
const myCar = new Car("Toyota", "Corolla");
console.log(myCar.make); // Output: Toyota
make 和 model 属性在初始化后是不可变的。
静态属性和方法
静态属性和方法属于类本身而不是实例。它们使用类名进行访问。
class MathOperations {
static PI: number = 3.14;
static calculateArea(radius: number): number {
return this.PI * radius * radius;
}
}
console.log(MathOperations.calculateArea(5)); // Output: 78.5
PI 属性和 calculateArea 方法是静态的，可以直接通过类访问。
抽象类
抽象类不能直接实例化。它们用作其他类的基类，并可以定义抽象方法。
abstract class Animal {
abstract makeSound(): void;
move(): void {
console.log("Moving...");
}
}
class Dog extends Animal {
makeSound(): void {
console.log("Woof!");
}
}
const dog = new Dog();
dog.makeSound(); // Output: Woof!
dog.move(); // Output: Moving...
Animal 类是抽象的，并定义了一个抽象方法 makeSound。Dog 类实现了这个方法。
Getter 和 Setter
Getter 和 Setter 允许受控访问类属性。它们使用 get 和 set 关键字定义。
class Temperature {
private _celsius: number = 0;
get celsius(): number {
return this._celsius;
}
set celsius(value: number) {
if (value < -273.15) {
throw new Error("Temperature below absolute zero is not possible.");
}
this._celsius = value;
}
}
const temp = new Temperature();
temp.celsius = 25;
console.log(temp.celsius); // Output: 25
celsius 属性通过 getter 和 setter 进行访问和修改，确保了值的有效性。
接口与类
接口定义了类的契约。实现接口的类必须遵守其结构。
interface Drivable {
start(): void;
stop(): void;
}
class Car implements Drivable {
start(): void {
console.log("Car started.");
}
stop(): void {
console.log("Car stopped.");
}
}
const myCar = new Car();
myCar.start(); // Output: Car started.
myCar.stop(); // Output: Car stopped.
Car 类实现了 Drivable 接口，确保它具有 start 和 stop 方法。
最佳实践
- 封装： 使用访问修饰符保护数据。
- 单一职责： 使类专注于一项任务。
- 继承： 使用继承避免代码重复。
- 接口： 使用接口定义类的契约。
- 静态成员： 使用静态成员共享功能。
来源
本教程通过实际示例介绍了 TypeScript 类。实现这些模式可以编写更清晰、更易于维护的代码。