TS（JS） - typescript中抽象类的特性

TypeScript中，抽象类是用于定义其他类的基础类，不能被实例化，只能被继承。主要用于抽离一些通用性的东西

定义

• 抽象类使用abstract关键字声明的类
• 抽象类不能被实例化，只能被继承
• 抽象类可以定义属性、方法和抽象方法
• 抽象类可以有构造器

抽象方法

• 抽象类必须在派生类中实现
• 抽象方法使用abstract关键字声明，没有方法体
• 示例

abstract class Animal {
    abstract eat():void
}

class Dog extends Animal {
    eat():void {
        console.log("Dog eat rice")
    }
}

const dogA = new Dog()
dogA.eat() //打印: "Dog eat rice"

抽象属性

• 抽象类中也可以包含抽象属性，这些属性必须在子类中实现
• 抽象属性也使用abstract关键字声明
• 示例

abstract class Animal {
    abstract name: string;
    
    eat():void {
        console.log(`${this.name} eat food`)
    }
}

class Dog extends Animal {
    name: string = "jerry"
    eat(): void {
        super.eat()
        console.log('wang wang ')
    }
}
const dogA = new Dog()
dogA.eat() //输出 jerry eat food wangwang

构造函数

• 抽象类可以有构造函数，派生类必须调用基类的构造函数
• 示例

abstract class Animal {
    constructor(public name: string){}
        
    abstract eat(): void;
    
}

class Dog extends Animal {
    constructor(name: string){
        super(name);
    }
    
    eat():void {
        console.log(`${this.name} eat food`)
    }
}

const dogA = new Dog("jerry")
dogA.eat()

多态

• 抽象类支持多态，可以通过父类引用指向子类对象的方法
• 示例

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

class Dog extends Animal {
    eat(): void{
        console.log("eat meat")
    }
}

class Cat extends Animal {
    eat(): void{
        console.log("eat fish")
    }
}

function eatFood(animal: Animal) {
    animal.eat()
}


const dog = new Dog();
const cat = new Cat();

eatFood(dog)  //输出 eat meat
eatFood(cat)  //输出 eat fish

封装

• 抽象类可以包含具体的方法和属性，这些方法和属性可以在子类中直接使用
• 示例

abstract class Animal {
    constructor(public name: string) {}

    eat(): void {
        console.log(`${this.name} 在吃饭`)
    }
    
    abstract specificSound(): void;
}

class Dog extends Animal {
    constructor(public name: string) {
        super(name)
    };
    specificSound(): void {
        console.log("wangwang")
    }
}

const dogA = new Dog("jerry")
dogA.eat()
dogA.specificSound()

总结：抽象类主要用于定义一个基类，不能直接实例化，只能被继承。抽象类中的抽象方法和属性必须在子类中实现。