クラス

Java – クラスの継承について1から初心者向けに解説

2025-04-15更新日: 2025-04-15

Javaのクラス継承は、既存のクラス(親クラスまたはスーパークラス)の機能を新しいクラス(子クラスまたはサブクラス)に引き継ぐ仕組みです。

これにより、コードの再利用性が向上し、開発効率が上がります。

継承はextendsキーワードを使って実現します。

子クラスは親クラスのフィールドやメソッドを利用でき、必要に応じてメソッドをオーバーライド(上書き)することも可能です。

ただし、親クラスのprivateメンバーは直接アクセスできません。

Javaでは単一継承のみ可能で、1つのクラスからしか継承できませんが、インターフェースを使うことで多重継承のような機能を実現できます。

目次から探す

クラスの継承とは？
- 継承のメリット
- 継承の基本
Javaでの継承の基本構文
- 例：基本的な継承の実装
継承で利用できるメンバー
メソッドのオーバーライド
コンストラクタと継承
継承と多態性(ポリモーフィズム)
継承の注意点とベストプラクティス
- 注意点
- ベストプラクティス
実践例：継承を使った簡単なアプリケーション
まとめ

クラスの継承とは？

クラスの継承は、オブジェクト指向プログラミングにおける重要な概念の一つです。

継承を使用することで、既存のクラス(親クラスまたはスーパークラス)の特性を新しいクラス(子クラスまたはサブクラス)に引き継ぐことができます。

これにより、コードの再利用性が向上し、プログラムの保守性が高まります。

継承のメリット

コードの再利用: 既存のクラスの機能を再利用できるため、新しいクラスをゼロから作成する必要がありません。
階層構造の構築: クラス間の関係を明確にし、オブジェクトの階層構造を作成できます。
多態性の実現: 同じメソッド名で異なる動作を持つメソッドを定義できるため、柔軟なプログラムが可能です。

継承の基本

親クラス: 他のクラスに継承されるクラス。
子クラス: 親クラスの特性を引き継ぐクラス。
is-a関係: 子クラスは親クラスの一種であるという関係を示します。

例えば、「犬は動物である」という関係です。

このように、クラスの継承はオブジェクト指向プログラミングの基盤を成す重要な要素であり、効率的なプログラム設計に寄与します。

次のセクションでは、Javaでの継承の基本構文について詳しく見ていきます。

Javaでの継承の基本構文

Javaにおける継承は、extendsキーワードを使用して実現します。

基本的な構文は以下の通りです。

class 親クラス名 {
    // 親クラスのメンバー(フィールドやメソッド)
}
class 子クラス名 extends 親クラス名 {
    // 子クラスのメンバー(フィールドやメソッド)
}

例：基本的な継承の実装

以下に、Animalクラスを親クラスとして、Dogクラスを子クラスとして継承する例を示します。

// App.java
class Animal {
    void sound() {
        System.out.println("動物の音がします。");
    }
}
class Dog extends Animal {
    void sound() {
        // 親クラスのメソッドをオーバーライド
        System.out.println("ワンワン！");
    }
}
public class App {
    public static void main(String[] args) {
        Dog dog = new Dog(); // Dogクラスのインスタンスを作成
        dog.sound(); // Dogクラスのsoundメソッドを呼び出す
    }
}

このコードでは、Animalクラスが親クラスで、Dogクラスがその子クラスです。

DogクラスはAnimalクラスのsoundメソッドをオーバーライドして、犬の鳴き声を出力します。

ワンワン！

このように、Javaではextendsキーワードを使って簡単にクラスの継承を実現できます。

継承を利用することで、親クラスの機能を子クラスで拡張したり、特定の動作を変更したりすることが可能です。

次のセクションでは、継承で利用できるメンバーについて詳しく解説します。

継承で利用できるメンバー

Javaの継承を利用することで、子クラスは親クラスのメンバー(フィールドやメソッド)を引き継ぐことができます。

ここでは、継承で利用できるメンバーの種類について詳しく説明します。

フィールド(属性)

子クラスは親クラスで定義されたフィールドをそのまま利用できます。

これにより、親クラスの属性を子クラスで再利用することが可能です。

メソッド

子クラスは親クラスのメソッドをそのまま使用することができます。

また、必要に応じてメソッドをオーバーライドして、子クラス独自の動作を定義することもできます。

コンストラクタ

親クラスのコンストラクタは子クラスから直接呼び出すことはできませんが、子クラスのコンストラクタ内でsuper()を使用して親クラスのコンストラクタを呼び出すことができます。

これにより、親クラスの初期化処理を行うことができます。

メンバーのアクセス修飾子

継承において、親クラスのメンバーのアクセス修飾子によって、子クラスからのアクセスが制限されることがあります。

以下の表に、各修飾子のアクセス範囲を示します。

アクセス修飾子	説明	子クラスからのアクセス
`public`	どこからでもアクセス可能	可能
`protected`	同じパッケージ内またはサブクラスからアクセス可能	可能
`default`	同じパッケージ内からのみアクセス可能	可能
`private`	同じクラス内からのみアクセス可能	不可能

例：継承で利用できるメンバーの実装

以下のコードでは、親クラスAnimalのフィールドとメソッドを子クラスDogで利用しています。

// App.java
class Animal {
    String name; // フィールド
    Animal(String name) { // コンストラクタ
        this.name = name;
    }
    void sound() { // メソッド
        System.out.println("動物の音がします。");
    }
}
class Dog extends Animal {
    Dog(String name) {
        super(name); // 親クラスのコンストラクタを呼び出す
    }
    void sound() { // メソッドのオーバーライド
        System.out.println(name + "はワンワン！と鳴きます。");
    }
}
public class App {
    public static void main(String[] args) {
        Dog dog = new Dog("ポチ"); // Dogクラスのインスタンスを作成
        dog.sound(); // Dogクラスのsoundメソッドを呼び出す
    }
}

ポチはワンワン！と鳴きます。

このように、継承を利用することで、親クラスのフィールドやメソッドを子クラスで簡単に利用できるようになります。

次のセクションでは、メソッドのオーバーライドについて詳しく解説します。

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

メソッドのオーバーライドは、子クラスが親クラスで定義されたメソッドを再定義することを指します。

これにより、親クラスのメソッドの動作を変更したり、特定の機能を拡張したりすることができます。

オーバーライドは、ポリモーフィズム(多態性)を実現するための重要な手段でもあります。

オーバーライドの基本ルール

メソッド名: 親クラスのメソッドと同じ名前である必要があります。
引数リスト: 親クラスのメソッドと同じ引数リストである必要があります。
戻り値の型: 親クラスのメソッドと同じか、サブクラスの型である必要があります。
アクセス修飾子: 親クラスのメソッドよりもアクセス範囲を狭くすることはできません。

オーバーライドの例

以下のコードでは、親クラスAnimalのsoundメソッドを子クラスDogでオーバーライドしています。

// App.java
class Animal {
    void sound() { // 親クラスのメソッド
        System.out.println("動物の音がします。");
    }
}
class Dog extends Animal {
    @Override // オーバーライドを明示するアノテーション
    void sound() { // 子クラスでのオーバーライド
        System.out.println("ワンワン！"); // 独自の動作を定義
    }
}
public class App {
    public static void main(String[] args) {
        Animal animal = new Animal(); // Animalクラスのインスタンスを作成
        animal.sound(); // 親クラスのメソッドを呼び出す
        Dog dog = new Dog(); // Dogクラスのインスタンスを作成
        dog.sound(); // 子クラスのオーバーライドされたメソッドを呼び出す
    }
}

動物の音がします。
ワンワン！

この例では、Animalクラスのsoundメソッドが親クラスで定義されており、Dogクラスでオーバーライドされています。

Dogクラスのインスタンスを作成すると、オーバーライドされたメソッドが呼び出され、犬の鳴き声が出力されます。

@Overrideアノテーション

オーバーライドを行う際に@Overrideアノテーションを使用することが推奨されます。

これにより、コンパイラがオーバーライドを正しく行っているかをチェックし、誤ってメソッド名を変更した場合などにエラーを通知してくれます。

メソッドのオーバーライドを利用することで、柔軟で拡張性のあるプログラムを作成することができます。

次のセクションでは、コンストラクタと継承について詳しく解説します。

コンストラクタと継承

Javaにおけるコンストラクタは、クラスのインスタンスが生成される際に呼び出される特別なメソッドです。

継承を使用する場合、子クラスのコンストラクタは親クラスのコンストラクタを呼び出す必要があります。

これにより、親クラスのフィールドが正しく初期化されます。

コンストラクタの呼び出し

子クラスのコンストラクタから親クラスのコンストラクタを呼び出すには、super()キーワードを使用します。

super()は、親クラスのコンストラクタを明示的に呼び出すための方法です。

引数を持つ親クラスのコンストラクタを呼び出す場合は、super(引数)の形式で使用します。

例：コンストラクタと継承の実装

以下のコードでは、親クラスAnimalに引数を持つコンストラクタがあり、子クラスDogがそのコンストラクタを呼び出しています。

// App.java
class Animal {
    String name; // フィールド
    // 引数を持つコンストラクタ
    Animal(String name) {
        this.name = name; // フィールドの初期化
    }
}
class Dog extends Animal {
    // 子クラスのコンストラクタ
    Dog(String name) {
        super(name); // 親クラスのコンストラクタを呼び出す
    }
    void sound() {
        System.out.println(name + "はワンワン！と鳴きます。");
    }
}
public class App {
    public static void main(String[] args) {
        Dog dog = new Dog("ポチ"); // Dogクラスのインスタンスを作成
        dog.sound(); // Dogクラスのsoundメソッドを呼び出す
    }
}

ポチはワンワン！と鳴きます。

この例では、Animalクラスのコンストラクタがnameフィールドを初期化しています。

Dogクラスのコンストラクタでは、super(name)を使用して親クラスのコンストラクタを呼び出し、nameフィールドを正しく初期化しています。

コンストラクタの呼び出し順序

子クラスのコンストラクタが呼び出されると、最初に親クラスのコンストラクタが呼び出されます。
親クラスのコンストラクタが完了した後に、子クラスのコンストラクタが実行されます。

このように、コンストラクタと継承を正しく理解することで、オブジェクトの初期化を適切に行うことができます。

次のセクションでは、継承と多態性(ポリモーフィズム)について詳しく解説します。

継承と多態性(ポリモーフィズム)

多態性(ポリモーフィズム)は、オブジェクト指向プログラミングの重要な概念であり、同じメソッド名で異なる動作を持つメソッドを定義できる能力を指します。

継承と組み合わせることで、より柔軟で拡張性のあるプログラムを作成することが可能になります。

多態性の種類

多態性には主に2つの種類があります。

コンパイル時多態性(静的多態性): メソッドのオーバーロードによって実現されます。

同じメソッド名で異なる引数リストを持つメソッドを定義することができます。

実行時多態性(動的多態性): メソッドのオーバーライドによって実現されます。

親クラスの参照型を使用して、子クラスのオーバーライドされたメソッドを呼び出すことができます。

実行時多態性の例

以下のコードでは、親クラスAnimalのsoundメソッドをオーバーライドした子クラスDogとCatを定義し、親クラスの参照型を使用して多態性を示しています。

// App.java
class Animal {
    void sound() { // 親クラスのメソッド
        System.out.println("動物の音がします。");
    }
}
class Dog extends Animal {
    @Override
    void sound() { // Dogクラスのオーバーライド
        System.out.println("ワンワン！");
    }
}
class Cat extends Animal {
    @Override
    void sound() { // Catクラスのオーバーライド
        System.out.println("ニャー！");
    }
}
public class App {
    public static void main(String[] args) {
        Animal myDog = new Dog(); // Animal型の参照でDogを指す
        Animal myCat = new Cat(); // Animal型の参照でCatを指す
        myDog.sound(); // Dogクラスのsoundメソッドを呼び出す
        myCat.sound(); // Catクラスのsoundメソッドを呼び出す
    }
}

ワンワン！
ニャー！

この例では、Animal型の参照変数myDogとmyCatがそれぞれDogクラスとCatクラスのインスタンスを指しています。

soundメソッドを呼び出すと、実行時にどのクラスのメソッドが呼び出されるかが決定され、オーバーライドされたメソッドが実行されます。

これが多態性の実行時の例です。

多態性の利点

柔軟性: 異なるクラスのオブジェクトを同じインターフェースで扱うことができ、コードの柔軟性が向上します。
拡張性: 新しいクラスを追加する際に、既存のコードを変更することなく新しい動作を追加できます。
保守性: コードの可読性が向上し、保守が容易になります。

このように、継承と多態性を組み合わせることで、より効率的で柔軟なプログラムを作成することができます。

次のセクションでは、継承の注意点とベストプラクティスについて詳しく解説します。

継承の注意点とベストプラクティス

継承は非常に強力な機能ですが、適切に使用しないと問題を引き起こす可能性があります。

ここでは、継承を使用する際の注意点とベストプラクティスについて解説します。

注意点

過度の継承:

継承を多用しすぎると、クラス間の関係が複雑になり、理解しづらくなります。

必要な場合にのみ継承を使用し、過度な階層構造を避けることが重要です。

親クラスの変更:

親クラスを変更すると、すべての子クラスに影響を与える可能性があります。

親クラスの設計は慎重に行い、変更が必要な場合は影響範囲を考慮する必要があります。

不適切なオーバーライド:

子クラスで親クラスのメソッドをオーバーライドする際、親クラスの意図を理解していないと、予期しない動作を引き起こすことがあります。

オーバーライドする際は、親クラスのメソッドの目的を十分に理解しておくことが重要です。

多重継承の制限:

Javaは多重継承をサポートしていません。

これは、複数の親クラスから同じメソッドを継承した場合の「ダイヤモンド問題」を避けるためです。

インターフェースを使用して多重継承のような機能を実現することができます。

ベストプラクティス

継承の代わりにコンポジションを検討:

継承が適切でない場合、コンポジション(オブジェクトの組み合わせ)を使用することを検討してください。

これにより、柔軟性が向上し、クラス間の依存関係を減らすことができます。

明確なクラス設計:

クラスの設計は明確に行い、クラスの責任を明確に定義します。

単一責任の原則に従い、各クラスが一つの責任を持つように設計することが重要です。

finalキーワードの活用:

親クラスが継承されることを望まない場合は、finalキーワードを使用してクラスを定義します。

これにより、意図しない継承を防ぐことができます。

ドキュメントの整備:

クラスやメソッドの設計意図を明確にするために、適切なコメントやドキュメントを整備します。

これにより、他の開発者がコードを理解しやすくなります。

テストの実施:

継承を使用する場合、親クラスと子クラスの両方の動作をテストすることが重要です。

特にオーバーライドされたメソッドについては、期待通りに動作するかを確認するためのテストを行います。

これらの注意点とベストプラクティスを考慮することで、継承を効果的に活用し、より良いプログラムを作成することができます。

次のセクションでは、継承を使った簡単なアプリケーションの実践例を紹介します。

実践例：継承を使った簡単なアプリケーション

ここでは、継承を利用した簡単なアプリケーションを作成します。

このアプリケーションでは、動物の種類に応じて異なる鳴き声を出す機能を持つクラスを定義します。

具体的には、Animalクラスを親クラスとして、DogクラスとCatクラスを子クラスとして実装します。

アプリケーションの設計

親クラス: Animal
フィールド: name(動物の名前)
メソッド: sound()(動物の鳴き声を出力)
子クラス: DogとCat
Animalクラスを継承し、sound()メソッドをオーバーライドしてそれぞれの鳴き声を出力します。

コード実装

以下が、継承を使った簡単なアプリケーションのコードです。

// App.java
class Animal {
    String name; // 動物の名前
    // コンストラクタ
    Animal(String name) {
        this.name = name; // 名前を初期化
    }
    // 鳴き声を出力するメソッド
    void sound() {
        System.out.println(name + "は動物の音がします。");
    }
}
class Dog extends Animal {
    // コンストラクタ
    Dog(String name) {
        super(name); // 親クラスのコンストラクタを呼び出す
    }
    // 鳴き声をオーバーライド
    @Override
    void sound() {
        System.out.println(name + "はワンワン！と鳴きます。");
    }
}
class Cat extends Animal {
    // コンストラクタ
    Cat(String name) {
        super(name); // 親クラスのコンストラクタを呼び出す
    }
    // 鳴き声をオーバーライド
    @Override
    void sound() {
        System.out.println(name + "はニャー！と鳴きます。");
    }
}
public class App {
    public static void main(String[] args) {
        Animal dog = new Dog("ポチ"); // Dogクラスのインスタンスを作成
        Animal cat = new Cat("ミケ"); // Catクラスのインスタンスを作成
        dog.sound(); // Dogの鳴き声を出力
        cat.sound(); // Catの鳴き声を出力
    }
}

ポチはワンワン！と鳴きます。
ミケはニャー！と鳴きます。

アプリケーションの説明

このアプリケーションでは、Animalクラスを親クラスとして、DogクラスとCatクラスがそれぞれの動物の鳴き声をオーバーライドしています。

mainメソッドでは、DogとCatのインスタンスを作成し、それぞれの鳴き声を出力しています。

このように、継承を利用することで、共通の機能を持つクラスを簡単に拡張し、異なる動作を持つクラスを作成することができます。

継承は、オブジェクト指向プログラミングの強力なツールであり、効率的なコードの再利用を可能にします。

ここでは、Javaの継承に関してよく寄せられる質問とその回答をまとめました。

これにより、継承の理解を深める手助けとなるでしょう。

Q1: Javaでは多重継承は可能ですか？

A1: Javaは多重継承をサポートしていません。

これは、複数の親クラスから同じメソッドを継承した場合に発生する「ダイヤモンド問題」を避けるためです。

ただし、インターフェースを使用することで、複数のインターフェースを実装することは可能です。

Q2: 親クラスのコンストラクタは子クラスでどのように呼び出しますか？

A2: 子クラスのコンストラクタから親クラスのコンストラクタを呼び出すには、super()キーワードを使用します。

引数を持つ親クラスのコンストラクタを呼び出す場合は、super(引数)の形式で使用します。

Q3: オーバーライドしたメソッドのアクセス修飾子はどうなりますか？

A3: オーバーライドしたメソッドのアクセス修飾子は、親クラスのメソッドと同じか、より広い範囲でなければなりません。

例えば、親クラスのメソッドがprotectedであれば、子クラスのオーバーライドメソッドはprotectedまたはpublicにすることができますが、privateにはできません。

Q4: finalキーワードはどのように使いますか？

A4: finalキーワードを使用すると、クラスやメソッドを継承できなくすることができます。

finalクラスは他のクラスから継承できず、finalメソッドはオーバーライドできません。

これにより、意図しない変更を防ぐことができます。

Q5: 継承とコンポジションの違いは何ですか？

A5: 継承は is-a 関係を表現するのに対し、コンポジションは has-a 関係を表現します。

継承はクラス間の階層構造を作成しますが、コンポジションはオブジェクトを組み合わせて新しい機能を作成します。

一般的には、継承よりもコンポジションを使用することが推奨される場合が多いです。

Q6: 継承を使用する際のベストプラクティスは何ですか？

A6: 継承を使用する際のベストプラクティスには、以下のようなものがあります。

過度の継承を避け、必要な場合にのみ使用する。
クラスの設計を明確にし、単一責任の原則に従う。
finalキーワードを使用して意図しない継承を防ぐ。
ドキュメントを整備し、他の開発者が理解しやすいようにする。
テストを実施し、親クラスと子クラスの動作を確認する。

これらの質問と回答を参考にすることで、Javaの継承に関する理解を深め、より効果的にプログラミングを行うことができるでしょう。

まとめ

この記事では、Javaにおけるクラスの継承について、基本的な概念から実践的な例まで幅広く解説しました。

継承を利用することで、コードの再利用性や柔軟性が向上し、オブジェクト指向プログラミングの強力な機能を活用することが可能になります。

今後は、継承の特性を活かして、より効率的で拡張性のあるプログラムを作成してみてください。