Herança e membros do modificador

A classe básica implementação

Definir uma classe Dog, e ES é diferente é que nós adicionamos ao tipo anotações atributo membro, mas também aumenta os tipos de anotações como um parâmetro para o construtor.

class Dog {
  constructor(name: string) {
    this.name = name
  }
  name: string
  run() {}
}

需要注意的是:
    （1）无论是在ES还是ts中，类成员的属性都是实例属性，而不是原型属性；类成员的方法也都是实例方法。对比可见：
　　console.log(Dog.prototype) // {run: ƒ, constructor: ƒ}
　　let dog = new Dog('wangwang')
　　console.log(dog) // Dog {name: "wangwang"}
　　（2）与ES不同的是，实例的属性必须具有初始值，或者在构造函数中被初始化。 以下√的三种方式均是可以的：

　　class Dog {
  　　constructor(name: string) {
    　　// this.name = name   √
  　　}
  　　// name: string = 'dog'   √
  　　// name?: string = 'dog'   √
  　　run() {}
　　}

A herança de classe (uso de palavras-chave estende-se)

class Husky extends Dog {
  constructor(name: string, color: string) {
    super(name)
    this.color = color
  }
  color: string
}

Note-se que:
(1) o construtor da classe derivada deve conter uma chamada 'super', os parâmetros e parâmetro deve conter a classe pai.
(2) propriedade recentemente adicionado ao ser inicializado no construtor em geral, e isso costumava ser chamado após a chamada super.

Os membros da classe de modificadores (que é uma extensão dos ts ES)

membro do público: todos são visíveis, público + formato de nome de atributo / função de
membros privados, também pode ser chamado em uma classe por si só, não pode ser invocado instância da classe não pode ser chamado por subclasses, privado + atributo formato nome / função

class Dog {
  constructor(name: string) {
    this.name = name
  }
  name: string
  run() {}
  private pri() {}
}
let dog = new Dog('wangwang')
dog.pri()   ❌
class Husky extends Dog {
  constructor(name: string) {
    super(name)
    this.pri()   ❌
  }
}

PS:
    也可以给构造函数加上私有成员属性，作用是类既不能被实例化，也不能被继承，都会提示错误。

　　class Dog {
  　　private constructor(name: string) {
    　　this.name = name
  　　}
  　　name: string
　　}
　　let dog = new Dog('wangwang')   ❌
　　class Husky extends Dog { }   ❌

Membros protegidos podem ser acessados ​​somente em classe ou sub-classe, mas a instância de classe não pode ser acessado, protegidos + formato de nome de atributo / função.

class Dog {
  constructor(name: string) {
    this.name = name
  }
  name: string
  protected pro() {}
}
let dog = new Dog('wangwang')
dog.pro()   ❌
class Husky extends Dog {
  constructor(name: string) {
    super(name)
    this.pro()     ✔
  }
}

PS: 
　　构造函数也能被声明为protected，作用是这个类不能被实例化，只能被继承，就相当于声明了一个基类。
　　class Dog {
  　　protected constructor(name: string) {
    　　this.name = name
  　　}
  　　name: string
　　}
　　let dog = new Dog('wangwang') // ❌
　　class Husky extends Dog {
  　　......
　　}

Read-only atributo: não pode ser alterada lembro como atributo de instância deve ser inicializado.

class Dog {
  constructor(name: string) {
    this.name = name
  }
  name: string
  readonly legs: number = 4
}

Construtor parâmetro modificador pode ser adicionado, o seu papel é o parâmetro automaticamente em uma propriedade da instância, e pode ser omitido na definição da classe.

class Husky extends Dog {
  constructor(name: string, public color: string) {
    super(name)
    this.color = color
  }
  // color: string
}

Membro estático: classe só pode ser chamado pelo nome, em vez de através de uma subclasse chamada, pode ser herdada, forma estática modificador + nome da propriedade.

class Dog {
  constructor(name: string) {
    this.name = name
  }
  name: string
  static food: string = 'bones'
}
let dog = new Dog('wangwang')
console.log(Dog.food) // ✔
// console.log(dog.food) ❌    
class Husky extends Dog {
  constructor(name: string, public color: string) {
    super(name)
    this.color = color
  }
}
console.log(Husky.food)  // ✔