TypeScript 教程：类与对象 5.2 构造函数与初始化

在 TypeScript 中，类是面向对象编程的核心概念之一。类允许我们创建对象的蓝图，并通过构造函数来初始化这些对象的状态。构造函数是一个特殊的方法，用于创建和初始化类的实例。本文将深入探讨构造函数的概念、用法、优缺点以及注意事项，并提供丰富的示例代码。

1. 构造函数的基本概念

构造函数是一个类中的特殊方法，其名称与类名相同。构造函数在创建类的实例时自动调用。它的主要作用是初始化对象的属性。

示例代码

class Person {
    name: string;
    age: number;

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

    introduce(): string {
        return `Hello, my name is ${this.name} and I am ${this.age} years old.`;
    }
}

const person1 = new Person("Alice", 30);
console.log(person1.introduce()); // 输出: Hello, my name is Alice and I am 30 years old.

在上面的示例中，Person 类有一个构造函数，它接受两个参数 name 和 age，并将它们赋值给实例属性。

2. 构造函数的优点

简化对象创建：构造函数允许我们在创建对象时直接传递参数，从而简化了对象的初始化过程。
提高代码可读性：通过使用构造函数，代码的意图更加明确，其他开发者可以更容易理解对象的初始化过程。
支持默认参数：构造函数可以定义默认参数，使得对象的创建更加灵活。

示例代码：默认参数

class Car {
    make: string;
    model: string;
    year: number;

    constructor(make: string, model: string, year: number = 2020) {
        this.make = make;
        this.model = model;
        this.year = year;
    }

    displayInfo(): string {
        return `${this.year} ${this.make} ${this.model}`;
    }
}

const car1 = new Car("Toyota", "Corolla");
console.log(car1.displayInfo()); // 输出: 2020 Toyota Corolla

在这个示例中，year 参数有一个默认值 2020，如果在创建 Car 实例时没有提供 year，则会使用默认值。

3. 构造函数的缺点

复杂性增加：当构造函数的参数数量较多时，可能会导致代码的复杂性增加，尤其是在需要传递多个参数时。
缺乏灵活性：如果构造函数中有多个参数，可能会导致在创建对象时需要提供不必要的参数，降低了灵活性。

示例代码：参数过多

class User {
    username: string;
    email: string;
    password: string;
    age: number;
    isActive: boolean;

    constructor(username: string, email: string, password: string, age: number, isActive: boolean) {
        this.username = username;
        this.email = email;
        this.password = password;
        this.age = age;
        this.isActive = isActive;
    }
}

const user1 = new User("john_doe", "john@example.com", "securepassword", 25, true);

在这个示例中，User 类的构造函数接受了五个参数，这可能会导致在创建 User 实例时的混淆。

4. 注意事项

构造函数的可见性：构造函数可以使用 public、private 或 protected 修饰符来控制其可见性。private 修饰符使得类的实例不能在类外部被创建。

示例代码：私有构造函数

class Singleton {
    private static instance: Singleton;

    private constructor() {}

    public static getInstance(): Singleton {
        if (!Singleton.instance) {
            Singleton.instance = new Singleton();
        }
        return Singleton.instance;
    }
}

const singleton1 = Singleton.getInstance();
const singleton2 = Singleton.getInstance();
console.log(singleton1 === singleton2); // 输出: true

初始化顺序：在构造函数中，属性的初始化顺序是按照它们在类中声明的顺序进行的，而不是按照它们在构造函数中的赋值顺序。

示例代码：初始化顺序

class Example {
    a: number;
    b: number;

    constructor(a: number) {
        this.a = a;
        this.b = this.a * 2; // 这里 b 的值依赖于 a
    }
}

const example = new Example(5);
console.log(example.b); // 输出: 10

使用构造函数的重载：TypeScript 支持构造函数的重载，可以根据不同的参数类型或数量来定义多个构造函数。

示例代码：构造函数重载

class Rectangle {
    width: number;
    height: number;

    constructor(width: number);
    constructor(width: number, height: number);
    constructor(width: number, height?: number) {
        this.width = width;
        this.height = height || width; // 如果没有提供 height，则使用 width
    }

    area(): number {
        return this.width * this.height;
    }
}

const square = new Rectangle(5);
const rectangle = new Rectangle(5, 10);
console.log(square.area()); // 输出: 25
console.log(rectangle.area()); // 输出: 50

结论

构造函数是 TypeScript 中类的重要组成部分，它为对象的创建和初始化提供了强大的支持。通过合理使用构造函数，我们可以提高代码的可读性和可维护性。然而，开发者在使用构造函数时也需要注意其复杂性和灵活性的问题。通过理解构造函数的优缺点以及注意事项，我们可以更有效地利用 TypeScript 的面向对象特性，编写出更高质量的代码。