TypeScript 中的类及其特性
TypeScript 是 JavaScript 的超集，它引入了类（Class）的概念，并在此基础上增加了类型系统和其他面向对象编程（OOP）的特性。TypeScript 的类与 ES6 的类类似，但提供了更强大的功能，如访问修饰符、抽象类、接口实现等。
1. 类的基本语法
TypeScript 中的类使用 class 关键字定义，可以包含属性、方法和构造函数。
示例：
class Person {
// 属性
name: string;
age: number;
// 构造函数
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
// 方法
greet() {
console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
}
}
// 创建实例
const person = new Person("Alice", 30);
person.greet(); // 输出: Hello, my name is Alice and I am 30 years old.
2. 类的特性
(1) 访问修饰符
TypeScript 提供了三种访问修饰符，用于控制类成员的访问权限：
public：默认修饰符，成员可以在任何地方访问。private：成员只能在类内部访问。protected：成员可以在类内部和子类中访问。
示例：
class Animal {
public name: string;
private age: number;
protected species: string;
constructor(name: string, age: number, species: string) {
this.name = name;
this.age = age;
this.species = species;
}
public getAge() {
return this.age; // 可以在类内部访问 private 成员
}
}
class Dog extends Animal {
constructor(name: string, age: number) {
super(name, age, "Dog");
}
public getSpecies() {
return this.species; // 可以在子类中访问 protected 成员
}
}
const dog = new Dog("Buddy", 5);
console.log(dog.name); // 可以访问 public 成员
console.log(dog.getAge()); // 通过公共方法访问 private 成员
console.log(dog.getSpecies()); // 通过子类方法访问 protected 成员
(2) 只读属性
使用 readonly 关键字可以将属性标记为只读，只能在构造函数中初始化。
示例：
class Circle {
readonly radius: number;
constructor(radius: number) {
this.radius = radius;
}
getArea() {
return Math.PI * this.radius * this.radius;
}
}
const circle = new Circle(5);
console.log(circle.getArea()); // 输出: 78.53981633974483
// circle.radius = 10; // 错误: 无法修改只读属性
(3) 静态成员
使用 static 关键字可以定义静态成员（属性和方法），它们属于类本身而不是类的实例。
示例：
class MathUtils {
static PI: number = 3.14159;
static calculateArea(radius: number) {
return this.PI * radius * radius;
}
}
console.log(MathUtils.PI); // 输出: 3.14159
console.log(MathUtils.calculateArea(5)); // 输出: 78.53975
(4) 抽象类
使用 abstract 关键字可以定义抽象类，抽象类不能被实例化，只能被继承。抽象类可以包含抽象方法（没有实现的方法），子类必须实现这些方法。
示例：
abstract class Shape {
abstract getArea(): number;
printArea() {
console.log(`Area: ${this.getArea()}`);
}
}
class Square extends Shape {
constructor(private side: number) {
super();
}
getArea() {
return this.side * this.side;
}
}
const square = new Square(5);
square.printArea(); // 输出: Area: 25
(5) 接口实现
TypeScript 的类可以通过 implements 关键字实现接口，确保类符合接口的规范。
示例：
interface Drivable {
start(): void;
stop(): void;
}
class Car implements Drivable {
start() {
console.log("Car started.");
}
stop() {
console.log("Car stopped.");
}
}
const car = new Car();
car.start(); // 输出: Car started.
car.stop(); // 输出: Car stopped.
(6) Getter 和 Setter
TypeScript 支持使用 get 和 set 关键字定义属性的访问器和修改器。
示例：
class Temperature {
private _celsius: number = 0;
get celsius() {
return this._celsius;
}
set celsius(value: number) {
if (value < -273.15) {
throw new Error("Temperature below absolute zero is not possible.");
}
this._celsius = value;
}
get fahrenheit() {
return (this._celsius * 9) / 5 + 32;
}
}
const temp = new Temperature();
temp.celsius = 25;
console.log(temp.celsius); // 输出: 25
console.log(temp.fahrenheit); // 输出: 77
(7) 继承
TypeScript 支持类的继承，子类可以继承父类的属性和方法，并可以重写父类的方法。
示例：
class Animal {
constructor(public name: string) {}
move(distance: number = 0) {
console.log(`${this.name} moved ${distance} meters.`);
}
}
class Dog extends Animal {
constructor(name: string) {
super(name);
}
bark() {
console.log("Woof! Woof!");
}
move(distance: number = 5) {
console.log(`${this.name} ran ${distance} meters.`);
}
}
const dog = new Dog("Buddy");
dog.move(); // 输出: Buddy ran 5 meters.
dog.bark(); // 输出: Woof! Woof!
3. 类的其他特性
- 方法重载：TypeScript 支持方法重载，允许定义多个方法签名。
- 参数属性：在构造函数参数前加上访问修饰符，可以同时声明和初始化属性。
- 装饰器：TypeScript 支持装饰器（Decorators），用于扩展类的行为。
总结
TypeScript 的类提供了强大的面向对象编程特性，包括：
- 访问修饰符（
public、private、protected）。 - 只读属性（
readonly）。 - 静态成员（
static）。 - 抽象类（
abstract）。 - 接口实现（
implements）。 - Getter 和 Setter。
- 继承和方法重写。
