抽象类

抽象类是不允许被实例化的，只能被继承

abstract class Animal {

}

let animal = new Animal(); // 错误: 不能创建一个抽象类的实例    

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

let dog = new Dog('Tom');

抽象类的好处就是可以抽离出一些事物的共性，有利于代码的复用和扩展，另外抽象类也可以实现多态。

多态

所谓多态，就是在父类中定义一个抽象方法，在多个子类中对这个方法有不同的实现，在程序运行的时候，会根据不同对象执行不同的操作，这样就是实现了运行时的绑定。

abstract class Animal {
    // 方法复用
    eat() {
        console.log('Animal is eating');
    }
    // 不指定方法具体实现，构成一个抽象方法
    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 is sleeping');
    } // 实现抽象方法
}

let dog = new Dog('Tom');
dog.eat(); // 输出: Animal is eating

class Cat extends Animal {
    sleep() {
        console.log('Cat is sleeping');
    } // 实现抽象方法
}

let cat = new Cat();

let animals: Animal[] = [dog, cat];
animals.forEach(a => a.sleep()); // 输出: Dog is sleeping, Cat is sleeping

this 类型

类的成员方法可以直接返回一个 this，这样就可以很方便的实现链式调用。

class WorkFlow {
    step1() {
        return this;
    }
    step2() {
        return this;
    }
}

new WorkFlow().step1().step2(); // 链式调用

在继承的时候，this 的类型也可以表现出多态，这里的多态是指 this 既可以是父类型，也可以是子类型。

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();