MENU
  1. ホーム
  2. TypeScript
  3. TypeScriptでアクセス指定子を使ったサブクラスの安全なメソッドオーバーライド方法

TypeScriptでアクセス指定子を使ったサブクラスの安全なメソッドオーバーライド方法

TypeScript

TypeScriptでオブジェクト指向プログラミングを行う際、サブクラスによるメソッドのオーバーライドは非常に重要です。しかし、適切に管理しなければ、コードの可読性や保守性が低下し、バグが発生するリスクが高まります。TypeScriptは、アクセス指定子（public、private、protected）を使うことで、クラス間のアクセス範囲を制御し、安全で効率的なオーバーライドを可能にします。本記事では、アクセス指定子の基本から、具体的なオーバーライド方法までを順を追って解説し、安全で管理しやすいコードを書くための方法を紹介します。

目次

TypeScriptのアクセス指定子とは

TypeScriptでは、クラスのメンバー（プロパティやメソッド）に対してアクセス制御を行うためにアクセス指定子が使用されます。これにより、外部からのアクセスを制限し、クラスの設計における安全性や一貫性を保つことができます。TypeScriptには主に3つのアクセス指定子が存在します。

public

publicはデフォルトの指定子で、クラスの外部からでも自由にアクセスできることを意味します。特に指定がない場合、メンバーはpublicとして扱われます。

private

privateは、そのメンバーがクラスの内部からしかアクセスできないことを意味します。他のクラスやサブクラスからはアクセスできず、外部からの誤用を防ぎます。

protected

protectedは、クラス自身とそのサブクラスのみがアクセスできることを示します。サブクラスでメソッドをオーバーライドする際に特に役立ちます。

これらの指定子を適切に使うことで、クラス設計の安全性を向上させ、コードの可読性を高めることが可能です。

サブクラスでのメソッドオーバーライド

メソッドオーバーライドとは、親クラス（スーパークラス）で定義されたメソッドを、サブクラスで再定義し、異なる動作を実装することを指します。TypeScriptでは、アクセス指定子の影響を受けながら、このオーバーライドを行うことができます。これにより、サブクラス固有の処理を実装しつつ、親クラスの基本機能を維持することが可能です。

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

サブクラスでメソッドをオーバーライドする際、親クラスで定義されたメソッドと同じ名前、引数、返り値の型を持つ必要があります。この際、親クラスのメソッドを呼び出す場合にはsuperキーワードを使用します。

class Animal {
  public sound(): void {
    console.log("Some generic sound");
  }
}

class Dog extends Animal {
  public sound(): void {
    console.log("Bark");
  }
}

const dog = new Dog();
dog.sound(); // "Bark"

上記の例では、DogクラスがAnimalクラスのsoundメソッドをオーバーライドしています。

アクセス指定子の影響

オーバーライドを行う際、親クラスのメソッドに付与されたアクセス指定子はサブクラスにも引き継がれます。例えば、privateなメソッドはサブクラスでオーバーライドできませんが、protectedやpublicなメソッドはオーバーライド可能です。

アクセス指定子に注意することで、安全なクラス設計とオーバーライドが可能になります。

protected指定子を用いた安全なオーバーライド

protected指定子は、親クラスとサブクラスの間でメソッドやプロパティを共有しながら、外部からのアクセスを制限するために非常に有用です。この指定子を使うことで、親クラスの機能を拡張しつつ、サブクラスの内部構造を保護し、外部からの誤用を防ぐことができます。

protectedの基本

protectedとして定義されたメンバーは、親クラスとそのサブクラスからのみアクセス可能です。これは、privateのように外部からのアクセスを制限しつつ、publicのようにサブクラスからの継承やオーバーライドを許可する中間的なアクセス制御を提供します。

class Animal {
  protected move(): void {
    console.log("Animal is moving");
  }
}

class Dog extends Animal {
  public move(): void {
    console.log("Dog is running");
  }
}

const dog = new Dog();
dog.move(); // "Dog is running"

この例では、Animalクラスのmoveメソッドはprotectedで定義されていますが、Dogクラスでオーバーライドされています。外部から直接Animalクラスのmoveメソッドにアクセスすることはできませんが、サブクラスでオーバーライドされたメソッドは利用可能です。

protectedを使った安全なオーバーライドのメリット

  1. サブクラスでの柔軟な拡張：サブクラスは親クラスのメソッドをオーバーライドし、独自の処理を追加できますが、外部からは直接操作されません。
  2. カプセル化の強化：protectedを使うことで、クラスの内部実装を隠し、外部から誤ったアクセスを防ぐことができます。特に、サブクラスでオーバーライドされたメソッドが外部から不必要に呼び出されるのを防ぐのに役立ちます。

このように、protected指定子はクラス設計において柔軟性と安全性を両立させる重要な役割を果たします。

privateメソッドのオーバーライドの制限

private指定子を持つメソッドやプロパティは、クラス内部でのみアクセス可能です。つまり、サブクラスを含めて外部のどのクラスからもアクセスできません。そのため、privateとして定義されたメソッドは、サブクラスでオーバーライドすることができないという制限があります。この制限は、クラスの内部実装を完全に隠蔽し、予期しない挙動や誤用を防ぐために設けられています。

privateメソッドの定義

privateメソッドはクラス内の機能を実装するために使用され、外部からは直接操作されることはありません。そのため、他のクラスやサブクラスがprivateメソッドにアクセスしたり、変更したりすることはできません。

class Animal {
  private eat(): void {
    console.log("Eating food");
  }
}

class Dog extends Animal {
  // Error: 'eat' is private and only accessible within class 'Animal'
  private eat(): void {
    console.log("Dog is eating");
  }
}

このコードでは、Animalクラスのeatメソッドはprivateとして定義されているため、Dogクラスでオーバーライドしようとするとエラーが発生します。

設計上の注意点

privateメソッドは強力なカプセル化を提供しますが、その反面、サブクラスでのオーバーライドや拡張が制限されます。そのため、サブクラスでの拡張を前提とした設計では、privateの代わりにprotectedを使用することが推奨されます。

privateを使う場合の利点

  1. 内部実装の保護：privateを使うことで、クラス内部の実装を完全に隠蔽し、外部の変更やアクセスを防ぎます。
  2. 安全性の向上：サブクラスや他のクラスから誤ってメソッドがオーバーライドされたり、呼び出されたりするリスクを防ぎます。

このように、privateメソッドは特定の状況で有用ですが、サブクラスでのオーバーライドを考慮する場合は慎重に設計する必要があります。

publicメソッドのオーバーライドと注意点

public指定子を持つメソッドは、クラス外部からも自由にアクセスでき、サブクラスでもオーバーライドが可能です。publicメソッドのオーバーライドは、クラスの柔軟な拡張を可能にしますが、注意点を踏まえたうえで実装する必要があります。

publicメソッドのオーバーライド

publicメソッドは、親クラスで定義された機能をサブクラスで再定義し、クラス固有の振る舞いを実装するために利用されます。オーバーライドによって、サブクラスの動作をカスタマイズできます。

class Animal {
  public sound(): void {
    console.log("Some generic sound");
  }
}

class Dog extends Animal {
  public sound(): void {
    console.log("Bark");
  }
}

const dog = new Dog();
dog.sound(); // "Bark"

この例では、DogクラスがAnimalクラスのsoundメソッドをpublicとしてオーバーライドしています。親クラスのsoundメソッドは一般的な音を出しますが、サブクラスでは具体的な動作に置き換えられています。

オーバーライド時の注意点

publicメソッドをオーバーライドする際には、いくつかのリスクや注意点が存在します。

1. 親クラスの動作を尊重する

オーバーライドは親クラスの機能を変更できる反面、親クラスの意図する動作や仕様を大きく逸脱しないようにすることが重要です。誤った実装はクラスの一貫性を損ない、予期しないバグを引き起こす可能性があります。

2. 一貫性の確保

親クラスのメソッドをオーバーライドする際、元のメソッドの署名（引数や返り値の型）を守る必要があります。TypeScriptは型チェックを行うため、不一致がある場合にはエラーが発生します。

class Animal {
  public move(speed: number): void {
    console.log(`Animal moves at ${speed} km/h`);
  }
}

class Dog extends Animal {
  // Error: Argument type 'string' is not assignable to parameter type 'number'
  public move(speed: string): void {
    console.log(`Dog runs at ${speed}`);
  }
}

この例では、親クラスのmoveメソッドがnumber型の引数を取るにもかかわらず、サブクラスではstring型の引数を取ろうとしてエラーが発生しています。

3. 基底メソッドの呼び出し

場合によっては、オーバーライドしたメソッド内で親クラスのメソッドを呼び出す必要があることがあります。この場合、superを使って親クラスのメソッドを呼び出すことができます。

class Animal {
  public sound(): void {
    console.log("Some generic sound");
  }
}

class Dog extends Animal {
  public sound(): void {
    super.sound();
    console.log("Bark");
  }
}

const dog = new Dog();
dog.sound(); // "Some generic sound", "Bark"

このコードでは、DogクラスがAnimalクラスのsoundメソッドを呼び出した後、独自の動作を追加しています。

publicメソッドオーバーライドのメリット

  1. 柔軟なクラス設計：オーバーライドにより、クラスの動作をサブクラスごとに異なる形で実装でき、柔軟な設計が可能です。
  2. 再利用性の向上：親クラスのコードを再利用しつつ、新たな機能を追加することで、コードのメンテナンス性が向上します。

publicメソッドのオーバーライドは強力な機能ですが、適切に使用しなければ設計の一貫性が失われるリスクがあるため、慎重な設計が求められます。

オーバーライド時の型安全性

TypeScriptは静的型付け言語であり、型安全性を確保することに重点を置いています。メソッドをオーバーライドする際に、親クラスで定義されたメソッドのシグネチャ（引数や戻り値の型）を守ることで、コードの信頼性とメンテナンス性が向上します。ここでは、オーバーライド時の型安全性について、基本的な原則とその重要性を解説します。

型の一致が重要な理由

メソッドオーバーライドでは、親クラスで定義されたメソッドとサブクラスでのメソッドのシグネチャが一致している必要があります。TypeScriptは、この型の一致を厳密にチェックすることで、以下のメリットを提供します。

1. 型の一貫性によるエラー防止

異なる型を持つ引数や戻り値をオーバーライドしようとすると、TypeScriptはコンパイル時にエラーを発生させます。これにより、実行時の予期しないバグを事前に防ぐことが可能です。

class Animal {
  public makeSound(volume: number): void {
    console.log(`Making sound at volume ${volume}`);
  }
}

class Dog extends Animal {
  // Error: Argument type 'string' is not assignable to parameter type 'number'
  public makeSound(volume: string): void {
    console.log(`Dog barks at volume ${volume}`);
  }
}

この例では、親クラスのmakeSoundメソッドがnumber型の引数を受け取るように定義されていますが、サブクラスではstring型の引数を指定したためエラーが発生します。

2. 明確なインターフェースの維持

型安全性が確保されている場合、コードのインターフェースが明確に保たれるため、他の開発者や将来的なメンテナンス作業が容易になります。親クラスで定義されたインターフェースに基づいて、サブクラスでも一貫した動作が期待できるため、予測可能な振る舞いが維持されます。

戻り値の型安全性

オーバーライドするメソッドの戻り値の型も、親クラスとサブクラスで一致している必要があります。型の不一致があると、TypeScriptはエラーを発生させるため、メソッドの呼び出し時に予期しない戻り値の型を受け取るリスクを防ぎます。

class Animal {
  public getSpeed(): number {
    return 30;
  }
}

class Dog extends Animal {
  // Error: Return type 'string' is not assignable to return type 'number'
  public getSpeed(): string {
    return "fast";
  }
}

この例では、getSpeedメソッドの戻り値の型がnumberであるべきところをstringに変更しようとしたため、エラーが発生しています。

型安全性を保つためのベストプラクティス

オーバーライド時に型の安全性を確保するためには、次のベストプラクティスを守ることが重要です。

1. 親クラスのシグネチャを厳守

親クラスで定義されたメソッドのシグネチャ（引数の型、戻り値の型）をそのまま引き継ぎ、変更しないことが基本です。これは、メソッドがどのように使われるかという期待を外さないためにも重要です。

2. 型アノテーションの明示

TypeScriptでは型アノテーションを使うことで、メソッドやプロパティに明確な型を指定できます。オーバーライドする際にも型を明示することで、型の誤りや曖昧さを避けられます。

まとめ

メソッドのオーバーライドにおいて、型の一致と型安全性を守ることは、TypeScriptの静的型付けの強みを最大限に活かすために不可欠です。これにより、コードの信頼性と一貫性が確保され、開発中のバグを未然に防ぐことができます。

継承とオーバーライドの実践例

TypeScriptでの継承とメソッドオーバーライドは、クラスを柔軟に設計し、再利用性を高めるために重要な機能です。ここでは、実際のコード例を用いて、アクセス指定子を活用した安全で効果的なオーバーライドの方法を解説します。

親クラスとサブクラスの基本的な構造

以下の例は、親クラスAnimalとサブクラスDog、Catを用いた基本的な継承とオーバーライドの例です。protectedおよびpublicアクセス指定子を利用し、メソッドのオーバーライドを実装します。

class Animal {
  protected sound(): void {
    console.log("Animal makes a sound");
  }

  public move(): void {
    console.log("Animal is moving");
  }
}

class Dog extends Animal {
  // オーバーライド: protectedメソッドの上書き
  protected sound(): void {
    console.log("Dog barks");
  }

  // オーバーライド: publicメソッドの上書き
  public move(): void {
    console.log("Dog is running");
    super.move(); // 親クラスのmoveメソッドも呼び出し
  }

  public makeSound(): void {
    this.sound(); // protectedメソッドにアクセス可能
  }
}

class Cat extends Animal {
  // オーバーライド: protectedメソッドの上書き
  protected sound(): void {
    console.log("Cat meows");
  }

  public makeSound(): void {
    this.sound(); // protectedメソッドにアクセス可能
  }
}

const dog = new Dog();
dog.move(); // "Dog is running", "Animal is moving"
dog.makeSound(); // "Dog barks"

const cat = new Cat();
cat.move(); // "Animal is moving"
cat.makeSound(); // "Cat meows"

このコードでは、以下の点に注目してください。

  • 親クラスAnimalのsoundメソッドはprotectedとして定義されており、DogおよびCatクラスでオーバーライドされています。
  • moveメソッドはpublicとして定義されており、サブクラスでもオーバーライドされています。Dogクラスでは、super.move()を使って親クラスのmoveメソッドも呼び出しています。

オーバーライドの活用例

オーバーライドは、共通の基本動作を親クラスに定義し、サブクラスで具体的な振る舞いを定義する際に非常に便利です。例えば、上記の例では、Animalクラスが動物全般に共通する動作を定義し、DogやCatクラスがそれぞれの特有の動作を追加しています。

この設計により、コードの再利用性が高まり、メンテナンスが容易になります。新しい動物のクラスを追加する際も、基本的な動作（moveやsound）をオーバーライドするだけで簡単に実装できます。

protectedメソッドの活用

protectedメソッドは、サブクラスからのみアクセス可能であるため、外部に公開せずにクラス内でのロジックを拡張できます。これにより、クラス設計の柔軟性を保ちながら、クラスの内部構造を安全に保つことができます。

例えば、DogクラスやCatクラスでのmakeSoundメソッドは、親クラスのsoundメソッドをprotectedとしているため、クラス外部からは直接呼び出せませんが、サブクラス内では自由に使用できます。

実装の拡張性と柔軟性

TypeScriptの継承とメソッドオーバーライドは、基本機能の再利用と新しい機能の追加をシンプルに行えるように設計されています。これにより、コードの拡張が容易になり、将来的に新しいクラスを追加したり、既存のクラスを変更したりする際も、基本的な設計を保ちながら柔軟に対応できます。

例えば、新しい動物のクラスを追加する場合も、親クラスAnimalの構造を利用して素早く実装できるため、開発効率が向上します。

このように、継承とオーバーライドを適切に活用することで、コードの再利用性と保守性を高め、効率的なソフトウェア開発が可能になります。

オーバーライドの応用例とベストプラクティス

メソッドオーバーライドは、継承を活用したクラス設計の中心的な要素ですが、複雑なクラス構造や実装シナリオにおいて、正しく活用するための応用例やベストプラクティスを理解することが重要です。ここでは、オーバーライドの応用例を紹介し、設計のベストプラクティスを解説します。

応用例1: 親クラスの動作を補強する

オーバーライドを使用する際、親クラスで提供される基本機能を維持しつつ、追加の動作をサブクラスで補強する方法は非常に有効です。このような設計は、クラス全体の動作を一貫して保ちながら、特定のクラスにカスタム機能を追加することができます。

class Vehicle {
  public start(): void {
    console.log("Starting the vehicle...");
  }
}

class Car extends Vehicle {
  public start(): void {
    super.start(); // 親クラスのstartメソッドを呼び出し
    console.log("Car is ready to go!");
  }
}

const car = new Car();
car.start(); // "Starting the vehicle...", "Car is ready to go!"

この例では、Carクラスが親クラスVehicleのstartメソッドをオーバーライドし、基本の動作に加えて特定の振る舞い（"Car is ready to go!"）を追加しています。

応用例2: 条件付きオーバーライド

時には、サブクラスで異なる条件に基づいてオーバーライドするメソッドの動作を変更することがあります。このような状況では、親クラスのメソッドを部分的に利用しつつ、特定の状況でのカスタムロジックを適用できます。

class Device {
  public status(online: boolean): void {
    if (online) {
      console.log("Device is online.");
    } else {
      console.log("Device is offline.");
    }
  }
}

class Smartphone extends Device {
  public status(online: boolean): void {
    if (online) {
      console.log("Smartphone is online with 4G.");
    } else {
      super.status(online); // 親クラスのロジックを再利用
    }
  }
}

const phone = new Smartphone();
phone.status(true);  // "Smartphone is online with 4G."
phone.status(false); // "Device is offline."

この例では、SmartphoneクラスがDeviceクラスのstatusメソッドをオーバーライドし、特定の条件（オンライン時）で独自の動作を追加しています。オフラインの場合は親クラスのロジックをそのまま使用することで、柔軟な制御が可能になります。

ベストプラクティス1: シンプルさを保つ

オーバーライドの設計においては、メソッドの挙動を複雑にしすぎないことが重要です。特に、複数のサブクラスでオーバーライドされたメソッドが複雑になると、動作が予測しにくくなり、バグを引き起こす可能性が高まります。シンプルかつ明確な目的に沿ったオーバーライドを心がけることで、メンテナンスしやすいコードを保つことができます。

ベストプラクティス2: 継承ツリーの設計に注意

継承ツリーが深くなりすぎると、親クラスとサブクラス間の関係が複雑化し、どのメソッドがオーバーライドされているか追跡するのが困難になります。一般的には、浅い継承ツリー（2～3段階）に留め、過剰な継承を避けることが推奨されます。また、インターフェースやコンポジションを使って、クラス間の依存を緩やかにすることも重要です。

ベストプラクティス3: Liskovの置換原則を守る

Liskovの置換原則（Liskov Substitution Principle, LSP）は、親クラスのインスタンスをサブクラスのインスタンスで置き換えた場合でも、システムの振る舞いが変わらないことを保証する設計原則です。オーバーライドを行う際に、この原則を守ることで、クラスの一貫性と予測可能な動作が確保されます。

class Bird {
  public fly(): void {
    console.log("Bird is flying");
  }
}

class Penguin extends Bird {
  // オーバーライドでflyメソッドを無効にするのは、LSPに反する例
  public fly(): void {
    throw new Error("Penguins cannot fly!");
  }
}

この例では、PenguinクラスがBirdクラスを継承しながらflyメソッドの動作を大きく変えています。これはLSPに反しており、継承を使う上で避けるべき設計です。

ベストプラクティス4: 親クラスの意図を尊重する

親クラスが提供するメソッドの意図や役割を理解し、それに沿った形でオーバーライドすることが重要です。オーバーライドによって親クラスの基本的な設計を逸脱してしまうと、後でコードの一貫性が崩れ、予期しない動作が発生することがあります。親クラスの動作を拡張する形でオーバーライドを実装することが望ましいです。

これらの応用例やベストプラクティスを踏まえることで、メソッドオーバーライドを安全かつ効率的に活用でき、より柔軟で再利用性の高いコードを設計することが可能になります。

演習問題: サブクラスでのオーバーライド

オーバーライドの概念をより深く理解するために、以下の演習問題を解いてみましょう。演習を通じて、アクセス指定子とメソッドオーバーライドの使い方を実際に試すことで、TypeScriptでのクラス設計の技術を向上させることができます。

問題1: 親クラスとサブクラスの基本オーバーライド

以下のコードを完成させてください。VehicleクラスにあるstartメソッドをサブクラスCarでオーバーライドし、サブクラス固有の挙動を実装してください。また、親クラスのメソッドを利用して、サブクラスのメソッドが親クラスの動作を引き継ぐようにしましょう。

class Vehicle {
  public start(): void {
    console.log("Starting the vehicle");
  }
}

class Car extends Vehicle {
  // オーバーライドして親クラスのstartメソッドを引き継ぎつつ、追加の動作を実装
}

const myCar = new Car();
myCar.start(); // "Starting the vehicle", "Car is ready to go"

目標: Carクラスでstartメソッドをオーバーライドし、"Car is ready to go"というメッセージを追加で表示させるように実装してください。

問題2: protectedメソッドを使ったオーバーライド

次に、AnimalクラスのprotectedメソッドをサブクラスBirdでオーバーライドしてみましょう。Birdクラスでは、親クラスのmakeSoundメソッドを変更し、特定の動物固有の動作を実装します。

class Animal {
  protected makeSound(): void {
    console.log("Animal makes a sound");
  }

  public speak(): void {
    this.makeSound();
  }
}

class Bird extends Animal {
  // オーバーライドして、鳥の鳴き声を出力するように実装
}

const bird = new Bird();
bird.speak(); // "Bird chirps"

目標: BirdクラスのmakeSoundメソッドをオーバーライドし、"Bird chirps"というメッセージを表示させるように実装してください。

問題3: privateメソッドとアクセス制限

Deviceクラスのprivateメソッドを使用して、サブクラスSmartphoneでのオーバーライドができないことを確認する問題です。Deviceクラスにprivateメソッドを追加し、サブクラスではアクセスできないことを確認します。

class Device {
  private checkStatus(): void {
    console.log("Checking device status...");
  }

  public status(): void {
    this.checkStatus();
  }
}

class Smartphone extends Device {
  // オーバーライドしようとするとエラーが発生
  // privateメソッドはオーバーライドできない
}

const phone = new Smartphone();
phone.status(); // "Checking device status..."

目標: SmartphoneクラスでcheckStatusメソッドをオーバーライドしようとした際、TypeScriptがどのようなエラーを発生させるかを確認し、なぜそのエラーが発生するかを理解してください。

問題4: Liskovの置換原則を守ったオーバーライド

以下のコードでは、BirdクラスのサブクラスPenguinが、flyメソッドを不適切にオーバーライドしています。Liskovの置換原則に従い、Penguinクラスでもクラスの一貫性を保った適切なオーバーライドを実装してください。

class Bird {
  public fly(): void {
    console.log("Flying high in the sky");
  }
}

class Penguin extends Bird {
  // 不適切なオーバーライド
  public fly(): void {
    throw new Error("Penguins cannot fly!");
  }
}

const penguin = new Penguin();
penguin.fly(); // Error: Penguins cannot fly!

目標: Penguinクラスのflyメソッドを適切な形でオーバーライドし、Penguinが飛べないことを示しつつも、クラスの整合性を保つ方法を考えてください。

まとめ

これらの演習問題を通じて、アクセス指定子を活用したオーバーライドの基本から応用までを学習できます。オーバーライドの仕組みや設計上の注意点を理解することで、より安全で効率的なクラス設計が可能になります。

トラブルシューティング: オーバーライド時のエラー対応

メソッドのオーバーライドを行う際、予期しないエラーが発生することがあります。特に、型の不一致やアクセス指定子に関連するエラーが一般的です。ここでは、メソッドオーバーライドに関連する代表的なエラーと、その解決方法について解説します。

エラー1: 型の不一致

TypeScriptでは、オーバーライドする際に親クラスのメソッドと同じシグネチャ（引数の型や戻り値の型）を持たなければなりません。これに違反すると、型の不一致エラーが発生します。

例:

class Animal {
  public move(speed: number): void {
    console.log(`Animal moves at ${speed} km/h`);
  }
}

class Dog extends Animal {
  // Error: Argument type 'string' is not assignable to parameter type 'number'
  public move(speed: string): void {
    console.log(`Dog runs at ${speed}`);
  }
}

解決策:
オーバーライドする際は、親クラスのメソッドの型と一致させる必要があります。引数の型や戻り値の型が一致しているか確認し、修正します。

class Dog extends Animal {
  public move(speed: number): void {
    console.log(`Dog runs at ${speed} km/h`);
  }
}

エラー2: アクセス指定子の不一致

サブクラスでオーバーライドするメソッドのアクセス指定子が親クラスのものと一致していない場合、アクセス指定子の不一致エラーが発生することがあります。たとえば、親クラスでprotectedとして定義されたメソッドをprivateとしてオーバーライドしようとするとエラーが発生します。

例:

class Animal {
  protected makeSound(): void {
    console.log("Animal makes a sound");
  }
}

class Dog extends Animal {
  // Error: 'makeSound' cannot have a more restrictive access modifier than its base class
  private makeSound(): void {
    console.log("Dog barks");
  }
}

解決策:
オーバーライドする際のアクセス指定子は、親クラスよりも厳しいものにすることはできません。protectedまたはpublicにして、親クラスと一致させるか、それ以上に緩やかな指定子に変更します。

class Dog extends Animal {
  protected makeSound(): void {
    console.log("Dog barks");
  }
}

エラー3: オーバーライドできないprivateメソッド

privateメソッドはクラス内でのみアクセス可能なため、サブクラスでオーバーライドすることができません。このエラーは、親クラスのprivateメソッドをサブクラスでオーバーライドしようとした場合に発生します。

例:

class Animal {
  private move(): void {
    console.log("Animal is moving");
  }
}

class Dog extends Animal {
  // Error: 'move' is private and only accessible within class 'Animal'
  public move(): void {
    console.log("Dog is running");
  }
}

解決策:
privateメソッドはサブクラスでオーバーライドできません。サブクラスでオーバーライドしたいメソッドがある場合、親クラスでそのメソッドをprotectedまたはpublicとして定義する必要があります。

class Animal {
  protected move(): void {
    console.log("Animal is moving");
  }
}

class Dog extends Animal {
  public move(): void {
    console.log("Dog is running");
  }
}

エラー4: superの誤用

superキーワードを使って親クラスのメソッドを呼び出す際、superの使用方法が誤っている場合にエラーが発生することがあります。特に、サブクラスのコンストラクタ内でsuperを呼び出さずに、親クラスのプロパティにアクセスしようとした場合です。

例:

class Animal {
  constructor(public name: string) {}
}

class Dog extends Animal {
  constructor(name: string, public breed: string) {
    // Error: 'super' must be called before accessing 'this' in the constructor
    console.log(name);
    super(name);
  }
}

解決策:
サブクラスのコンストラクタ内でthisを使用する前にsuperを必ず呼び出す必要があります。修正後のコードは以下のようになります。

class Dog extends Animal {
  constructor(name: string, public breed: string) {
    super(name);
    console.log(name);
  }
}

まとめ

オーバーライド時に発生するエラーの多くは、型の不一致やアクセス指定子に関連するものです。これらのエラーを適切にトラブルシュートすることで、メソッドのオーバーライドを安全かつ効率的に行うことができます。

まとめ

TypeScriptにおけるメソッドオーバーライドは、アクセス指定子を活用することで安全に行うことができます。public、protected、privateといったアクセス指定子を正しく使い分けることで、サブクラスと親クラス間の動作を適切に制御し、柔軟で拡張性のあるクラス設計が可能になります。オーバーライドの際には、型の一致やアクセス指定子のルールに注意し、エラーのトラブルシューティングを行いながら、効率的で安全なコードを書くことが大切です。

TypeScript
TypeScript アクセス指定子 メソッドオーバーライド

コメント

コメントする

目次