TypeScript 支持面向对象的术语

面向对象编程（OOP）是一种流行的编程范例，已经被广泛应用于软件开发行业。OOP基于对象的概念，对象是类的实例，封装数据和行为。TypeScript是JavaScript的静态类型的超集，旨在支持大规模应用程序的开发，并且也是一种面向对象的编程语言。在本文中，我们将探讨TypeScript支持的面向对象术语。

下面我们讨论TypeScript支持的各种面向对象术语。

类

在TypeScript中，类是创建对象的蓝图，定义了一组属性和方法，这些属性和方法对类的所有实例都是共享的。使用 class 关键字声明一个类，后面跟着类名和包含类定义的花括号。

语法

在TypeScript中声明类的语法如下：

class ClassName {
   // properties and methods
}

示例1

这里我们声明了一个 Car 类，包含 make、model 和 year 属性以及它们对应的getter和setter方法。

class Car {
   private make: string;
   private model: string;
   private year: number;  
   constructor(make: string, model: string, year: number) {
      this.make = make;
      this.model = model;
      this.year = year;
   }  
   public getMake(): string {
      return this.make;
   }  
   public setMake(make: string): void {
      this.make = make;
   }  
   public getModel(): string {
      return this.model;
   }  
   public setModel(model: string): void {
      this.model = model;
   }  
   public getYear(): number {
      return this.year;
   }  
   public setYear(year: number): void {
      this.year = year;
   }
}

对象

在TypeScript中，一个对象是一个类的实例，它有自己的一组属性和方法。对象是使用 new 关键字创建的，后面跟着类名和类构造函数所需的参数。

语法

创建类实例（对象）的语法如下：

let objectName = new ClassName(arguments);

示例2

这创建了一个名为 myCar 的对象，其制造商为：Toyota，型号为：Camry，年份为：2022

let myCar = new Car('Toyota', 'Camry', 2022);
console.log(myCar.getMake(), myCar.getModel(), myCar.getYear());

构造函数

在TypeScript中，构造函数是一个特殊的方法，在从类创建对象时调用。构造函数用于使用默认值初始化对象。构造函数方法使用 constructor 关键字声明，后跟任何必要的参数。

语法

在TypeScript中编写构造函数的语法−

class ClassName {
   constructor(arguments) {
      // initialization code
   }
}

示例3

这个定义了一个构造函数，没有具体实现，有三个参数，分别是： make, model 和 year 。

class Car {
   constructor(private make: string, private model: string, private year: number) {}
}

继承

在TypeScript中，继承是一种机制，允许一个类从另一个类继承属性和方法。从另一个类继承的类被称为子类或派生类，被继承的类被称为父类或基类。在TypeScript中，继承使用 extends 关键字声明。

语法

从父类创建一个子类的语法如下：

class SubclassName extends SuperclassName {
   // additional properties and methods
}

示例4

这里是子类： ElectricCar ，继承了父类： Car 的属性和方法。此外，它有自己的属性 range 和它的getter和setter方法，在父类中不存在。

class ElectricCar extends Car {
   private range: number;  
   constructor(make: string, model: string, year: number, range: number) {
      super(make, model, year);
      this.range = range;
   }
   public getRange(): number {
      return this.range;
   } 
   public setRange(range: number): void {
      this.range = range;
   }
}
const tesla = new ElectricCar("Tesla", "Model S", 2019, 300);
console.log(
   tesla.getMake(),
   tesla.getModel(),
   tesla.getYear(),
   tesla.getRange()
);

多态性

在TypeScript中，多态性是对象能够以多种形式或类型呈现的能力，允许将不同类的对象视为是公共类的对象。多态性通过继承和接口实现。下面是一个示例演示多态性。

示例5

这里，我们首先创建了一个接口 Shape ，它类似于TypeScript中的类。它有一个声明为 area 的方法。这个接口被实现了两次，一次是为 Circle 类，另一次是为 Rectangle 类。在这两个类中，我们定义了 area 函数的实现体，这两个实现体不同，但函数的名称完全相同。这展示了面向对象编程中的多态性（相同的名称但不同的形式）。

interface Shape {
   area(): number;
}

class Circle implements Shape {
   constructor(private radius: number) {}

   public area(): number {
      return Math.PI * this.radius ** 2;
   }
}

class Rectangle implements Shape {
   constructor(private width: number, private height: number) {}

   public area(): number {
      return this.width * this.height;
   }
}
let shapes: Shape[] = [new Circle(5), new Rectangle(10, 20)];
shapes.forEach(shape => console.log(shape.area()));

在编译时，它将生成以下JavaScript代码：

var Circle = /** @class */ (function () {
   function Circle(radius) {
      this.radius = radius;
   }
   Circle.prototype.area = function () {
      return Math.PI * Math.pow(this.radius, 2);
   };
   return Circle;
}());
var Rectangle = /** @class */ (function () {
   function Rectangle(width, height) {
      this.width = width;
      this.height = height;
   }
   Rectangle.prototype.area = function () {
      return this.width * this.height;
   };
   return Rectangle;
}());
var shapes = [new Circle(5), new Rectangle(10, 20)];
shapes.forEach(function (shape) { return console.log(shape.area()); });

输出

上述代码将产生以下输出−

78.53981633974483
200

接口

在TypeScript中，接口是用来创建对象的蓝图，定义了一组属性和方法，任何实现该接口的对象都必须实现这些属性和方法。接口使用 interface 关键字声明，后面跟着接口的名称和一对花括号，其中包含接口的定义。

语法

interface InterfaceName {
   // properties and methods
}

例子6

interface Person {
   firstName: string;
   lastName: string;
   age: number;
}

class Employee implements Person {
   constructor(public firstName: string, public lastName: string, public age: number, public jobTitle: string) {}
}

let Employee: Person = new Employee('John', 'Doe', 30, 'Software Engineer');
console.log(employee.firstName, employee.lastName, employee.age);

编译后，将生成以下JavaScript代码 –

var Employee = /** @class */ (function () {
   function Employee(firstName, lastName, age, jobTitle) {
      this.firstName = firstName;
      this.lastName = lastName;
      this.age = age;
      this.jobTitle = jobTitle;
   }
   return Employee;
}());
var employee = new Employee('John', 'Doe', 30, 'Software Engineer');
console.log(employee.firstName, employee.lastName, employee.age);