TypeScript 私有、公共和受保护访问修饰符

访问修饰符是必不可少的，因为它们允许我们强制封装并定义类成员的边界。通过访问修饰符，我们可以限制对某些成员的访问，确保它们仅在类内部可访问。我们还可以将成员设为公共，允许从我们代码库中的任何地方访问它们。此外，受保护成员可以在类及其派生类中访问。

在本教程中，我们将探讨TypeScript中的私有、公共和受保护访问修饰符。

语法

用户可以按照下面的语法将访问修饰符应用到TypeScript类的成员上：

class ClassName {
   private propertyName: type;
   public methodName(): returnType {
      // Method body
   }
   protected anotherPropertyName: type;
}

在上面的语法中 −

private − 这个访问修饰符限制了成员的访问范围，只能在声明它的类中访问。关键字 private 用于表示它。
public − 这个访问修饰符允许从任何地方无限制地访问成员。如果没有指定访问修饰符，则它是默认的访问修饰符。关键字 public 用于表示它。
protected − 这个访问修饰符允许在类及其派生类中访问成员。它由关键字 protected 表示。

示例1：公共访问修饰符

在这个例子中，我们创建了一个名为 Person 的类，它有一个公共的属性 name，可以在代码中的任何地方访问和修改。我们还有一个公共的方法 greet()，它使用 name 属性打印一个问候信息。

然后我们创建了一个名为 Person 的 Person 类的实例。我们可以直接访问 person 对象的 name 属性并为它赋值。最后，我们在 person 对象上调用 greet() 方法，输出包含提供的名字的问候消息。用户可以观察输出结果来查看包含提供的名字的问候消息。

class Person {
   public name: string = "";

   public greet(): void {
      console.log(`Hello, my name is ${this.name}!`);
   }
} 
// Creating an instance of the Person class
const person = new Person(); 

// Assigning a value to the public property
person.name = "John"; 

// Calling the public method to display the greeting
person.greet();

在编译时，它会生成以下的JavaScript代码−

var Person = /** @class */ (function () {
   function Person() {
      this.name = "";
   }
   Person.prototype.greet = function () {
      console.log("Hello, my name is ".concat(this.name, "!"));
   };
   return Person;
}());
// Creating an instance of the Person class
var person = new Person();

// Assigning a value to the public property
person.name = "John";

// Calling the public method to display the greeting
person.greet();

输出

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

Hello, my name is John!

示例2：私有访问修饰符

在这个示例中，我们创建了一个BankAccount类，其中包含一个私有属性balance，只能在类内访问和修改。此外，我们还有一个私有方法calculateInterest()，根据余额计算利息。

在定义了类之后，我们创建了一个名为account的BankAccount类实例，初始余额为$1000。

然而，试图从类外直接访问私有属性balance或调用私有方法calculateInterest()将导致错误，因为这些成员在类范围之外是不可访问的。

用户可以观察到尝试访问私有成员将导致TypeError的输出。

class BankAccount {
   private balance: number; 
   constructor(initialBalance: number) {
      this.balance = initialBalance;
   } 
   private calculateInterest(): number {
      const interestRate = 0.05;
      return this.balance * interestRate;
   } 
}  
// Creating an instance of the BankAccount class
const account = new BankAccount(1000); 

// Attempting to access private members
console.log(account.balance); 
console.log(account.calculateInterest());

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

var BankAccount = /** @class */ (function () {
   function BankAccount(initialBalance) {
      this.balance = initialBalance;
   }
   BankAccount.prototype.calculateInterest = function () {
      var interestRate = 0.05;
      return this.balance * interestRate;
   };
   return BankAccount;
}());
// Creating an instance of the BankAccount class
var account = new BankAccount(1000);

// Attempting to access private members
console.log(account.balance);
console.log(account.calculateInterest());

并且它会产生以下错误−

Property 'balance' is private and only accessible within class 'BankAccount'.
Property 'calculateInterest' is private and only accessible within class 'BankAccount'.

输出

以上的 JavaScript 代码将会产生以下的输出 −

1000
50

示例3：受保护的访问修饰符

在这个例子中，我们创建了一个基类Animal，具有一个受保护的属性name，可以在类及其派生类中访问和修改。我们还有一个受保护的方法makeSound()，仅仅记录一条消息。

然后，我们创建了一个派生类Dog，它扩展了Animal类。Dog类添加了一个公共方法bark()，利用从基类继承的name属性输出一条狗吠的消息。

最后，我们创建了一个名为”Buddy”的Dog类实例dog，并调用bark()方法。

输出将显示狗的名字，后跟狗吠的消息。

class Animal {
   protected name: string; 
   constructor(name: string) {
      this.name = name;
   } 
   protected makeSound(): void {
      console.log("The animal makes a sound");
   }
} 
class Dog extends Animal {
   public bark(): void {
      console.log(`${this.name} barks!`);
   }
} 
// Creating an instance of the Dog class
const dog = new Dog("Buddy"); 
dog.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.makeSound = function () {
      console.log("The animal makes a sound");
   };
   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, " barks!"));
   };
   return Dog;
}(Animal));
// Creating an instance of the Dog class
var dog = new Dog("Buddy");
dog.bark();