【Java徹底解説】継承の全て！基本から応用、設計思想までプロが徹底解説

はじめに：なぜJavaの「継承」を学ぶべきなのか？

Javaを学ぶ上で避けて通れない、いや、むしろ「マスターすべき」概念の一つが「継承（Inheritance）」です。オブジェクト指向プログラミング（OOP）の三大要素（カプセル化、継承、ポリモーフィズム）の一つとして、コードの再利用性、拡張性、保守性を劇的に向上させる強力な仕組みを提供します。

しかし、「継承」と聞くと、「難しそう」「いつ使えばいいのか分からない」「ポリモーフィズムとの関係が曖昧」と感じる方も少なくないでしょう。本記事では、そんな疑問を全て解消すべく、Javaの継承について基礎から応用、さらには設計思想まで、プロの視点から徹底的に解説していきます。この記事を読み終える頃には、あなたはJavaの継承を自信を持って使いこなし、より高品質なコードを書けるようになっているはずです。

さあ、Javaの継承の奥深き世界へ一緒に飛び込みましょう！

Javaの「継承」とは？基本のキ

まず、Javaの継承が一体何であるか、その基本的な概念から理解していきましょう。

「継承」とは、あるクラス（親クラス、スーパークラス）が持つプロパティ（フィールド）や振る舞い（メソッド）を、別のクラス（子クラス、サブクラス）が受け継ぎ、さらに独自の機能を追加・拡張できる仕組みですです。これにより、共通する部分のコードを重複して書く手間を省き、効率的に開発を進めることができます。

継承の最も重要な原則は「is-a関係」です。例えば、「犬は動物である」「車は乗り物である」のように、論理的に「〜は〜の一種である」と表現できる関係性が継承の適切な適用場面となります。

extendsキーワード

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

class 子クラス名 extends 親クラス名 {
    // 子クラス独自のフィールドやメソッド
}

親クラス、子クラス、そしてObjectクラス

• 親クラス（Superclass / Parent class）: 継承される側のクラス。共通の機能を提供します。
• 子クラス（Subclass / Child class）: 親クラスの機能を継承し、独自の機能を追加するクラス。
• Objectクラス: Javaにおける全てのクラスは、明示的にextendsキーワードを使わなくても、暗黙的にjava.lang.Objectクラスを継承しています。つまり、Objectクラスは全てのクラスの頂点に立つ、究極の親クラスです。

継承の基本的な使い方（コード例）

動物を例に、継承の基本的な動作を見てみましょう。

// 親クラス：Animal（動物）
class Animal {
    String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + "は食べます。");
    }

    public void sleep() {
        System.out.println(name + "は寝ます。");
    }
}

// 子クラス：Dog（犬）
// Animalクラスの機能を継承します
class Dog extends Animal {
    public Dog(String name) {
        super(name); // 親クラスのコンストラクタを呼び出す
    }

    // 犬独自のメソッド
    public void bark() {
        System.out.println(name + "はワンワン吠えます！");
    }
}

// 子クラス：Cat（猫）
// Animalクラスの機能を継承します
class Cat extends Animal {
    public Cat(String name) {
        super(name); // 親クラスのコンストラクタを呼び出す
    }

    // 猫独自のメソッド
    public void meow() {
        System.out.println(name + "はニャーと鳴きます。");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Dog myDog = new Dog("ポチ");
        myDog.eat();    // Animalクラスから継承したメソッド
        myDog.sleep();  // Animalクラスから継承したメソッド
        myDog.bark();   // Dogクラス独自のメソッド

        System.out.println("---");

        Cat myCat = new Cat("ミケ");
        myCat.eat();    // Animalクラスから継承したメソッド
        myCat.sleep();  // Animalクラスから継承したメソッド
        myCat.meow();   // Catクラス独自のメソッド
    }
}

実行結果:

ポチは食べます。
ポチは寝ます。
ポチはワンワン吠えます！
---
ミケは食べます。
ミケは寝ます。
ミケはニャーと鳴きます。

この例からわかるように、DogクラスとCatクラスは、Animalクラスが持つeat()やsleep()メソッドを、自分でコードを書かずに利用できています。これが継承の基本的なメリットです。

継承の核心！知っておくべき重要概念

継承を真に使いこなすためには、いくつかの重要な概念を深く理解する必要があります。

1. メソッドのオーバーライド (Override)

子クラスは、親クラスから継承したメソッドを、自分独自の振る舞いに「上書き（override）」することができます。これがメソッドのオーバーライドです。

@Overrideアノテーション

オーバーライドするメソッドには、@Overrideアノテーションを付けることが推奨されます。これは、コンパイラに対して「このメソッドは親クラスのメソッドをオーバーライドしている」ことを明示的に伝える役割があります。もし親クラスに対応するメソッドが存在しない場合や、シグネチャ（メソッド名、引数の型と数）が一致しない場合はコンパイルエラーとなるため、意図しないミスを防ぐことができます。

superキーワードによる親メソッド呼び出し

オーバーライドしたメソッドの中から、親クラスの同名メソッドを呼び出したい場合は、superキーワードを使用します。

class Animal {
    String name;

    public Animal(String name) {
        this.name = name;
    }

    public void speak() {
        System.out.println(name + "は何も言わない。");
    }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override // 親クラスのspeakメソッドをオーバーライド
    public void speak() {
        System.out.print(name + "：");
        super.speak(); // 親クラスのspeakメソッドを呼び出す
        System.out.println(name + "はワンワン吠える！"); // さらに独自の処理を追加
    }
}

public class OverrideExample {
    public static void main(String[] args) {
        Dog myDog = new Dog("ジョン");
        myDog.speak();
    }
}

実行結果:

ジョン：ジョンは何も言わない。
ジョンはワンワン吠える！

2. コンストラクタと継承

子クラスをインスタンス化する際、その子クラスのコンストラクタが呼び出される前に、必ず親クラスのコンストラクタが呼び出されます。これは、子クラスが親クラスのフィールドなどを初期化するために必要なプロセスです。

super()による親クラスコンストラクタの呼び出し

子クラスのコンストラクタから親クラスの特定のコンストラクタを明示的に呼び出すには、super()キーワード（引数がある場合はsuper(引数)）を使用します。

• super()は、子クラスのコンストラクタの最初の行でしか呼び出すことができません。
• もし子クラスのコンストラクタでsuper()を明示的に呼び出さなかった場合、Javaコンパイラは引数なしのsuper()を自動的に挿入します。したがって、親クラスには引数なしのコンストラクタ（デフォルトコンストラクタ）が最低一つは存在する必要があります。
• もし親クラスが引数を持つコンストラクタしか持たず、デフォルトコンストラクタが存在しない場合、子クラスは明示的にsuper(引数)を呼び出す必要があります。

class Vehicle {
    String type;

    public Vehicle(String type) { // 引数ありのコンストラクタ
        this.type = type;
        System.out.println("Vehicleコンストラクタが呼ばれました: " + type);
    }
}

class Car extends Vehicle {
    int doors;

    public Car(String type, int doors) {
        super(type); // 親クラスのコンストラクタを明示的に呼び出し
        this.doors = doors;
        System.out.println("Carコンストラクタが呼ばれました。ドア数: " + doors);
    }
}

public class ConstructorInheritanceExample {
    public static void main(String[] args) {
        Car myCar = new Car("セダン", 4);
        // 出力順序に注目！親のコンストラクタが先に実行される
    }
}

実行結果:

Vehicleコンストラクタが呼ばれました: セダン
Carコンストラクタが呼ばれました。ドア数: 4

3. アクセス修飾子と継承の関係

親クラスのメンバー（フィールドやメソッド）へのアクセスは、そのアクセス修飾子によって制御されます。継承における各修飾子の振る舞いを理解することは非常に重要です。

• public: どこからでもアクセス可能。子クラスからも直接アクセス・利用できます。
• protected: 同じパッケージ内、または子クラスからアクセス可能。継承関係にあるクラスに対して、特定のメンバーへのアクセスを許可したい場合に非常に便利です。
• default (パッケージプライベート): 同じパッケージ内からのみアクセス可能。異なるパッケージの子クラスからはアクセスできません。
• private: そのクラス内からのみアクセス可能。子クラスからも直接アクセスすることはできません（継承はされますが、アクセスはカプセル化によって制限されます）。privateなメンバーに子クラスからアクセスしたい場合は、親クラスでpublicまたはprotectedなgetter/setterメソッドを提供する必要があります。

class Parent {
    public String publicField = "Public";
    protected String protectedField = "Protected";
    String defaultField = "Default"; // default (パッケージプライベート)
    private String privateField = "Private";

    public void publicMethod() { System.out.println("Parent Public Method"); }
    protected void protectedMethod() { System.out.println("Parent Protected Method"); }
    void defaultMethod() { System.out.println("Parent Default Method"); }
    private void privateMethod() { System.out.println("Parent Private Method"); }

    public String getPrivateField() { // privateFieldへのgetter
        return privateField;
    }
}

class Child extends Parent {
    public void accessParentMembers() {
        System.out.println("Child can access: ");
        System.out.println("  Public Field: " + publicField); // OK
        System.out.println("  Protected Field: " + protectedField); // OK
        // System.out.println("  Default Field: " + defaultField); // ERROR if Child is in different package
        // System.out.println("  Private Field: " + privateField); // ERROR: private
        System.out.println("  Private Field via getter: " + getPrivateField()); // OK

        publicMethod(); // OK
        protectedMethod(); // OK
        // defaultMethod(); // ERROR if Child is in different package
        // privateMethod(); // ERROR: private
    }
}

// 別パッケージをシミュレートする場合
// package com.mypackage;
// class ChildInAnotherPackage extends Parent { ... }
// この場合、defaultField と defaultMethod はアクセス不可

4. finalキーワードによる継承の制御

finalキーワードは、継承の挙動を制限するために使用できます。

• finalクラス: クラス宣言にfinalを付けると、そのクラスは継承されることを禁止します。つまり、子クラスを作成することができなくなります。これは、セキュリティ上の理由や、そのクラスの設計が完全に完結しており、それ以上の拡張を望まない場合に利用されます。
  • 例: java.lang.Stringクラスはfinalクラスであり、継承できません。
• finalメソッド: メソッド宣言にfinalを付けると、そのメソッドは子クラスでオーバーライドされることを禁止します。これは、特定のロジックが変更されるべきではない場合に保証するために使われます。
  • 例: 親クラスの重要な初期化ロジックなどがこれに該当する場合があります。

final class ImmutableClass { // 継承不可
    // ...
}

// class MyChildClass extends ImmutableClass {} // コンパイルエラー

class BaseWithFinalMethod {
    public final void criticalMethod() { // オーバーライド不可
        System.out.println("このメソッドは変更できません。");
    }
}

class DerivedClass extends BaseWithFinalMethod {
    // @Override
    // public void criticalMethod() {} // コンパイルエラー
}

継承がもたらす最大の恩恵「ポリモーフィズム（多態性）」

Javaの継承を語る上で、ポリモーフィズム（Polymorphism：多態性）は決して外せない概念です。「多態性」とは、「多くの形を取る性質」という意味で、一つのインターフェースや型で、異なる型のオブジェクトを扱うことができる能力を指します。

継承とポリモーフィズムが組み合わさることで、コードの柔軟性と拡張性が飛躍的に向上します。

型の柔軟性

ポリモーフィズムの最も基本的な形は、親クラスの型を持つ変数に、子クラスのインスタンスを代入できることです。

// 親クラスの型として子クラスのインスタンスを扱う
Animal myDog = new Dog("ジョン"); // Animal型の変数にDogインスタンスを代入
Animal myCat = new Cat("ミケ"); // Animal型の変数にCatインスタンスを代入

myDog.speak(); // 実行されるのはDogクラスのspeak()
myCat.speak(); // 実行されるのはCatクラスのspeak()

上記の例では、myDogもmyCatもAnimal型として宣言されていますが、実際に呼び出されるspeak()メソッドは、それぞれのインスタンスが持つ固有のメソッドです。これは、Javaが実行時にオブジェクトの実際の型に基づいてメソッドを呼び出すためです（動的メソッドディスパッチ）。

コードの抽象化と拡張性

ポリモーフィズムの真価は、異なる子クラスを共通の親クラスの型として一括して扱える点にあります。これにより、共通の処理を抽象化し、新しい子クラスが追加されても既存のコードを変更する必要がない、拡張性の高いシステムを構築できます。

// Animalクラス（親）とDog, Catクラス（子）は前述の例を使用

class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }

    public void feed(Animal animal) { // Animal型の引数を受け取る
        System.out.println(name + "が" + animal.name + "に餌をあげます。");
        animal.eat(); // 呼び出されるeat()は、animalの実際の型に応じて変化
    }

    public void makeAnimalSpeak(Animal animal) {
        System.out.print(name + "が" + animal.name + "に話しかけました。結果：");
        animal.speak(); // 呼び出されるspeak()は、animalの実際の型に応じて変化
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Dog dog = new Dog("ポチ");
        Cat cat = new Cat("タマ");
        Animal unknownAnimal = new Animal("名無し"); // 親クラスのインスタンスもOK

        Person owner = new Person("山田さん");

        owner.feed(dog);           // DogをAnimalとして渡す
        owner.makeAnimalSpeak(dog);

        System.out.println("---");

        owner.feed(cat);           // CatをAnimalとして渡す
        owner.makeAnimalSpeak(cat);

        System.out.println("---");

        owner.feed(unknownAnimal); // AnimalをAnimalとして渡す
        owner.makeAnimalSpeak(unknownAnimal);

        // 配列やリストでも同様に利用可能
        Animal[] pets = new Animal[3];
        pets[0] = new Dog("ハル");
        pets[1] = new Cat("ルナ");
        pets[2] = new Dog("コタロウ");

        System.out.println("\n--- ペットたちとの触れ合い ---");
        for (Animal pet : pets) {
            owner.makeAnimalSpeak(pet);
        }
    }
}

実行結果:

山田さんがポチに餌をあげます。
ポチは食べます。
山田さんがポチに話しかけました。結果：ポチ：ポチは何も言わない。
ポチはワンワン吠える！
---
山田さんがタマに餌をあげます。
タマは食べます。
山田さんがタマに話しかけました。結果：タマ：タマは何も言わない。
タマはニャーと鳴きます。
---
山田さんが名無しに餌をあげます。
名無しは食べます。
山田さんが名無しに話しかけました。結果：名無しは何も言わない。

--- ペットたちとの触れ合い ---
山田さんがハルに話しかけました。結果：ハル：ハルは何も言わない。
ハルはワンワン吠える！
山田さんがルナに話しかけました。結果：ルナ：ルナは何も言わない。
ルナはニャーと鳴きます。
山田さんがコタロウに話しかけました。結果：コタロウ：コタロウは何も言わない。
コタロウはワンワン吠える！

Personクラスのfeed()やmakeAnimalSpeak()メソッドは、具体的なDogやCatの型を知らなくても、Animal型として受け取ることで、共通の操作（餌をあげる、話しかける）を実行できます。これがポリモーフィズムの強力な点です。

継承と深い関係にある概念

継承を理解する上で、しばしば比較される「抽象クラス」と「インターフェース」についても触れておきましょう。これらは継承と密接に関連し、OOPの設計において重要な役割を担います。

抽象クラス (Abstract Class)

抽象クラスは、それ自体ではインスタンス化できないクラスで、主に「共通の型定義」と「部分的な実装」を提供するために使用されます。

• abstractキーワードをクラス宣言に付けることで、抽象クラスになります。
• 抽象クラスは、抽象メソッド（abstractキーワードが付いた、実装を持たないメソッド）を持つことができます。抽象メソッドを持つクラスは、必ず抽象クラスとして宣言されなければなりません。
• 抽象クラスは、通常のメソッド（実装を持つメソッド）やフィールドも持つことができます。
• 子クラスは抽象クラスをextendsし、その抽象メソッドを必ずオーバーライドして実装しなければなりません。もし実装しない場合、その子クラスも抽象クラスとして宣言する必要があります。

抽象クラスの目的:

1. 子クラスに特定のメソッドの実装を強制する。
2. 共通の処理（具象メソッド）やフィールドをまとめて提供し、コードの重複を防ぐ。
3. is-a関係を表現しつつ、親クラスのインスタンス化を禁止することで、より抽象的な概念を表現する。

// 抽象クラス：Shape
abstract class Shape {
    String name;

    public Shape(String name) {
        this.name = name;
    }

    // 抽象メソッド：面積を計算する（子クラスで実装を強制）
    public abstract double calculateArea();

    // 具象メソッド：共通の処理
    public void display() {
        System.out.println("図形: " + name);
        System.out.println("面積: " + calculateArea());
    }
}

class Circle extends Shape {
    double radius;

    public Circle(String name, double radius) {
        super(name);
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    double width;
    double height;

    public Rectangle(String name, double width, double height) {
        super(name);
        this.width = width;
        this.height = height;
    }

    @Override
    public double calculateArea() {
        return width * height;
    }
}

public class AbstractClassExample {
    public static void main(String[] args) {
        // Shape s = new Shape("一般図形"); // コンパイルエラー: 抽象クラスはインスタンス化できない

        Shape circle = new Circle("円", 5.0);
        circle.display();

        System.out.println("---");

        Shape rectangle = new Rectangle("長方形", 4.0, 6.0);
        rectangle.display();
    }
}

インターフェース (Interface) との比較

インターフェースもまた、型を定義し、ポリモーフィズムを実現するための重要な要素ですが、抽象クラスとは異なる目的と特性を持っています。

インターフェースの主な目的:

1. 振る舞いの契約（Contract）: 特定の機能（「泳げる」「飛べる」など）を持つことを保証する。
2. 多重継承の実現: Javaはクラスの多重継承をサポートしませんが、インターフェースを複数実装することで、複数の異なる「振る舞い」をクラスに持たせることができます。
3. 疎結合: 実装の詳細から呼び出し側を分離し、システム全体の結合度を低減させる。

Java 8以降、インターフェースにdefaultメソッドやstaticメソッドが追加され、抽象クラスとの境界が一部曖昧になりましたが、基本的な使い分けの原則（is-a vs can-do）は変わりません。

継承のメリットとデメリット：賢く使うために

継承は強力なツールですが、そのメリットとデメリットを理解し、適切に使い分けることが重要です。

メリット

1. コードの再利用性: 親クラスに共通の機能を集約することで、子クラスで同じコードを何度も書く必要がなくなります。これにより、開発効率が向上し、コード量が削減されます。
2. 拡張性: 新しい機能を追加したい場合、既存の親クラスを壊すことなく、新しい子クラスを作成して独自の機能を追加したり、親のメソッドをオーバーライドしたりできます。これにより、システムの変更が容易になります。
3. 保守性: 共通のロジックが親クラスに一元化されているため、そのロジックに変更が必要になった場合、親クラスだけを修正すれば、全ての子クラスにその変更が反映されます。これにより、バグの修正や機能改善が容易になります。
4. ポリモーフィズム: 親クラスの型として子クラスのオブジェクトを扱えるため、汎用的なコードを書くことができます。これにより、システムの柔軟性と拡張性が向上します。

デメリット

1. 密結合 (Tight Coupling): 子クラスは親クラスの実装に強く依存します。親クラスの変更が、意図せず全ての子クラスに影響を与えてしまう「脆い基底クラス問題 (Fragile Base Class Problem)」を引き起こす可能性があります。
2. 柔軟性の欠如: 継承の階層が深くなると、特定の機能を持つ子クラスを作成するために、不要な親クラスの機能を一緒に継承してしまうことがあります。また、一度確立した継承関係は、後から変更するのが困難です。
3. 複雑性: 継承の階層が深くなりすぎると、どのクラスがどの機能を持っているのか、メソッドがどこでオーバーライドされているのかなどが分かりにくくなり、コードの理解やデバッグが難しくなります。
4. リスコフの置換原則 (LSP) 違反のリスク: リスコフの置換原則とは「プログラム中の任意の場所で、基底クラスのオブジェクトをそのサブクラスのオブジェクトに置き換えても、プログラムの振る舞いは変わらないべきである」という原則です。継承を安易に使うと、この原則に違反し、予期せぬ動作を引き起こす可能性があります（例：「正方形は長方形である」という関係で継承すると、正方形で幅と高さを個別に設定できなくなり、LSPに違反する）。

より良い設計のために：「委譲 (Composition)」との比較

継承のデメリット、特に「密結合」と「柔軟性の欠如」を克服するために、オブジェクト指向設計の重要な原則として「継承よりも委譲を優先せよ (Composition over Inheritance)」というものがあります。

委譲 (Composition) とは？

委譲とは、あるクラスが別のクラスのインスタンスをフィールドとして持ち、そのインスタンスのメソッドを呼び出すことで、特定の機能を実現する設計パターンです。これは「has-a関係」（〜は〜を持っている）と表現されます。

例えば、「車はエンジンを持っている」という関係は委譲で表現できます。

// エンジンクラス
class Engine {
    public void start() {
        System.out.println("エンジンがかかりました。");
    }

    public void stop() {
        System.out.println("エンジンが停止しました。");
    }
}

// 車クラス（委譲を使用）
class Car {
    private Engine engine; // Engineクラスのインスタンスをフィールドとして持つ

    public Car() {
        this.engine = new Engine(); // CarがEngineを持っている
    }

    public void startCar() {
        System.out.println("車を発進します。");
        engine.start(); // Engineの機能を使っている
    }

    public void stopCar() {
        System.out.println("車を停止します。");
        engine.stop(); // Engineの機能を使っている
    }
}

public class CompositionExample {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.startCar();
        myCar.stopCar();
    }
}

継承 vs 委譲：使い分けの指針

• 継承（Inheritance）:
  • is-a関係が明確な場合（例：DogはAnimalである）。
  • 親クラスの振る舞いを子クラスで変更（オーバーライド）したい場合。
  • ポリモーフィズムを活用して、共通の型として扱いたい場合。
  • 親クラスの実装が安定しており、変更が少ないと予想される場合。
• 委譲（Composition）:
  • has-a関係が明確な場合（例：CarはEngineを持っている）。
  • クラスが複数の機能（振る舞い）を持つ必要があるが、それらが直感的なis-a関係でない場合（Javaのクラスは多重継承できないため、複数の振る舞いを集約するのに向いている）。
  • 機能の実装を柔軟に切り替えたい場合（例：Carがガソリンエンジンだけでなく、電気エンジンも搭載できるようにする）。
  • 密結合を避け、クラス間の独立性を高めたい場合。

現代のオブジェクト指向設計では、不必要な継承は避け、委譲やインターフェースの実装を積極的に利用することで、より柔軟で変更に強いシステムを構築することが推奨されています。

まとめ：Javaの継承をマスターする道

本記事では、Javaの継承について多角的に解説してきました。ここで、特に重要なポイントを再確認しましょう。

• 継承の基本: extendsキーワードを使い、親クラスのフィールドやメソッドを子クラスが受け継ぐ「is-a関係」を表現します。
• オーバーライドとsuper: 親クラスのメソッドを上書きし、独自の振る舞いを定義できます。superで親の処理を呼び出すことも可能です。
• コンストラクタ: 子クラスのコンストラクタは、必ず最初に親クラスのコンストラクタを呼び出します（明示的なsuper()または自動挿入）。
• アクセス修飾子: publicやprotectedは継承された子クラスからアクセス可能ですが、privateはアクセスできません。
• ポリモーフィズム: 親クラスの型として子クラスのインスタンスを扱うことで、柔軟で拡張性の高いコードが実現します。
• 抽象クラスとインターフェース: 継承と並んで、型定義とポリモーフィズムを実現する重要な概念です。それぞれの特性を理解し、適切に使い分けましょう。
• メリット・デメリット: コードの再利用性、拡張性、保守性というメリットがある一方、密結合や複雑化のリスクというデメリットも理解しておくべきです。
• 委譲との使い分け: 継承が不適切な場面では、「継承よりも委譲を優先せよ」という原則に従い、より疎結合な設計を目指しましょう。

Javaの継承は、単にコードを再利用するだけでなく、オブジェクト指向の三大要素であるポリモーフィズムを実現し、柔軟で拡張性のあるシステムを構築するための土台となります。しかし、その強力さゆえに、安易な使用はシステムの複雑性を増したり、メンテナンス性を損なったりする可能性もあります。

重要なのは、それぞれの概念を深く理解し、目の前の問題に対して「最適な」設計パターンを選択する力です。この記事を通じて、あなたがJavaの継承に対する理解を深め、より良いコードを書くための一助となれば幸いです。

ぜひ、実際にコードを書いてみて、継承の挙動を肌で感じてみてください。実践を通してこそ、真の理解が生まれるはずです！

よくある質問 (FAQ)

Q1: Javaは多重継承できますか？

A1: いいえ、Javaはクラスの多重継承をサポートしていません。つまり、1つのクラスが複数の親クラスをextendsすることはできません。これは、複数の親クラスから同じ名前のメソッドが継承された場合に、どちらのメソッドを呼び出すべきかコンパイラが判断できなくなる「ダイヤモンド問題」を避けるためです。 ただし、インターフェースであれば、1つのクラスが複数のインターフェースをimplementsすることは可能です。これにより、多重継承が提供する「複数の異なる振る舞いをクラスに持たせる」という目的を達成できます。

Q2: 子クラスのコンストラクタでsuper()を必ず呼び出す必要がありますか？

A2: 明示的にsuper()（または引数付きのsuper(args)）を記述しなくても、子クラスのコンストラクタの最初の行で、引数なしのsuper()が自動的に呼び出されます。 しかし、親クラスが引数なしのコンストラクタ（デフォルトコンストラクタ）を持っておらず、引数付きのコンストラクタしか持っていない場合は、子クラスは明示的にsuper(引数)を呼び出す必要があります。そうしないとコンパイルエラーになります。

Q3: 親クラスのprivateメンバーは子クラスに継承されますか？

A3: 厳密には、privateメンバーもメモリ上には存在し、技術的には「継承される」と言えます。しかし、子クラスから直接そのprivateメンバーにアクセスすることはできません。privateアクセス修飾子は、そのメンバーが宣言されたクラス内からのみアクセス可能であることを意味するため、子クラスであっても直接操作は許されません。 子クラスからprivateメンバーにアクセスしたい場合は、親クラスがpublicまたはprotectedなgetter/setterメソッドを提供している必要があります。