4.类-静态方法及抽象类

类的静态属性与静态方法

类可以直接使用静态属性及调用静态方法
静态方法中无法调用类上面的属性(public,protected,private ), 但可以使用静态属性

class PersonStatic {
    public name:string // 公共
    protected protectedName:string; // 保护
    private privateName:string; // 私有
    static sexStatic:string = 'person';
    constructor(n:string) {
        this.name = n;
        this.protectedName = n;
        this.privateName = n;
    }

    // 定义静态方法
    static spreakSex() {
        // 使用静态属性
        console.log(this.sexStatic);
    }

    static spreakName() { // 静态方法无法调用类上面的属性（除静态外）
        console.log(this.name); // 类型“typeof PersonStatic”上不存在属性“name”
        console.log(this.protectedName); // 类型“typeof PersonStatic”上不存在属性“protectedName”。
        console.log(this.privateName); // 类型“typeof PersonStatic”上不存在属性“privateName”
    }
}

// 静态方法的调用，类直接调用
PersonStatic.spreakSex();

类的多态

多态： (龙生九子，各有不同) 父类定义了一个方法，让继承它的子类去实现，每个子类都有不同的表现方式

// 动物有一个吃的方法,但不知道吃什么
class Animal {
    name:string
    constructor(n:string) {
        this.name = name;
    }
    eat() {
        console.log('不知道吃什么')
    }
}

// 猫继承于动物，也有吃的方法，表现形式为吃猫粮
class Cat extends Animal {
    constructor(n:string) {
        super(n);
    }

    eat() {
        console.log('猫粮');
    }
}

// 狗继承于动物，也有吃的方法，表现形式为吃狗粮
class Dog extends Animal {
    constructor(n:string) {
        super(n);
    }

    eat() {
        console.log('狗粮')
    }
}

猫和狗都有eat方法，他们都属于动物，但eat的表现各有不同，这就是多态（多种形态）

抽象类

使用abstract关键词定义抽象类及抽象方法，抽象类中的抽象方法不包含具体实现，并且必须在继承类(派生类)中去实现

abstract 抽象方法只能在抽象类中定义

// 错误
// class AnimalAbsError {
//     abstract eat():void; // 不能定义抽象方法
// }

// 正确
abstract class AnimalAbs {
    abstract eat():void;
}

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

// 错误
new AnimalAbs() //  无法创建抽象类的实例

作用：指定某个派生类的标准，例如派生类必须有一个特定的方法

image.png

class Mouse extends AnimalAbs {
    constructor() {
        super();
    }

    eat() { // 必须写eat，因为抽象类中定义标准必须有eat方法
        console.log('玉米');
    }
}

demo

// 抽象类： 它是提供其他继承类的基类，给其他类制定标准规范，不能直接被实例化

// 定义一个抽象类
abstract class apeMan {
    // 派生的属性
    abstract singer: string;
    // 抽象的方法
    abstract sing(): void
}



// 派生给其他类, 其他类中必须有抽象类所规定的方法
class Man extends apeMan {
    singer: string;   // 呼应
    constructor(s: string) {
        super()
        this.singer = s;
    }
    sing() {
        console.log('我会唱歌')
    }

}


// 抽象的动物
abstract class Animal {
    abstract name:string;
    abstract eat(f:string):void;
    abstract play():void;
}


// 实际的狗   
class Dog extends Animal {
    name:string; 
   
    constructor(n:string) {
        super();
        this.name = n;
    }

    eat(f:string) {
        console.log(`${this.name}喜欢吃${f}`)

    }

    play() {

    }
}



class Cat extends Animal {
    name:string;
    constructor(n:string) {
        super();
        this.name = n;
    }

    eat(f:string) {
        // 具体的实现由不同的派生类来决定
        alert(`${this.name}喜欢吃${f}`)

    }

    play() {

    }

}