在本章中，我们将深入探讨 TypeScript 中的泛型类。泛型使得我们能够创建可重用、灵活且类型安全的代码。在上一篇中，我们聊到了泛型与接口的结合，提到了如何使用泛型接口来描述函数和类的参数类型。在本章，我们将进一步了解如何将泛型应用到类中，以提高我们代码的可重用性。

什么是泛型类？

泛型类是一个类的定义，其中可以使用类型参数。通过类型参数，我们能够在类的实例化时指定其类型，进而使类的实例能够适应多种类型。

泛型类的基本语法

一个泛型类的定义通常如下所示：

class GenericClass<T> {
  private value: T;

  constructor(value: T) {
    this.value = value;
  }

  public getValue(): T {
    return this.value;
  }
}
复制

在这个例子中，GenericClass 是一个泛型类，它接受一个类型参数 T。这个参数 T 在类的内部可以作为类型使用。

实例化泛型类

当我们实例化这个泛型类时，可以为 T 指定任何类型：

const numberInstance = new GenericClass<number>(42);
console.log(numberInstance.getValue()); // 输出: 42

const stringInstance = new GenericClass<string>('Hello, TypeScript');
console.log(stringInstance.getValue()); // 输出: Hello, TypeScript
复制

在上面的示例中，我们创建了两个 GenericClass 的实例：一个用于 number 类型，另一个用于 string 类型。通过这种方式，泛型类能够适应不同的类型而不丢失类型信息。

使用泛型类的案例

现在，让我们来看一个更复杂的案例，假设我们想要创建一个泛型栈（Stack）类。这是一个常见的数据结构，我们可以将其实现如下：

class Stack<T> {
  private items: T[] = [];

  public push(item: T): void {
    this.items.push(item);
  }

  public pop(): T | undefined {
    return this.items.pop();
  }

  public peek(): T | undefined {
    return this.items[this.items.length - 1];
  }

  public isEmpty(): boolean {
    return this.items.length === 0;
  }

  public size(): number {
    return this.items.length;
  }
}

// 使用泛型栈类
const numberStack = new Stack<number>();
numberStack.push(1);
numberStack.push(2);
console.log(numberStack.pop()); // 输出: 2

const stringStack = new Stack<string>();
stringStack.push('TypeScript');
stringStack.push('JavaScript');
console.log(stringStack.peek()); // 输出: JavaScript
复制

在这个 Stack 类的实现中，我们定义了一个数组 items 来存储栈的元素。通过使用泛型 T，我们能够创建一个类型安全的栈，支持任意类型的元素。

结合其他泛型类型

为了加强代码的可重用性，我们也可以将泛型类与其他泛型类型组合使用。例如，我们可以定义一个泛型类，接受一个泛型接口作为参数。

interface Serializable<T> {
  serialize(): T;
}

class JsonSerializer<T> implements Serializable<T> {
  constructor(private value: T) {}

  public serialize(): string {
    return JSON.stringify(this.value);
  }
}

// 使用 JsonSerializer
const serializer = new JsonSerializer<number>(42);
console.log(serializer.serialize()); // 输出: 42
复制

在这个示例中，我们定义了一个 Serializable 接口，表示可以序列化的对象。JsonSerializer 泛型类实现了这个接口，并且可以序列化任意类型的数据。

小结

本章介绍了泛型类的基本用法和灵活性，以及如何将其应用于泛型接口和其他类型中。通过使用泛型类，我们能够编写更具灵活性的代码，减少重复，并提供类型安全性。这为我们后续的 TypeScript 编程打下了坚实的基础。

在下一章中，我们将探讨 TypeScript 与 JavaScript 的关系，了解这两者之间的异同，如何利用 TypeScript 的特性来更好地编写 JavaScript 代码。