TypeScript 中面向对象编程的基本概念和实现方法-JavaScript中文网-JavaScript教程资源分享门户

在编写大型应用程序时，面向对象编程是一个非常常用的编程范式。在 TypeScript 中，我们可以使用接口、类、继承、抽象类和类修饰器等特性来实现面向对象编程。

接口

接口是一种特殊的类型声明，用来定义一个对象的结构。在 TypeScript 中，接口可以用来描述对象的属性，以及对象的行为。以下是一个接口的例子：

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

在这个例子中，Person 接口定义了一个人的结构，包含名字、年龄和说话的行为。在 TypeScript 中，我们可以使用接口来限制函数或对象的参数，以保证它们的类型正确：

// www.javascriptcn.com code example
function printPerson(person: Person) {
  console.log(`${person.name}, ${person.age}`);
  person.sayHello();
}

const john: Person = {
  name: 'John',
  age: 30,
  sayHello() {
    console.log(`Hello, I'm ${this.name}`);
  },
};

printPerson(john);

在这个例子中，我们定义了一个名为 printPerson 的函数，它接受一个 Person 类型的参数，并输出这个人的名字、年龄和称呼。我们还定义了一个名为 john 的对象，它满足 Person 接口的定义，包含名字、年龄和说话的行为。最后，我们将 john 作为参数传递给 printPerson，并正确输出了它的信息。

类

类是一种面向对象编程的基本概念，它是一种包含属性和方法的结构体。在 TypeScript 中，我们可以使用 class 关键字来定义一个类：

// www.javascriptcn.com code example
class Animal {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  sayHello() {
    console.log(`Hello, I'm ${this.name}`);
  }
}

在这个例子中，我们定义了一个名为 Animal 的类，它包含一个名字属性和一个说话的行为，以及一个构造函数，用于创建新的动物实例。我们可以使用 new 关键字来创建一个动物实例，并调用它的方法：

const cat = new Animal('Cat');
cat.sayHello(); // 输出：Hello, I'm Cat

继承

继承是一种面向对象编程的重要特性，它允许我们定义一个新的类，它从一个父类中继承属性和方法。在 TypeScript 中，我们可以使用 extends 关键字来实现继承：

class Dog extends Animal {
  constructor(name: string) {
    super(name);
  }
  bark() {
    console.log('Woof!');
  }
}

在这个例子中，我们定义了一个名为 Dog 的子类，它从 Animal 类中继承属性和方法。我们还定义了一个名为 bark 的方法，用于发出狗叫声。我们可以创建一个狗的实例，并调用它的方法：

const dog = new Dog('Dog');
dog.sayHello(); // 输出：Hello, I'm Dog
dog.bark(); // 输出：Woof!

抽象类

抽象类是一种不能被实例化的类，它可以包含抽象方法和非抽象方法。抽象类用于定义不同类的通用行为和属性。在 TypeScript 中，我们可以使用 abstract 关键字来定义一个抽象类：

abstract class Shape {
  abstract getArea(): number;
  getName(): string {
    return 'Shape';
  }
}

在这个例子中，我们定义了一个名为 Shape 的抽象类，它包含一个抽象方法 getArea 和一个非抽象方法 getName。抽象方法必须在子类中实现，而非抽象方法可以被子类继承和重写。

// www.javascriptcn.com code example
class Circle extends Shape {
  readonly radius: number;
  constructor(radius: number) {
    super();
    this.radius = radius;
  }
  getArea() {
    return Math.PI * this.radius * this.radius;
  }
  getName() {
    return 'Circle';
  }
}

class Rectangle extends Shape {
  readonly width: number;
  readonly height: number;
  constructor(width: number, height: number) {
    super();
    this.width = width;
    this.height = height;
  }
  getArea() {
    return this.width * this.height;
  }
  getName() {
    return 'Rectangle';
  }
}

const circle = new Circle(10);
const rectangle = new Rectangle(5, 6);
console.log(circle.getName(), circle.getArea()); // 输出：Circle 314.1592653589793
console.log(rectangle.getName(), rectangle.getArea()); // 输出：Rectangle 30

在这个例子中，我们定义了两个子类 Circle 和 Rectangle，它们继承了 Shape 类，并实现了抽象方法 getArea。我们还重写了 getName 方法，以返回子类的名字。最后，我们创建了一个圆和一个矩形实例，并输出它们的名字和面积。

类修饰器

类修饰器是一种特殊的函数，它可以用来修改或扩展类的行为。在 TypeScript 中，类修饰器是一个用 @ 符号紧跟着类声明的函数，它接受一个类作为参数，并返回一个新的类或修改过的类。以下是一个类修饰器的例子：

// www.javascriptcn.com code example
function sealed(constructor: Function) {
  Object.seal(constructor);
  Object.seal(constructor.prototype);
}

@sealed
class Person {
  readonly name: string;
  readonly age: number;
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
  sayHello() {
    console.log(`Hello, I'm ${this.name}`);
  }
}

在这个例子中，我们定义了一个名为 sealed 的类修饰器，它使用 Object.seal 方法来禁止修改类和类的原型。我们还定义了一个名为 Person 的类，并使用 @sealed 修饰器将其标记为不可修改的。我们可以创建一个 Person 类的实例，并调用它的方法：

const person = new Person('John', 30);
person.sayHello(); // 输出：Hello, I'm John

在以上的文章中，我们介绍了 TypeScript 中面向对象编程的基本概念和实现方法，包括接口、类、继承、抽象类和类修饰器等特性。希望以上内容对你在开发过程中有所帮助。

来源：JavaScript中文网，转载请注明来源 https://www.javascriptcn.com/post/67d08875e46428fe9ed99b6e

TypeScript 中面向对象编程的基本概念和实现方法

接口

类

继承

抽象类

类修饰器

接着读