#

在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();


# 多态

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

# 参考

更新时间: 5/13/2020, 11:23:00 PM