当前位置：极客笔记 > TypeScript > TypeScript 精选笔记 > TypeScript 是否支持所有面向对象的原则

TypeScript 是否支持所有面向对象的原则

TypeScript 是否支持所有面向对象的原则

在编程世界中，面向对象的原则为设计和构建软件系统提供了坚实的基础。面向对象编程（OOP）语言使开发人员能够将现实世界的实体建模为对象，封装数据和行为，并建立对象之间的关系。TypeScript是JavaScript的超集，为语言引入了静态类型，并提供了许多支持面向对象编程的特性。在本教程中，我们将探讨各种情景，以了解TypeScript如何与面向对象编程的核心原则相符。

封装

封装指的是将数据和方法捆绑到一个单元（称为类）中，并隐藏内部实现细节。TypeScript通过类和访问修饰符完全支持封装。

在下面的示例中，Car类具有两个用访问修饰符标记的属性（品牌和年份）。private修饰符限制了在类内部访问品牌属性，而protected修饰符允许子类访问年份属性。startEngine方法被定义为public，使得它能够从类外部访问。我们创建了一个Car类的实例并调用了startEngine方法。

class Car {
   private brand: string;
   protected year: number;    
   constructor(brand: string, year: number) {
      this.brand = brand;
      this.year = year;
   }    
   public startEngine() {
      console.log(`Starting the ${this.brand} engine...`);
   }
}
const myCar = new Car("Tesla", 2023);
myCar.startEngine();

编译后，上述代码将生成以下JavaScript代码 −

var Car = /** @class */ (function () {
   function Car(brand, year) {
      this.brand = brand;
      this.year = year;
   }
   Car.prototype.startEngine = function () {
      console.log("Starting the ".concat(this.brand, " engine..."));
   };
   return Car;
}());
var myCar = new Car("Tesla", 2023);
myCar.startEngine();

输出

Starting the Tesla engine...

在这个例子中，我们在Car类中封装了品牌和年份信息，并暴露了startEngine方法供外部使用。封装原则确保类的内部细节对外界隐藏，促进模块化和可维护的代码。

继承

继承是面向对象编程中的一个基本概念，允许一个类从另一个类继承属性和方法。TypeScript提供了强大的继承支持，使开发人员可以构建类之间的分层关系。

在这个例子中，Dog类使用extends关键字继承Animal类。因此，Dog类继承了Animal的name属性，并且定义了自己的bark方法。然后我们创建了一个Dog类的实例，并调用了move和bark方法。

class Animal {
   protected name: string;    
   constructor(name: string) {
      this.name = name;
   }    
   public move() {
      console.log(`{this.name} is moving...`);
   }
}
class Dog extends Animal {
   public bark() {
      console.log(`{this.name} is barking...`);
   }
}
const myDog = new Dog("Jimmy");
myDog.move();
myDog.bark();

在编译后，以上代码将生成JavaScript代码。

var __extends = (this && this.__extends) || (function () {
   var extendStatics = function (d, b) {
      extendStatics = Object.setPrototypeOf ||
         ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
         function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
      return extendStatics(d, b);
   };
   return function (d, b) {
      if (typeof b !== "function" && b !== null)
         throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
      extendStatics(d, b);
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
   };
})();
var Animal = /** @class */ (function () {
   function Animal(name) {
      this.name = name;
   }
   Animal.prototype.move = function () {
      console.log("".concat(this.name, " is moving..."));
   };
   return Animal;
}());
var Dog = /** @class */ (function (_super) {
   __extends(Dog, _super);
   function Dog() {
      return _super !== null && _super.apply(this, arguments) || this;
   }
   Dog.prototype.bark = function () {
      console.log("".concat(this.name, " is barking..."));
   };
   return Dog;
}(Animal));
var myDog = new Dog("Jimmy");
myDog.move();
myDog.bark();

输出

编译后，上述代码将生成JavaScript代码。JavaScript代码将产生以下结果 –

Jummy is moving…
Jimmy is barking…

TypeScript中的继承功能允许我们创建一个类的层次结构，促进代码重用，并以结构化方式组织相关的类。

多态性

多态性是对象在不同上下文中以多种形式或行为不同的能力。 TypeScript通过方法重写和方法重载支持多态性。

方法重写

方法重写允许子类重写其超类中定义的方法。下面是一个示例来演示方法重写。在这个示例中，我们有一个抽象类Shape，它定义了一个抽象方法calculateArea()。Circle和Rectangle类扩展了Shape，并提供了它们各自calculateArea()方法的实现。我们创建了Circle和Rectangle类的实例并计算了它们各自的面积。

abstract class Shape {
   protected color: string;    
   constructor(color: string) {
      this.color = color;
   }    
   public abstract calculateArea(): number;
}
class Circle extends Shape {
   private radius: number;    
   constructor(color: string, radius: number) {
      super(color);
      this.radius = radius;
   }    
   public calculateArea(): number {
      return Math.PI * this.radius * this.radius;
   }
}
class Rectangle extends Shape {
   private width: number;
   private height: number;    
   constructor(color: string, width: number, height: number) {
      super(color);
      this.width = width;
      this.height = height;
   }    
   public calculateArea(): number {
       return this.width * this.height;
   }
}
const myCircle = new Circle("red", 5);
const myRectangle = new Rectangle("blue", 4, 6);
console.log(myCircle.calculateArea()); 
console.log(myRectangle.calculateArea());

在编译时，上述代码将生成JavaScript代码。

var __extends = (this && this.__extends) || (function () {
   var extendStatics = function (d, b) {
      extendStatics = Object.setPrototypeOf ||
         ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
         function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
      return extendStatics(d, b);
   };
   return function (d, b) {
      if (typeof b !== "function" && b !== null)
         throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
      extendStatics(d, b);
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
   };
})();
var Shape = /** @class */ (function () {
   function Shape(color) {
      this.color = color;
   }
   return Shape;
}());
var Circle = /** @class */ (function (_super) {
   __extends(Circle, _super);
   function Circle(color, radius) {
      var _this = _super.call(this, color) || this;
      _this.radius = radius;
      return _this;
   }
   Circle.prototype.calculateArea = function () {
      return Math.PI * this.radius * this.radius;
   };
   return Circle;
}(Shape));
var Rectangle = /** @class */ (function (_super) {
   __extends(Rectangle, _super);
   function Rectangle(color, width, height) {
      var _this = _super.call(this, color) || this;
      _this.width = width;
      _this.height = height;
      return _this;
   }
   Rectangle.prototype.calculateArea = function () {
      return this.width * this.height;
   };
   return Rectangle;
}(Shape));
var myCircle = new Circle("red", 5);
var myRectangle = new Rectangle("blue", 4, 6);
console.log(myCircle.calculateArea());
console.log(myRectangle.calculateArea());

输出

编译后，上面的代码将生成JavaScript代码。JavaScript代码将产生以下结果-

78.53981633974483
24

在这个例子中，Circle和Rectangle类都从抽象Shape类继承了calculateArea()方法。然而，每个子类都以不同的方式实现该方法，以根据其特定的形状计算面积。这展示了多态性，即可以将不同类的对象视为共同超类的实例，并展示不同的行为。

方法重载

另一方面，方法重载使我们能够定义多个具有相同名称但不同参数的方法。TypeScript根据传递的参数数量或类型来确定要调用的适当方法。

在下面的代码片段中，我们有一个Calculator类，定义了两个add方法，一个用于添加数字，另一个用于连接字符串。然后，我们创建了一个Calculator类的实例，并调用了两个add方法。

class Calculator {
   public add(a: string, b: string): string;
   public add(a: number, b: number): number;

   public add(a: any, b: any): any {
      return a + b;
   }
}

const myCalculator = new Calculator();
const sum = myCalculator.add(3, 5);
const concatenated = myCalculator.add("Hello, ", "TypeScript!");

console.log(sum);
console.log(concatenated);

编译后，上面的代码将生成以下JavaScript代码。

var Calculator = /** @class */ (function () {
   function Calculator() {
   }
   Calculator.prototype.add = function (a, b) {
      return a + b;
   };
   return Calculator;
}());
var myCalculator = new Calculator();
var sum = myCalculator.add(3, 5);
var concatenated = myCalculator.add("Hello, ", "TypeScript!");
console.log(sum);
console.log(concatenated);

输出

它将产生以下结果：-

8
Hello, TypeScript!

抽象

抽象允许我们定义对象的基本特征，同时隐藏实现细节。TypeScript通过抽象类和方法来支持抽象。抽象类作为其他类的蓝图，不能直接实例化。它可以包含派生类必须实现的抽象方法。

在这个例子中，Shape类被声明为抽象类，并且定义了一个叫做draw的抽象方法。Circle类继承Shape并为draw方法提供了实现。我们创建了一个Circle类的实例并调用了draw方法。

abstract class Shape {
   protected color: string;

   constructor(color: string) {
      this.color = color;
   }

   public abstract draw(): void;
}

class Circle extends Shape {
   private radius: number;

   constructor(color: string, radius: number) {
      super(color);
      this.radius = radius;
   }

   public draw() {
      console.log(`Drawing a {this.color} circle with radius{this.radius}`);
   }
}

const myCircle = new Circle("red", 5);
myCircle.draw();

在编译时，上述代码将生成以下JavaScript代码。

var __extends = (this && this.__extends) || (function () {
   var extendStatics = function (d, b) {
      extendStatics = Object.setPrototypeOf ||
         ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
         function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
      return extendStatics(d, b);
   };
   return function (d, b) {
      if (typeof b !== "function" && b !== null)
         throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
      extendStatics(d, b);
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
   };
})();
var Shape = /** @class */ (function () {
   function Shape(color) {
      this.color = color;
   }
   return Shape;
}());
var Circle = /** @class */ (function (_super) {
   __extends(Circle, _super);
   function Circle(color, radius) {
      var _this = _super.call(this, color) || this;
      _this.radius = radius;
      return _this;
   }
   Circle.prototype.draw = function () {
      console.log("Drawing a ".concat(this.color, " circle with radius ").concat(this.radius));
   };
   return Circle;
}(Shape));
var myCircle = new Circle("red", 5);
myCircle.draw();

输出

编译后，上述代码将生成JavaScript代码。JavaScript代码将产生以下结果-

Drawing a red circle with radius 5

抽象类Shape提供了一个共同的接口（draw），所有派生类都必须实现。这使得我们能够定义通用的行为并在不同的子类中强制执行特定的方法，促进抽象化并确保应用程序结构的一致性。

结论

TypeScript提供了对面向对象编程原则的强大支持，包括封装、继承、多态和抽象化。通过利用类、访问修饰符、继承、方法覆盖、方法重载和抽象类，开发人员可以以更结构化和可维护的方式设计和实现面向对象系统。TypeScript的静态类型能力进一步增强了面向对象代码库的可靠性和可扩展性。

Camera课程

Camera API2 教程

API2 教程
Camera 性能教程

Perf 教程
Camera Native Framework 教程

Native FW 教程
Camera QCOM ISP 教程

ISP 教程
Camera QCOM Sensor 教程

Sensor 教程

Python教程

Python 教程

Python 教程
NumPy 教程

NumPy 教程
Django 教程

Django 教程

Java教程

Java 教程

Java 教程

Web教程

JavaScript 教程

JavaScript 教程
jQuery 教程

jQuery 教程
CSS 教程

CSS 教程
PHP 教程

PHP 教程
Laravel 教程

Laravel 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程

数据库教程

SQL 教程

SQL 教程
SQLite 教程

SQLite 教程
MySQL 教程

MySQL 教程
PL/SQL 教程

PL/SQL 教程
MongoDB 教程

MongoDB 教程

图形图像教程

OpenCV 教程

OpenCV 教程

办公软件教程

Excel 教程

Excel 教程

Linux教程

Linux命令全集

Linux命令全集
Linux内核API

Linux内核API
LVGL 教程

LVGL 教程

计算机教程

操作系统 教程

操作系统 教程
计算机网络 教程

计算机网络 教程
C语言 教程

C语言 教程
C++ 教程

C++ 教程
Swift 教程

Swift 教程

大数据教程

Hadoop 教程

Hadoop 教程
Spark 教程

Spark 教程
Scala 教程

Scala 教程

开发工具教程

Git 教程

Git 教程
Jenkins 教程

Jenkins 教程
ChatGPT 教程

ChatGPT 教程
IntelliJ 教程

IntelliJ 教程

TypeScript 精选笔记