TypeScript 入门教程之类的静态属性、静态方法、修饰符、多态、抽象类

类的定义

类(class)这个概念来源于OOP（Object Oriented Programming），也就是面向对象编程，OOP是一种计算机编程架构，其有着封装，继承，多态三种特性。而类在OOP中是实现信息封装的基础。类是一种用户定义类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。

静态属性、静态方法

static 关键字用于定义类的数据成员（属性和方法）为静态的，静态成员可以直接通过类名调用。

class Animal {
  static alias: string;

  static run(): void {
    console.log(`${Animal.alias} is run`)
  }

  constructor(alias: string) {
    Animal.alias = alias
  }
}

Animal.alias = 'Dog'; // 初始化静态变量
Animal.run(); // 调用静态方法

// 静态属性、静态方法不能实列化调用
const animal = new Animal('Cat')
animal.alias // 报错
animal.run() // 报错

修饰符

• public：公有，不加修饰符默认公有。类里、子类、外部可以访问
• protected：保护类型，类里、子类可以访问，类外不可访问
• private：类里可以访问，子类、外部不可访问

class Person {
  public name: string; // 公有
  protected age: number; // 保护
  private phone: number; // 私有

  constructor(name: string, age: number, phone: number) {
    this.name = name;
    this.age = age;
    this.phone = phone;
  }
}

class ChildPerson extends Person {
  constructor(name: string, age: number, phone: number) {
    super(name, age, phone);
  }

  getName(): string {
    return this.name
  }

  getAge(): number {
    return this.age
  }

  getPhone(): number {
    return this.phone // 报错，私有属性，派生类不能访问私有属性
  }
}

const cp = new ChildPerson('张三', 20, 13666666666);
console.log(cp.name); // 张三
console.log(cp.age); // 报错，实例化不能访问访问保护属性
console.log(cp.phone); // 报错，实例化不能访问访问私有属性

const p = new Person('李四', 20, 13888888888)
console.log(p.name); // 李四
console.log(p.age); // 报错，实例化不能访问访问保护属性
console.log(p.phone); // 报错，实例化不能访问访问私有属性

多态

父类定义一个方法不去实现，让继承他的子类去实现，每一个子类有不同的表现

class Animal {
  public name: string;

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

  eat(): void {

  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name);
  }

  eat(): string {
    return `${this.name}吃肉！`;
  }
}

class Cat extends Animal {
  constructor(name: string) {
    super(name);
  }

  eat(): string {
    return `${this.name}吃鱼！`;
  }
}

const d1 = new Dog('大黄');
console.log(d1.eat()); // 大黄吃肉！
const c1 = new Cat('小白');
console.log(c1.eat()); // 小白吃鱼！

抽象类

它是提供其他类继承的基类，不能直接被实例化。

用 abstract 关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。

abstract 抽象方法只能放在抽象类里面

抽象类和抽象方法用来定义标准， 继承他的子类实现抽象方法

abstract class Animal {
  abstract eat(): void;
}

class Dog extends Animal {
  eat(): void {
    console.log('吃肉！')
  }
}

class Cat extends Animal {
  eat(): void {
    console.log('吃鱼！')
  }
}