Javaにおける一般的なデザインパターンは何か？

Question

Accepted Answer

**デザインパターン**は、ソフトウェア設計における反復的な問題に対する再利用可能なソリューションです。Javaの OOP の性質とエコシステムにより、いくつかのパターンが特に一般的です — これらを知ることで、パターンを認識し、コミュニケーションを取り、証明済みの構造を適用するのに役立ちます。これらは生成、構造、行動のカテゴリに分類されます。

## Singleton（生成パターン）— 1つの共有インスタンス

```java
public class Config {
    private static final Config INSTANCE = new Config();   // the single instance
    private Config() {}                                     // private constructor
    public static Config getInstance() { return INSTANCE; }
}
// (enum singletons are an even safer idiom). Used for shared config, connection pools.
```

## Factory（生成パターン）— オブジェクト生成のカプセル化

```java
public static Shape createShape(String type) {
    return switch (type) {                 // hides the concrete class from the caller
        case "circle" -> new Circle();
        case "square" -> new Square();
        default -> throw new IllegalArgumentException();
    };
}
// caller depends on Shape, not concrete classes — decoupling.
```

## Builder（生成パターン）— 複雑なオブジェクトを段階的に構築

```java
User user = new User.Builder()
    .name("Ann")
    .email("ann@x.com")
    .age(30)
    .build();    // readable construction; avoids huge telescoping constructors
```

## Strategy（行動パターン）— 交換可能なアルゴリズム

```java
interface PaymentStrategy { void pay(double amount); }
class CreditCard implements PaymentStrategy { public void pay(double a) {...} }
class PayPal implements PaymentStrategy { public void pay(double a) {...} }

// swap behavior at runtime — lambdas make this trivial in modern Java
processor.setStrategy(new PayPal());
```

## Observer（行動パターン）— publish/subscribe

```java
// subjects notify registered observers of changes (events, listeners)
button.addActionListener(e -> handleClick());   // GUI events use this everywhere
```

## Decorator（構造パターン）— ラップして機能を追加

```java
// Java's I/O streams ARE the decorator pattern:
BufferedReader r = new BufferedReader(new FileReader("f.txt"));
// BufferedReader wraps FileReader, adding buffering
```

## Java自体に現れるパターン

```text
Singleton  → Runtime.getRuntime()
Factory    → Calendar.getInstance(), DriverManager
Builder    → StringBuilder, Stream.Builder
Observer   → event listeners, java.util.Observer
Decorator  → java.io streams (BufferedReader wrapping FileReader)
Iterator   → the Iterator interface / Collections
Strategy   → Comparator, functional interfaces
```

## 過度な使用に対する警告

```text
Patterns are tools, not goals. Applying them where they don't fit ADDS complexity.
Use them when they genuinely solve your problem — many can be simpler with lambdas now.
```

## なぜ重要なのか

デザインパターンは、共通の設計問題に対する共有語彙と証明済みのソリューションを提供します。これはコミュニケーション（「ここでStrategyを使おう」）、既存のコードの構造認識、および欠陥のあるソリューションの再発明を避けるのに有益です。

Javaの標準ライブラリ全体に現れ（I/Oデコレータ、ファクトリーメソッド、ビルダー、オブザーバーベースのイベント）、これらを理解することは標準ライブラリを効果的に使用および拡張するのに役立ちます。

主要なパターン（Singleton、Factory、Builder、Strategy、Observer、Decorator）を知り、それぞれがどこに適合するかを理解することは、経験豊富な開発者の証し であり、頻繁に面接のトピックになります。

同様に重要なのは、特にラムダなどの最新の機能が多くの古典的なパターンを簡素化するため、適切に適用する（実際の問題を解決する）か、強制的に適用しないかの判断です。