ts中類的繼承

定義類

class Person {
    name: string;   //屬性
    constructor(_name: string) {
        this.name = _name;
    }   //構造函數
    sayHello(): string {
        return "Hi,everyone"
    }   //方法
}

let firstOne = new Person("Fred")   //實例化類

繼承：繼承使用關鍵字extends，調用父類使用super，子類繼承父類的屬性和方法，並且子類可以改寫父類的屬性和方法

class Animal {
    name: string;
    constructor(_name: string) {
        this.name = _name;
    }
    skinColour(color: string = "black"): void {
        console.log(`${this.name} skin colour is ${color}`)
    }
}

class Horse extends Animal {
    constructor(name: string) { super(name) }
    skinColour(color: string = "brown"): void {
        console.log(`I'am ${this.name}`);
        super.skinColour("brown");
    }
}

let horse = new Horse("horse");
horse.skinColour()
// I'am horse
// horse skin colour is brown

public、private、protected、readonly

• public（不聲明默認都為public，也可以顯示的設置為public）

  class Person {
      public name: string;   //屬性
      public constructor(_name: string) {
          this.name = _name;
      }   //構造函數
      public sayHello(): string {
          return "Hi,everyone"
      }   //方法
  }
  
  let firstOne = new Person("Fred")   //實例化類

• private（private的成員不能被外部訪問；比較帶有private或protected成員的類型時，兩個類型兼容的條件是private或protected的成員必須相同切來至同一個聲明（同一個類））

  class Person {
      private name: string;   
      public constructor(_name: string) {
          this.name = _name;
      }   
  }
  
  class Employee {
      private name: string;   
      public constructor(_name: string) {
          this.name = _name;
      }   
  }
  
  let firstOne = new Person("Fred")
  console.log(firstOne.name)  //error: Property 'name' is private;
  let lastOne = new Employee("Fred")
  firstOne = lastOne  // error: Type 'Employee' is not assignable to type 'Person'.Types have separate declarations of a private property 'name'.

• protected（protected和private相似，但protected成員可以在派生類中訪問（能被繼承，但不能在實例中訪問，若構造函數是protected，則不能被實例化，只能被繼承））

  class Person {
      protected name: string;   
      protected constructor(_name: string) {
          this.name = _name;
      }   
  }
  
  class Employee extends Person {
      private department: string;   
      public constructor(name: string,department:string) {
          super(name);
          this.department = department;
      }   
  }
  
  let Bob = new Person;   //error: Constructor of class 'Person' is protected
  let fred = new Employee("fred","test");
  console.log(fred.name)  //error: Property 'name' is protected

• readonly（設置屬性為只讀，必須在聲明時或構造函數里初始化）

  class Person {
      readonly name: string;   
      constructor(_name: string) {
          this.name = _name;
      }   
  }
  
  let fred = new Person("fred");
  fred.name = "Bob"   //error: Cannot assign to 'name' because it is a constant or a read-only property.

  參數屬性（參數屬性通過給構造函數參數添加一個訪問限定符來聲明（public,private,protected）,把聲明和賦值合並至一處）

  class Person {
      constructor(private name: string) { }
      sayHello(): void {
          console.log(`my name is ${this.name}`)
      }
  }
  
  let fred = new Person("fred");
  fred.sayHello() //my name is fred

  存取器（get、set   只帶有 get不帶有set的存取器自動被推斷為readonly）

  let passcode = "secret passcode";
  
  class Employee {
      private _fullName: string;
  
      get fullName(): string {
          return this._fullName;
      }
  
      set fullName(newName: string) {
          if (passcode && passcode == "secret passcode") {
              this._fullName = newName;
          }
          else {
              console.log("Error: Unauthorized update of employee!");
          }
      }
  }
  
  let employee = new Employee();
  employee.fullName = "Bob Smith";
  if (employee.fullName) {
      console.log(employee.fullName);
  }

  靜態屬性（static，不能被實例訪問，在類里面訪問時，需要加上類名）

  class Person {
      static height:number = 180;
      constructor(private name: string) { }
      sayHello(): void {
          console.log(`my name is ${this.name}, I height is ${Person.height}`)
      }
  }
  
  let fred = new Person("fred");
  fred.sayHello() //my name is fred, I height is 180

  抽象類（abstract，抽象類做為其它派生類的基類使用。 它們一般不會直接被實例化。抽象類中的抽象方法不包含具體實現並且必須在派生類中實現）

  abstract class Person {
      constructor(public name: string) { }
      abstract sayHello():void;
  }
  
  class Empoloy extends Person{
      constructor(){
          super("Fred")
      }
      sayHello(){
          console.log(`my name is ${this.name}`)
      }
  }
  
  let firstOne = new Empoloy();
  firstOne.sayHello();    //my name is Fred