您现在的位置是：首页 >技术教程 >TypeScript学习总结（三）网站首页技术教程

接口和类

接口的定义和实现

接口的定义通常使用 interface 关键字，例如：

interface Person {
  name: string;
  age: number;
  sayHello(): void;
}

这个例子中，我们定义了一个 Person 接口，它要求实现类（或对象）有 name 和 age 两个属性，并且必须有一个 sayHello 方法，该方法不需要返回值。

接口的实现可以通过 implements 关键字来实现，例如：

class Student implements Person {
  name: string;
  age: number;

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

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

在这个例子中，我们创建了一个 Student 类，并且通过 implements 关键字来表明它实现了 Person 接口。因此，Student 类必须实现 Person 接口规定的所有属性和方法。

需要注意的是，接口只定义了类型和方法签名，而没有实现逻辑。因此，在实现接口时，开发人员需要按照接口定义的规范来编写具体的实现代码。

类的定义和实现

类是一种创建对象的模板，它描述了对象拥有的属性和方法。在 TypeScript 中，可以使用 class 关键字来定义一个类。例如，以下是一个简单的 TypeScript 类的定义：

class Person {
  name: string;
  age: number;

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

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

这个类被命名为 Person，它有两个属性：name 和 age，两个参数都是字符串类型。还有一个构造函数，用于初始化 name 和 age 属性。最后，还定义了一个 sayHello 方法，该方法打印出一个问候语，并使用 name 和 age 属性来填充问候语中的信息。

可以使用 new 关键字创建 Person 类的实例，并传递一个名字和年龄作为参数。例如：

const person = new Person('John', 30);
person.sayHello(); // 打印出 "Hello, my name is John and I'm 30 years old."

此时，person 实例会调用 sayHello 方法并输出一个问候语。

在 TypeScript 中，类还支持继承和访问修饰符，这些功能可以用于更复杂的对象定义和组织。

继承和多态

1. 继承：继承是面向对象编程中的一个基本概念，它允许新的类从现有的类派生。在TS中，可以使用关键字extends来创建一个子类，它继承了父类的属性和方法，并且可以添加自己独有的属性和方法。例如：

class Animal {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  move(distanceInMeters: number = 0) {
    console.log(`${this.name} moved ${distanceInMeters}m.`);
  }
}

class Dog extends Animal {
  bark() {
    console.log('Woof! Woof!');
  }
}

const myDog = new Dog('Buddy');
myDog.bark(); // 输出 "Woof! Woof!"
myDog.move(10); // 输出 "Buddy moved 10m."

2. 多态：多态是对象-oriented编程的另一个重要概念，指同样的方法名在不同的类中有不同的实现。在TS中，可以通过在父类中声明一个抽象方法来实现多态。抽象方法只需要声明方法名和参数列表，不需要具体实现，而在子类中需要实现这个方法。例如：

abstract class Animal {
  abstract makeSound(): void;
}

class Cat extends Animal {
  makeSound() {
    console.log('Meow! Meow!');
  }
}

class Dog extends Animal {
  makeSound() {
    console.log('Woof! Woof!');
  }
}

function animalSounds(animals: Animal[]) {
  animals.forEach(animal => animal.makeSound());
}

const myCat = new Cat();
const myDog = new Dog();
animalSounds([myCat, myDog]); // 输出 "Meow! Meow!" 和 "Woof! Woof!"

在这个例子中，Animal类是一个抽象类，定义了一个抽象方法makeSound()。Cat和Dog继承自Animal，并且分别实现了自己的makeSound()方法。animalSounds()函数接受一个Animal数组作为参数，遍历其中的每个动物并调用它们的makeSound()方法，从而实现了多态。

访问修饰符

在 TypeScript 中，有三种访问修饰符用于限制类中属性和方法的访问：

1. public：公共访问修饰符，没有限制，可以从任何地方访问类的属性和方法（默认情况下）。

2. private：私有访问修饰符，只能在声明它的类内部访问，外部无法访问。

3. protected：受保护访问修饰符，与私有访问修饰符相似，但可以在派生类中访问。

这些访问修饰符可以应用于类的成员变量和方法。默认情况下，TypeScript 类的成员变量和方法是 public 访问级别。使用访问修饰符可以帮助控制类的封装性和数据安全性。

抽象类和抽象方法

抽象类是一个不能被实例化的基类，其中至少包含一个抽象方法。抽象方法是没有具体实现的方法，它们只是定义了方法名称、参数和返回类型，具体的实现由子类来完成。

声明抽象类需要使用 abstract 关键字，在类中声明抽象方法也需要使用 abstract 关键字，如下所示：

abstract class Animal {
  abstract makeSound(): void; // 抽象方法
}

class Cat extends Animal {
  makeSound() {
    console.log("Meow"); // 子类必须实现抽象方法
  }
}

在上述代码中，Animal类是一个抽象类，它声明了一个抽象方法 makeSound()。Cat类继承自Animal类，并实现了 makeSound() 方法。注意到Cat类必须实现所有继承自Animal类的抽象方法，否则它自己也必须声明为抽象类。

抽象类和抽象方法的优点在于它们可以使得代码更加模块化和高度可重用，同时也能够使得代码更加规范化和易于维护。