Javaの内部クラスを使ったデザインパターンの実装例：効果的な使い方を徹底解説

Javaの内部クラスは、外部クラスと密接に関連する設計で使われる強力なツールです。特にデザインパターンを実装する際に、内部クラスを使うことでコードの簡潔さやモジュール性を向上させ、クラス同士の依存関係を管理しやすくすることが可能です。本記事では、Javaの内部クラスの基本的な概念から、Singleton、Factory、Observer、Builderなど、代表的なデザインパターンにおける内部クラスの実装方法を解説し、可読性と保守性を保ちながら効率的にコードを構築するための手法を紹介します。

内部クラスの基本概念

Javaの内部クラスは、他のクラスの内部で定義されるクラスのことを指します。外部クラスと密接に関連しており、外部クラスのメンバーに直接アクセスできる点が大きな特徴です。内部クラスを使用することで、外部クラスの論理的なまとまりを維持しつつ、クラス同士の関係を効率的に管理できます。

内部クラスの主な特徴

1. 外部クラスのメンバーにアクセス: 内部クラスは、外部クラスのフィールドやメソッドに直接アクセスでき、外部クラスと強い結びつきを持ちます。
2. カプセル化の向上: 内部クラスを使用することで、関連するクラスや機能を1つのクラスにまとめ、外部に露出させたくないロジックを隠すことが可能です。
3. インスタンスの相互依存: 非静的な内部クラスは、外部クラスのインスタンスなしには存在できないため、インスタンス間の依存関係が強化されます。

内部クラスは、設計上のメリットを提供しますが、乱用するとコードの複雑化につながるため、適切な使用が求められます。

内部クラスの種類

Javaには複数の内部クラスの種類があり、それぞれ異なる目的や使用シナリオに適しています。内部クラスは、大きく4つの種類に分類されます。これらのクラスは、特定の設計やロジックを実装する際に便利なツールです。

静的内部クラス

静的内部クラス（Static Nested Class）は、外部クラスのインスタンスに依存せずに定義される内部クラスです。静的なため、外部クラスの静的メンバーにのみアクセスできます。インスタンスの相互依存を避けたい場合に有効です。

class OuterClass {
    static class StaticNestedClass {
        void display() {
            System.out.println("This is a static nested class.");
        }
    }
}

非静的内部クラス

非静的内部クラスは、外部クラスのインスタンスに依存し、外部クラスのメンバー（フィールドやメソッド）に直接アクセスできます。非静的内部クラスは、外部クラスの状態に強く関連する場合に便利です。

class OuterClass {
    class InnerClass {
        void display() {
            System.out.println("This is a non-static inner class.");
        }
    }
}

匿名クラス

匿名クラスは、特定のクラスやインターフェースを即座に拡張または実装するための内部クラスです。名前を持たず、その場限りで定義・使用されることが多いです。短いコードで簡潔な実装を行いたい場合に使用されます。

OuterClass outer = new OuterClass();
outer.doSomething(new SomeInterface() {
    @Override
    public void perform() {
        System.out.println("This is an anonymous class.");
    }
});

ローカルクラス

ローカルクラスは、メソッド内で定義されるクラスです。メソッドのローカル変数にアクセスでき、メソッドが呼ばれた際にのみ利用されるクラスです。メソッド内で特定の動作をカプセル化したいときに使用されます。

class OuterClass {
    void method() {
        class LocalClass {
            void display() {
                System.out.println("This is a local class.");
            }
        }
        LocalClass local = new LocalClass();
        local.display();
    }
}

これらの内部クラスは、それぞれ異なるシチュエーションで役立つため、適切に選択することが重要です。

デザインパターンとは

デザインパターンは、ソフトウェア開発における一般的な問題に対する再利用可能な解決策のことを指します。これらのパターンは、ソフトウェア設計におけるベストプラクティスとして多くの開発者に共有され、システムの構造を効率化し、保守性や拡張性を向上させるために使用されます。

デザインパターンの分類

デザインパターンは主に3つのカテゴリに分類されます。

1. 生成パターン

オブジェクトの作成に関連するパターンで、オブジェクトの生成方法やそのプロセスをカプセル化し、柔軟性を提供します。以下は代表的な生成パターンです。

• Singleton: クラスのインスタンスが1つしか存在しないことを保証するパターン。
• Factory Method: インスタンス化の責務をサブクラスに委譲するパターン。

2. 構造パターン

クラスやオブジェクトの構造を効率的に組み合わせるパターンで、システムの拡張や変更がしやすくなります。代表的な構造パターンには以下があります。

• Adapter: インターフェースの違いを埋めて異なるクラスを接続するパターン。
• Decorator: オブジェクトに新しい機能を追加するパターン。

3. 行動パターン

オブジェクト間のコミュニケーションや、動作に関連するパターンです。オブジェクトの相互作用を効率化します。

• Observer: オブジェクトの状態変化を他のオブジェクトに通知するパターン。
• Strategy: アルゴリズムを動的に切り替えるパターン。

デザインパターンの重要性

デザインパターンは、以下の理由からソフトウェア開発において非常に重要です。

• 再利用性: パターンは、多くのシステムで繰り返し使用できるため、設計の効率を向上させます。
• コミュニケーションの効率化: 開発者間で共通のパターンを使用することで、設計の意図を明確に伝えることができ、理解が容易になります。
• 保守性の向上: 設計をパターンに従って行うことで、変更や修正が容易になり、コードの保守性が向上します。

デザインパターンを理解することで、柔軟かつメンテナンスしやすいコードを設計する能力が向上します。特にJavaの内部クラスと組み合わせることで、デザインパターンをさらに効果的に実装することができます。

内部クラスとSingletonパターン

Singletonパターンは、あるクラスのインスタンスが1つしか存在しないことを保証するデザインパターンです。Javaでは、内部クラスを利用することでこのパターンを簡潔かつ効率的に実装することができます。内部クラスを使ったSingletonの実装は、「Lazy Initialization（遅延初期化）」の利点を活かしつつ、スレッドセーフな設計を実現するのが特徴です。

内部クラスを使ったSingletonパターンの実装

内部クラスを利用してSingletonパターンを実装する場合、外部クラスの静的メソッドから内部クラスにアクセスすることで、インスタンスの作成タイミングを制御できます。この方法では、クラスが初めて使用されたタイミングでインスタンスが生成されるため、Lazy Initializationを自然に実現できます。

以下が、内部クラスを使ったSingletonパターンのコード例です。

public class Singleton {
    // プライベートコンストラクタで外部からのインスタンス化を防ぐ
    private Singleton() {}

    // 静的内部クラス：インスタンスを保持する
    private static class SingletonHolder {
        // Singletonクラスの唯一のインスタンスを保持
        private static final Singleton INSTANCE = new Singleton();
    }

    // インスタンスを返すメソッド
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

この実装のメリット

1. 遅延初期化: SingletonHolderクラスは、getInstance()メソッドが呼ばれるまでロードされないため、インスタンスが必要になるまで初期化されません。これにより、リソースを効率的に使用できます。
2. スレッドセーフ: 内部クラスのロードはJVMによってスレッドセーフに処理されるため、特別な同期処理を追加せずともスレッドセーフなSingletonが実現できます。
3. 簡潔で保守性が高い: 内部クラスを使うことで、従来のDouble-Checked Locking（DCL）などの複雑な同期機構を使わずに、安全で効率的なSingletonを実装できます。

Singletonパターンを使うべきシナリオ

内部クラスを使ったSingletonパターンは、以下のようなシナリオで効果的です。

• グローバルに1つだけ存在するオブジェクト（例：設定ファイルの管理クラス、ログ管理クラスなど）が必要な場合。
• インスタンス生成がリソース集約型であり、遅延初期化が求められる場合。

内部クラスを使うことで、効率的かつシンプルにSingletonパターンを実装でき、スレッドセーフな環境でも問題なく動作するため、多くのJavaプロジェクトで採用されています。

内部クラスとFactoryパターン

Factoryパターンは、オブジェクトの生成をカプセル化し、どのクラスのインスタンスを作成するかを外部から隠すデザインパターンです。このパターンでは、インスタンス生成のロジックを1つの場所に集約することで、コードの可読性やメンテナンス性を向上させることができます。Javaの内部クラスを使用することで、Factoryパターンの実装をさらに整理された形で提供できます。

内部クラスを使ったFactoryパターンの実装

内部クラスを使用することで、Factoryクラスとその生成メソッドを外部クラスの内部に隠しつつ、複数のオブジェクト生成ロジックを整理してカプセル化できます。以下のコードは、内部クラスを使用したFactoryパターンの例です。

public class ProductFactory {

    // 抽象製品クラス
    public static abstract class Product {
        abstract void create();
    }

    // 具体的な製品クラスA
    private static class ProductA extends Product {
        @Override
        void create() {
            System.out.println("Product A is created.");
        }
    }

    // 具体的な製品クラスB
    private static class ProductB extends Product {
        @Override
        void create() {
            System.out.println("Product B is created.");
        }
    }

    // Factoryクラス：製品を生成するメソッドを提供
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            default:
                throw new IllegalArgumentException("Unknown product type");
        }
    }
}

上記の例では、ProductFactoryクラスが外部から製品を生成する役割を担い、ProductAとProductBは内部クラスとして隠されています。このように、内部クラスを使用することで、具体的な製品の詳細を外部に露出させず、生成ロジックを整理できます。

この実装のメリット

1. カプセル化の向上: 製品クラス（ProductAやProductB）は外部に公開されておらず、生成の詳細が隠されています。これにより、外部からはFactoryのインターフェースを通してオブジェクトを取得するだけでよくなります。
2. 柔軟なオブジェクト生成: createProductメソッドを使用することで、特定の条件に応じて適切な製品を生成できます。条件分岐や追加の処理を簡単に組み込むことができるため、将来の拡張性が高まります。
3. メンテナンスが容易: 製品クラスの追加や変更があっても、Factoryの内部で処理できるため、外部コードには影響を与えません。これにより、コード全体のメンテナンスが簡単になります。

Factoryパターンを使うべきシナリオ

• クライアントコードが具体的なクラスを知らずに、オブジェクトを生成できる必要がある場合。
• オブジェクトの生成ロジックが複雑で、生成プロセスを一元管理したい場合。
• 生成するオブジェクトの種類が増える可能性があるプロジェクトで、拡張性が求められる場合。

このように、内部クラスを使うことで、Factoryパターンの実装を整理し、製品生成の詳細を隠蔽しつつ柔軟性の高いコードを構築することが可能です。

内部クラスとObserverパターン

Observerパターンは、あるオブジェクトの状態が変化した際に、他のオブジェクトに通知を行うデザインパターンです。このパターンは、多対多の依存関係を持つオブジェクト間の効率的な通知メカニズムを提供します。Javaでは内部クラスを使用することで、ObserverとSubjectのロジックをよりコンパクトに整理し、コードの可読性と保守性を向上させることが可能です。

Observerパターンの基本構造

Observerパターンは、以下の2つの要素から構成されます。

• Subject（観察対象）: 状態の変化を通知するオブジェクト。
• Observer（観察者）: 状態変化を受け取るオブジェクト。

内部クラスを使えば、これらのクラスを1つのファイル内に整理でき、必要な依存関係を外部に露出させずに実装することができます。

内部クラスを使ったObserverパターンの実装例

次に、内部クラスを使ったObserverパターンの実装例を示します。Subjectは状態が変わった際にObserverに通知を行い、Observerはそれに応じて動作を行います。

import java.util.ArrayList;
import java.util.List;

public class WeatherStation {

    // Observerインターフェース
    public interface Observer {
        void update(float temperature);
    }

    // Subjectクラス
    public class Subject {
        private List<Observer> observers = new ArrayList<>();
        private float temperature;

        // Observerを登録
        public void addObserver(Observer observer) {
            observers.add(observer);
        }

        // Observerに通知
        public void notifyObservers() {
            for (Observer observer : observers) {
                observer.update(temperature);
            }
        }

        // 状態が変化した時に通知
        public void setTemperature(float temperature) {
            this.temperature = temperature;
            notifyObservers();
        }
    }

    // 具体的なObserverクラス
    public class Display implements Observer {
        @Override
        public void update(float temperature) {
            System.out.println("Temperature updated: " + temperature);
        }
    }

    public static void main(String[] args) {
        WeatherStation station = new WeatherStation();
        Subject weatherData = station.new Subject();
        Observer display = station.new Display();

        // Observerを登録
        weatherData.addObserver(display);

        // 温度を更新
        weatherData.setTemperature(25.5f);
    }
}

この実装のメリット

1. コンパクトなコード構造: 内部クラスを使うことで、SubjectとObserverの実装を1つのクラス内に収め、コード全体をコンパクトにできます。これにより、クラス間の依存関係を明確にしつつ、構造を整理できます。
2. 柔軟な通知システム: Subjectは複数のObserverを管理でき、状態変化を即座に通知します。Observerはその変化を受けて必要な処理を行うため、柔軟かつ効率的な通知メカニズムを提供します。
3. 保守性の向上: 内部クラスを使用することで、ObserverとSubjectの関連を明確にし、必要な変更があった場合にも1つのクラス内で簡単に修正できます。

Observerパターンを使うべきシナリオ

• 状態が変化するオブジェクト（Subject）が複数のオブジェクト（Observer）に通知する必要がある場合。
• MVC（Model-View-Controller）パターンで、モデルの変化をビューに反映させる必要がある場合。
• イベント駆動型のシステムで、あるオブジェクトのイベントを他のオブジェクトに伝えたい場合。

Observerパターンは、リアルタイムでオブジェクトの変化を追跡し、他の関連するオブジェクトに即座に反映させる際に便利な手法です。内部クラスを活用することで、実装を整理し、可読性と保守性を向上させたObserverパターンを効率的に構築できます。

内部クラスとBuilderパターン

Builderパターンは、複雑なオブジェクトを段階的に構築するためのデザインパターンです。このパターンは、オブジェクトの生成プロセスを分離することで、コードの可読性と柔軟性を向上させます。Javaの内部クラスを利用することで、Builderパターンを簡潔に実装し、クラス設計を整理できます。

Builderパターンの基本概念

Builderパターンの主な目的は、可読性の高いコードで複雑なオブジェクトを構築することです。通常、複数のフィールドを持つオブジェクトの生成には多くのコンストラクタが必要となり、コードが煩雑になります。Builderパターンを使うことで、この問題を解決し、柔軟かつ分かりやすいオブジェクトの構築が可能です。

内部クラスを使ったBuilderパターンの実装例

以下は、内部クラスを使ったBuilderパターンの実装例です。外部クラス内にBuilderクラスを定義し、オブジェクト生成のロジックを整理します。

public class House {

    // Houseクラスのフィールド
    private String foundation;
    private String structure;
    private String roof;
    private boolean hasGarage;

    // プライベートコンストラクタ（Builder経由でのみ生成可能）
    private House(HouseBuilder builder) {
        this.foundation = builder.foundation;
        this.structure = builder.structure;
        this.roof = builder.roof;
        this.hasGarage = builder.hasGarage;
    }

    // Builderクラス（内部クラス）
    public static class HouseBuilder {
        private String foundation;
        private String structure;
        private String roof;
        private boolean hasGarage;

        // 基礎を設定
        public HouseBuilder setFoundation(String foundation) {
            this.foundation = foundation;
            return this;
        }

        // 構造を設定
        public HouseBuilder setStructure(String structure) {
            this.structure = structure;
            return this;
        }

        // 屋根を設定
        public HouseBuilder setRoof(String roof) {
            this.roof = roof;
            return this;
        }

        // ガレージの有無を設定
        public HouseBuilder setGarage(boolean hasGarage) {
            this.hasGarage = hasGarage;
            return this;
        }

        // Houseオブジェクトを生成
        public House build() {
            return new House(this);
        }
    }

    @Override
    public String toString() {
        return "House with " + foundation + ", " + structure + ", roof: " + roof + ", Garage: " + hasGarage;
    }

    // 実行例
    public static void main(String[] args) {
        House house = new House.HouseBuilder()
                            .setFoundation("Concrete")
                            .setStructure("Wood")
                            .setRoof("Shingle")
                            .setGarage(true)
                            .build();
        System.out.println(house);
    }
}

この実装のメリット

1. 可読性の向上: HouseBuilder内部クラスを使って、メソッドチェーン形式でオブジェクトを段階的に構築できるため、オブジェクト生成のプロセスが明確で可読性が高くなります。
2. 柔軟性: HouseBuilderクラスを使えば、必要なフィールドのみを指定してオブジェクトを生成でき、複雑なコンストラクタを使う必要がありません。オプションのフィールドを含む柔軟なオブジェクト構築が可能です。
3. 不変オブジェクトの生成: Builderパターンを使用することで、生成されたオブジェクトは不変になります。つまり、オブジェクトが生成された後にフィールドを変更することができないため、安全で信頼性の高い設計が可能です。

Builderパターンを使うべきシナリオ

• コンストラクタに多くのパラメータが必要な場合。
• オブジェクトの作成において、柔軟に設定を変更したり、段階的に構築する必要がある場合。
• オブジェクト生成時に、オプションの設定や複雑な初期化が必要な場合。

Builderパターンは、特に複雑なオブジェクトを構築する際に役立つデザインパターンです。内部クラスを使用することで、生成ロジックを外部に隠蔽し、シンプルかつ柔軟なコードを実現できます。この方法により、柔軟でメンテナンス性の高いオブジェクト生成が可能となります。

内部クラスを使ったコードの可読性と保守性

Javaの内部クラスは、コードの構造を整理し、クラスの関連性を高めるための強力なツールです。適切に使用することで、コードの可読性や保守性を大幅に向上させることができますが、乱用すると逆にコードが複雑化し、理解しにくくなることもあります。本項では、内部クラスが可読性と保守性に与える影響について解説します。

内部クラスによる可読性の向上

内部クラスは、外部クラスに強く関連する処理やロジックを一箇所にまとめることで、コードの分かりやすさを向上させます。以下はその具体的なメリットです。

1. 関連性の強いコードの集約

内部クラスを使用することで、関連するクラスや処理を1つのファイルにまとめられます。これにより、外部クラスの構造やロジックと緊密な関係を持つクラスが近くに配置され、クラス間の関係が明確になります。例えば、デザインパターンを実装する際、内部クラスを使うことでそのパターンに関連するクラスを適切にグループ化できます。

2. コードの分割による簡潔な実装

匿名クラスやローカルクラスを利用することで、特定の処理に限定されたクラスをその場で定義でき、わざわざクラスを別ファイルに定義する必要がありません。これにより、コードがスリム化し、読みやすくなります。

内部クラスによる保守性の向上

保守性の高いコードは、将来的な変更や拡張が容易であることが重要です。内部クラスはその面でも役立ちます。

1. クラスのカプセル化と依存関係の制御

内部クラスを使用することで、外部に公開する必要のないロジックをクラス内に隠蔽できます。これにより、外部クラスの実装に直接影響を与えることなく、内部クラスを変更したり拡張したりすることが可能です。特に、FactoryパターンやObserverパターンのように、複数のクラスが密接に関連する場合、内部クラスを用いることで変更範囲を局所化し、コード全体の保守性を高めることができます。

2. 名前衝突の防止

内部クラスを使用することで、名前の競合を避けやすくなります。クラス名が外部に公開されず、外部クラスのスコープ内でのみ使用されるため、クラスの再利用や修正時に名前衝突の心配が少なくなります。

内部クラスの乱用によるデメリット

一方で、内部クラスを多用すると、コードが不必要に複雑になり、可読性や保守性が低下する場合もあります。

1. 複雑なネストによる可読性の低下

内部クラスが過度に入れ子状になると、コードの階層が深くなり、可読性が損なわれます。特に、複数の匿名クラスやローカルクラスが1つのメソッド内で定義されている場合、メソッドの目的や流れを把握するのが難しくなる可能性があります。

2. クラス依存度の過度な強化

内部クラスは、外部クラスに強く依存するため、外部クラスの変更が内部クラスにも大きな影響を与える可能性があります。このような高い依存関係は、クラス設計が複雑になる原因となり、将来的な変更が困難になることがあります。

内部クラスを適切に使用するためのガイドライン

1. 関連性の高い処理に限定して使用: 内部クラスは、外部クラスと強い関連性を持つ場合にのみ使用すべきです。無関係なロジックを内部クラスに持たせると、クラス設計が不自然になり、可読性が損なわれます。
2. 簡潔な設計を心がける: 内部クラスは必要最小限に抑え、階層を深くしすぎないように注意しましょう。特に匿名クラスやローカルクラスを使用する際は、メソッドやクラスの役割が複雑にならないようにすることが重要です。
3. 名前の競合を防ぐ: 内部クラスを使用することで、外部クラスの命名規則をシンプルに保ち、名前衝突を避ける設計を心がけます。

内部クラスを効果的に使用することで、コードの可読性と保守性を向上させることができますが、乱用は避け、適切な場面でのみ使用することが重要です。

内部クラスを用いるべきケースと避けるべきケース

内部クラスは、Javaの強力な機能の一つであり、適切な場面で使用することでコードの整理や効率性を向上させます。しかし、適切でない場面で使用すると、かえって複雑化や可読性の低下を招くことがあります。ここでは、内部クラスを使うべきケースと、避けるべきケースについて解説します。

内部クラスを用いるべきケース

1. 外部クラスと密接に関連する処理を持つ場合

内部クラスは、外部クラスのデータやメソッドに直接アクセスできるため、外部クラスの状態や動作に強く依存する場合に効果的です。例えば、FactoryパターンやObserverパターンのように、内部クラスと外部クラスが協調して動作する場面では、内部クラスを使うことでコードの一貫性を保ちつつ、実装を簡潔にできます。

2. カプセル化を強化したい場合

内部クラスは、外部クラスに依存する詳細な実装を隠す手段として有効です。これにより、クライアントコードに対して外部クラスのインターフェースのみを公開し、内部ロジックを隠蔽できます。例えば、あるクラスの内部状態を処理する補助的なクラスを公開せずに使用したい場合、内部クラスは理想的な選択です。

3. 簡潔に一度だけ使用するロジックを表現したい場合

匿名クラスやローカルクラスは、一度しか使用しないロジックを簡潔に表現する際に便利です。例えば、イベントリスナーやコールバックメソッドをその場で定義して渡す場合に、匿名クラスを使用すればクラス全体を別途定義する必要がなくなり、コードを簡素化できます。

内部クラスを避けるべきケース

1. 外部クラスと無関係な処理を行う場合

内部クラスは外部クラスと強く関連付けられているため、外部クラスに依存しない処理を行う場合には適していません。このような場合、外部クラスとは独立した通常のクラスとして定義する方が、責務が明確であり、コードの再利用性も高まります。

2. 複雑なネスト構造を持つ場合

内部クラスを多用して階層が深くなると、コードの可読性が低下し、保守が困難になります。特に、匿名クラスやローカルクラスを乱用すると、メソッド内のロジックが複雑になり、後から修正する際に混乱を招く可能性があります。複雑なロジックを扱う場合は、明確に分離されたクラスを作成する方が望ましいです。

3. 大規模プロジェクトでの使用

内部クラスは、外部クラスとの強い依存関係を持つため、大規模なプロジェクトでは変更や再利用が難しくなることがあります。特に、チーム開発において、内部クラスの存在を知らない他の開発者にとっては、意図を理解するのが難しくなることがあります。このような場合、クラス設計を明確に分離することが推奨されます。

内部クラスを使用する際の判断基準

• 密接な関連性があるかどうか: 内部クラスは、外部クラスとの関係が強い場合にのみ使用することが適しています。
• 保守性が損なわれないか: 長期的な保守を考慮し、内部クラスを使用することでコードが複雑化しないか検討することが重要です。
• コードの簡潔さを保てるか: 内部クラスの使用がコードを簡潔にする場合にのみ、使用を検討するべきです。無駄に多用するとかえって複雑化を招く恐れがあります。

内部クラスは、特定の場面では強力なツールですが、適切に判断して使用することが重要です。これにより、コードの可読性と保守性を保ちながら、効果的な設計を行うことが可能になります。

実践的な演習問題

内部クラスとデザインパターンの理解を深めるために、以下の演習問題に取り組んでみましょう。これらの問題では、Javaの内部クラスを活用して、設計パターンを実装する練習を行います。実際にコードを書いて動作を確認しながら、内部クラスとパターンの効果を体感してください。

演習1: 内部クラスを使ったSingletonパターンの実装

問題
以下の要件を満たすように、内部クラスを用いたSingletonパターンを実装してください。

• クラス名は DatabaseConnection とする。
• このクラスは、データベース接続を管理するもので、システム全体で1つのインスタンスしか存在しないことを保証する。
• getInstance() メソッドで、インスタンスを取得できるようにする。

public class DatabaseConnection {
    // 内部クラスを使ってSingletonパターンを実装せよ
}

ヒント
内部クラスを使ったSingletonパターンの基本構造は、DatabaseConnectionHolderという静的な内部クラスを使うことです。この内部クラスがインスタンスを保持し、getInstance()メソッドが初めて呼ばれた時点でインスタンスを生成します。

演習2: 内部クラスを使ったFactoryパターンの実装

問題
以下の要件を満たすように、内部クラスを使ったFactoryパターンを実装してください。

• クラス名は ShapeFactory とする。
• ShapeFactory クラスの中に Circle と Square という2つの図形クラスを定義する。
• ShapeFactory 内に createShape(String type) メソッドを実装し、”Circle” または “Square” を指定すると、それぞれの図形オブジェクトを返すようにする。

public class ShapeFactory {
    // 内部クラスを使ってFactoryパターンを実装せよ
}

ヒント
ShapeFactory の内部クラスとして Circle と Square を定義し、createShape() メソッドでそのインスタンスを生成するように実装します。

演習3: 内部クラスを使ったObserverパターンの実装

問題
次の要件を満たすように、内部クラスを使ったObserverパターンを実装してください。

• クラス名は WeatherStation とする。
• WeatherStation クラスは Observer インターフェースを実装するクラスを複数持つ。
• addObserver(Observer observer) メソッドで観察者を登録し、setTemperature(float temp) メソッドで温度を更新した際にすべての観察者に通知を行う。

public class WeatherStation {
    // 内部クラスを使ってObserverパターンを実装せよ
}

ヒント
Observer インターフェースを実装した内部クラスを作成し、WeatherStation クラス内にリストとして保持します。温度が変更された際に、そのリスト内のすべてのオブザーバに通知するようにします。

演習4: Builderパターンを使ったオブジェクト生成

問題
内部クラスを使って Car クラスのBuilderパターンを実装してください。Car クラスは、以下のフィールドを持ちます。

• エンジンの種類
• カラー
• シート数
• ナビゲーションシステムの有無

Builderパターンを使って、必要なオプションを選択しながら Car オブジェクトを生成できるようにしてください。

public class Car {
    // 内部クラスを使ってBuilderパターンを実装せよ
}

ヒント
Car クラスの内部に CarBuilder クラスを定義し、各フィールドを設定するメソッドを作成します。最終的に build() メソッドを使って Car のインスタンスを生成します。

まとめ

これらの演習問題に取り組むことで、Javaの内部クラスとデザインパターンの理解を深めることができます。各パターンの特徴を学びながら、実装の練習を行い、実際の開発に役立つスキルを身につけましょう。

まとめ

本記事では、Javaの内部クラスを使ったデザインパターンの実装例を紹介しました。内部クラスを使用することで、コードのカプセル化や可読性が向上し、設計パターンの実装が効率的に行えることが確認できました。Singleton、Factory、Observer、Builderなど、各パターンに適した内部クラスの使い方を理解することで、Javaの開発における柔軟性と保守性を高めることができます。