TypeScript 抽象类：抽象方法、属性及与接口的区别

抽象类是用 abstract 标记的基类。它不能用 new 创建，并且可以声明没有方法体的 abstract 方法，每个子类都必须实现这些方法。

abstract class Shape {
    abstract area(): number; // no body: subclasses provide it

    describe(): string {
        // Concrete methods can call abstract ones.
        return `${this.constructor.name} with area ${this.area().toFixed(2)}`;
    }
}

class Circle extends Shape {
    constructor(private r: number) {
        super();
    }
    area(): number {
        return Math.PI * this.r ** 2;
    }
}

class Rect extends Shape {
    constructor(private w: number, private h: number) {
        super();
    }
    area(): number {
        return this.w * this.h;
    }
}

const shapes: Shape[] = [new Circle(1), new Rect(2, 3)];
for (const s of shapes) console.log(s.describe());
// Circle with area 3.14
// Rect with area 6.00

Shape 把 describe() 共享给所有子类，同时强制每个子类提供 area()。类型 Shape[] 可以容纳各种子类的任意组合。

抽象类不能被实例化

对抽象类调用 new 会产生编译错误，因为这样得到的对象会带有没有实现的方法：

// This does not compile: Shape is abstract.
abstract class Shape {
    abstract area(): number;
}

const s = new Shape();
console.log(s.area());

index.ts(6,11): error TS2511: Cannot create an instance of an abstract class.

这是一条编译时规则。abstract 会从输出中擦除，所以生成的 Shape 就是一个普通的 JavaScript 类，没有类型检查的 JavaScript 代码仍然可以调用 new Shape()。当一个库需要运行时保护时，可以在构造函数里检查 new.target：

abstract class Plugin {
    constructor() {
        if (new.target === Plugin) {
            throw new TypeError("Plugin is abstract; extend it");
        }
    }
    abstract run(): string;
}

class Hello extends Plugin {
    run(): string {
        return "hello";
    }
}

console.log(new Hello().run()); // hello

抽象方法和抽象属性

子类必须实现每一个抽象成员，否则它自己也必须是抽象类。漏掉一个会报错 TS2515，内容类似 Non-abstract class 'Square' does not implement inherited abstract member area from class 'Shape'；如果漏掉好几个，则会报 TS2654 并把它们全部列出来。

字段、getter 和方法都可以是抽象的，也都可以是 protected：

abstract class Report {
    abstract readonly title: string;          // abstract property
    protected abstract rows(): string[];      // only for subclasses

    abstract get footer(): string;            // abstract getter

    render(): string {
        return [this.title, ...this.rows(), this.footer].join("\n");
    }
}

class SalesReport extends Report {
    readonly title = "Sales Q1";

    protected rows(): string[] {
        return ["Jan: 120", "Feb: 95", "Mar: 140"];
    }

    get footer(): string {
        return "Total: 355";
    }
}

console.log(new SalesReport().render());

抽象方法没有方法体，给它写方法体会报错 TS1245（Method 'x' cannot have an implementation because it is marked abstract）。抽象类也不一定要有抽象成员：单独一个 abstract 只是用来阻止直接实例化。

模板方法模式

写抽象类最常见的理由是：基类固定步骤的顺序，每个子类填充其中会变化的步骤。

abstract class Importer<T> {
    // The algorithm lives here, once.
    import(raw: string): T[] {
        const lines = raw.trim().split("\n");
        const records = lines.map((line) => this.parse(line));
        return records.filter((r) => this.isValid(r));
    }

    protected abstract parse(line: string): T;

    // A default subclasses may override.
    protected isValid(_record: T): boolean {
        return true;
    }
}

type Person = { name: string; age: number };

class PersonImporter extends Importer<Person> {
    protected parse(line: string): Person {
        const [name, age] = line.split(",");
        return { name, age: Number(age) };
    }

    protected override isValid(p: Person): boolean {
        return !Number.isNaN(p.age);
    }
}

console.log(new PersonImporter().import("Ada,36\nBob,x\nCy,29"));
// [ { name: 'Ada', age: 36 }, { name: 'Cy', age: 29 } ]

抽象类也可以是泛型的，就像这里一样，这样每个子类都能选择自己的记录类型。

抽象构造函数类型

对抽象类来说，typeof Shape 是一个不允许调用的构造函数，所以类型为 typeof Shape 的参数不能执行 new c()。当一个函数需要接收抽象类（比如注册它们或检查 instanceof）时，就用抽象构造签名来标注类型：

abstract class Animal {
    abstract sound(): string;
}
class Dog extends Animal {
    sound(): string {
        return "woof";
    }
}

type AbstractCtor<T> = abstract new (...args: never[]) => T;
type Ctor<T> = new () => T;

function isKind<T>(value: unknown, kind: AbstractCtor<T>): value is T {
    return value instanceof kind;
}

function create<T>(kind: Ctor<T>): T {
    return new kind();
}

const pet = create(Dog);     // fine: Dog is concrete
console.log(pet.sound());    // woof
console.log(isKind(pet, Animal), isKind("cat", Animal)); // true false
// create(Animal) is an error: Animal is abstract

abstract new 同时接受抽象类和具体类；普通的 new 只接受具体类。

抽象类与接口的区别

经验法则：只需要描述结构时用接口（这是最常见的情况，而且对对象字面量也适用）；子类之间共享真正的实现、并且你希望编译器强制它们补齐空缺时，用抽象类。两者也可以很好地结合：用接口定义公共契约，再用一个抽象类作为实现该接口的便捷基类。另一个常见的对比见 interface 与 type 的区别。

常见错误

• 该用接口的地方用了抽象类。 如果基类里没有任何代码，它就是一个多了运行时负担、还受单继承限制的接口。
• 尝试使用 static abstract。 这是不允许的，静态成员不能是抽象的。
• 以为对抽象类调用 new 会在运行时报错。 除非你自己写了 new.target 检查，否则不会报错。
• 在基类构造函数里调用抽象方法。 它会在子类的字段初始化之前运行，所以实现代码看到的这些字段都是 undefined。