TypeScriptの抽象クラス（abstract）: interface との違い

抽象クラスは 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

抽象メソッドと抽象プロパティ

サブクラスはすべての抽象メンバーを実装するか、自分も抽象クラスにしなければなりません。1つ足りないとエラー 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 は具象クラスしか受け付けません。

抽象クラスとインターフェースの比較

目安として、形を表すだけならインターフェース（いちばんよくあるケースで、オブジェクトリテラルにも使えます）、サブクラスが実際の実装を共有し、足りない部分を埋めることをコンパイラーに強制させたいなら抽象クラスを使います。この2つはうまく組み合わせられます。公開の約束にはインターフェースを、それを実装する便利な基底として抽象クラスを使います。もう1つのよくある比較については interface と type の違い を参照してください。

よくある間違い

• インターフェースで十分なところに抽象クラスを使う。 基底クラスにコードがないなら、それは実行時の重さと単一継承の制限が付いたインターフェースです。
• static abstract を試す。 許可されていません。static メンバーは抽象にできません。
• 抽象クラスへの new で実行時エラーが出ると期待する。 new.target のチェックを書かない限り、エラーは出ません。
• 基底クラスのコンストラクターから抽象メソッドを呼ぶ。 サブクラスのフィールドが初期化される前に実行されるので、実装からはそれらが undefined に見えます。