繼承

class Animal {
  move(distance: number = 0) {
    console.log(`Animal moved ${distance}m.`)
  }
}

class Dog extends Animal {
  bark() {
    console.log('Woof! Woof!')
  }
}

const dog = new Dog()
dog.bark()
dog.move(10)

子類重寫父類的方法

派生類包含了一個建構函式，它必須呼叫super()，它會執行基類的建構函式。

class Animal {
  name: string
  constructor(name: string) { 
    this.name = name
  }
  move(distance: number = 0) {
    console.log(`${this.name} moved ${distance}m.`)
  }
}

class Snake extends Animal {
  constructor(name: string) { 
    super(name)
  }
  move(distance: number = 5) {
    console.log('Slithering...')
    super.move(distance)
  }
}

class Horse extends Animal {
  constructor(name: string) {
    super(name)
  }
  move(distance: number = 45) {
    console.log('Galloping...')
    super.move(distance)
  }
}

let sam = new Snake('Sammy')
let tom: Animal = new Horse('Tommy')

sam.move()
tom.move(34)
 

Snake類和 Horse 類都建立了 move 方法，它們重寫了從 Animal 繼承來的 move 方法，使得 move 方法根據不同的類而具有不同的功能。注意，即使 tom 被宣告為 Animal 型別，但因為它的值是 Horse，呼叫 tom.move(34) 時，它會呼叫 Horse 裡重寫的方法。

Slithering...
Sammy moved 5m.
Galloping...
Tommy moved 34m.

公共，私有與受保護的修飾符

僅當類被例項化的時候才會被初始化的屬性

預設為 public

class Animal {
  public name: string
  public constructor(name: string) {
    this.name = name
  }
  public move(distance: number) {
    console.log(`${this.name} moved ${distance}m.`)
  }
}
 

private

當成員被標記成 private 時，它就不能在宣告它的類的外部訪問。

class Animal {
  private name: string
  constructor(name: string) { 
    this.name = name
  }
}

new Animal('Cat').name // 錯誤: 'name' 是私有的.

protected

protected與private的行為很相似，但有一點不同，protected成員在派生類中仍然可以訪問。

class Person {
  protected name: string
  constructor(name: string) { 
    this.name = name 
  }
}

class Employee extends Person {
  private department: string

  constructor(name: string, department: string) {
    super(name)
    this.department = department
  }
  
  getElevatorPitch() {
    return `Hello, my name is ${this.name} and I work in ${this.department}.`
  }
}

let howard = new Employee('Howard', 'Sales')
console.log(howard.getElevatorPitch())  // protected成員在派生類中仍然可以訪問。
console.log(howard.name) // error  不能在宣告它的類的外部訪問
 

readonly

readonly 只讀屬性必須在宣告時或建構函式裡被初始化

class Person {
  readonly name: string
  constructor(name: string) {
    this.name = name
  }
}

靜態屬性

屬性存在於類本身上面而不是類的例項上。

class Grid {
  static origin = {x: 0, y: 0}

  scale: number

  constructor (scale: number) {
    this.scale = scale
  }

  calculateDistanceFromOrigin(point: {x: number; y: number}) {
    let xDist = point.x - Grid.origin.x
    let yDist = point.y - Grid.origin.y
    return Math.sqrt(xDist * xDist + yDist * yDist) * this.scale
  }
}

let grid1 = new Grid(1.0)  // 1x scale
let grid2 = new Grid(5.0)  // 5x scale

console.log(grid1.calculateDistanceFromOrigin({x: 3, y: 4}))
console.log(grid2.calculateDistanceFromOrigin({x: 3, y: 4}))

每個例項想要訪問這個屬性的時候，都要在 origin 前面加上類名。 如同在例項屬性上使用 this.xxx 來訪問屬性一樣，這裡我們使用 Grid.xxx 來訪問靜態屬性。

把類當做介面使用

class Point {
  x: number
  y: number
}

interface Point3d extends Point {
  z: number
}

let point3d: Point3d = {x: 1, y: 2, z: 3}