@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/getting-start-tdd/java/08-design-patterns.md

@@ -0,0 +1,393 @@
+# 第 8 章: デザインパターンの適用
+
+## 8.1 はじめに
+
+前章ではカプセル化とポリモーフィズムを使って `switch` 文を排除し、タイプ別のクラス階層を構築しました。この章では、さらに **デザインパターン** を適用してコードの品質を高めていきます。
+
+扱うパターンは以下の 5 つです。
+
+| パターン | 目的 |
+|---------|------|
+| Value Object（値オブジェクト） | プリミティブ型を意味のあるオブジェクトに置換 |
+| First-Class Collection（ファーストクラスコレクション） | コレクションをドメインオブジェクトでラップ |
+| Factory Method（ファクトリメソッド） | オブジェクト生成ロジックを一箇所に集約 |
+| Command（コマンド） | 操作をオブジェクトとしてカプセル化 |
+| Null Object（ヌルオブジェクト） | null の代わりにデフォルト動作を提供 |
+
+## 8.2 Value Object（値オブジェクト）
+
+### 問題: プリミティブ型への執着
+
+現在、`generate` メソッドは `String` を返しています。しかし FizzBuzz の結果には「元の数値」と「変換後の文字列」の 2 つの情報があります。`String` だけでは元の数値が失われてしまいます。
+
+### 解決: FizzBuzzValue
+
+数値と変換結果をペアにした **値オブジェクト** を作成します。
+
+```java
+import java.util.Objects;
+
+public class FizzBuzzValue {
+    private final int number;
+    private final String value;
+
+    public FizzBuzzValue(int number, String value) {
+        this.number = number;
+        this.value = value;
+    }
+
+    public int getNumber() {
+        return number;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    @Override
+    public String toString() {
+        return number + ":" + value;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        }
+        FizzBuzzValue that = (FizzBuzzValue) obj;
+        return number == that.number
+            && Objects.equals(value, that.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(number, value);
+    }
+}
+```
+
+### Value Object の特徴
+
+| 特徴 | 実装 |
+|------|------|
+| 不変（Immutable） | `final` フィールド、setter なし |
+| 等価性（Equality） | `equals` / `hashCode` をオーバーライド |
+| 自己記述的 | `toString` で意味のある表現 |
+
+### FizzBuzzType の戻り値を変更
+
+各タイプクラスの `generate` メソッドが `FizzBuzzValue` を返すように変更します。
+
+```java
+public abstract class FizzBuzzType {
+    // ...
+    public abstract FizzBuzzValue generate(int number);
+}
+
+public class FizzBuzzType01 extends FizzBuzzType {
+    @Override
+    public FizzBuzzValue generate(int number) {
+        if (isFizzBuzz(number)) {
+            return new FizzBuzzValue(number, "FizzBuzz");
+        }
+        if (isFizz(number)) {
+            return new FizzBuzzValue(number, "Fizz");
+        }
+        if (isBuzz(number)) {
+            return new FizzBuzzValue(number, "Buzz");
+        }
+        return new FizzBuzzValue(number, String.valueOf(number));
+    }
+}
+```
+
+## 8.3 First-Class Collection（ファーストクラスコレクション）
+
+### 問題: 生の List
+
+`generateList` は `List<String>` を返していますが、これではリストに対する操作（追加、検索など）がどこでも自由にできてしまいます。
+
+### 解決: FizzBuzzList
+
+コレクションを専用クラスでラップし、ドメインに必要な操作だけを公開します。
+
+```java
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+public class FizzBuzzList {
+    private final List<FizzBuzzValue> values;
+
+    public FizzBuzzList(List<FizzBuzzValue> values) {
+        this.values = new ArrayList<>(values);
+    }
+
+    public List<FizzBuzzValue> getValues() {
+        return new ArrayList<>(values);
+    }
+
+    public FizzBuzzValue get(int index) {
+        return values.get(index);
+    }
+
+    public int size() {
+        return values.size();
+    }
+
+    public FizzBuzzList add(List<FizzBuzzValue> newValues) {
+        List<FizzBuzzValue> combined = new ArrayList<>(values);
+        combined.addAll(newValues);
+        return new FizzBuzzList(combined);
+    }
+
+    @Override
+    public String toString() {
+        return values.toString();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        }
+        FizzBuzzList that = (FizzBuzzList) obj;
+        return Objects.equals(values, that.values);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(values);
+    }
+}
+```
+
+### First-Class Collection の利点
+
+- **防御的コピー**: コンストラクタと getter で `new ArrayList<>()` を使い、外部からの変更を防ぐ
+- **不変操作**: `add` メソッドは新しい `FizzBuzzList` を返す（元のリストは変更しない）
+- **ドメインロジックの集約**: リストに関する操作がこのクラスに集まる
+
+## 8.4 Factory Method（ファクトリメソッド）
+
+### 問題: 生成ロジックの分散
+
+現在、`FizzBuzz` クラスの `createType` メソッドでタイプコードから `FizzBuzzType` を生成しています。しかし、タイプ生成のロジックは `FizzBuzzType` 自身が知るべき責務です。
+
+### 解決: 静的ファクトリメソッド
+
+`FizzBuzzType` に `create` メソッドを追加します。
+
+```java
+public abstract class FizzBuzzType {
+    // ...
+
+    public static FizzBuzzType create(int type) {
+        switch (type) {
+            case 1:
+                return new FizzBuzzType01();
+            case 2:
+                return new FizzBuzzType02();
+            case 3:
+                return new FizzBuzzType03();
+            default:
+                throw new IllegalArgumentException(
+                    "該当するタイプは存在しません");
+        }
+    }
+}
+```
+
+`FizzBuzz` クラスは `FizzBuzzType.create()` を呼ぶだけになります。
+
+```java
+public FizzBuzz(int typeCode) {
+    this.type = FizzBuzzType.create(typeCode);
+}
+```
+
+## 8.5 Command パターン
+
+### 問題: 操作の種類
+
+FizzBuzz には「1 つの数値を変換する」操作と「リストを生成する」操作があります。これらの操作を **オブジェクト** として扱うことで、柔軟に切り替えられるようにします。
+
+### 解決: FizzBuzzCommand
+
+```java
+import java.util.List;
+
+public interface FizzBuzzCommand {
+    FizzBuzzValue execute(int number);
+    FizzBuzzList executeList(int count);
+}
+```
+
+#### 単一値コマンド
+
+```java
+public class FizzBuzzValueCommand implements FizzBuzzCommand {
+    private final FizzBuzzType type;
+
+    public FizzBuzzValueCommand(FizzBuzzType type) {
+        this.type = type;
+    }
+
+    @Override
+    public FizzBuzzValue execute(int number) {
+        return type.generate(number);
+    }
+
+    @Override
+    public FizzBuzzList executeList(int count) {
+        throw new UnsupportedOperationException();
+    }
+}
+```
+
+#### リスト生成コマンド
+
+```java
+import java.util.ArrayList;
+import java.util.List;
+
+public class FizzBuzzListCommand implements FizzBuzzCommand {
+    private final FizzBuzzType type;
+
+    public FizzBuzzListCommand(FizzBuzzType type) {
+        this.type = type;
+    }
+
+    @Override
+    public FizzBuzzValue execute(int number) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public FizzBuzzList executeList(int count) {
+        List<FizzBuzzValue> values = new ArrayList<>();
+        for (int i = 1; i <= count; i++) {
+            values.add(type.generate(i));
+        }
+        return new FizzBuzzList(values);
+    }
+}
+```
+
+### Command パターンの利点
+
+- **操作のカプセル化**: 実行する操作をオブジェクトとして渡せる
+- **柔軟な組み合わせ**: タイプとコマンドを自由に組み合わせ可能
+- **責務の分離**: 「何を変換するか」（Type）と「どう実行するか」（Command）が分離
+
+## 8.6 Null Object パターン
+
+### 問題: 不正なタイプの処理
+
+現在、不正なタイプコードを指定すると `IllegalArgumentException` がスローされます。例外を投げる代わりに、**安全なデフォルト動作** を提供するアプローチもあります。
+
+### 解決: FizzBuzzTypeNotDefined
+
+```java
+public class FizzBuzzTypeNotDefined extends FizzBuzzType {
+    @Override
+    public FizzBuzzValue generate(int number) {
+        return new FizzBuzzValue(number, String.valueOf(number));
+    }
+}
+```
+
+`create` メソッドで例外の代わりに `FizzBuzzTypeNotDefined` を返すこともできます。
+
+```java
+public static FizzBuzzType create(int type) {
+    switch (type) {
+        case 1:
+            return new FizzBuzzType01();
+        case 2:
+            return new FizzBuzzType02();
+        case 3:
+            return new FizzBuzzType03();
+        default:
+            return new FizzBuzzTypeNotDefined();
+    }
+}
+```
+
+> **注**: 本プロジェクトでは不正なタイプを早期に検出するため、例外スローを維持します。Null Object パターンは「例外よりも安全なデフォルト動作が適切な場合」に使用します。
+
+## 8.7 リファクタリング後のクラス構造
+
+```plantuml
+@startuml
+title FizzBuzz クラス構造（第 8 章完了時点）
+
+abstract class FizzBuzzType {
+  + {abstract} generate(number : int) : FizzBuzzValue
+  + {static} create(type : int) : FizzBuzzType
+  # isFizz(number : int) : boolean
+  # isBuzz(number : int) : boolean
+  # isFizzBuzz(number : int) : boolean
+}
+
+class FizzBuzzType01 extends FizzBuzzType
+class FizzBuzzType02 extends FizzBuzzType
+class FizzBuzzType03 extends FizzBuzzType
+
+class FizzBuzzValue {
+  - number : int
+  - value : String
+  + getNumber() : int
+  + getValue() : String
+  + equals(obj : Object) : boolean
+  + hashCode() : int
+  + toString() : String
+}
+
+class FizzBuzzList {
+  - values : List<FizzBuzzValue>
+  + get(index : int) : FizzBuzzValue
+  + size() : int
+  + add(newValues : List) : FizzBuzzList
+  + getValues() : List<FizzBuzzValue>
+}
+
+interface FizzBuzzCommand {
+  + execute(number : int) : FizzBuzzValue
+  + executeList(count : int) : FizzBuzzList
+}
+
+class FizzBuzzValueCommand implements FizzBuzzCommand
+class FizzBuzzListCommand implements FizzBuzzCommand
+
+FizzBuzzType ..> FizzBuzzValue : 生成
+FizzBuzzList o-- FizzBuzzValue
+FizzBuzzValueCommand --> FizzBuzzType
+FizzBuzzListCommand --> FizzBuzzType
+
+@enduml
+```
+
+## 8.8 まとめ
+
+この章では 5 つのデザインパターンを適用しました。
+
+| パターン | クラス | 効果 |
+|---------|--------|------|
+| Value Object | `FizzBuzzValue` | プリミティブ型への執着を排除 |
+| First-Class Collection | `FizzBuzzList` | コレクション操作をドメインに集約 |
+| Factory Method | `FizzBuzzType.create()` | 生成ロジックを一箇所に集約 |
+| Command | `FizzBuzzCommand` 階層 | 操作をオブジェクトとしてカプセル化 |
+| Null Object | `FizzBuzzTypeNotDefined` | null/例外の代わりに安全なデフォルト |
+
+### リファクタリングの原則
+
+> **プリミティブ型への執着**（Primitive Obsession）を避け、ドメインの概念をオブジェクトで表現する。
+
+次の第 9 章では、SOLID 原則に基づいてモジュール設計を行い、パッケージ構造を整理します。

package/lib/assets/docs/article/getting-start-tdd/java/09-solid-principles-and-module-design.md

@@ -0,0 +1,310 @@
+# 第 9 章: SOLID 原則とモジュール設計
+
+## 9.1 はじめに
+
+前章までで、FizzBuzz のコードはデザインパターンを適用して大きく改善されました。しかし、すべてのクラスが `tdd.fizzbuzz` という 1 つのパッケージに詰め込まれています。
+
+この章では、**SOLID 原則** を確認しながら、クラスを適切なパッケージに分割する **モジュール設計** を行います。
+
+## 9.2 SOLID 原則の確認
+
+FizzBuzz のコードが SOLID 原則にどの程度準拠しているか確認しましょう。
+
+### 単一責任原則（SRP: Single Responsibility Principle）
+
+> クラスを変更する理由は 1 つだけであるべき。
+
+| クラス | 責務 | 変更理由 | SRP 準拠 |
+|--------|------|---------|---------|
+| `FizzBuzzType01` | タイプ 1 の変換ルール | タイプ 1 のルール変更時 | OK |
+| `FizzBuzzType02` | タイプ 2 の変換ルール | タイプ 2 のルール変更時 | OK |
+| `FizzBuzzType03` | タイプ 3 の変換ルール | タイプ 3 のルール変更時 | OK |
+| `FizzBuzzValue` | 値の保持と等価性 | 値の表現が変わるとき | OK |
+| `FizzBuzzList` | コレクション操作 | コレクション操作が変わるとき | OK |
+| `FizzBuzzValueCommand` | 単一値変換の実行 | 実行方法が変わるとき | OK |
+| `FizzBuzzListCommand` | リスト生成の実行 | 実行方法が変わるとき | OK |
+
+ポリモーフィズムとデザインパターンの適用により、各クラスが単一の責務を持つようになっています。
+
+### 開放閉鎖原則（OCP: Open-Closed Principle）
+
+> 拡張に対して開いていて、修正に対して閉じているべき。
+
+新しいタイプ（例: タイプ 4）を追加する場合を考えてみましょう。
+
+```java
+// タイプ 4 を追加するのに必要な変更
+// 1. 新しいクラスを追加（既存コードの修正なし）
+public class FizzBuzzType04 extends FizzBuzzType {
+    @Override
+    public FizzBuzzValue generate(int number) {
+        // タイプ 4 のルール
+        return new FizzBuzzValue(number, String.valueOf(number));
+    }
+}
+
+// 2. ファクトリメソッドに 1 行追加（最小限の修正）
+case 4: return new FizzBuzzType04();
+```
+
+`FizzBuzzType` 階層は拡張に対して開いています。新しいタイプを追加しても、既存のタイプクラスや `FizzBuzzCommand` を修正する必要はありません。
+
+### 依存性逆転原則（DIP: Dependency Inversion Principle）
+
+> 上位モジュールは下位モジュールに依存すべきではない。どちらも抽象に依存すべき。
+
+```
+FizzBuzz → FizzBuzzType（抽象）← FizzBuzzType01, 02, 03
+FizzBuzzCommand（抽象）← FizzBuzzValueCommand, FizzBuzzListCommand
+```
+
+`FizzBuzz` クラスは具体的な `FizzBuzzType01` ではなく、抽象的な `FizzBuzzType` に依存しています。
+
+## 9.3 パッケージ設計
+
+### 現在の問題
+
+すべてのクラスが `tdd.fizzbuzz` に入っています。
+
+```
+tdd.fizzbuzz/
+├── FizzBuzz.java
+├── FizzBuzzType.java
+├── FizzBuzzType01.java
+├── FizzBuzzType02.java
+├── FizzBuzzType03.java
+├── FizzBuzzValue.java
+├── FizzBuzzList.java
+├── FizzBuzzCommand.java
+├── FizzBuzzValueCommand.java
+├── FizzBuzzListCommand.java
+└── Main.java
+```
+
+クラスが増えるにつれて、どのクラスがどの責務を持つかが分かりにくくなります。
+
+### パッケージ分割
+
+責務に基づいてパッケージを分割します。
+
+```
+tdd/
+├── App.java                         # エントリポイント
+└── fizzbuzz/
+    ├── domain/
+    │   ├── type/
+    │   │   ├── FizzBuzzType.java     # 抽象タイプ + Factory
+    │   │   ├── FizzBuzzType01.java   # タイプ 1
+    │   │   ├── FizzBuzzType02.java   # タイプ 2
+    │   │   └── FizzBuzzType03.java   # タイプ 3
+    │   └── model/
+    │       ├── FizzBuzzValue.java    # 値オブジェクト
+    │       └── FizzBuzzList.java     # コレクション
+    └── application/
+        ├── FizzBuzzCommand.java      # コマンドインターフェース
+        ├── FizzBuzzValueCommand.java # 単一値コマンド
+        └── FizzBuzzListCommand.java  # リストコマンド
+```
+
+### パッケージの責務
+
+| パッケージ | 責務 | 含まれるクラス |
+|-----------|------|--------------|
+| `tdd.fizzbuzz.domain.type` | 変換ルール（ビジネスロジック） | `FizzBuzzType` 階層 |
+| `tdd.fizzbuzz.domain.model` | ドメインモデル（値・コレクション） | `FizzBuzzValue`, `FizzBuzzList` |
+| `tdd.fizzbuzz.application` | アプリケーション層（操作の実行） | `FizzBuzzCommand` 階層 |
+
+### 依存関係
+
+```plantuml
+@startuml
+title パッケージ依存関係
+
+package "tdd" {
+  class App
+}
+
+package "tdd.fizzbuzz.application" {
+  interface FizzBuzzCommand
+  class FizzBuzzValueCommand
+  class FizzBuzzListCommand
+}
+
+package "tdd.fizzbuzz.domain.type" {
+  abstract class FizzBuzzType
+  class FizzBuzzType01
+  class FizzBuzzType02
+  class FizzBuzzType03
+}
+
+package "tdd.fizzbuzz.domain.model" {
+  class FizzBuzzValue
+  class FizzBuzzList
+}
+
+App --> FizzBuzzCommand
+App --> FizzBuzzType
+
+FizzBuzzValueCommand --> FizzBuzzType
+FizzBuzzListCommand --> FizzBuzzType
+FizzBuzzListCommand --> FizzBuzzList
+
+FizzBuzzType ..> FizzBuzzValue : 生成
+FizzBuzzList o-- FizzBuzzValue
+
+@enduml
+```
+
+`application` パッケージは `domain` に依存しますが、`domain` は `application` に依存しません。これにより、ビジネスロジックがアプリケーション層から独立して変更・テストできます。
+
+## 9.4 エントリポイントの更新
+
+パッケージ分割後の `App.java` です。
+
+```java
+package tdd;
+
+import tdd.fizzbuzz.application.FizzBuzzListCommand;
+import tdd.fizzbuzz.application.FizzBuzzValueCommand;
+import tdd.fizzbuzz.domain.model.FizzBuzzList;
+import tdd.fizzbuzz.domain.model.FizzBuzzValue;
+import tdd.fizzbuzz.domain.type.FizzBuzzType;
+
+public class App {
+    private static final int MAX_NUMBER = 100;
+
+    public static void main(String[] args) {
+        FizzBuzzType type = FizzBuzzType.create(1);
+
+        // 単一値の取得
+        FizzBuzzValueCommand valueCommand
+            = new FizzBuzzValueCommand(type);
+        FizzBuzzValue value = valueCommand.execute(15);
+        System.out.println(value);
+
+        // リストの生成
+        FizzBuzzListCommand listCommand
+            = new FizzBuzzListCommand(type);
+        FizzBuzzList list = listCommand.executeList(MAX_NUMBER);
+        for (FizzBuzzValue item : list.getValues()) {
+            System.out.println(item.getValue());
+        }
+    }
+}
+```
+
+## 9.5 テストの更新
+
+テストもパッケージ構造に合わせて再配置します。
+
+```
+src/test/java/tdd/fizzbuzz/
+├── domain/
+│   ├── type/
+│   │   └── FizzBuzzTypeTest.java    # タイプ別テスト
+│   └── model/
+│       ├── FizzBuzzValueTest.java   # 値オブジェクトテスト
+│       └── FizzBuzzListTest.java    # コレクションテスト
+└── application/
+    └── FizzBuzzCommandTest.java     # コマンドテスト
+```
+
+### FizzBuzzTypeTest（タイプ別テスト）
+
+```java
+package tdd.fizzbuzz.domain.type;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class FizzBuzzTypeTest {
+
+    @Nested
+    class タイプ1の場合 {
+        private final FizzBuzzType type = FizzBuzzType.create(1);
+
+        @Test
+        void 三と五の倍数でFizzBuzzを返す() {
+            assertEquals("FizzBuzz", type.generate(15).getValue());
+        }
+
+        @Test
+        void 三の倍数でFizzを返す() {
+            assertEquals("Fizz", type.generate(3).getValue());
+        }
+
+        @Test
+        void 五の倍数でBuzzを返す() {
+            assertEquals("Buzz", type.generate(5).getValue());
+        }
+
+        @Test
+        void その他は数値を返す() {
+            assertEquals("1", type.generate(1).getValue());
+        }
+    }
+
+    @Nested
+    class タイプ2の場合 {
+        private final FizzBuzzType type = FizzBuzzType.create(2);
+
+        @Test
+        void 常に数値を返す() {
+            assertEquals("3", type.generate(3).getValue());
+            assertEquals("5", type.generate(5).getValue());
+            assertEquals("15", type.generate(15).getValue());
+        }
+    }
+
+    @Nested
+    class タイプ3の場合 {
+        private final FizzBuzzType type = FizzBuzzType.create(3);
+
+        @Test
+        void 十五の倍数のみFizzBuzzを返す() {
+            assertEquals("FizzBuzz", type.generate(15).getValue());
+            assertEquals("3", type.generate(3).getValue());
+            assertEquals("5", type.generate(5).getValue());
+        }
+    }
+
+    @Nested
+    class 不正なタイプの場合 {
+        @Test
+        void 例外をスローする() {
+            assertThrows(IllegalArgumentException.class,
+                () -> FizzBuzzType.create(4));
+        }
+    }
+}
+```
+
+## 9.6 まとめ
+
+この章では SOLID 原則を確認しながらモジュール設計を行いました。
+
+| 概念 | 適用 |
+|------|------|
+| 単一責任原則（SRP） | 各クラスが 1 つの責務を持つ |
+| 開放閉鎖原則（OCP） | 新タイプ追加で既存コード変更不要 |
+| 依存性逆転原則（DIP） | 抽象への依存で結合度を低減 |
+| パッケージ分割 | `domain`（ビジネスロジック）と `application`（操作）の分離 |
+
+### 第 3 部の振り返り
+
+第 3 部（第 7〜9 章）を通じて、手続き的な FizzBuzz をオブジェクト指向設計に変換しました。
+
+| 章 | テーマ | 学んだこと |
+|----|--------|-----------
+| 7 | カプセル化とポリモーフィズム | `private` / `final`、Strategy パターン、抽象クラス |
+| 8 | デザインパターンの適用 | Value Object、First-Class Collection、Command、Factory Method |
+| 9 | SOLID 原則とモジュール設計 | SRP / OCP / DIP、パッケージ分割、ドメインモデル |
+
+```
+Before: 1 つのクラスに全ロジック（手続き型）
+After:  責務ごとにパッケージ分割された OOP 設計
+```
+
+次の第 4 部では、Java の関数型プログラミング機能（Stream API、Optional、Lambda）を使って、さらにコードを発展させます。