面向对象编程

1. 类与继承

在 TypeScript 中，类是创建对象的蓝图。可以通过继承来创建一个新类，使其具有父类的特性和功能。

示例：

class Animal {
    protected name: string; // 保护属性，子类可以访问

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

    speak(): void {
        console.log(`${this.name} makes a noise.`);
    }
}

class Dog extends Animal { // 继承
    speak(): void {
        console.log(`${this.name} barks.`);
    }
}

const dog = new Dog("Buddy");
dog.speak(); // 输出：Buddy barks.

2. 修饰符

TypeScript 支持三种访问修饰符：

• public：公共的，任何地方都可以访问（默认修饰符）。
• private：私有的，仅在类内部可访问。
• protected：受保护的，可以在类及其子类中访问。

示例：

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 introduce(): void {
        console.log(`Hello, I am ${this.name}, and I work as a ${this.job}.`);
    }

    private getAge(): number {
        return this.age;
    }
}

const person = new Person("Alice", 30, "Engineer");
person.introduce(); // 输出：Hello, I am Alice, and I work as a Engineer.
// console.log(person.age); // 报错：属性 'age' 是私有的

3. 抽象类与接口

• 抽象类：不能被实例化的类，通常用于定义基类。抽象类可以包含抽象方法（没有实现的方法）和具体方法。
• 接口：用于定义对象的结构，可以被类实现。接口只定义属性和方法，没有实现。

示例：

// 抽象类
abstract class Shape {
    abstract area(): number; // 抽象方法

    printArea(): void {
        console.log(`Area: ${this.area()}`);
    }
}

class Circle extends Shape {
    constructor(private radius: number) {
        super();
    }

    area(): number {
        return Math.PI * this.radius ** 2; // 实现抽象方法
    }
}

const circle = new Circle(5);
circle.printArea(); // 输出：Area: 78.53981633974483

// 接口
interface Vehicle {
    speed: number; // 属性
    drive(): void; // 方法
}

class Car implements Vehicle { // 实现接口
    constructor(public speed: number) {}

    drive(): void {
        console.log(`Driving at ${this.speed} km/h`);
    }
}

const car = new Car(120);
car.drive(); // 输出：Driving at 120 km/h

总结

通过类与继承、访问修饰符、抽象类和接口，TypeScript 提供了强大的面向对象编程特性，可以帮助开发者创建结构良好、可维护性高的代码。