ts中的類

TypeScript 除了實現了全部 ES6 中的類的功能之外，還添加了一些新的用法（部分ES7）。

1、ES6中類的主要用法：

一、使用 class 定義類，使用 constructor 定義構造函數。經過 new 生成新實例的時候，會自動調用構造函數。

二、使用 extends 關鍵字實現繼承，子類中使用 super 關鍵字來調用父類的構造函數和方法。

三、使用 static 修飾符修飾的方法稱爲靜態方法，它們不須要實例化，而是直接經過類來調用。

類至關於實例的原型，全部在類中定義的方法，都會被實例繼承。若是在一個方法前，加上static關鍵字，就表示該方法不會被實例繼承，而是直接經過類來調用

class Person {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  run = (): string => {
    // 實例方法
    return this.name;
  };
  static print = () => { console.log("Persion的靜態方法"); };
}
var p = new Person("testName");
p.run();
Person.print();

2、實現的ES7中類的用法：

一、ES6 中實例的屬性只能經過構造函數中的 this.xxx 來定義，ES7 提案中能夠直接在類裏面定義

二、ES6 中只有靜態方法，ES7 提案中，可使用 static 定義靜態屬性

class Person {
  name: string;
  static title: string = "類的靜態屬性";
  constructor(name: string) {
    this.name = name;
  }
  run = (): string => {
    // 實例方法
    return this.name;
  };
  static print = () => {
    console.log("Persion的靜態方法");
  };
}
var p = new Person("testName");
p.run();
Person.print();
console.log(Person.title);

3、TypeScript自身實現的類的用法：

一、TypeScript 新增了三種訪問修飾符來修飾屬性或方法，分別是 public、private 和 protected。

• public （共有）修飾的屬性或方法是公有的，能夠在任何地方被訪問到，默認全部的屬性和方法都是 public 的。在類的裏邊、子類以及類的外邊均可以訪問

  class Person {
    name: string; //定義屬性  前面省略了public關鍵詞
    constructor(n: string) {
      // 構造函數---實例化類的時候出發的方法
      this.name = n;
    }
    run = (): string => {
      return this.name;
    };
  }
  var p = new Person("testName");
  console.log(26, p.name); // 可訪問
  console.log(p.run()); // 可調用

• protected（保護） 修飾的屬性或方法是受保護的，它和 private 相似，區別是它在子類中也是容許被訪問的。在類裏邊和子類中能夠訪問，在類外部沒法訪問

  class Person {
    protected name: string; //定義屬性  前面省略了public關鍵詞
    constructor(n: string) {
      // 構造函數---實例化類的時候出發的方法
      this.name = n;
    }
    run = (): string => {
      return this.name; // 可訪問
    };
  }
  var p = new Person("testName");
  console.log(p.run()); // 可調用
  
  // 經過extends和super實現繼承
  class Web extends Person {
    constructor(name: string) {
      super(name);
      console.log(this.name); // 可訪問
    }
  }
  const w = new Web("test");
  // console.log(w.name) //不可訪問
  // console.log(p.name) // 不可訪問

• private （私有）修飾的屬性或方法是私有的，不能在聲明它的類的外部訪問。在類裏邊能夠訪問，子類和類外部沒法訪問

• class Person {
    private name: string; //定義屬性  前面省略了public關鍵詞
    constructor(name: string) {
      // 構造函數---實例化類的時候出發的方法
      this.name = name;
    }
    run = (): string => {
      return this.name; // 可訪問
    };
  }
  var p = new Person("testName");
  
  // 經過extends和super實現繼承
  class Web extends Person {
    constructor(name: string) {
      super(name);
      // console.log(this.name); // 可訪問
    }
  }
  const w = new Web("test");
  // console.log(w.name) //不可訪問
  // console.log(p.name) // 不可訪問

二、readonly只讀屬性關鍵字，只容許出如今屬性聲明或索引簽名中

三、abstract 用於定義抽象類和其中的抽象方法。抽象類是不容許被實例化的；抽象類中的抽象方法必須被子類實現，抽象方法只能放在抽象類中。抽象類和抽象方法用來定義標準,爲子類提供一個基類

abstract class Animal {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  abstract eat(): string;
}

class Dog extends Animal {
  eat = () => { return "狗糧"; };
}

let dog = new Dog("kittle");
console.log(dog.eat());