TypeScript（ts）学习笔记（四）：类（Class）

从ECMAScript 2015，也就是ES6 之后，JavaScript 加入了 class 关键字，使得开发者能够使用基于类的面向对象的开发方式，但是它的本质依然是构造函数，而且有一些重要特性（修饰符、抽象类等）还没有加入。
在TypeScript中，我们现在就可以使用这些特性了：

访问限定修饰符

public

在 TypeScript，类的成员都默认为 public，被public修饰的成员是可以被外部访问的

class Dog {
  public name: string;
  constructor(name:string) {
    this.name = name;
  };
  public bark() {
    console.log('汪');
  }
}
const dog = new Dog("大黄");
dog.bark()

private

被private修饰符修饰的成员是只能被类的内部访问：

class Dog {
    private name: string;
    constructor(name: string) {
        this.name = name;
    }
    public bark() {
        console.log(this.name);
    }
}
const dog = new Dog('小黑');

console.log(dog.name);
dog.bark();

protected

protected修饰符与 private修饰符类似，但是 protected成员在派生类（子类）中仍然可以访问：

class Animal {
  protected run(): void {
    console.log('跑。。。');
  }
}
class Dog extends Animal{
  init() {
    this.run()
  }
}
const animal = new Animal();
const dog = new Dog();
animal.run(); // 属性“run”受保护，只能在类“Animal”及其子类中访问。
dog.run(); // 属性“run”受保护，只能在类“Animal”及其子类中访问。
dog.init(); // OK

构造函数如果被标记为 protected， 它就不能在包含它的类外被实例化，但是可以被继承：

class Person {
  protected name: string;
  protected age: number;
  protected constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
}
class Employee extends Person {
    private department: string;
    constructor(name: string, age: number, department: string) {
        super(name, age);
        this.department = department;
    }
}
const p1= new Person('Ergou',20); //类“Person”的构造函数是受保护的，仅可在类声明中访问。
const p2 = new Employee('张三', 800, '研发部');

静态属性（static）

被static标记的属性或方法是静态的，静态成员存在于类本身上面而不是类的实例上，可以直接通过类名调用：

class Person {
  static age: number;
  constructor() {
    Person.age = 20
  }
}

const p1 = new Person();
console.log(Person.age); // 20

抽象类（abstract）

抽象类做为其它派生类的基类使用， 它们一般不会直接被实例化。和接口不同，抽象类可以包含成员的实现细节。 abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法。

abstract class Animal{
  constructor(public name: string) {
  };
  getName(): void {
    console.log(this.name);
  };
  abstract makeSound(): void;
}
class Dog extends Animal {
  constructor(name: string) {
    super(name);//在派生类的构造函数中必须调用 super()
  };
  makeSound() {
    console.log('汪汪汪');
  }
}
const animal = new Animal(); //无法创建抽象类的实例
const dog = new Dog("小黑");
dog.makeSound();

抽象类中的抽象方法不包含具体实现，必须在子类中实现。与接口方法相似，两者都是定义方法签名但不包含方法体， 然而，抽象方法必须包含 abstract关键字并且可以包含访问修饰符。