Javaコードで学ぶデザインパターン

プログラミングをしていると、「同じような問題をもっと効率的に解決する方法はないだろうか？」と考えることがあります。デザインパターン（Design Pattern） は、このような悩みを解決するために生まれた、プログラミングの知恵です。本記事では、デザインパターンの概念や重要性を理解し、生成（Creational）、構造（Structural）、振る舞い（Behavioral） パターンの主要な例をJavaコードとともに紹介します。

1. デザインパターンとは？

デザインパターン とは、ソフトウェア設計における繰り返し発生する問題を解決するための 再利用可能な設計テンプレート です。
これを活用することで、コードをシンプルにし、保守性と拡張性を向上させることができます。

デザインパターンの主なメリット

コード再利用性: 検証済みの設計手法のため、高い安定性を提供します。
効率性: 問題解決のために新たな手法を考える必要がありません。
可読性: チーム間でコードの理解が容易になり、円滑な協力を促進します。
柔軟性: 拡張性と保守性を考慮した構造を提供します。

2. デザインパターンの分類

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

生成パターン（Creational Patterns）
- オブジェクト生成のプロセスをカプセル化し、複雑さを軽減しつつ柔軟性を高めます。
- 主なパターン: Singleton, Factory Method, Builder など。
構造パターン（Structural Patterns）
- クラスやオブジェクトを組み合わせて、より大きな構造を作成します。
- 主なパターン: Adapter, Composite, Decorator など。
振る舞いパターン（Behavioral Patterns）
- オブジェクト間の相互作用や責任の分担に焦点を当てます。
- 主なパターン: Observer, Strategy, Command など。

3. 主なデザインパターンとJavaの例

3-1. 生成パターン（Creational Patterns）

1) シングルトンパターン（Singleton Pattern）

定義:
クラスのインスタンスを1つだけ作成し、どこからでもアクセスできるように保証します。

使用する場面:

データベース接続やログ記録など、アプリケーション全体で同一のオブジェクトが必要な場合。

Javaコード例:

public class Singleton {
    // 唯一のインスタンスを保持する静的変数
    private static Singleton instance;

    // privateコンストラクタで外部からのインスタンス生成を防止
    private Singleton() {}

    // 唯一のインスタンスを返すメソッド
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    public void showMessage() {
        System.out.println("Hello, I am a Singleton!");
    }
}

// 使用例
public class Main {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        singleton.showMessage();
    }
}

メリット:

メモリ使用を最適化します。
デメリット:
マルチスレッド環境では同期化（synchronization）が必要な場合があります。

2) ファクトリメソッドパターン（Factory Method Pattern）

定義:
オブジェクト生成コードをカプセル化し、オブジェクト生成方法をサブクラスに委譲します。

使用する場面:

オブジェクト生成ロジックが複雑な場合、または実行時にオブジェクトの種類を決定する必要がある場合。

Javaコード例:

// 共通インターフェース
public interface Product {
    void use();
}

// 具体的な製品クラス
public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using Product A");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using Product B");
    }
}

// ファクトリクラス
public class ProductFactory {
    public static Product createProduct(String type) {
        if (type.equalsIgnoreCase("A")) {
            return new ConcreteProductA();
        } else if (type.equalsIgnoreCase("B")) {
            return new ConcreteProductB();
        }
        throw new IllegalArgumentException("Unknown product type");
    }
}

// 使用例
public class Main {
    public static void main(String[] args) {
        Product productA = ProductFactory.createProduct("A");
        productA.use(); // Using Product A

        Product productB = ProductFactory.createProduct("B");
        productB.use(); // Using Product B
    }
}

メリット:

オブジェクト生成ロジックが一元化され、管理が容易になります。
デメリット:
新しい製品タイプを追加する際にファクトリメソッドを修正する必要があります。

3-2. 構造パターン（Structural Patterns）

1) アダプタパターン（Adapter Pattern）

定義:
互換性のないインターフェースを持つクラスを接続します。

使用する場面:

既存クラスを修正できないが、新しいインターフェースと互換性を持たせる必要がある場合。

Javaコード例:

// ターゲットインターフェース
public interface Target {
    void request();
}

// 既存のクラス
public class Adaptee {
    public void specificRequest() {
        System.out.println("Specific request executed");
    }
}

// アダプタクラス
public class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

// 使用例
public class Main {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target adapter = new Adapter(adaptee);

        adapter.request(); // Specific request executed
    }
}

メリット:

既存コードを変更せずに新しい要件に対応できます。
デメリット:
コード構造が複雑になる場合があります。

3-3. 振る舞いパターン（Behavioral Patterns）

1) オブザーバーパターン（Observer Pattern）

定義:
1つのオブジェクトの状態変化が他のオブジェクトに自動的に通知されるように設計します。

使用する場面:

イベント駆動型のシステムで、複数のオブジェクトが特定のオブジェクトの状態を監視する必要がある場合。

Javaコード例:

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

// オブザーバーインターフェース
public interface Observer {
    void update(String message);
}

// 具体的なオブザーバー
public class ConcreteObserver implements Observer {
    private String name;

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

    @Override
    public void update(String message) {
        System.out.println(name + " received message: " + message);
    }
}

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

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

// 使用例
public class Main {
    public static void main(String[] args) {
        Subject subject = new Subject();

        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");

        subject.addObserver(observer1);
        subject.addObserver(observer2);

        subject.notifyObservers("Hello, Observers!"); 
        // Observer 1 received message: Hello, Observers!
        // Observer 2 received message: Hello, Observers!
    }
}

メリット:

オブジェクト間の結合度を低くすることができます。
デメリット:
オブザーバーの数が増えると管理が複雑になる可能性があります。

4. まとめ

デザインパターンは、単なるコーディングテクニックではなく、問題解決のための 標準化されたソリューション です。それぞれのパターンの意図を理解し、適切に活用することで、コード品質を大幅に向上させることができます。
今回の記事では、主要なパターンの一部のみを紹介しましたが、さらに深い学習のために「GoF デザインパターン本」などの資料を参照することをおすすめします。