TypeScript类

类

在TypeScript中，类的成员属性 都是 实例 属性，而不是原型属性，类的成员方法 都是 原型 方法。

类的继承

派生类的构造函数必须包含 super 调用。
访问派生类的构造函数中的 this 前，必须调用 super。
super 代表父类的实例
调用 super()，会执行基类的构造函数

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

let dog= new Dog('11');
console.log(dog);

class Husky extends Dog {
  constructor(name: string,color: string) {
    // 报错 派生类的构造函数必须包含 "super" 调用。访问派生类的构造函数中的 "this" 前，必须调用 "super"。
    // super(name);
    this.color = color;
  }
  color: string
}

类的修饰符

public: 所有人可见（默认）。
private: 只能被类本身调用，不能被类的实例调用，也不能被子类调用。当成员被标记成 private 时，它就不能在声明它的类的外部访问
protected: 只能在类或类的子类中调用，不能被类的实例调用。
readonly: 只读，只读属性必须初始化。
static: 静态属性，只能通过类名访问，可以被继承。
除了类的成员可以添加修饰符，构造函数参数也可以添加修饰符

private修饰符

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

// 属性“name”为私有属性，只能在类“Animal”中访问。
new Animal('Cat').name

当给类的构造函数添加 private 修饰符，表示这个类既不能实例化，也不能继承。

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

// 类“Animal”的构造函数是私有的，仅可在类声明中访问。
new Animal("Cat");

// 无法扩展类“Animal”。类构造函数标记为私有。
class Dog extends Animal {
  constructor(name:string) {
      super(name);
  }
}

protected修饰符

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

let animal = new Animal("Cat");
// 属性“name”受保护，只能在类“Animal”及其子类中访问。
console.log(animal.name);

class Dog extends Animal {
  constructor(name: string) {
    super(name);
    this.name = '1111'
  }
}

当给类的构造函数添加 protected 修饰符时，表示这个类不能被实例化，只能被继承。

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

// 类“Animal”的构造函数是受保护的，仅可在类声明中访问。
let animal = new Animal("Cat");
console.log(animal.name);

class Dog extends Animal {
  constructor(name: string) {
    super(name);
    this.name = '1111'
  }
}

抽象类

只能被继承不能实例化。抽象类可以包含成员的实现细节。 abstract 关键字是用于定义抽象类和在抽象类内部定义抽象方法。

抽象类中可以定义一个方法的具体实现，这样就实现了方法的复用。

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

抽象类中抽象方法，可在不同子类中实现类的多态。

子类必须实现抽象类的抽象方法

abstract class Animal {
  eat() {
    console.log("eat");
  }
  abstract sleep(): void;
}

// 无法创建抽象类的实例。
// let animal = new Animal();

class Dog extends Animal {
  constructor(name: string) {
    super();
    this.name = "1111";
  }
  name: string;
  // 子类必须实现抽象类的抽象方法
  sleep() {
    console.log("dog sleep");
  }
}

let dog = new Dog('111');
dog.eat();

多态

在父类中定义一个抽象方法，在多个子类中对这个方法有不同的实现。在程序运行时，会根据不同的对象，执行不同的操作，这样就实现了运行时绑定。

类

类的继承

类的修饰符

private修饰符

protected修饰符

抽象类

多态

参考