TypeScript 中的类和修饰符：揭秘更高级的类型系统

2023-09-18 01:18:22






## **TypeScript 中的类和修饰符** 

在本章中，我们将探讨 TypeScript 中的类和修饰符，了解它们如何帮助我们构建更强大、更灵活的类型系统。

### **类** 

类是 TypeScript 中用来表示对象的蓝图。它定义了对象的属性和方法，并提供了创建新对象的机制。

```typescript
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.`);
  }
}

在这个例子中，Person 类定义了两个属性：name 和 age，以及一个方法：greet()。

修饰符

修饰符用于控制类的成员（属性和方法）的访问权限。有以下几种修饰符：

public：表示该成员可以在类的任何地方访问。
protected：表示该成员只能在类及其子类中访问。
private：表示该成员只能在类内部访问。

class Person {
  public name: string;
  protected age: number;
  private _secret: string;

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

  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }

  getSecret() {
    return this._secret;
  }
}

在这个例子中，name 是一个公共属性，可以在类的任何地方访问。age 是一个受保护的属性，只能在类及其子类中访问。_secret 是一个私有属性，只能在类内部访问。

访问控制

访问控制是 TypeScript 中的一个重要概念，它用于控制对类成员的访问。有以下几种访问控制级别：

public：表示该成员可以在类的任何地方访问。
protected：表示该成员只能在类及其子类中访问。
private：表示该成员只能在类内部访问。

class Person {
  public name: string;
  protected age: number;
  private _secret: string;

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

  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }

  getSecret() {
    return this._secret;
  }
}

class Employee extends Person {
  salary: number;

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

  getSalary() {
    return this.salary;
  }
}

const person = new Person('John Doe', 30, 'I am a secret');
console.log(person.name); // "John Doe"
console.log(person.age); // Error: Property 'age' is protected and only accessible within class 'Person' and its subclasses.
console.log(person.getSecret()); // Error: Property '_secret' is private and only accessible within class 'Person'.

const employee = new Employee('Jane Doe', 25, 'I am also a secret', 100000);
console.log(employee.name); // "Jane Doe"
console.log(employee.age); // Error: Property 'age' is protected and only accessible within class 'Person' and its subclasses.
console.log(employee.salary); // 100000
console.log(employee.getSecret()); // Error: Property '_secret' is private and only accessible within class 'Person'.

继承

继承是 TypeScript 中的一个重要概念，它允许一个类从另一个类继承属性和方法。

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.`);
  }
}

class Employee extends Person {
  salary: number;

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

  getSalary() {
    return this.salary;
  }
}

const person = new Person('John Doe', 30);
console.log(person.name); // "John Doe"
console.log(person.age); // 30
console.log(person.salary); // Error: Property 'salary' does not exist on type 'Person'.

const employee = new Employee('Jane Doe', 25, 100000);
console.log(employee.name); // "Jane Doe"
console.log(employee.age); // 25
console.log(employee.salary); // 100000
console.log(employee.getSalary()); // 100000

在这个例子中，Employee 类从 Person 类继承了 name 和 age 属性，以及 greet() 方法。Employee 类还定义了一个新的属性 salary 和一个新的方法 getSalary()。

多态性

多态性是 TypeScript 中的一个重要概念，它允许对父类对象进行操作，而无需知道其具体类型。

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.`);
  }
}

class Employee extends Person {
  salary: number;

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

  getSalary() {
    return this.salary;
  }
}

const person = new Person('John Doe', 30);
const employee = new Employee('Jane Doe', 25, 100000);

function greetAll(people: Person[]) {
  for (const person of people) {
    person.greet();
  }
}

greetAll([person, employee]);

在这个例子中，greetAll() 函数接受一个 Person[] 数组作为参数，并调用每个 Person 对象的 greet() 方法。即使 employee 对象是 Employee 类的实例，它仍然可以被 greetAll() 函数调用，因为 Employee 类继承了 Person 类。