所谓类的抽象是只能被继承，而不能被实例化的类。
抽象就是指不具体的，所以抽象类就是指不具体的类。所以抽象类自身没有什么功能，通常作为父类类使用。需要注意，抽象类仅仅作为基类，不能new。

abstract class Animal {
    eat() {
        console.log('eat');
    }
}

// let animal = new Animal(); // 无法创建抽象类的实例。

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

    }
}

let dog = new Dog('wangwang');
dog.eat(); // 打印出来eat

抽象方法

abstract class Animal {
    eat() {
        console.log('eat');
    }

    abstract sleep(): void // 抽象方法
}

// let animal = new Animal(); // 无法创建抽象类的实例。

class Dog extends Animal {
    constructor(name: string) {
        super();
        this.name = name;
    }
    name: string
    run() {}
    sleep() {
        console.log('dog sleep');
    }
}

let dog = new Dog('wangwang');
dog.eat(); // 打印出来eat
dog.sleep(); // 打印出来dog sleep

多态

抽象类还可以实现多态，在程序运行中我们定义一个抽象方法，在子类中我们可以对这个方法进行不同的实现。在程序运行的时候会根据不同的对象执行不同的操作。这样就实现了运行时的绑定。

abstract class Animal {
    eat() {
        console.log('eat');
    }

    abstract sleep(): void // 抽象方法
}

// let animal = new Animal(); // 无法创建抽象类的实例。

class Dog extends Animal {
    constructor(name: string) {
        super();
        this.name = name;
    }
    name: string
    run() {}
    sleep() {
        console.log('dog sleep');
    }
}

class Cat extends Animal {
    sleep() {
        console.log('cat sleep');
    }
}
 
let dog = new Dog('wangwang');

let cat = new Cat();
let animals: Animal[] = [dog, cat];
animals.forEach(i => {
    i.sleep();
});

链式调用

class Workflow {
    step1() {
        return this;
    }

    step2() {
        return this;
    }
}

new Workflow().step1().step2();

class Myflow extends Workflow {
    next() {
        return this;
    }
}
new Myflow().next().step1().next().step2();