Typescript 静态属性&方法 多态 抽象类

静态属性、静态方法

• 用 static 关键词定义的属性和方法就是静态属性和静态方法，不需要类实例化就可以调用。
  • 静态方法里不能直接调用类里面的属性，可以调用静态属性。

class Person{
    
    
    public name:string; 
    static age:number;   //静态属性
    constructor(n:string){
    
       
        this.name = n
    }
    getName():void{
    
      //实例方法
        console.log(`my name is ${
      
      this.name}`)
    }
    static getAge(){
    
       //静态方法，不能直接调用类里面的属性，可以调用静态属性
        console.log(`静态方法，获取age：${
      
      this.age}`)
    }
}
var p = new Person('小明')
p.getName()   //my name is 小明
console.log(p.name);  //小明
console.log(Person.age);   //undefined
Person.age = 22
Person.getAge()   //静态方法，获取age：22

多态

• 父类定义一个方法不去实现，让继承它的子类去实现，每个子类都不同的表现
• 多态属于继承

class Animal{
    
    
    name:string
    constructor(n:string){
    
    
        this.name = n
    }
    eat(){
    
    
        console.log('吃东西');
    }
}
class dog extends Animal{
    
    
    constructor(n:string){
    
    
        super(n)
    }
    eat(){
    
        //重写Animal里的eat方法
        console.log(`${
      
      this.name}吃肉`);
    }
}
class cat extends Animal{
    
    
    constructor(n:string){
    
    
        super(n)
    }
    eat(){
    
    
        console.log(`${
      
      this.name}吃鱼`);
    }
}
let d = new dog('小狗狗')
d.eat()   //小狗狗吃肉
let c = new cat('小花猫')
c.eat()   //小花猫吃鱼

抽象类

• Typescript中的抽象类提供其他类继承的基类，不能直接被实例化
• 用abstract关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现，并且必须在子类中实现

abstract class Animal{
    
    
    name:string
    constructor(name:string){
    
    
        this.name = name
    }
    abstract eat():any
    sleep(){
    
    
        console.log('sleep');
    }
}
class Dog extends Animal{
    
    
    // 抽象类的子类必须实现抽象类的抽象方法
    constructor(name:string){
    
    
        super(name)
    }
    eat(){
    
    
        console.log(`${
      
      this.name}吃肉`);
    }
}
let d = new Dog("旺旺")
d.eat() // 旺旺吃肉
d.sleep()   //sleep