TypeScriptで複数のインターフェースをimplementsする方法と使い分けのポイント

TypeScriptは静的型付けの強力な機能を備えており、大規模なアプリケーション開発においてクラスの設計をより安全かつ柔軟に行うことができます。

特に、クラスが特定の機能を備えていることを保証する「インターフェース」は、オブジェクト指向プログラミングにおいて欠かせない要素の一つです。

本記事では、TypeScriptにおいてクラスが複数のインターフェースを同時に実装するimplementsの具体的な手法や、設計上の注意点について詳しく解説します。

TypeScriptにおけるimplementsの役割

TypeScriptのimplementsキーワードは、クラスが特定のインターフェースの構造に従っていることを強制するために使用されます。

クラスがインターフェースを実装する場合、そのインターフェースで定義されているすべてのプロパティとメソッドをクラス内で定義しなければなりません。

これは、クラスの利用側に対して「このクラスは特定のメソッドを必ず持っている」という契約を交わすことに相当します。

継承（extends）とは異なり、implementsは振る舞いの型だけを定義し、実装そのものは提供しないという点が大きな特徴です。

これにより、複数の異なるクラスに対して共通の型定義を適用し、ポリモーフィズムを実現することが可能になります。

複数インターフェースを実装する基本構文

TypeScriptでは、一つのクラスに対して複数のインターフェースを同時に適用することが可能です。

複数のインターフェースを実装するには、implementsキーワードの後に、インターフェース名をカンマ（,）で区切って記述します。

カンマ区切りによる記述方法

以下のコード例では、二つの異なるインターフェースを一つのクラスに実装する方法を示しています。

interface Logger {
    log(message: string): void;
}

interface Serializable {
    toJSON(): string;
}

// 複数のインターフェースをカンマで区切って指定
class ApplicationService implements Logger, Serializable {
    log(message: string): void {
        console.log(`Log: ${message}`);
    }

    toJSON(): string {
        return JSON.stringify({ service: "ApplicationService" });
    }
}

const service = new ApplicationService();
service.log("初期化されました");
console.log(service.toJSON());

Log: 初期化されました
{"service":"ApplicationService"}

このように、LoggerとSerializableという異なる役割を持つ型を、一つのクラスに集約させることができます。

実装漏れに対するコンパイラの挙動

複数のインターフェースを実装する場合、指定したすべてのインターフェースが要求するメンバーを過不足なく実装する必要があります。

もし一つでもメソッドやプロパティの実装を忘れてしまうと、TypeScriptコンパイラはエラーを出力して開発者に通知します。

この厳格なチェックこそが、開発時のバグを未然に防ぐための重要な仕組みとなっています。

インターフェース分離の原則（ISP）と複数実装のメリット

なぜ一つの大きなインターフェースを作るのではなく、複数の小さなインターフェースに分けて実装すべきなのでしょうか。

その答えは、SOLID原則の一つである「インターフェース分離の原則（ISP）」にあります。

コードの再利用性と疎結合の実現

インターフェースを小さく分割することで、各インターフェースは特定の責任のみを持つようになります。

これにより、あるクラスには「保存機能」だけを、別のクラスには「保存機能とログ出力機能」の両方を持たせるといった柔軟な設計が可能になります。

必要な機能だけを組み合わせることで、クラス間の不要な依存関係を排除し、コードの再利用性を高めることができます。

テストのしやすさの向上

小さなインターフェースに分割されていると、ユニットテストの際にモック（代用オブジェクト）を作成するのが非常に容易になります。

巨大なインターフェースを実装した巨大なクラスをテストする場合、関係のない多くのプロパティを初期化しなければならない手間が生じます。

しかし、機能を細分化しておけば、テストに必要な特定のインターフェースだけを対象にした最小限のスタブを用意するだけで済みます。

複数実装における競合と回避策

複数のインターフェースを実装する際には、異なるインターフェース間でプロパティ名やメソッド名が重複してしまう「名前の競合」が発生することがあります。

この場合、どのように対処すべきかを知っておくことは非常に重要です。

同名メソッドのシグネチャ競合

もし二つのインターフェースが全く同じ名前のメソッドを持っていた場合、そのシグネチャ（引数や戻り値の型）が一致していれば問題ありません。

クラス側で一度そのメソッドを実装すれば、両方のインターフェースを満たしたことになります。

しかし、引数の型や戻り値の型が異なる場合は注意が必要です。

interface Reader {
    read(): string;
}

interface NumericReader {
    read(): number;
}

// 以下のクラス定義はコンパイルエラーになります
// class MixedReader implements Reader, NumericReader {
//     read(): string | number {
//         return "data";
//     }
// }

上記の例では、戻り値の型がstringとnumberで異なるため、一つの実装で両方の契約を同時に満たすことができません。

戻り値の型に互換性がない場合、TypeScriptではそれらを同時に実装することは不可能です。

このような状況に直面した場合は、インターフェースの名前をより具体的に変更するか、設計を見直す必要があります。

プロパティのアクセス修飾子に関する制限

インターフェースで定義されたプロパティをクラスで実装する場合、そのプロパティは必ずpublicでなければなりません。

インターフェースは外部との境界（パブリックAPI）を定義するものであるため、privateやprotectedとして実装することは許可されていません。

もし内部的に保持したいデータであれば、インターフェースには含めず、クラス固有のプロパティとして定義すべきです。

extends（クラス継承）との使い分け基準

TypeScriptでは、他のクラスを継承するextendsと、インターフェースを実装するimplementsを併用することもできます。

これらの使い分けを整理するために、以下の比較表を確認してください。

一般的には、「振る舞いの共通化」を目的とする場合はインターフェースの複数実装を選び、「既存の実装を引き継ぐ」場合はクラスの継承を選ぶのが定石です。

実践：リポジトリパターンへの応用

複数のインターフェースを利用する具体的な場面として、データアクセス層（リポジトリパターン）の実装が挙げられます。

読み取り専用の権限と、書き込み権限を分けて定義することで、安全なデータ操作を実現できます。

interface ReadOnlyRepository<T> {
    findById(id: string): T | null;
    findAll(): T[];
}

interface WriteRepository<T> {
    save(entity: T): void;
    delete(id: string): void;
}

interface User {
    id: string;
    name: string;
}

// 読み書き両方の機能を実装する
class UserRepository implements ReadOnlyRepository<User>, WriteRepository<User> {
    private users: User[] = [];

    findById(id: string): User | null {
        return this.users.find(u => u.id === id) || null;
    }

    findAll(): User[] {
        return this.users;
    }

    save(entity: User): void {
        this.users.push(entity);
        console.log(`${entity.name} を保存しました`);
    }

    delete(id: string): void {
        this.users = this.users.filter(u => u.id !== id);
    }
}

const repo = new UserRepository();
repo.save({ id: "1", name: "田中太郎" });

田中太郎 を保存しました

このようにインターフェースを分けておくことで、ある関数にはReadOnlyRepositoryとして型指定し、データの参照のみを許可するといった制御が容易になります。

インターフェースを合成して利用する方法

クラスに直接複数のインターフェースを書く代わりに、新しいインターフェースとしてそれらを合成（継承）しておく方法もあります。

これにより、クラス定義の部分がスッキリし、型の意味合いも明確になります。

interface Flyable {
    fly(): void;
}

interface Swimmable {
    swim(): void;
}

// インターフェース同士を結合
interface Amphibious extends Flyable, Swimmable {}

class SuperVehicle implements Amphibious {
    fly() { console.log("空を飛びます"); }
    swim() { console.log("水の中を進みます"); }
}

頻繁にセットで使用されるインターフェースがある場合は、このように一つのインターフェースにまとめておくと管理が楽になります。

ただし、あまりに多くのインターフェースを合成しすぎると、インターフェース分離の原則のメリットが薄れてしまうため、バランスが重要です。

implementsとIntersection Types（交差型）の関連

TypeScriptには&（アンパサンド）を使ったIntersection Types（交差型）という仕組みも存在します。

implementsに指定する複数のインターフェースは、意味的には交差型で表現される型構造と非常に似ています。

しかし、クラスの定義においてはimplementsを使うのが標準的な書き方であり、型安全性と可読性の両面で優れています。

一方で、関数の引数などで「複数のインターフェースを満たしているオブジェクト」を受け取りたい場合には、交差型を活用するのが一般的です。

まとめ

TypeScriptのimplementsを用いた複数インターフェースの実装は、堅牢で拡張性の高いクラス設計を実現するための強力な手段です。

カンマ区切りで複数の型契約を指定することで、一つのクラスに多様な役割を持たせつつ、それぞれの責任を明確に分離することが可能になります。

特にインターフェース分離の原則に従い、小さく再利用可能なインターフェースを定義することは、長期的なメンテナンスコストの削減に直結します。

実装時のメソッド名競合やアクセス修飾子のルールに注意しながら、複数のインターフェースを適切に使いこなしましょう。

この記事で紹介したテクニックを活用して、より型安全でクリーンなTypeScriptコードの記述に役立ててください。