TypeScript 创建抽象类

抽象简介

我们希望读者在实现抽象类之前，先熟悉抽象类和抽象类的要求。抽象的意思是隐藏。它被用来向用户和一些开发者隐藏低级别的代码实现。此外，它被用来只显示方法的必要信息，而不是显示整个复杂的方法实现。

创建抽象类

我们可以使用abstract关键字来定义抽象类或方法。抽象类可以包含普通和抽象类型的方法。在抽象类中，我们需要实现功能或普通方法，只需要声明抽象方法。

我们可以使用任何其他类来继承抽象类，但是我们需要将抽象类的所有抽象方法实现到继承类中。如果我们不想在继承类中实现抽象方法，我们需要使用abstract关键字使继承类变成抽象类。

另外，我们不能创建抽象类的对象，但我们可以创建继承类的对象并使用抽象类的方法。抽象类的限制是，我们不能使用多个抽象类实现多个继承。

语法

用户可以按照下面的语法来创建抽象类并将其继承给其他类。

abstract class sample {
   // define variables inside the abstract class,
   // declare the abstract methods or non-abstract method inside the abstract class
   abstract demo(string): void;
}
// extend sample class and implement all abstract methods of sample to demo class
class test extends sample {
   demo(name: string): void {
      // code for the demo method
   }
}

步骤

• 第1步–定义名为sample的抽象类，它包含名为propert1和propert2的属性。

• 第2步 – 同时，将构造函数添加到样本类中，以初始化property1和property2的值。

• 第3步 – 在抽象类中声明抽象方法名称demo()。同时，定义抽象类的save()方法，这个非抽象方法可以打印property1和property2的值。

• 第4步–定义测试类，一个继承了样本类的非抽象类。同时，在测试类中添加字符串类型的property3。

• 第5步 – 为测试类添加构造函数，它需要3个参数，使用前两个参数，我们调用超类的构造函数，也就是样本类。

• 第6步–在测试类中实现样本类的demo()方法，该方法打印出属性3的值。

示例 1

在下面的例子中，我们已经定义了包含抽象方法的抽象类。在继承的测试类中，我们实现了样本类的抽象方法。接下来，我们用3个参数创建了测试类的对象，并用它来调用demo()和save()方法。

abstract class sample {
   // define variables inside the abstract class,
   property1: string;
   constructor(property1: string, property2: number) {
      this.property1 = property1;
   }
   // declare the abstract methods
   abstract demo(): void;

   // defining the non-abstract methods
   save(): void {
      console.log("The save method of the abstract class is executed.");
   }
}
// extend sample class and implement all abstract methods of sample to demo class
class test extends sample {
   property2: number;
   constructor(property1: string, property2: number) {
      super(property1);
      this.property2 = property2;
   }
   demo(): void {
      // code for the demo method
      console.log("The value of the property 3 is " + this.propert2);
   }
}
let test_obj = new test("TutorialsPont", 9999);
test_obj.demo();
test_obj.save();

在上面的例子中，我们把save()方法的实现从继承的类测试中隐藏起来。我们允许开发者按照自己的意愿实现demo()方法，但隐藏了其他类的信息，如property1、property2和save()方法的实现。

现在，用户正确理解了使用抽象类的动机，以及我们如何使用它来隐藏信息，并可以只显示所需的信息。

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 (b.hasOwnProperty(p)) d[p] = b[p]; };
      return extendStatics(d, b);
   };
   return function (d, b) {
      extendStatics(d, b);
      function __() { this.constructor = d; 
   }
   d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var sample = /** @class */ (function () {
   function sample(property1, property2) {
      this.property1 = property1;
   }
   // defining the non-abstract methods
   sample.prototype.save = function () {
      console.log("The save method of the abstract class is executed.");
   };
   return sample;
}());
// extend sample class and implement all abstract methods of sample to demo class
var test = /** @class */ (function (_super) {
   __extends(test, _super);
   function test(property1, property2) {
      var _this = _super.call(this, property1) || this;
      _this.property2 = property2;
      return _this;
   }
   test.prototype.demo = function () {
      // code for the demo method
      console.log("The value of the property 3 is " + this.propert2);
   };
   return test;
}(sample));
var test_obj = new test("TutorialsPont", 9999);
test_obj.demo();
test_obj.save();

输出

它将产生以下输出 —

The value of the property 3 is undefined
The save method of the abstract class is executed.

示例 2

在下面的例子中，class1是抽象类，它包含了名为method1的抽象方法的声明。 class2只包含method2()的定义。它扩展了class1，但并没有实现名为method1()的抽象方法。

之后，我们定义了class3并通过class2继承了它。同时，我们在class3中定义了类的方法1。最后，我们创建了class3的对象并调用了method1()和method2()。

// define the abstract class1 containing the abstract method1
abstract class class1 {
   abstract method1(): void;
}
// Need to create class2 to abstract as we inherited class1 but doesn't defined abstract method1()
abstract class class2 extends class1 {
   method2(): void {
      console.log("Inside the method 2 of class2.");
   }
}
// defining the class3 inherited by the class2
class class3 extends class2 {
   // Implementation of the method1 of the abstract class1
   method1(): void {
      console.log(
         "Implemented the abstract method name method1 of class1 inside the class3"
      );
   }
}
// Crating the object of the class3
var object = new class3();

// Invoking the method1 of class1 which is declared in the abstract class1
object.method1();

// Invoking the method2 of class2
object.method2();

上面的例子告诉我们，如果我们用任何一个类来继承抽象类，并且不想在继承的类中实现抽象方法，我们需要使继承的类成为抽象的。

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 (b.hasOwnProperty(p)) d[p] = b[p]; };
         return extendStatics(d, b);
      };
      return function (d, b) {
         extendStatics(d, b);
         function __() { this.constructor = d; }
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
})();
// define the abstract class1 containing the abstract method1
var class1 = /** @class */ (function () {
   function class1() {

   }
   return class1;
}());
// Need to create class2 to abstract as we inherited class1 but doesn't defined abstract method1()
var class2 = /** @class */ (function (_super) {
   __extends(class2, _super);
   function class2() {
      return _super !== null && _super.apply(this, arguments) || this;
   }
   class2.prototype.method2 = function () {
      console.log("Inside the method 2 of class2.");
   };
   return class2;
}(class1));
// defining the class3 inherited by the class2
var class3 = /** @class */ (function (_super) {
   __extends(class3, _super);
   function class3() {
   return _super !== null && _super.apply(this, arguments) || this;
   }
   // Implementation of the method1 of the abstract class1
   class3.prototype.method1 = function () {
      console.log("Implemented the abstract method name method1 of class1 inside the class3");
   };
   return class3;
}(class2));
// Crating the object of the class3
var object = new class3();

// Invoking the method1 of class1 which is declared in the abstract class1
object.method1();

// Invoking the method2 of class2
object.method2();

输出

Implemented the abstract method name method1 of class1 inside the class3
Inside the method 2 of class2.

用户在本教程中学习了如何实现抽象类。现在，用户可以理解我们是如何利用抽象类和抽象方法隐藏类的其他信息的。

另外，用户可以使用接口来进行抽象化。在TypeScript中，接口的所有方法都是抽象的，它不允许使用非抽象的方法。另外，我们还可以使用接口进行多重继承。