多态：静态多态：方法的重载

        一个类中的方法名相同，但是参数不同，重载

动态的多态：方法的重写

class food{
  beCook(){

  }
}

export class Vegetable extends Food{
  beCook(){
    console.log('素菜')
  }
}

export class Fish extends Food{
  beCook(){
    console.log('Fish')
  }
}

export class Pig extends Food{
  beCook(){
    console.log('Pig')
  }
}
//厨师可以做各种菜，我们认为这是一种多态的形态
export class Cooker{
  cook(food:Fish)
  cook(food:Vegetable)
  cook(food:Pig)
  cook(food:Pig | Fish | Vegetable){
    
  }
}

多态中cooker，只有这样写才不会报错，说明一个多态只能取传一个参数，不能传多个参数。上面cooker的写法是最后判断出一个，这样的写法没有意义。

现在我们要实现一个功能：这个菜谱会增加或减少，用到动态多态

用父类做参数，隔离子类的变化

export class Cooker{
  //动态的多态
  cook(food:Food){
    food.beCook()

  }
}

let cook = new Cooker() //是创建Cooker类的一个实例化对象
cook.cook(new Fish())
cook.cook(new Vegetable())
cook.cook(new Pig())

编译时不确定：cook 方法不知道参数的具体类型是pig，vegetable,Fish

运行时决定：调用 food.beCook() 时，程序根据 food 实际指向的对象类型，动态决定执行哪个版本的 beCook 方法

通过继承/接口实现：子类重写父类方法，父类引用指向子类对象

静态成员属于类，不属于对象

static关键字开头的成员

静态字段    静态方法    静态代码块

export class MyMath{
  static pi: number = 3.14192653
  
  static show(){
    
  }
  //静态代码块有且只能写一个，两个会报错
  static{
    console.log('ken','静态代码快')
  }
}

通过类名去访问

MyMath.pi;
MyMath.show()

可以完成一些单例模式

//单例模式：一个类只有一个对象，这个是类的设计者的责任，而不是使用者的责任
class DbHelper {
  private const instance: DbHelper | null = null

  private constructor() {
  }
  static getInstace():DbHelper{
     if(DbHelper.instace == null){
       DbHelper.instace = new DbHelper()
     }
     return DbHelper.instace
  }

}

静态字段去做：1，构造方法私有化  2，静态成员  3，做一个公共方法去做一个返回