es6 class類 typescript中的類，文章三

定義一個類

class Person {
  name: string; // 屬性 前面省略了public關鍵字，默認是public
  constructor(name: string) {
    // 構造函數，實例化觸發的方法
    this.name = name
  }
  run(): void {
    console.log(this.name + '在運動')
  }

  getNane():string {
    return this.name
  }

  setName(name: string):void {
    this.name = name
  }
}

// 實例化
var p = new Person('李狗蛋')
p.run() // 李狗蛋在工作
p.getNane() // 李狗蛋
p.setName('張翠花') // name = 張翠花

繼承

class Person {
  name: string // 屬性 前面省略了public關鍵字，默認是public
  constructor(name: string) {
    // 構造函數，實例化觸發的方法
    this.name = name
  }
  run(): void {
    console.log(this.name + '在運動')
  }
}

// 繼承 通過關鍵字extends繼承父類，子類必需調用super
class Student extends Person {
  constructor(name: string) {
    super(name) // 初始化父類構造函數
  }
  // 子類不僅可以繼承父類的屬性和方法，還可以拓展自己的屬性和方法
  work(): void {
  	console.log(this.name + '在工作')
  }
  // 如果子類和父類有同樣的方法，會調用子類的方法，如果調用的方法在子類找不到就去父類找，一直往上找，直到找不到爲止
  run(): void {
    console.log(this.name + '在運動')
  }
}

var s = new Student('趙鐵柱')
s.run() // 趙鐵柱在運動
s.work() // 趙鐵柱在工作

類裏面的修飾符

// 類裏面的修飾符，typescript裏面定義屬性的時候給我們提供了三種修飾符
/**
 * public     共有類型：在類裏面、子類、外部都可以訪問
 * protected  保護類型：在類裏面、子類都可以訪問。在類外部不可訪問
 * private    私有類型：在類裏面可以訪問。在子類、外部不可訪問
 * 如果屬性不加修飾符，默認是public
 */

// 演示public
class Person {
  public name: string
  constructor(name: string) {
    this.name = name
  }
  run(): void {
    console.log(this.name)
  }
}

class Student extends Person {
  constructor(name: string) {
    super(name)
  }
  log(): void {
    console.log(this.name)
  }
}

let p = new Person('李狗蛋')
console.log(p.name) // 李狗蛋

let s = new Student('張翠花')
s.log() // 張翠花


// 演示protected
class Person {
  protected name: string
  constructor(name: string) {
    this.name = name
  }
  run(): void {
    console.log(this.name)
  }
}

class Student extends Person {
  constructor(name: string) {
    super(name)
  }
  log(): void {
    console.log(this.name)
  }
}

let p = new Person('李狗蛋')
// protected在外部調用時還是可以執行的，最終轉化爲js，但是在ts會語法提示報錯
console.log(~~p.name~~ ) // 李狗蛋

let s = new Student('張翠花')
s.log() // 張翠花

// 演示private
class Person {
  private name: string
  constructor(name: string) {
    this.name = name
  }
  run(): void {
    console.log(this.name)
  }
}

class Student extends Person {
  constructor(name: string) {
    super(name)
  }
  log(): void {
  // 私有隻能在類裏面使用，外部有子類會語法提示錯誤
    console.log(~~this.name~~ )
  }
}

let p = new Person('李狗蛋')
p.run() // 李狗蛋  類內部使用了name
// 私有隻能在類裏面使用，外部有子類會語法提示錯誤
console.log(~~p.name~~ ) // 李狗蛋

let s = new Student('張翠花')
s.log() // 張翠花

類裏面的靜態屬性和方法

/**
 * 類裏面的靜態屬性、靜態方法
 * 在屬性和方法前面加 static
 */
class Person {
  name: string
  static code: number = 1
  constructor(name: string) {
    this.name = name
  }
  run(): void {
    console.log(this.name)
  }
  static print(): void {
    // 靜態方法裏面不能調用實例屬性
    console.log('靜態方法' + ~~this.name~~ ) // 語法提示錯誤
    // 只能調用靜態屬性
    console.log('靜態方法' + Person.code) // 靜態方法1
    console.log('靜態方法')
  }
}

console.log(Person.code) // 1
Person.print() // 靜態方法

多態：多態屬於繼承

// 類：多態，父定義一個方法不去實現，讓繼承它的子類去實現，每一個子類有不同的表現
class Animal {
  name: string
  constructor(name: string) {
    this.name = name
  }
  // 如果父的方法能滿足子類的需求，那麼子類就不用寫eat方法
  // 相反父類不能滿足，那麼就在子類再寫一個eat方法
  eat(food: string): void {
    console.log(`${this.name}喫${food}`)
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name)
  }
}

// 實例
let dog = new Dog('小黑')
dog.eat('狗糧') // 小黑喫狗糧

class Cat extends Animal {
  constructor(name: string) {
    super(name)
  }
  // 父類方法不能滿足子類，子類自己寫一個方法
  eat(food: string): void {
    console.log(`${this.name}喫${food}，喝水`)
  }
}

let cat = new Cat('小花貓')
cat.eat('貓糧') // 小花貓喫貓糧，喝水

typescript中的抽象類

/**
 * typescript中的抽象類，它是提供其它類繼承的基類，不能直接被實例化
 * abstract關鍵字定義抽象類和抽象方法，抽象類中的抽象方法不包含具體實現並且必須在派生類中實現
 * 抽象類和抽象方法用來定義標準
 */
abstract class Animal {
  name: string
  constructor(name: string) {
    this.name = name
  }
  // 抽象方法
  abstract eat(): void
}

// 無法直接實例化，，錯誤的寫法
// let animal = new Animal('小花貓') 錯誤的寫法
// abstract定義標準， 是子類必須定義抽象類的抽象方法，不然語法提示錯誤
class Dog extends Animal {
  constructor(name: string) {
    super(name)
  }
  // 抽象類的子類，必須實現抽象類的抽象方法
  eat(): void {
    console.log(this.name + '喫東西')
  }
}

let dog = new Dog('小黑')
dog.eat() // 小黑喫東西