TypeScriptにおけるクラスのオーバーライドメソッドを型安全に実装する方法

TypeScriptにおいて、オブジェクト指向プログラミングの一部であるクラスは、コードを整理しやすくし、再利用性を高める強力な手段です。特にメソッドのオーバーライドは、親クラスの動作を変更するための重要な技術です。しかし、型安全性を確保しないと、予期しないエラーやバグを引き起こす可能性があります。本記事では、TypeScriptでクラスのメソッドをオーバーライドする際に、型安全に実装する方法について詳しく解説します。開発の質を向上させるため、最新の機能も含めて学んでいきましょう。

TypeScriptの基本的なクラス構造

TypeScriptでは、クラスを使用してオブジェクト指向プログラミングを実現します。クラスは、プロパティやメソッドを持つオブジェクトの設計図として機能し、インスタンス化して利用することが可能です。以下のコードは、TypeScriptにおける基本的なクラスの定義例です。

class Animal {
  name: string;

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

  speak(): void {
    console.log(`${this.name} makes a sound.`);
  }
}

この例では、Animalというクラスが定義され、nameプロパティとconstructorメソッド、そしてメソッドspeak()が含まれています。クラスのインスタンスを生成し、プロパティやメソッドにアクセスすることで、オブジェクトを操作します。

const dog = new Animal('Dog');
dog.speak(); // 出力: Dog makes a sound.

このように、クラスはオブジェクトの作成と管理を効率化します。次に、クラスの継承とメソッドのオーバーライドについて解説していきます。

メソッドオーバーライドの基本概念

メソッドオーバーライドとは、親クラスで定義されたメソッドを子クラスで再定義し、異なる動作を実装する機能です。これにより、親クラスから継承したメソッドを子クラスのニーズに合わせて変更できます。

オーバーライドを行う場合、基本的なメソッド名やシグネチャ（引数や戻り値の型）は親クラスと同じである必要があります。しかし、メソッドの内部実装を子クラスで変更することができるため、異なる動作を提供することが可能です。

以下は、メソッドオーバーライドの基本的な例です。

class Animal {
  name: string;

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

  speak(): void {
    console.log(`${this.name} makes a sound.`);
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name);
  }

  // 親クラスのspeakメソッドをオーバーライド
  speak(): void {
    console.log(`${this.name} barks.`);
  }
}

ここでは、DogクラスがAnimalクラスを継承しています。DogクラスでAnimalのメソッドspeak()をオーバーライドし、"barks"という動作に変更しています。

const dog = new Dog('Rex');
dog.speak(); // 出力: Rex barks.

メソッドオーバーライドは、継承を活用して再利用性を高めながら、特定のクラスに固有の振る舞いを実装するための強力な手段です。次に、オーバーライド時に型安全性を確保する重要性について解説します。

オーバーライドにおける型の重要性

TypeScriptにおけるオーバーライドでは、型の一貫性を保つことが非常に重要です。なぜなら、型が正しく管理されていないと、ランタイムエラーや予期しない動作を引き起こす可能性があるからです。特に、親クラスと子クラス間で異なる型を扱う場合、型の互換性を確保することが不可欠です。

例えば、メソッドの引数や戻り値の型が親クラスと子クラスで一致していない場合、意図しないエラーが発生することがあります。TypeScriptの型システムは、開発者にエラーを事前に警告することができるため、これを活用して型の安全性を担保する必要があります。

型安全でないオーバーライドの例

以下は、型を無視したオーバーライドの例です。

class Animal {
  name: string;

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

  speak(): string {
    return `${this.name} makes a sound.`;
  }
}

class Dog extends Animal {
  // 戻り値の型が親クラスと異なる
  speak(): number {
    return 42; // 意図しない戻り値
  }
}

この例では、Animalクラスのメソッドspeak()はstringを返すように設計されていますが、Dogクラスではnumberを返すようにオーバーライドされています。これは、動作としては一見エラーがないように見えても、実際には期待される型と異なる結果を返してしまうため、意図しない不具合を生じさせる可能性があります。

型安全なオーバーライドの実装

オーバーライドの際には、親クラスで定義されたメソッドの型を正しく引き継ぎ、型の一貫性を保つことが重要です。以下は、型安全なオーバーライドの例です。

class Dog extends Animal {
  speak(): string {
    return `${this.name} barks.`;
  }
}

このように、メソッドの引数や戻り値の型が親クラスと一致しているため、型安全なオーバーライドが実現されています。

型の整合性を保つことで、コードの信頼性とメンテナンス性が向上します。次に、具体的な型定義の方法について詳しく見ていきます。

オーバーライドメソッドの型定義の方法

TypeScriptでは、オーバーライドする際に親クラスと同じ型を厳密に継承することが型安全性を保つ鍵となります。親クラスで定義されたメソッドと同じ引数と戻り値の型を維持することで、オーバーライドされたメソッドの挙動を予測可能にし、意図しないエラーを防ぐことができます。

型定義の基本ルール

親クラスと子クラスで、次の点を一致させることが重要です。

1. 引数の型と数
   親クラスで定義されている引数の型や数は、子クラスでも厳密に一致させる必要があります。
2. 戻り値の型
   戻り値の型も親クラスと一致する必要があります。異なる型を返してしまうと、型安全性が失われるため注意が必要です。

基本的な型定義の例

以下は、型定義を意識した親クラスと子クラスのオーバーライド例です。

class Animal {
  name: string;

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

  speak(sound: string): string {
    return `${this.name} makes a ${sound} sound.`;
  }
}

class Dog extends Animal {
  // 親クラスと同じ引数と戻り値の型を維持
  speak(sound: string): string {
    return `${this.name} barks with a ${sound} sound.`;
  }
}

ここでは、Animalクラスのメソッドspeak()は引数としてsoundというstring型の値を受け取り、戻り値としてstringを返します。Dogクラスでも、この引数と戻り値の型を完全に一致させることで、型安全性が保証されています。

異なる型を使用する場合

親クラスと異なる型を子クラスで使いたい場合には、型の互換性を考慮しなければなりません。たとえば、引数や戻り値の型をサブタイプにすることは可能です。次の例では、より具体的な型を用いたオーバーライドを示しています。

class Animal {
  name: string;

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

  move(distance: number): string {
    return `${this.name} moved ${distance} meters.`;
  }
}

class Bird extends Animal {
  // 親クラスの引数より狭い範囲の型を使用
  move(distance: 1 | 2 | 3): string {
    return `${this.name} flew ${distance} meters.`;
  }
}

このように、引数の型をサブタイプにすることが可能であり、これは型の互換性を保ちながら、子クラス固有の振る舞いを追加する方法の一例です。

このような型定義のルールに従うことで、オーバーライドメソッドの型安全性を確保できます。次に、TypeScript 4.3で導入されたoverrideキーワードを使った型安全なオーバーライドの方法を解説します。

TypeScriptにおける`override`キーワードの使い方

TypeScript 4.3以降では、クラスのメソッドをオーバーライドする際にoverrideキーワードを使うことが推奨されています。このキーワードは、子クラスで親クラスのメソッドを正しくオーバーライドしていることをコンパイラに明示する役割を果たします。

なぜoverrideキーワードが重要か

overrideキーワードを使うことで、次のような利点があります。

1. オーバーライドが保証される
   子クラスでメソッドを定義するとき、overrideキーワードを使うと、そのメソッドが確実に親クラスに存在するメソッドをオーバーライドしていることをコンパイラが確認します。もし親クラスに該当するメソッドが存在しなければ、エラーが発生します。
2. 予期しないメソッドの再定義を防止
   overrideを使用しない場合、親クラスに存在しないメソッド名を誤って子クラスで定義してしまう可能性がありますが、overrideを付けることでこれを防ぐことができます。

overrideキーワードの使い方

以下のコードは、overrideキーワードを使用した例です。

class Animal {
  name: string;

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

  speak(): string {
    return `${this.name} makes a sound.`;
  }
}

class Dog extends Animal {
  // 'override' キーワードを使用してオーバーライドを明示
  override speak(): string {
    return `${this.name} barks.`;
  }
}

この例では、Dogクラスのメソッドspeak()にoverrideキーワードを付けています。これにより、Dogクラスのメソッドspeak()は親クラスで定義されたメソッドspeak()を正しくオーバーライドしていることが保証されます。

overrideを使わない場合のリスク

overrideを使わない場合、メソッドが親クラスのものを正しくオーバーライドしていないことに気付かない可能性があります。例えば、タイポによって誤ったメソッド名を使ってしまうと、オーバーライドされず新しいメソッドが定義されてしまいます。

class Dog extends Animal {
  // タイポにより、実際にはオーバーライドされない
  speakk(): string {
    return `${this.name} barks.`;
  }
}

上記のコードでは、speakk()という誤ったメソッド名が定義されているため、Animalクラスのメソッドspeak()はオーバーライドされず、新しいメソッドとして扱われてしまいます。しかし、overrideキーワードを使用していれば、このようなミスはコンパイル時に検出され、エラーとして通知されます。

まとめ

overrideキーワードを使うことで、オーバーライドの正確さと型安全性をさらに強化することができます。特に大規模なプロジェクトや複雑な継承構造の中では、予期しないバグを防ぐために役立ちます。次に、型の継承と互換性について詳しく説明します。

型の継承と互換性

TypeScriptにおけるクラスの継承では、親クラスのメソッドやプロパティをそのまま子クラスで使用するだけでなく、オーバーライドして独自の処理を追加できます。オーバーライド時に重要なのが、親クラスと子クラス間の型の互換性です。型の継承が正しく行われていれば、メソッドのオーバーライドにおいても型安全性が維持されます。

型の互換性とは

型の互換性とは、親クラスで定義された型が子クラスでも問題なく利用できる状態のことを指します。TypeScriptでは、親クラスのメソッドが受け取る引数や戻り値の型が、子クラスの同じメソッドでも適用可能かどうかを検証します。互換性がない場合、エラーが発生し、意図しない動作を回避できます。

サブタイプとスーパータイプ

TypeScriptの型システムでは、サブタイプとスーパータイプの概念が存在します。

• スーパータイプは、より汎用的な型であり、すべてのサブタイプを包含します。
• サブタイプは、スーパータイプを具体的にした型であり、スーパータイプを持つプロパティやメソッドを利用できます。

例えば、number型はany型のサブタイプであり、any型はnumber型のスーパータイプです。

型の互換性を保ったオーバーライドの例

親クラスと子クラスのメソッドで型の互換性を保つためには、子クラスでメソッドをオーバーライドする際に、親クラスの型定義を厳密に遵守する必要があります。

class Animal {
  move(distance: number): string {
    return `Animal moved ${distance} meters.`;
  }
}

class Dog extends Animal {
  // オーバーライドしても引数や戻り値の型は親クラスと同じ
  move(distance: number): string {
    return `Dog ran ${distance} meters.`;
  }
}

この例では、Animalクラスのメソッドmove()と、Dogクラスのオーバーライドされたメソッドmove()が、引数の型（number）および戻り値の型（string）が一致しているため、型の互換性が保たれています。

型の互換性がない場合のリスク

型の互換性が保たれない場合、オーバーライドが正しく機能せず、エラーが発生する可能性があります。たとえば、引数の型が親クラスと異なる場合、コンパイル時にエラーが発生します。

class Bird extends Animal {
  // 親クラスと異なる型でオーバーライドしようとする
  move(distance: string): string {
    return `Bird flew ${distance} meters.`;
  }
}

// エラー: 'move' メソッドは 'Animal' のメソッドをオーバーライドしていません

このように、オーバーライドするメソッドで親クラスのメソッドと異なる型を使用する場合、TypeScriptは型の不整合を検出し、エラーを報告します。これにより、意図しないバグを事前に防ぐことができます。

まとめ

型の継承と互換性を維持することは、オーバーライドの際に型安全性を保証するために非常に重要です。特に、大規模なプロジェクトでは、この型の整合性が保たれることでメンテナンス性が向上し、バグを未然に防ぐことができます。次に、型安全なオーバーライドの具体的な実装例を見ていきます。

実際のコード例：型安全なオーバーライドの実装

ここでは、TypeScriptで型安全にオーバーライドを実装するための具体的なコード例を示します。オーバーライドを行う際、親クラスのメソッドの型を子クラスで正確に継承し、互換性を保ちながら独自の振る舞いを追加する方法を実践的に学んでいきます。

例1: 基本的な型安全なオーバーライド

以下の例では、親クラスで定義されたメソッドの型を厳密に継承して、子クラスでオーバーライドしています。

class Animal {
  name: string;

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

  // 親クラスのspeakメソッド
  speak(): string {
    return `${this.name} makes a sound.`;
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name);
  }

  // オーバーライド: 親クラスと同じ引数と戻り値の型を使用
  override speak(): string {
    return `${this.name} barks.`;
  }
}

const myDog = new Dog("Rex");
console.log(myDog.speak()); // 出力: Rex barks.

このコードでは、DogクラスがAnimalクラスを継承し、speak()メソッドをオーバーライドしています。引数や戻り値の型は親クラスの型と一致しており、型安全なオーバーライドが行われています。

例2: 型を拡張したオーバーライド

次に、親クラスのメソッドで使われている型を拡張するケースを紹介します。TypeScriptでは、子クラスのメソッドで親クラスの型をサブタイプに拡張することが許可されています。以下の例では、引数の型を特定の数値リテラルに制限しています。

class Animal {
  move(distance: number): string {
    return `${this.constructor.name} moved ${distance} meters.`;
  }
}

class Bird extends Animal {
  // 引数の型をサブタイプ（1, 2, 3の数値リテラル）に制限
  override move(distance: 1 | 2 | 3): string {
    return `${this.constructor.name} flew ${distance} meters.`;
  }
}

const myBird = new Bird();
console.log(myBird.move(2)); // 出力: Bird flew 2 meters.
// console.log(myBird.move(5)); // コンパイルエラー: '5' は引数型に適合しない

この例では、Birdクラスのメソッドmove()の引数が親クラスのnumber型よりも狭い範囲（1 | 2 | 3）に制限されています。このように、サブタイプを使って特定の型に制限することが可能ですが、親クラスで許可されている範囲よりも広げることはできません。

例3: 複数のオーバーライドメソッド

複雑な継承構造において、複数のメソッドをオーバーライドする場合もあります。以下の例では、親クラスの2つのメソッドをオーバーライドしています。

class Animal {
  name: string;

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

  speak(): string {
    return `${this.name} makes a sound.`;
  }

  move(distance: number): string {
    return `${this.name} moved ${distance} meters.`;
  }
}

class Cat extends Animal {
  constructor(name: string) {
    super(name);
  }

  // 複数のメソッドをオーバーライド
  override speak(): string {
    return `${this.name} meows.`;
  }

  override move(distance: number): string {
    return `${this.name} prowled ${distance} meters.`;
  }
}

const myCat = new Cat("Whiskers");
console.log(myCat.speak()); // 出力: Whiskers meows.
console.log(myCat.move(5)); // 出力: Whiskers prowled 5 meters.

この例では、CatクラスでAnimalクラスのメソッドspeak()とメソッドmove()の両方をオーバーライドしています。オーバーライドされたメソッドは、それぞれ異なる動作を持っていますが、引数や戻り値の型は親クラスと一致しているため、型安全な実装になっています。

まとめ

これらの例から、TypeScriptにおける型安全なオーバーライドの方法を理解できたでしょう。親クラスの型を正確に継承することで、意図しないエラーを防ぎ、コードの信頼性を高めることができます。次に、型エラーやランタイムエラーを回避するためのベストプラクティスを紹介します。

エラー回避のためのベストプラクティス

型安全なオーバーライドを実現するためには、TypeScriptの型システムを正しく活用し、エラーを未然に防ぐ工夫が必要です。ここでは、オーバーライドにおける型エラーやランタイムエラーを回避するためのベストプラクティスをいくつか紹介します。

1. overrideキーワードを必ず使用する

TypeScript 4.3以降では、オーバーライドするメソッドには必ずoverrideキーワードを付けることが推奨されています。これにより、親クラスに対応するメソッドが存在しない場合にエラーが発生し、意図しないオーバーライドミスを防げます。

class Animal {
  speak(): string {
    return "Animal sound";
  }
}

class Dog extends Animal {
  override speak(): string { // 必ず 'override' を使用
    return "Dog barks";
  }
}

2. 型定義を親クラスと一致させる

オーバーライドメソッドでは、引数や戻り値の型を親クラスのメソッドと一致させることが基本です。型の違いはコンパイルエラーやランタイムエラーの原因となります。特に、引数や戻り値の型を変更したくなった場合は、型の継承やサブタイプの使用を検討しましょう。

class Animal {
  move(distance: number): void {
    console.log(`Animal moved ${distance} meters.`);
  }
}

class Bird extends Animal {
  override move(distance: number): void { // 型は親クラスと一致
    console.log(`Bird flew ${distance} meters.`);
  }
}

3. 型アサーションを避ける

型アサーション（型キャスト）を乱用すると、TypeScriptの型安全性が崩れ、ランタイムエラーを引き起こす原因となります。特にオーバーライドの際には、型アサーションに頼らず、型推論や型定義を厳密に行うことが重要です。

class Animal {
  speak(): string {
    return "Animal sound";
  }
}

class Dog extends Animal {
  override speak(): string {
    // 型アサーションを避け、正確な型を使う
    return "Dog barks";
  }
}

4. インターフェースや抽象クラスの活用

大規模なプロジェクトでは、インターフェースや抽象クラスを使って型安全性を強化することが有効です。親クラスでインターフェースや抽象クラスを定義し、子クラスでその型に従って実装することで、オーバーライド時の型の一貫性を確保できます。

interface AnimalInterface {
  speak(): string;
}

class Animal implements AnimalInterface {
  speak(): string {
    return "Animal sound";
  }
}

class Dog extends Animal {
  override speak(): string {
    return "Dog barks";
  }
}

5. 型チェックツールの導入

TypeScript自体の型システムに加えて、ESLintやTSLintのような型チェックツールを使用すると、潜在的な型の不整合やミスを検出しやすくなります。これらのツールは、プロジェクト全体の型整合性を保つために有効です。

6. ストリクトモードを有効にする

TypeScriptのstrictモードを有効にすることで、型安全性がより厳密に検査されます。これにより、潜在的な型エラーを事前に防ぐことができ、型安全なオーバーライドを保証できます。

{
  "compilerOptions": {
    "strict": true
  }
}

まとめ

型安全なオーバーライドを実現するためには、overrideキーワードの利用、型定義の正確な継承、型アサーションの回避など、いくつかのベストプラクティスに従うことが重要です。これらの対策を講じることで、オーバーライドに伴うエラーや予期しない動作を未然に防ぎ、堅牢でメンテナブルなコードを書くことができます。次に、オーバーライドの実装を試すための演習問題を紹介します。

演習問題：オーバーライドメソッドの実装

ここでは、型安全なオーバーライドメソッドの実装をより深く理解するために、いくつかの演習問題を提供します。これらの問題に取り組むことで、オーバーライドと型安全性の重要な概念を実践的に学ぶことができます。

演習1: 基本的なオーバーライドの実装

次のコードを完成させ、DogクラスでAnimalクラスのメソッドspeak()をオーバーライドしてください。Dogクラスでは、"barks"というメッセージを返すようにします。

class Animal {
  name: string;

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

  speak(): string {
    return `${this.name} makes a sound.`;
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name);
  }

  // ここにメソッドを追加してください
}

const myDog = new Dog("Buddy");
console.log(myDog.speak()); // 出力: "Buddy barks."

ポイント:

• overrideキーワードを使用すること。
• 親クラスの型に合ったメソッドを定義すること。

演習2: 型を拡張したオーバーライド

次のコードを修正し、Birdクラスでmove()メソッドをオーバーライドしてください。Birdクラスでは、move()メソッドの引数として1 | 2 | 3の数値リテラルを受け取り、それに基づいて出力するようにします。

class Animal {
  move(distance: number): string {
    return `Animal moved ${distance} meters.`;
  }
}

class Bird extends Animal {
  // ここにメソッドを追加してください
}

const myBird = new Bird();
console.log(myBird.move(2)); // 出力: "Bird flew 2 meters."

ポイント:

• 引数の型をサブタイプ（1 | 2 | 3）に制限すること。
• 親クラスの戻り値型（string）を維持すること。

演習3: 複数のオーバーライドメソッド

次に示すCatクラスには、speak()とmove()の2つのメソッドがあります。これらのメソッドをAnimalクラスからオーバーライドし、それぞれが適切なメッセージを出力するようにしてください。

class Animal {
  name: string;

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

  speak(): string {
    return `${this.name} makes a sound.`;
  }

  move(distance: number): string {
    return `${this.name} moved ${distance} meters.`;
  }
}

class Cat extends Animal {
  constructor(name: string) {
    super(name);
  }

  // ここに2つのメソッドをオーバーライドしてください
}

const myCat = new Cat("Whiskers");
console.log(myCat.speak()); // 出力: "Whiskers meows."
console.log(myCat.move(5)); // 出力: "Whiskers prowled 5 meters."

ポイント:

• speak()では猫の鳴き声（meows）を返すようにする。
• move()では「歩く」または「歩み寄る」動作を表す適切な動詞を使用する。

演習4: 親クラスを抽象クラスとして定義

Animalクラスを抽象クラスとして定義し、DogクラスとCatクラスでspeak()メソッドを具体的に実装してください。Animalクラスのmove()メソッドはそのまま継承します。

abstract class Animal {
  name: string;

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

  abstract speak(): string;

  move(distance: number): string {
    return `${this.name} moved ${distance} meters.`;
  }
}

class Dog extends Animal {
  // ここにspeakメソッドを実装してください
}

class Cat extends Animal {
  // ここにspeakメソッドを実装してください
}

const myDog = new Dog("Rex");
console.log(myDog.speak()); // 出力: "Rex barks."
console.log(myDog.move(10)); // 出力: "Rex moved 10 meters."

const myCat = new Cat("Whiskers");
console.log(myCat.speak()); // 出力: "Whiskers meows."
console.log(myCat.move(3)); // 出力: "Whiskers moved 3 meters."

ポイント:

• abstractキーワードを正しく使用し、抽象メソッドを子クラスで実装する。
• 抽象クラスをインスタンス化しないようにする。

まとめ

これらの演習を通して、型安全なオーバーライドの実装方法を身に付けられるでしょう。特に、親クラスの型を尊重しながら、子クラス固有のロジックを適切に追加することが重要です。これらの演習に取り組むことで、オーバーライドに関する理解を深め、実践的なスキルを向上させてください。次に、よくある間違いとその解決方法について説明します。

よくある間違いとその解決方法

TypeScriptにおけるオーバーライドの実装では、特に初心者が犯しやすい間違いがあります。ここでは、よく見られるエラーや誤解を紹介し、それをどのように解決できるかを説明します。

1. 親クラスのメソッドをオーバーライドせずに新規メソッドを作成する

TypeScriptでは、親クラスのメソッドを正しくオーバーライドしていない場合、子クラスに同じ名前の新しいメソッドを定義してしまうことがあります。この問題は、overrideキーワードを使わない場合によく発生します。

よくある間違い

class Animal {
  speak(): string {
    return "Animal sound";
  }
}

class Dog extends Animal {
  // 'speak' にタイポがあるため、オーバーライドされていない
  speek(): string {
    return "Dog barks";
  }
}

この例では、メソッド名がタイポされており、実際にはオーバーライドされていません。speek()は新しいメソッドとして扱われ、Animalのspeak()メソッドはそのままです。

解決方法

overrideキーワードを使うことで、親クラスに存在しないメソッド名が指定された場合にエラーを発生させることができます。

class Dog extends Animal {
  override speak(): string {
    return "Dog barks";
  }
}

このようにoverrideを使うことで、誤ったオーバーライドを防ぐことができます。

2. オーバーライド時に型を変更してしまう

オーバーライドする際、引数や戻り値の型が親クラスの型と一致していない場合、型エラーが発生します。これは、親クラスのメソッドの型定義を守らないことによるものです。

よくある間違い

class Animal {
  move(distance: number): string {
    return `Animal moved ${distance} meters.`;
  }
}

class Bird extends Animal {
  // 親クラスと異なる型を使用している
  override move(distance: string): string {
    return `Bird flew ${distance}.`;
  }
}

ここでは、Birdクラスでmove()の引数の型をstringに変更しているため、コンパイルエラーが発生します。

解決方法

親クラスのメソッドの型を正しく継承し、引数と戻り値の型が一致するように修正します。

class Bird extends Animal {
  override move(distance: number): string {
    return `Bird flew ${distance} meters.`;
  }
}

3. 親クラスのメソッドを呼び出さない

オーバーライドしたメソッドで、親クラスの処理をそのまま利用したい場合、superを使って親クラスのメソッドを呼び出すことができます。しかし、superを忘れることで、意図しない挙動になることがあります。

よくある間違い

class Animal {
  move(distance: number): string {
    return `Animal moved ${distance} meters.`;
  }
}

class Dog extends Animal {
  override move(distance: number): string {
    // 親クラスの処理が実行されない
    return `Dog ran ${distance} meters.`;
  }
}

この例では、Animalクラスのmove()メソッドの動作が完全に無視されています。

解決方法

superを使って親クラスのメソッドを呼び出すことで、親クラスの処理を引き継ぎつつ、追加の動作を定義できます。

class Dog extends Animal {
  override move(distance: number): string {
    return `${super.move(distance)} Dog ran quickly.`;
  }
}

4. 型の互換性を無視する

子クラスで親クラスよりも広い型や無関係な型を使用すると、型の互換性が失われ、エラーが発生します。

よくある間違い

class Animal {
  move(distance: number): string {
    return `Animal moved ${distance} meters.`;
  }
}

class Fish extends Animal {
  // 型が互換性を持たない
  override move(distance: boolean): string {
    return `Fish swam ${distance ? "far" : "near"}.`;
  }
}

この例では、boolean型の引数を受け取るmove()メソッドは、親クラスのnumber型と互換性がないためエラーになります。

解決方法

型の互換性を保つため、親クラスと同じ型定義を使用するか、サブタイプを指定します。

class Fish extends Animal {
  override move(distance: number): string {
    return `Fish swam ${distance} meters.`;
  }
}

まとめ

これらのよくある間違いを避けることで、型安全なオーバーライドを実装することができます。overrideキーワードの使用や、型の互換性を意識したコーディングにより、エラーを防ぎ、堅牢なコードを構築しましょう。次に、この記事のまとめを行います。

まとめ

本記事では、TypeScriptにおけるクラスのオーバーライドメソッドを型安全に実装するための方法とその重要性について解説しました。overrideキーワードを活用することで、意図しないミスを防ぎ、型安全なコードを実現できます。また、親クラスと子クラスの間で型の互換性を保つことが、エラーを回避し、堅牢なコードを維持するための重要なポイントです。演習問題やよくある間違いを通じて、実践的なスキルを身に付けることができたでしょう。型安全性を確保しながら、柔軟でメンテナブルなオーバーライドを行うことが、プロジェクトの成功に繋がります。