From 8b0dbc1086779542580aa3ba455ebdf0a94bc650 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EB=B0=95=EB=AF=BC=EC=9A=B1?=
 <88137420+JohnPrk@users.noreply.github.com>
Date: Sun, 2 Nov 2025 15:56:17 +0900
Subject: [PATCH 01/10] Update README.md

---
 README.md | 216 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 215 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 5fa2560b46..a71d9a7ea2 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,215 @@
-# java-lotto-precourse
+# 🎰 로또 게임 (Lotto Game)
+
+사용자가 입력한 금액만큼 로또를 자동으로 발행하고, 당첨 번호와 보너스 번호를 기준으로 결과 통계와 수익률을 출력하는 콘솔 기반 프로그램입니다.
+
+Java 21 환경에서 동작하며, 기능별 책임을 분리해 구현하는 데 중점을 두었습니다.
+
+<br>
+<br>
+
+## 🍭 **🎯 프로젝트의 지향점 및** 방향
+
+관련된 데이터와 동작을 함께 묶어 **각 클래스가 분명한 책임을 갖도록 구성**하고, **여러 객체들이 역할에 따라 협력**하며 하나의 기능을 완성할 수 있도록 설계합니다.
+
+TDD 사이클 중 **Inside-Out 방식을 기반으로**, **입출력보다는 먼저 도메인 로직을 중심으로 개발을 시작**하고, 테스트 가능한 작은 단위부터 점차 확장해 나갑니다.
+
+<br>
+<br>
+
+## 🔁 시퀀스 다이어그램
+
+애플리케이션의 전체 동작 과정과 객체 간의 상호작용을 시각화하기 위해 시퀀스 다이어그램을 사용했습니다.
+
+```mermaid
+sequenceDiagram
+    participant U as 사용자
+    participant I as InputView
+    participant O as OutputView
+    participant C as LottoController
+    participant M as Money
+    participant F as LottoFactory
+    participant L as Lotto
+    participant W as WinningNumbers
+    participant R as LottoResults
+
+Note over U,C: 🎫 1단계: 로또 구매
+    loop 유효한 금액이 입력될 때까지
+        U->>I: 구입 금액 입력
+        I->>C: 금액 전달
+        C->>M: Money 생성 및 검증
+        alt 검증 성공
+            M-->>C: 유효한 Money 객체
+        else 검증 실패
+            M-->>C: IllegalArgumentException
+            C->>O: 메시지 출력
+            O->>U: 에러 표시
+        end
+    end
+
+    C->>M: getLottoCount() 호출
+    M-->>C: 구매 가능한 로또 개수
+    loop N번 (로또 개수만큼)
+        C->>F: generateLotto() 호출
+        F->>F: Randoms.pickUniqueNumbersInRange(1,45,6)
+        F-->>C: 생성된 번호 목록
+        C->>L: Lotto 객체 생성
+    end
+    C->>O: 구매한 로또 목록 출력
+    O->>U: 로또 목록 표시
+    		
+Note over U,C: 🏆 2단계: 당첨 번호 입력
+    loop 유효한 당첨 번호가 입력될 때까지
+        U->>I: 당첨 번호 입력 (쉼표 구분)
+        I->>C: 당첨 번호 전달
+        C->>W: WinningNumbers 생성 및 검증
+        alt 검증 성공
+            W-->>C: 당첨 번호 객체 생성됨
+        else 검증 실패
+            W-->>C: IllegalArgumentException
+            C->>O: 메시지 출력
+            O->>U: 에러 표시
+        end
+    end
+
+    loop 유효한 보너스 번호가 입력될 때까지
+        U->>I: 보너스 번호 입력
+        I->>C: 보너스 번호 전달
+        C->>W: 보너스 번호 설정 및 검증
+        alt 검증 성공
+            W-->>C: 최종 당첨 번호 객체 완성
+        else 검증 실패
+            W-->>C: IllegalArgumentException
+            C->>O: 메시지 출력
+            O->>U: 에러 표시
+        end
+    end
+    Note over U,C: 📊 3단계: 결과 분석 및 출력
+    C->>R: LottoResults 생성 (List<Lotto>, WinningNumbers)
+    loop 각 로또에 대해
+        R->>R: calculateRank(lotto, winningNumbers)
+        R->>R: 등수별 카운트 증가
+        R->>R: 총 상금 누적
+    end
+    R->>R: 수익률 계산
+    R-->>C: 분석 결과
+    C->>O: 당첨 통계 출력
+    O->>U: 통계 표시
+    C->>O: 수익률 출력
+    O->>U: 수익률 표시
+```
+
+<br>
+<br>
+
+## **🧱 객체 역할 요약**
+
+| 객체 이름 | 역할(책임) | 보유 값(상태) | 주요 행위 |
+| --- | --- | --- | --- |
+| `Money` | 구입 금액을 표현하고 관련 규칙을 검증하는 값 객체 | * 구입 금액 | - 금액 유효성 검사, 구매 가능한 로또 수 계산 |
+| `Lotto` | 로또 한 장을 표현하며 번호 규칙(개수, 범위, 중복)의 불변성을 보장 | * 6개의 로또 번호 | - 번호 정렬 및 중복 검사, 당첨 번호와 일치 개수 계산, 보너스 포함 여부 확인 |
+| `LottoFactory` | 로또 규칙에 맞는 랜덤 번호를 생성하여 `Lotto` 객체를 만드는 책임을 짐 |  | -`Randoms.pickUniqueNumbersInRange()`를 사용해 로또 번호 생성 |
+| `WinningNumbers` | 당첨 번호와 보너스 번호를 가지며 관련 규칙(개수, 범위, 중복)을 책임짐 | * 6개 당첨 번호, 1개 보너스 번호 | - 당첨 번호 유효성 검사, 보너스 번호 유효성 검사 및 중복 확인 |
+| `LottoRank` | 당첨 등수(1~5등, 꽝)의 조건(일치 개수, 보너스)과 상금을 정의 | *Enum class(일치 개수, 보너스 포함여부,당첨 금액) | - 일치 수/보너스 포함 여부로 등수 반환, 상금 반환 |
+| `LottoResults` | 전체 당첨 결과를 집계하고 최종 수익률을 계산 | * 등수별 당첨 횟수, 총 수익률, 누적 상금 | - 각 로또에 대한 등수 계산, 당첨 결과 누적, 수익률 계산 |
+| `InputView` | 사용자로부터 입력을 받는 모든 로직을 담당 | * 입력 접두사 | - 사용자로부터 입력을 받음, `camp.nextstep.edu.missionutils.Console`의 `readLine()`을 사용 |
+| `OutputView` | 사용자에게 정보를 출력하는 모든 로직을 담당 | * 출력 접두사 | - 구매한 로또 목록 출력, 당첨 결과 출력, 수익률 출력 |
+| `LottoController` | 애플리케이션의 전체 실행 흐름을 조율. View와 Domain 객체들을 연결 |  | - 전체 흐름 제어 |
+
+<br>
+<br>
+
+## **🚰 구현 순서 (Inside-Out 방식)**
+
+### **1단계: 핵심 도메인 모델 구현**
+
+> 비즈니스의 가장 본질적인 규칙과 데이터를 정의하고 테스트합니다.
+> 
+- `Money`: 금액을 표현하고, 1,000원 단위 검증 및 로또 구매 가능 개수 계산 책임을 가집니다.
+- `Lotto`: 로또 한 장(6개 번호)을 표현하며, 번호 개수, 범위, 중복 등 규칙의 불변성을 보장합니다.
+
+### **2단계: 당첨 규칙 및 판정 로직 구현**
+
+> 당첨을 결정하는 기준과 로직을 구현합니다.
+> 
+- `WinningNumbers`: 당첨 번호(6개)와 보너스 번호(1개)를 가지며, 관련된 유효성 검증 책임을 가집니다.
+- `LottoRank`: 5개 등수와 '꽝'에 대한 조건(일치 개수, 보너스 여부)과 상금을 `enum`으로 정의합니다. **(등수 판정 로직 포함)**
+
+### **3단계: 결과 집계 및 분석 로직 구현**
+
+> 구매한 로또들의 결과를 종합하여 통계를 내는 책임을 구현합니다.
+> 
+- `LottoResults`: 구매한 모든 `Lotto`와 `WinningNumbers`를 비교하여, 등수별 당첨 횟수를 집계하고 최종 수익률을 계산합니다.
+
+### **4단계: 로또 생성 로직 구현**
+
+> 도메인 규칙에 따라 로또를 생성하는 책임을 구현합니다.
+> 
+- `LottoFactory`: `Randoms` 유틸리티를 사용하여 로또 번호를 생성하고, 검증된 `Lotto` 객체를 생성하여 반환합니다.
+
+### **5단계: 입출력(UI) 계층 구현**
+
+> 사용자와 상호작용하는 부분을 구현합니다.
+> 
+- `InputView`: 사용자로부터 구입 금액, 당첨 번호, 보너스 번호를 입력받는 책임을 가집니다.
+- `OutputView`: 구매 내역, 당첨 통계, 수익률, 에러 메시지 등 모든 출력 내용을 형식에 맞게 보여주는 책임을 가집니다.
+- `InputValidator`: `InputView`를 통해 들어온 사용자 입력 값의 형식(숫자인지, 쉼표로 구분되는지 등)을 검증합니다.
+
+### **6단계: 애플리케이션 통합 및 실행**
+
+> 구현된 모든 객체를 조립하여 프로그램을 완성합니다.
+> 
+- `LottoController`: 전체 애플리케이션의 실행 흐름(로또 구매 → 당첨 번호 입력 → 결과 발표)을 제어하고, 예외 발생 시 재입력 로직을 처리합니다.
+- `Application`: 프로그램의 시작점(`main` 메서드)으로, `LottoController`를 생성하고 실행합니다.
+
+### **7단계: 리팩토링 및 최종 검토**
+
+> 코드 품질을 개선하고 요구사항을 최종 점검합니다.
+> 
+- `ValidationUtil`, `Retry` 등 중복 로직을 유틸리티 클래스로 추출합니다.
+- 전체 코드에 대해 프로그래밍 제약 조건(들여쓰기, 메서드 길이 등) 준수 여부를 검토합니다.
+
+<br>
+<br>
+
+## 📋 예외 처리
+
+사용자의 입력 오류로 예외가 발생하면  **`[ERROR] ...` 로 시작하는 에러 메시지를 사용자에게 출력하고 해당 입력부터 다시 입력을 진행할 수 있도록 합니다.**
+
+예외 처리 메세지는 구현하면서 하나씩 채워 넣을 예정입니다.
+
+| 예외 상황 | 에러 메시지 |
+| --- | --- |
+|  |  |
+|  |  |
+|  |  |
+
+<br>
+<br>
+
+## ⚙️ 개발 및 기술 제약
+
+- 이 프로그램은 **Java 21**에서 실행되어야 한다.
+- 프로그램의 시작점은 **`Application` 클래스의 `main()`** 메서드여야 한다.
+- **제공된 `build.gradle` 파일은 수정할 수 없다.** 외부 라이브러리를 추가하지 않는다.
+- 로또 번호 생성은 **`camp.nextstep.edu.missionutils.Randoms.pickUniqueNumbersInRange(1, 45, 6)`** 을 사용한다.
+- 사용자 입력은 **`camp.nextstep.edu.missionutils.Console.readLine()`** 으로만 받는다.
+- 프로그램 종료를 위해 **`System.exit()`를 호출해서는 안 된다.**
+- 들여쓰기는 **2단계 이내**로 유지한다.
+- **`else` 문, `switch/case`, 삼항 연산자**는 사용하지 않는다.
+- 하나의 메서드는 **한 가지 일만** 하도록 작성하고, **15줄을 넘기지 않도록** 한다.
+- 제공된 `Lotto` 클래스에는 **필드를 추가하지 않는다.**
+
+<br>
+<br>
+
+## 📝 구현 기록 / 고민 정보
+
+구현 과정에서 배우고 고민했던 것들을 기록하는 공간입니다.
+
+- [도메인 설계시 고려했던 것](https://github.com/JohnPrk/java-lotto-8/issues/1)
+- **[Inside-Out vs Outside-In TDD 선택 이유](**https://github.com/JohnPrk/java-lotto-8/issues/2**)**
+- **[Supplier는 무엇인가?](**https://github.com/JohnPrk/java-lotto-8/issues/3**)**
+- **[2023년 구현 vs 지금 구현 비교[회고]](**https://github.com/JohnPrk/java-lotto-8/issues/4**)**
+
+<br>
+<br>

From f6cf77a5dec468d9354f455210a1dbe963a05afb Mon Sep 17 00:00:00 2001
From: JohnPrk <uo3641493@gmail.com>
Date: Sun, 2 Nov 2025 20:38:56 +0900
Subject: [PATCH 02/10] =?UTF-8?q?refactor:=20lotto.domain=20=ED=8C=A8?=
 =?UTF-8?q?=ED=82=A4=EC=A7=80=EB=A1=9C=20=EB=8F=84=EB=A9=94=EC=9D=B8=20?=
 =?UTF-8?q?=EB=B0=8F=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=ED=81=B4=EB=9E=98?=
 =?UTF-8?q?=EC=8A=A4=20=EC=9D=B4=EB=8F=99?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/lotto/{ => domain}/Lotto.java     | 2 +-
 src/test/java/lotto/{ => domain}/LottoTest.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename src/main/java/lotto/{ => domain}/Lotto.java (95%)
 rename src/test/java/lotto/{ => domain}/LottoTest.java (97%)

diff --git a/src/main/java/lotto/Lotto.java b/src/main/java/lotto/domain/Lotto.java
similarity index 95%
rename from src/main/java/lotto/Lotto.java
rename to src/main/java/lotto/domain/Lotto.java
index 88fc5cf12b..d7797b2d7d 100644
--- a/src/main/java/lotto/Lotto.java
+++ b/src/main/java/lotto/domain/Lotto.java
@@ -1,4 +1,4 @@
-package lotto;
+package lotto.domain;
 
 import java.util.List;
 
diff --git a/src/test/java/lotto/LottoTest.java b/src/test/java/lotto/domain/LottoTest.java
similarity index 97%
rename from src/test/java/lotto/LottoTest.java
rename to src/test/java/lotto/domain/LottoTest.java
index 309f4e50ae..2309a29ad5 100644
--- a/src/test/java/lotto/LottoTest.java
+++ b/src/test/java/lotto/domain/LottoTest.java
@@ -1,4 +1,4 @@
-package lotto;
+package lotto.domain;
 
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;

From a67a5728c99ca43eea22e780406cfb51bef6bbb3 Mon Sep 17 00:00:00 2001
From: JohnPrk <uo3641493@gmail.com>
Date: Sun, 2 Nov 2025 20:59:20 +0900
Subject: [PATCH 03/10] =?UTF-8?q?feat:=20=EA=B5=AC=EB=A7=A4=20=EA=B8=88?=
 =?UTF-8?q?=EC=95=A1=EC=9D=84=20=ED=91=9C=ED=98=84=ED=95=98=EB=8A=94=20Mon?=
 =?UTF-8?q?ey=20=EB=8F=84=EB=A9=94=EC=9D=B8=20=ED=81=B4=EB=9E=98=EC=8A=A4?=
 =?UTF-8?q?=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 1,000원 단위 검증
- 0원 및 음수 금액 방지를 위한 검증
- 구매 가능한 로또 개수 계산
- IllegalArgumentException을 통한 도메인 예외 처리
- 위의 기능 단위 테스트 작성
- README.md 예외 처리 표에 Money 관련 예외 메시지 추가
---
 README.md                                 | 57 ++++++++++++++---------
 src/main/java/lotto/domain/Money.java     | 29 ++++++++++++
 src/test/java/lotto/domain/MoneyTest.java | 53 +++++++++++++++++++++
 3 files changed, 117 insertions(+), 22 deletions(-)
 create mode 100644 src/main/java/lotto/domain/Money.java
 create mode 100644 src/test/java/lotto/domain/MoneyTest.java

diff --git a/README.md b/README.md
index a71d9a7ea2..2b621907dc 100644
--- a/README.md
+++ b/README.md
@@ -103,17 +103,17 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
 
 ## **🧱 객체 역할 요약**
 
-| 객체 이름 | 역할(책임) | 보유 값(상태) | 주요 행위 |
-| --- | --- | --- | --- |
-| `Money` | 구입 금액을 표현하고 관련 규칙을 검증하는 값 객체 | * 구입 금액 | - 금액 유효성 검사, 구매 가능한 로또 수 계산 |
-| `Lotto` | 로또 한 장을 표현하며 번호 규칙(개수, 범위, 중복)의 불변성을 보장 | * 6개의 로또 번호 | - 번호 정렬 및 중복 검사, 당첨 번호와 일치 개수 계산, 보너스 포함 여부 확인 |
-| `LottoFactory` | 로또 규칙에 맞는 랜덤 번호를 생성하여 `Lotto` 객체를 만드는 책임을 짐 |  | -`Randoms.pickUniqueNumbersInRange()`를 사용해 로또 번호 생성 |
-| `WinningNumbers` | 당첨 번호와 보너스 번호를 가지며 관련 규칙(개수, 범위, 중복)을 책임짐 | * 6개 당첨 번호, 1개 보너스 번호 | - 당첨 번호 유효성 검사, 보너스 번호 유효성 검사 및 중복 확인 |
-| `LottoRank` | 당첨 등수(1~5등, 꽝)의 조건(일치 개수, 보너스)과 상금을 정의 | *Enum class(일치 개수, 보너스 포함여부,당첨 금액) | - 일치 수/보너스 포함 여부로 등수 반환, 상금 반환 |
-| `LottoResults` | 전체 당첨 결과를 집계하고 최종 수익률을 계산 | * 등수별 당첨 횟수, 총 수익률, 누적 상금 | - 각 로또에 대한 등수 계산, 당첨 결과 누적, 수익률 계산 |
-| `InputView` | 사용자로부터 입력을 받는 모든 로직을 담당 | * 입력 접두사 | - 사용자로부터 입력을 받음, `camp.nextstep.edu.missionutils.Console`의 `readLine()`을 사용 |
-| `OutputView` | 사용자에게 정보를 출력하는 모든 로직을 담당 | * 출력 접두사 | - 구매한 로또 목록 출력, 당첨 결과 출력, 수익률 출력 |
-| `LottoController` | 애플리케이션의 전체 실행 흐름을 조율. View와 Domain 객체들을 연결 |  | - 전체 흐름 제어 |
+| 객체 이름             | 역할(책임)                                      | 보유 값(상태)                           | 주요 행위                                                                       |
+|-------------------|---------------------------------------------|------------------------------------|-----------------------------------------------------------------------------|
+| `Money`           | 구입 금액을 표현하고 관련 규칙을 검증하는 값 객체                | * 구입 금액                            | - 금액 유효성 검사, 구매 가능한 로또 수 계산                                                 |
+| `Lotto`           | 로또 한 장을 표현하며 번호 규칙(개수, 범위, 중복)의 불변성을 보장     | * 6개의 로또 번호                        | - 번호 정렬 및 중복 검사, 당첨 번호와 일치 개수 계산, 보너스 포함 여부 확인                              |
+| `LottoFactory`    | 로또 규칙에 맞는 랜덤 번호를 생성하여 `Lotto` 객체를 만드는 책임을 짐 |                                    | -`Randoms.pickUniqueNumbersInRange()`를 사용해 로또 번호 생성                         |
+| `WinningNumbers`  | 당첨 번호와 보너스 번호를 가지며 관련 규칙(개수, 범위, 중복)을 책임짐   | * 6개 당첨 번호, 1개 보너스 번호              | - 당첨 번호 유효성 검사, 보너스 번호 유효성 검사 및 중복 확인                                       |
+| `LottoRank`       | 당첨 등수(1~5등, 꽝)의 조건(일치 개수, 보너스)과 상금을 정의      | *Enum class(일치 개수, 보너스 포함여부,당첨 금액) | - 일치 수/보너스 포함 여부로 등수 반환, 상금 반환                                              |
+| `LottoResults`    | 전체 당첨 결과를 집계하고 최종 수익률을 계산                   | * 등수별 당첨 횟수, 총 수익률, 누적 상금          | - 각 로또에 대한 등수 계산, 당첨 결과 누적, 수익률 계산                                          |
+| `InputView`       | 사용자로부터 입력을 받는 모든 로직을 담당                     | * 입력 접두사                           | - 사용자로부터 입력을 받음, `camp.nextstep.edu.missionutils.Console`의 `readLine()`을 사용 |
+| `OutputView`      | 사용자에게 정보를 출력하는 모든 로직을 담당                    | * 출력 접두사                           | - 구매한 로또 목록 출력, 당첨 결과 출력, 수익률 출력                                            |
+| `LottoController` | 애플리케이션의 전체 실행 흐름을 조율. View와 Domain 객체들을 연결  |                                    | - 전체 흐름 제어                                                                  |
 
 <br>
 <br>
@@ -123,33 +123,38 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
 ### **1단계: 핵심 도메인 모델 구현**
 
 > 비즈니스의 가장 본질적인 규칙과 데이터를 정의하고 테스트합니다.
-> 
+>
+
 - `Money`: 금액을 표현하고, 1,000원 단위 검증 및 로또 구매 가능 개수 계산 책임을 가집니다.
 - `Lotto`: 로또 한 장(6개 번호)을 표현하며, 번호 개수, 범위, 중복 등 규칙의 불변성을 보장합니다.
 
 ### **2단계: 당첨 규칙 및 판정 로직 구현**
 
 > 당첨을 결정하는 기준과 로직을 구현합니다.
-> 
+>
+
 - `WinningNumbers`: 당첨 번호(6개)와 보너스 번호(1개)를 가지며, 관련된 유효성 검증 책임을 가집니다.
 - `LottoRank`: 5개 등수와 '꽝'에 대한 조건(일치 개수, 보너스 여부)과 상금을 `enum`으로 정의합니다. **(등수 판정 로직 포함)**
 
 ### **3단계: 결과 집계 및 분석 로직 구현**
 
 > 구매한 로또들의 결과를 종합하여 통계를 내는 책임을 구현합니다.
-> 
+>
+
 - `LottoResults`: 구매한 모든 `Lotto`와 `WinningNumbers`를 비교하여, 등수별 당첨 횟수를 집계하고 최종 수익률을 계산합니다.
 
 ### **4단계: 로또 생성 로직 구현**
 
 > 도메인 규칙에 따라 로또를 생성하는 책임을 구현합니다.
-> 
+>
+
 - `LottoFactory`: `Randoms` 유틸리티를 사용하여 로또 번호를 생성하고, 검증된 `Lotto` 객체를 생성하여 반환합니다.
 
 ### **5단계: 입출력(UI) 계층 구현**
 
 > 사용자와 상호작용하는 부분을 구현합니다.
-> 
+>
+
 - `InputView`: 사용자로부터 구입 금액, 당첨 번호, 보너스 번호를 입력받는 책임을 가집니다.
 - `OutputView`: 구매 내역, 당첨 통계, 수익률, 에러 메시지 등 모든 출력 내용을 형식에 맞게 보여주는 책임을 가집니다.
 - `InputValidator`: `InputView`를 통해 들어온 사용자 입력 값의 형식(숫자인지, 쉼표로 구분되는지 등)을 검증합니다.
@@ -157,14 +162,16 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
 ### **6단계: 애플리케이션 통합 및 실행**
 
 > 구현된 모든 객체를 조립하여 프로그램을 완성합니다.
-> 
+>
+
 - `LottoController`: 전체 애플리케이션의 실행 흐름(로또 구매 → 당첨 번호 입력 → 결과 발표)을 제어하고, 예외 발생 시 재입력 로직을 처리합니다.
 - `Application`: 프로그램의 시작점(`main` 메서드)으로, `LottoController`를 생성하고 실행합니다.
 
 ### **7단계: 리팩토링 및 최종 검토**
 
 > 코드 품질을 개선하고 요구사항을 최종 점검합니다.
-> 
+>
+
 - `ValidationUtil`, `Retry` 등 중복 로직을 유틸리티 클래스로 추출합니다.
 - 전체 코드에 대해 프로그래밍 제약 조건(들여쓰기, 메서드 길이 등) 준수 여부를 검토합니다.
 
@@ -178,10 +185,16 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
 예외 처리 메세지는 구현하면서 하나씩 채워 넣을 예정입니다.
 
 | 예외 상황 | 에러 메시지 |
-| --- | --- |
-|  |  |
-|  |  |
-|  |  |
+|-------|--------|
+
+## 📋 예외 처리
+
+사용자의 입력 오류로 예외가 발생하면  **`[ERROR] ...` 로 시작하는 에러 메시지를 사용자에게 출력하고 해당 입력부터 다시 입력을 진행할 수 있도록 합니다.**
+
+| 예외 상황                   | 에러 메시지                        |
+|-------------------------|-------------------------------|
+| 구입 금액이 0 이하인 경우         | `[ERROR] 구입 금액은 0보다 커야 합니다.`  |
+| 구입 금액이 1,000원 단위가 아닌 경우 | `[ERROR] 1,000원 단위로 입력해 주세요.` |
 
 <br>
 <br>
diff --git a/src/main/java/lotto/domain/Money.java b/src/main/java/lotto/domain/Money.java
new file mode 100644
index 0000000000..a564f220e7
--- /dev/null
+++ b/src/main/java/lotto/domain/Money.java
@@ -0,0 +1,29 @@
+package lotto.domain;
+
+public class Money {
+
+    private static final int UNIT_MONEY_FOR_BUY_LOTTO = 1000;
+    private final int amount;
+
+    public Money(int amount) {
+        validatePositive(amount);
+        validateUnit(amount);
+        this.amount = amount;
+    }
+
+    private void validatePositive(int amount) {
+        if (amount <= 0) {
+            throw new IllegalArgumentException("[ERROR] 구입 금액은 0보다 커야 합니다.");
+        }
+    }
+
+    private void validateUnit(int amount) {
+        if (amount % UNIT_MONEY_FOR_BUY_LOTTO != 0) {
+            throw new IllegalArgumentException("[ERROR] 1,000원 단위로 입력해 주세요.");
+        }
+    }
+
+    public int getLottoCount() {
+        return amount / UNIT_MONEY_FOR_BUY_LOTTO;
+    }
+}
diff --git a/src/test/java/lotto/domain/MoneyTest.java b/src/test/java/lotto/domain/MoneyTest.java
new file mode 100644
index 0000000000..f28728b1dc
--- /dev/null
+++ b/src/test/java/lotto/domain/MoneyTest.java
@@ -0,0 +1,53 @@
+package lotto.domain;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class MoneyTest {
+
+    private static final int UNIT_MONEY_FOR_BUY_LOTTO = 1000;
+
+    @ParameterizedTest
+    @ValueSource(ints = {1000, 5000, 1000000000})
+    void 로또_구매_금액이_천_원으로_나눠지면_Money_객체가_생성된다(int amount) {
+        // when
+        Money money = new Money(amount);
+
+        // then
+        assertThat(money).isNotNull();
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {500, 1100, 2500})
+    void 로또_구매_금액이_천_원으로_나눠지지_않으면_예외가_발생한다(int amount) {
+        // when & then
+        assertThatThrownBy(() -> new Money(amount))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 1,000원 단위로 입력해 주세요.");
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {0, -1000, -5000})
+    void 로또_구매_금액이_0원_이하면_예외가_발생한다(int amount) {
+        // when & then
+        assertThatThrownBy(() -> new Money(amount))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 구입 금액은 0보다 커야 합니다.");
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {1000, 3000, 100000})
+    void 로또_구매_금액을_입력하면_구매_가능한_로또_개수를_반환한다(int amount) {
+        // given
+        Money money = new Money(amount);
+
+        // when
+        int count = money.getLottoCount();
+
+        // then
+        assertThat(count).isEqualTo(amount / UNIT_MONEY_FOR_BUY_LOTTO);
+    }
+}

From 8679601c33afb5a632bcc063edb9cbc72a479961 Mon Sep 17 00:00:00 2001
From: JohnPrk <uo3641493@gmail.com>
Date: Sun, 2 Nov 2025 22:02:28 +0900
Subject: [PATCH 04/10] =?UTF-8?q?feat:=20=EB=A1=9C=EB=98=90=20=ED=95=9C=20?=
 =?UTF-8?q?=EC=9E=A5=EC=9D=84=20=ED=91=9C=ED=98=84=ED=95=98=EB=8A=94=20Lot?=
 =?UTF-8?q?to=20=EB=8F=84=EB=A9=94=EC=9D=B8=20=ED=81=B4=EB=9E=98=EC=8A=A4?=
 =?UTF-8?q?=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 로또 번호 개수(6개) 검증
- 로또 번호 범위(1~45) 검증
- 로또 번호 중복 검증
- 로또 번호 오름차순 자동 정렬 및 불변 리스트 저장
- IllegalArgumentException을 통한 도메인 예외 처리
- 위의 검증 및 기능 단위 테스트 작성
- README.md 예외 처리 표에 Lotto 관련 예외 메시지 추가
---
 README.md                                 | 11 ++-
 src/main/java/lotto/domain/Lotto.java     | 41 +++++++++--
 src/test/java/lotto/domain/LottoTest.java | 90 +++++++++++++++++++++--
 3 files changed, 125 insertions(+), 17 deletions(-)

diff --git a/README.md b/README.md
index 2b621907dc..4da6696200 100644
--- a/README.md
+++ b/README.md
@@ -191,10 +191,13 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
 
 사용자의 입력 오류로 예외가 발생하면  **`[ERROR] ...` 로 시작하는 에러 메시지를 사용자에게 출력하고 해당 입력부터 다시 입력을 진행할 수 있도록 합니다.**
 
-| 예외 상황                   | 에러 메시지                        |
-|-------------------------|-------------------------------|
-| 구입 금액이 0 이하인 경우         | `[ERROR] 구입 금액은 0보다 커야 합니다.`  |
-| 구입 금액이 1,000원 단위가 아닌 경우 | `[ERROR] 1,000원 단위로 입력해 주세요.` |
+| 예외 상황                   | 에러 메시지                            |
+|-------------------------|-----------------------------------|
+| 구입 금액이 0 이하인 경우         | `[ERROR] 구입 금액은 0보다 커야 합니다.`      |
+| 구입 금액이 1,000원 단위가 아닌 경우 | `[ERROR] 1,000원 단위로 입력해 주세요.`     |
+| 로또 번호가 6개가 아닌 경우        | `[ERROR] 로또 번호는 6개여야 합니다.`        |
+| 로또 번호에 중복이 있는 경우        | `[ERROR] 로또 번호는 중복될 수 없습니다.`      |
+| 로또 번호가 1~45 범위를 벗어나는 경우 | `[ERROR] 로또 번호는 1부터 45 사이여야 합니다.` |
 
 <br>
 <br>
diff --git a/src/main/java/lotto/domain/Lotto.java b/src/main/java/lotto/domain/Lotto.java
index d7797b2d7d..f390874d89 100644
--- a/src/main/java/lotto/domain/Lotto.java
+++ b/src/main/java/lotto/domain/Lotto.java
@@ -1,20 +1,51 @@
 package lotto.domain;
 
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 public class Lotto {
+
+    private static final int LOTTO_SIZE = 6;
+    private static final int MIN_NUMBER = 1;
+    private static final int MAX_NUMBER = 45;
     private final List<Integer> numbers;
 
     public Lotto(List<Integer> numbers) {
-        validate(numbers);
-        this.numbers = numbers;
+        validateCount(numbers);
+        validateRange(numbers);
+        validateDuplicate(numbers);
+        this.numbers = sort(numbers);
+    }
+
+    public List<Integer> getNumbers() {
+        return numbers;
     }
 
-    private void validate(List<Integer> numbers) {
-        if (numbers.size() != 6) {
+    private void validateCount(List<Integer> numbers) {
+        if (numbers.size() != LOTTO_SIZE) {
             throw new IllegalArgumentException("[ERROR] 로또 번호는 6개여야 합니다.");
         }
     }
 
-    // TODO: 추가 기능 구현
+    private void validateRange(List<Integer> numbers) {
+        for (int number : numbers) {
+            if (number < MIN_NUMBER || number > MAX_NUMBER) {
+                throw new IllegalArgumentException("[ERROR] 로또 번호는 1부터 45 사이여야 합니다.");
+            }
+        }
+    }
+
+    private void validateDuplicate(List<Integer> numbers) {
+        Set<Integer> unique = new HashSet<>(numbers);
+        if (unique.size() != numbers.size()) {
+            throw new IllegalArgumentException("[ERROR] 로또 번호는 중복될 수 없습니다.");
+        }
+    }
+
+    private List<Integer> sort(List<Integer> numbers) {
+        return numbers.stream()
+                .sorted()
+                .toList();
+    }
 }
diff --git a/src/test/java/lotto/domain/LottoTest.java b/src/test/java/lotto/domain/LottoTest.java
index 2309a29ad5..89d41a2c6e 100644
--- a/src/test/java/lotto/domain/LottoTest.java
+++ b/src/test/java/lotto/domain/LottoTest.java
@@ -1,25 +1,99 @@
 package lotto.domain;
 
-import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 class LottoTest {
+
+    @Test
+    void 로또_번호가_6개보다_많으면_예외가_발생한다() {
+
+        // given
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7);
+
+        // when & then
+        assertThatThrownBy(() -> new Lotto(numbers))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 번호는 6개여야 합니다.");
+    }
+
     @Test
-    void 로또_번호의_개수가_6개가_넘어가면_예외가_발생한다() {
-        assertThatThrownBy(() -> new Lotto(List.of(1, 2, 3, 4, 5, 6, 7)))
-                .isInstanceOf(IllegalArgumentException.class);
+    void 로또_번호가_6개보다_적으면_예외가_발생한다() {
+
+        // given
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5);
+
+        // when & then
+        assertThatThrownBy(() -> new Lotto(numbers))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 번호는 6개여야 합니다.");
     }
 
-    @DisplayName("로또 번호에 중복된 숫자가 있으면 예외가 발생한다.")
     @Test
     void 로또_번호에_중복된_숫자가_있으면_예외가_발생한다() {
-        assertThatThrownBy(() -> new Lotto(List.of(1, 2, 3, 4, 5, 5)))
-                .isInstanceOf(IllegalArgumentException.class);
+
+        // given
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 5);
+
+        // when & then
+        assertThatThrownBy(() -> new Lotto(numbers))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 번호는 중복될 수 없습니다.");
+    }
+
+    @Test
+    void 로또_번호가_1보다_작으면_예외가_발생한다() {
+
+        // given
+        List<Integer> numbers = List.of(0, 2, 3, 4, 5, 6);
+
+        // when & then
+        assertThatThrownBy(() -> new Lotto(numbers))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 번호는 1부터 45 사이여야 합니다.");
     }
 
-    // TODO: 추가 기능 구현에 따른 테스트 코드 작성
+    @Test
+    void 로또_번호가_45보다_크면_예외가_발생한다() {
+
+        // given
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 46);
+
+        // when & then
+        assertThatThrownBy(() -> new Lotto(numbers))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 번호는 1부터 45 사이여야 합니다.");
+    }
+
+    @Test
+    void 올바른_로또_번호_6개면_로또_객체가_생성된다() {
+
+        // given
+        List<Integer> numbers = List.of(8, 1, 45, 3, 20, 10);
+
+        // when
+        Lotto lotto = new Lotto(numbers);
+
+        // then
+        assertThat(lotto).isNotNull();
+    }
+
+    @Test
+    void 로또_번호는_오름차순으로_정렬되어_저장된다() {
+
+        // given
+        List<Integer> numbers = List.of(8, 1, 45, 3, 20, 10);
+
+        // when
+        Lotto lotto = new Lotto(numbers);
+
+        // then
+        assertThat(lotto).isNotNull();
+        assertThat(lotto.getNumbers())
+                .containsExactly(1, 3, 8, 10, 20, 45);
+    }
 }

From e61d56cab3019a0da8e5f911381b39a9cc17c4a9 Mon Sep 17 00:00:00 2001
From: JohnPrk <uo3641493@gmail.com>
Date: Mon, 3 Nov 2025 01:42:04 +0900
Subject: [PATCH 05/10] =?UTF-8?q?feat:=20=EB=8B=B9=EC=B2=A8=20=EB=B2=88?=
 =?UTF-8?q?=ED=98=B8=EC=99=80=20=EB=B3=B4=EB=84=88=EC=8A=A4=20=EB=B2=88?=
 =?UTF-8?q?=ED=98=B8=EB=A5=BC=20=EA=B0=80=EC=A7=80=EB=8A=94=20WinningNumbe?=
 =?UTF-8?q?rs=20=EB=8F=84=EB=A9=94=EC=9D=B8=20=ED=81=B4=EB=9E=98=EC=8A=A4?=
 =?UTF-8?q?=20=EA=B5=AC=ED=98=84=20=EB=B0=8F=20Lotto=20=ED=81=B4=EB=9E=98?=
 =?UTF-8?q?=EC=8A=A4=20=ED=99=95=EC=9E=A5?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Lotto를 활용해 당첨 번호 불변성(개수 6개, 1~45 범위, 중복 불가) 선행 검증
- 보너스 번호 범위(1~45) 및 당첨 번호와의 중복 검증
- 구매한 로또와의 일치 개수 조회
- 구매한 로또가 보너스 번호를 포함하는지 여부 확인
- [Lotto 확장] 생성자에서 null 방어
- [Lotto 확장] 번호 포함 여부 조회
- [Lotto 확장] 비교 대상 로또가 null일 때 예외 발생하도록 방어
- 로또 번호 목록을 불변 리스트로 노출하도록 변경해 캡슐화 강화
- WinningNumbersTest, LottoTest에 경계값/중복/null 검증 및 기능 단위 테스트 추가
- README.md 예외 처리 표에 Lotto/WinningNumbers 관련 예외 메시지 추가
---
 README.md                                     |  27 ++---
 src/main/java/lotto/domain/Lotto.java         |  39 ++++++-
 .../java/lotto/domain/WinningNumbers.java     |  45 ++++++++
 src/test/java/lotto/domain/LottoTest.java     | 106 +++++++++++++++---
 .../java/lotto/domain/WinningNumbersTest.java | 106 ++++++++++++++++++
 5 files changed, 287 insertions(+), 36 deletions(-)
 create mode 100644 src/main/java/lotto/domain/WinningNumbers.java
 create mode 100644 src/test/java/lotto/domain/WinningNumbersTest.java

diff --git a/README.md b/README.md
index 4da6696200..c2db501433 100644
--- a/README.md
+++ b/README.md
@@ -182,22 +182,17 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
 
 사용자의 입력 오류로 예외가 발생하면  **`[ERROR] ...` 로 시작하는 에러 메시지를 사용자에게 출력하고 해당 입력부터 다시 입력을 진행할 수 있도록 합니다.**
 
-예외 처리 메세지는 구현하면서 하나씩 채워 넣을 예정입니다.
-
-| 예외 상황 | 에러 메시지 |
-|-------|--------|
-
-## 📋 예외 처리
-
-사용자의 입력 오류로 예외가 발생하면  **`[ERROR] ...` 로 시작하는 에러 메시지를 사용자에게 출력하고 해당 입력부터 다시 입력을 진행할 수 있도록 합니다.**
-
-| 예외 상황                   | 에러 메시지                            |
-|-------------------------|-----------------------------------|
-| 구입 금액이 0 이하인 경우         | `[ERROR] 구입 금액은 0보다 커야 합니다.`      |
-| 구입 금액이 1,000원 단위가 아닌 경우 | `[ERROR] 1,000원 단위로 입력해 주세요.`     |
-| 로또 번호가 6개가 아닌 경우        | `[ERROR] 로또 번호는 6개여야 합니다.`        |
-| 로또 번호에 중복이 있는 경우        | `[ERROR] 로또 번호는 중복될 수 없습니다.`      |
-| 로또 번호가 1~45 범위를 벗어나는 경우 | `[ERROR] 로또 번호는 1부터 45 사이여야 합니다.` |
+| 예외 상황                   | 에러 메시지                               |
+|-------------------------|--------------------------------------|
+| 구입 금액이 0 이하인 경우         | `[ERROR] 구입 금액은 0보다 커야 합니다.`         |
+| 구입 금액이 1,000원 단위가 아닌 경우 | `[ERROR] 1,000원 단위로 입력해 주세요.`        |
+| 로또 번호 리스트가 null인 경우     | `[ERROR] 로또 번호는 null일 수 없습니다.`       |
+| 비교할 로또 번호 리스트가 null인 경우 | `[ERROR] 비교할 로또가 null일 수 없습니다.`      |
+| 로또 번호가 6개가 아닌 경우        | `[ERROR] 로또 번호는 6개여야 합니다.`           |
+| 로또 번호에 중복이 있는 경우        | `[ERROR] 로또 번호는 중복될 수 없습니다.`         |
+| 로또 번호가 1~45 범위를 벗어나는 경우 | `[ERROR] 로또 번호는 1부터 45 사이여야 합니다.`    |
+| 보너스 번호가 1~45 범위를 벗어난 경우 | `[ERROR] 보너스 번호는 1부터 45 사이여야 합니다.`   |
+| 보너스 번호가 당첨 번호와 중복되는 경우  | `[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.` |
 
 <br>
 <br>
diff --git a/src/main/java/lotto/domain/Lotto.java b/src/main/java/lotto/domain/Lotto.java
index f390874d89..18bdc0ef86 100644
--- a/src/main/java/lotto/domain/Lotto.java
+++ b/src/main/java/lotto/domain/Lotto.java
@@ -1,8 +1,10 @@
 package lotto.domain;
 
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 public class Lotto {
 
@@ -12,14 +14,39 @@ public class Lotto {
     private final List<Integer> numbers;
 
     public Lotto(List<Integer> numbers) {
+        validateNotNull(numbers);
         validateCount(numbers);
         validateRange(numbers);
         validateDuplicate(numbers);
-        this.numbers = sort(numbers);
+        this.numbers = sortNumbers(numbers);
     }
 
     public List<Integer> getNumbers() {
-        return numbers;
+        return Collections.unmodifiableList(numbers);
+    }
+
+    public boolean containsNumber(int number) {
+        return numbers.contains(number);
+    }
+
+    public int countMatchingNumbers(Lotto otherLotto) {
+        validateOtherLottoNotNull(otherLotto);
+        Set<Integer> otherNumbers = new HashSet<>(otherLotto.numbers);
+        return (int) numbers.stream()
+                .filter(otherNumbers::contains)
+                .count();
+    }
+
+    private void validateOtherLottoNotNull(Lotto otherLotto) {
+        if (otherLotto == null) {
+            throw new IllegalArgumentException("[ERROR] 비교할 로또가 null일 수 없습니다.");
+        }
+    }
+
+    private void validateNotNull(List<Integer> numbers) {
+        if (numbers == null) {
+            throw new IllegalArgumentException("[ERROR] 로또 번호는 null일 수 없습니다.");
+        }
     }
 
     private void validateCount(List<Integer> numbers) {
@@ -37,15 +64,15 @@ private void validateRange(List<Integer> numbers) {
     }
 
     private void validateDuplicate(List<Integer> numbers) {
-        Set<Integer> unique = new HashSet<>(numbers);
-        if (unique.size() != numbers.size()) {
+        Set<Integer> uniqueNumbers = new HashSet<>(numbers);
+        if (uniqueNumbers.size() != LOTTO_SIZE) {
             throw new IllegalArgumentException("[ERROR] 로또 번호는 중복될 수 없습니다.");
         }
     }
 
-    private List<Integer> sort(List<Integer> numbers) {
+    private List<Integer> sortNumbers(List<Integer> numbers) {
         return numbers.stream()
                 .sorted()
-                .toList();
+                .collect(Collectors.toList());
     }
 }
diff --git a/src/main/java/lotto/domain/WinningNumbers.java b/src/main/java/lotto/domain/WinningNumbers.java
new file mode 100644
index 0000000000..b90dc0b219
--- /dev/null
+++ b/src/main/java/lotto/domain/WinningNumbers.java
@@ -0,0 +1,45 @@
+package lotto.domain;
+
+import java.util.List;
+
+public class WinningNumbers {
+
+    private final Lotto winningLotto;
+    private final int bonusNumber;
+
+    public WinningNumbers(List<Integer> winningNumbers, int bonusNumber) {
+        Lotto lotto = new Lotto(winningNumbers);
+        validateBonusNumber(lotto, bonusNumber);
+        this.winningLotto = lotto;
+        this.bonusNumber = bonusNumber;
+    }
+
+    public int getBonusNumber() {
+        return bonusNumber;
+    }
+
+    public int countMatchingNumbers(Lotto lotto) {
+        return winningLotto.countMatchingNumbers(lotto);
+    }
+
+    public boolean containsBonusNumber(Lotto lotto) {
+        return lotto.containsNumber(bonusNumber);
+    }
+
+    private void validateBonusNumber(Lotto winningLotto, int bonusNumber) {
+        validateBonusRange(bonusNumber);
+        validateBonusDuplicate(winningLotto, bonusNumber);
+    }
+
+    private void validateBonusRange(int bonusNumber) {
+        if (bonusNumber < 1 || bonusNumber > 45) {
+            throw new IllegalArgumentException("[ERROR] 보너스 번호는 1부터 45 사이여야 합니다.");
+        }
+    }
+
+    private void validateBonusDuplicate(Lotto winningLotto, int bonusNumber) {
+        if (winningLotto.containsNumber(bonusNumber)) {
+            throw new IllegalArgumentException("[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.");
+        }
+    }
+}
diff --git a/src/test/java/lotto/domain/LottoTest.java b/src/test/java/lotto/domain/LottoTest.java
index 89d41a2c6e..d535420017 100644
--- a/src/test/java/lotto/domain/LottoTest.java
+++ b/src/test/java/lotto/domain/LottoTest.java
@@ -1,11 +1,16 @@
 package lotto.domain;
 
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.NullSource;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import java.util.List;
+import java.util.stream.Stream;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.Assertions.*;
 
 class LottoTest {
 
@@ -45,11 +50,12 @@ class LottoTest {
                 .hasMessage("[ERROR] 로또 번호는 중복될 수 없습니다.");
     }
 
-    @Test
-    void 로또_번호가_1보다_작으면_예외가_발생한다() {
+    @ParameterizedTest()
+    @ValueSource(ints = {0, 46})
+    void 로또_번호가_1부터_45_사이의_값이_아니면_예외가_발생한다(int invalidNumber) {
 
         // given
-        List<Integer> numbers = List.of(0, 2, 3, 4, 5, 6);
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5, invalidNumber);
 
         // when & then
         assertThatThrownBy(() -> new Lotto(numbers))
@@ -57,20 +63,28 @@ class LottoTest {
                 .hasMessage("[ERROR] 로또 번호는 1부터 45 사이여야 합니다.");
     }
 
+    @ParameterizedTest
+    @NullSource
+    void 로또_번호가_null이면_예외가_발생한다(List<Integer> numbers) {
+
+        // when & then
+        assertThatThrownBy(() -> new Lotto(numbers))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 번호는 null일 수 없습니다.");
+    }
+
     @Test
-    void 로또_번호가_45보다_크면_예외가_발생한다() {
+    void 로또_번호가_정상_범위에서_극_값인_1과_45를_포함해도_예외가_발생하지_않는다() {
 
         // given
-        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 46);
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 45);
 
         // when & then
-        assertThatThrownBy(() -> new Lotto(numbers))
-                .isInstanceOf(IllegalArgumentException.class)
-                .hasMessage("[ERROR] 로또 번호는 1부터 45 사이여야 합니다.");
+        assertThatNoException().isThrownBy(() -> new Lotto(numbers));
     }
 
     @Test
-    void 올바른_로또_번호_6개면_로또_객체가_생성된다() {
+    void 정상_범위의_6개_값을_사용하면_객체_생성이_가능하다() {
 
         // given
         List<Integer> numbers = List.of(8, 1, 45, 3, 20, 10);
@@ -80,6 +94,7 @@ class LottoTest {
 
         // then
         assertThat(lotto).isNotNull();
+        assertThat(lotto.getNumbers()).hasSize(6);
     }
 
     @Test
@@ -92,8 +107,71 @@ class LottoTest {
         Lotto lotto = new Lotto(numbers);
 
         // then
-        assertThat(lotto).isNotNull();
-        assertThat(lotto.getNumbers())
-                .containsExactly(1, 3, 8, 10, 20, 45);
+        assertThat(lotto.getNumbers()).containsExactly(1, 3, 8, 10, 20, 45);
+    }
+
+    @Test
+    void 로또가_특정_번호를_포함하면_true를_반환한다() {
+
+        // given
+        Lotto lotto = new Lotto(List.of(1, 3, 5, 10, 20, 45));
+
+        // when & then
+        assertThat(lotto.containsNumber(10)).isTrue();
+        assertThat(lotto.containsNumber(7)).isFalse();
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideLottoMatchScenarios")
+    void 다른_로또와_일치하는_번호_개수를_계산할_수_있다(Lotto priorLotto, Lotto nextLotto, int expectedMatchCount) {
+
+        // when
+        int matchCount = priorLotto.countMatchingNumbers(nextLotto);
+
+        // then
+        assertThat(matchCount).isEqualTo(expectedMatchCount);
+    }
+
+    @Test
+    void 비교할_로또가_null이면_예외가_발생한다() {
+
+        // given
+        Lotto lotto = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+
+        // when & then
+        assertThatThrownBy(() -> lotto.countMatchingNumbers(null))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 비교할 로또가 null일 수 없습니다.");
+    }
+
+    @Test
+    void 로또_번호_목록은_외부에서_수정할_수_없다() {
+
+        // given
+        Lotto lotto = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+
+        // when & then
+        assertThatThrownBy(() -> lotto.getNumbers().add(7))
+                .isInstanceOf(UnsupportedOperationException.class);
+    }
+
+    private static Stream<Arguments> provideLottoMatchScenarios() {
+        return Stream.of(
+                Arguments.of(
+                        new Lotto(List.of(1, 2, 3, 4, 5, 6)),
+                        new Lotto(List.of(4, 5, 6, 40, 41, 42)),
+                        3
+                ),
+                Arguments.of(
+                        new Lotto(List.of(1, 2, 3, 4, 5, 6)),
+                        new Lotto(List.of(7, 8, 9, 10, 11, 12)),
+                        0
+                ),
+                Arguments.of(
+                        new Lotto(List.of(1, 2, 3, 4, 5, 6)),
+                        new Lotto(List.of(1, 2, 3, 4, 5, 6)),
+                        6
+                )
+        );
     }
 }
diff --git a/src/test/java/lotto/domain/WinningNumbersTest.java b/src/test/java/lotto/domain/WinningNumbersTest.java
new file mode 100644
index 0000000000..f802764dc6
--- /dev/null
+++ b/src/test/java/lotto/domain/WinningNumbersTest.java
@@ -0,0 +1,106 @@
+package lotto.domain;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.*;
+
+class WinningNumbersTest {
+
+    @ParameterizedTest
+    @ValueSource(ints = {1, 45})
+    void 보너스_번호가_정상_범위에서_극_값인_1과_45_값이_들어가도_예외가_발생하지_않는다(int validBonusNumber) {
+
+        // given
+        List<Integer> numbers = List.of(2, 3, 4, 5, 6, 7);
+
+        // when & then
+        assertThatNoException()
+                .isThrownBy(() -> new WinningNumbers(numbers, validBonusNumber));
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {0, 46})
+    void 보너스_번호가_정상_범위를_벗어난_1부터_45_사이의_값이_아니면_예외가_발생한다(int invalidBonusNumber) {
+
+        // given
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
+
+        // when & then
+        assertThatThrownBy(() -> new WinningNumbers(numbers, invalidBonusNumber))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 보너스 번호는 1부터 45 사이여야 합니다.");
+    }
+
+    @Test
+    void 보너스_번호가_당첨_번호와_중복되면_예외가_발생한다() {
+
+        // given
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
+
+        // when & then
+        assertThatThrownBy(() -> new WinningNumbers(numbers, 6))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.");
+    }
+
+    @Test
+    void 당첨_번호_로또의_생성자_검증이_보너스_번호_검증보다_먼저_수행된다() {
+
+        // given
+        List<Integer> invalidNumbers = List.of(1, 2, 3, 4, 5, 5);
+
+        // when & then
+        assertThatThrownBy(() -> new WinningNumbers(invalidNumbers, 7))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 번호는 중복될 수 없습니다.");
+    }
+
+    @Test
+    void 당첨_번호와_보너스_번호가_모두_유효하면_생성된다() {
+
+        // given
+        List<Integer> lottoNumbers = List.of(4, 36, 3, 28, 44, 11);
+        int bonusNumber = 7;
+
+        // when
+        WinningNumbers winningNumbers = new WinningNumbers(lottoNumbers, bonusNumber);
+
+        // then
+        assertThat(winningNumbers).isNotNull();
+        assertThat(winningNumbers.getBonusNumber()).isEqualTo(bonusNumber);
+
+        Lotto testLotto = new Lotto(lottoNumbers);
+        assertThat(winningNumbers.countMatchingNumbers(testLotto)).isEqualTo(6);
+    }
+
+    @Test
+    void 당첨_번호_로또와_비교할_로또의_값_일치_개수를_구할_수_있다() {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        Lotto lotto = new Lotto(List.of(1, 2, 10, 11, 12, 13));
+
+        // when
+        int matchCount = winningNumbers.countMatchingNumbers(lotto);
+
+        // then
+        assertThat(matchCount).isEqualTo(2);
+    }
+
+    @Test
+    void 보너스_번호를_포함하는지_확인할_수_있다() {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        Lotto containsBonus = new Lotto(List.of(7, 10, 20, 30, 40, 45));
+        Lotto notContainsBonus = new Lotto(List.of(8, 10, 20, 30, 40, 45));
+
+        // when & then
+        assertThat(winningNumbers.containsBonusNumber(containsBonus)).isTrue();
+        assertThat(winningNumbers.containsBonusNumber(notContainsBonus)).isFalse();
+    }
+}

From c354951e6882c0ef446f7a2a5ac00f38e4b2f8e0 Mon Sep 17 00:00:00 2001
From: JohnPrk <uo3641493@gmail.com>
Date: Mon, 3 Nov 2025 03:39:39 +0900
Subject: [PATCH 06/10] =?UTF-8?q?feat:=20=EB=A1=9C=EB=98=90=20=EB=8B=B9?=
 =?UTF-8?q?=EC=B2=A8=20=EB=93=B1=EC=88=98=EC=99=80=20=EC=83=81=EA=B8=88?=
 =?UTF-8?q?=EC=9D=84=20=EC=A0=95=EC=9D=98=ED=95=98=EB=8A=94=20LottoRank=20?=
 =?UTF-8?q?enum=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 1등부터 5등 및 꽝에 대한 등수 조건 정의
- 등수별 상금 제공 기능
- 일치 개수와 보너스 일치 여부 기반 등수 판정 로직 구현
- 등수 판정 및 상금 제공 기능에 대한 단위 테스트
- 보너스 번호가 등수에 미치는 영향 범위 검증
---
 src/main/java/lotto/domain/LottoRank.java     |  37 +++++
 src/test/java/lotto/domain/LottoRankTest.java | 152 ++++++++++++++++++
 2 files changed, 189 insertions(+)
 create mode 100644 src/main/java/lotto/domain/LottoRank.java
 create mode 100644 src/test/java/lotto/domain/LottoRankTest.java

diff --git a/src/main/java/lotto/domain/LottoRank.java b/src/main/java/lotto/domain/LottoRank.java
new file mode 100644
index 0000000000..d2496e1afe
--- /dev/null
+++ b/src/main/java/lotto/domain/LottoRank.java
@@ -0,0 +1,37 @@
+package lotto.domain;
+
+import java.util.Arrays;
+
+public enum LottoRank {
+
+    FIRST(6, false, 2_000_000_000L),
+    SECOND(5, true, 30_000_000L),
+    THIRD(5, false, 1_500_000L),
+    FOURTH(4, false, 50_000L),
+    FIFTH(3, false, 5_000L),
+    NONE(0, false, 0L);
+
+    private final int matchCount;
+    private final boolean requiresBonus;
+    private final long prize;
+
+    LottoRank(int matchCount, boolean requiresBonus, long prize) {
+        this.matchCount = matchCount;
+        this.requiresBonus = requiresBonus;
+        this.prize = prize;
+    }
+
+    public long getPrize() {
+        return prize;
+    }
+
+    public static LottoRank from(int matchCount, boolean bonusMatched) {
+        if (matchCount == 5) {
+            return bonusMatched ? SECOND : THIRD;
+        }
+        return Arrays.stream(values())
+                .filter(rank -> rank.matchCount == matchCount)
+                .findFirst()
+                .orElse(NONE);
+    }
+}
diff --git a/src/test/java/lotto/domain/LottoRankTest.java b/src/test/java/lotto/domain/LottoRankTest.java
new file mode 100644
index 0000000000..ffbb85c6a7
--- /dev/null
+++ b/src/test/java/lotto/domain/LottoRankTest.java
@@ -0,0 +1,152 @@
+package lotto.domain;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class LottoRankTest {
+
+    @Test
+    void 여섯_개가_모두_일치하면_1등이다() {
+
+        // given
+        int matchCount = 6;
+        boolean bonusMatched = false;
+
+        // when
+        LottoRank rank = LottoRank.from(matchCount, bonusMatched);
+
+        // then
+        assertThat(rank).isEqualTo(LottoRank.FIRST);
+    }
+
+    @Test
+    void 다섯_개와_보너스까지_일치하면_2등이다() {
+
+        // given
+        int matchCount = 5;
+        boolean bonusMatched = true;
+
+        // when
+        LottoRank rank = LottoRank.from(matchCount, bonusMatched);
+
+        // then
+        assertThat(rank).isEqualTo(LottoRank.SECOND);
+    }
+
+    @Test
+    void 다섯_개만_일치하고_보너스는_다르면_3등이다() {
+
+        // given
+        int matchCount = 5;
+        boolean bonusMatched = false;
+
+        // when
+        LottoRank rank = LottoRank.from(matchCount, bonusMatched);
+
+        // then
+        assertThat(rank).isEqualTo(LottoRank.THIRD);
+    }
+
+    @Test
+    void 네_개가_일치하면_4등이다() {
+
+        // given
+        int matchCount = 4;
+
+        // when
+        LottoRank rank = LottoRank.from(matchCount, false);
+
+        // then
+        assertThat(rank).isEqualTo(LottoRank.FOURTH);
+    }
+
+    @Test
+    void 세_개가_일치하면_5등이다() {
+
+        // given
+        int matchCount = 3;
+
+        // when
+        LottoRank rank = LottoRank.from(matchCount, false);
+
+        // then
+        assertThat(rank).isEqualTo(LottoRank.FIFTH);
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {0, 1, 2})
+    void 두_개_이하로_일치하면_꽝이다(int matchCount) {
+
+        // when
+        LottoRank rank = LottoRank.from(matchCount, false);
+
+        // then
+        assertThat(rank).isEqualTo(LottoRank.NONE);
+    }
+
+    @ParameterizedTest
+    @MethodSource("providePrizePerRank")
+    void 등수별_당첨금을_반환한다(LottoRank rank, long expectedPrize) {
+
+        //when
+        long prize = rank.getPrize();
+
+        // then
+        assertThat(prize).isEqualTo(expectedPrize);
+    }
+
+
+    @ParameterizedTest
+    @MethodSource("bonusShouldBeIgnoredCases")
+    void 보너스는_다섯_개가_맞을_때를_제외하고는_영향을_주지_않는다(int matchCount) {
+
+        // when
+        LottoRank withBonus = LottoRank.from(matchCount, true);
+        LottoRank withoutBonus = LottoRank.from(matchCount, false);
+
+        // then
+        assertThat(withBonus).isEqualTo(withoutBonus);
+    }
+
+    @Test
+    void 다섯_개_일치_시_보너스_여부에_따라_등수가_바뀐다() {
+
+        // when
+        LottoRank withBonus = LottoRank.from(5, true);
+        LottoRank withoutBonus = LottoRank.from(5, false);
+
+        // then
+        assertThat(withBonus).isEqualTo(LottoRank.SECOND);
+        assertThat(withoutBonus).isEqualTo(LottoRank.THIRD);
+        assertThat(withBonus).isNotEqualTo(withoutBonus);
+    }
+
+    private static Stream<Arguments> bonusShouldBeIgnoredCases() {
+        return Stream.of(
+                Arguments.of(0),
+                Arguments.of(1),
+                Arguments.of(2),
+                Arguments.of(3),
+                Arguments.of(4),
+                Arguments.of(6)
+        );
+    }
+
+    private static Stream<Arguments> providePrizePerRank() {
+        return Stream.of(
+                Arguments.of(LottoRank.FIRST, 2_000_000_000L),
+                Arguments.of(LottoRank.SECOND, 30_000_000L),
+                Arguments.of(LottoRank.THIRD, 1_500_000L),
+                Arguments.of(LottoRank.FOURTH, 50_000L),
+                Arguments.of(LottoRank.FIFTH, 5_000L),
+                Arguments.of(LottoRank.NONE, 0L)
+        );
+    }
+}

From 24c96805b1084a274cc5683ef98e3cb98c02e792 Mon Sep 17 00:00:00 2001
From: JohnPrk <uo3641493@gmail.com>
Date: Mon, 3 Nov 2025 20:06:35 +0900
Subject: [PATCH 07/10] =?UTF-8?q?feat:=20=EB=A1=9C=EB=98=90=20=EB=8B=B9?=
 =?UTF-8?q?=EC=B2=A8=20=EA=B2=B0=EA=B3=BC=EB=A5=BC=20=EC=A7=91=EA=B3=84?=
 =?UTF-8?q?=ED=95=98=EB=8A=94=20LottoResults=20=EB=8F=84=EB=A9=94=EC=9D=B8?=
 =?UTF-8?q?=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 구매한 로또 목록과 당첨 번호를 기반으로 등수별 당첨 개수 집계
- 등수별 상금을 누적해 총 당첨 금액 계산
- 구입 금액을 인자로 받아 수익률(총 당첨금 / 구입 금액) 계산
- 로또 목록 및 각 원소, 당첨 번호에 대한 null 방어 로직과 예외 메시지 정의
- 검증 및 총 당첨금 집계, 수익률 조회 기능 관련 단위 테스트 작성
- README.md 예외 처리 표에 LottoResults 관련 예외 메시지 추가
---
 README.md                                     |  34 ++--
 src/main/java/lotto/domain/LottoResults.java  |  71 ++++++++
 .../java/lotto/domain/LottoResultsTest.java   | 157 ++++++++++++++++++
 3 files changed, 247 insertions(+), 15 deletions(-)
 create mode 100644 src/main/java/lotto/domain/LottoResults.java
 create mode 100644 src/test/java/lotto/domain/LottoResultsTest.java

diff --git a/README.md b/README.md
index c2db501433..f3c7d6e20e 100644
--- a/README.md
+++ b/README.md
@@ -110,7 +110,7 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
 | `LottoFactory`    | 로또 규칙에 맞는 랜덤 번호를 생성하여 `Lotto` 객체를 만드는 책임을 짐 |                                    | -`Randoms.pickUniqueNumbersInRange()`를 사용해 로또 번호 생성                         |
 | `WinningNumbers`  | 당첨 번호와 보너스 번호를 가지며 관련 규칙(개수, 범위, 중복)을 책임짐   | * 6개 당첨 번호, 1개 보너스 번호              | - 당첨 번호 유효성 검사, 보너스 번호 유효성 검사 및 중복 확인                                       |
 | `LottoRank`       | 당첨 등수(1~5등, 꽝)의 조건(일치 개수, 보너스)과 상금을 정의      | *Enum class(일치 개수, 보너스 포함여부,당첨 금액) | - 일치 수/보너스 포함 여부로 등수 반환, 상금 반환                                              |
-| `LottoResults`    | 전체 당첨 결과를 집계하고 최종 수익률을 계산                   | * 등수별 당첨 횟수, 총 수익률, 누적 상금          | - 각 로또에 대한 등수 계산, 당첨 결과 누적, 수익률 계산                                          |
+| `LottoResults`    | 전체 당첨 결과를 집계하고 최종 수익률을 계산                   | * 등수별 당첨 횟수, 누적 상금                 | - 각 로또에 대한 등수 계산, 당첨 결과 누적, 수익률 계산                                          |
 | `InputView`       | 사용자로부터 입력을 받는 모든 로직을 담당                     | * 입력 접두사                           | - 사용자로부터 입력을 받음, `camp.nextstep.edu.missionutils.Console`의 `readLine()`을 사용 |
 | `OutputView`      | 사용자에게 정보를 출력하는 모든 로직을 담당                    | * 출력 접두사                           | - 구매한 로또 목록 출력, 당첨 결과 출력, 수익률 출력                                            |
 | `LottoController` | 애플리케이션의 전체 실행 흐름을 조율. View와 Domain 객체들을 연결  |                                    | - 전체 흐름 제어                                                                  |
@@ -182,17 +182,21 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
 
 사용자의 입력 오류로 예외가 발생하면  **`[ERROR] ...` 로 시작하는 에러 메시지를 사용자에게 출력하고 해당 입력부터 다시 입력을 진행할 수 있도록 합니다.**
 
-| 예외 상황                   | 에러 메시지                               |
-|-------------------------|--------------------------------------|
-| 구입 금액이 0 이하인 경우         | `[ERROR] 구입 금액은 0보다 커야 합니다.`         |
-| 구입 금액이 1,000원 단위가 아닌 경우 | `[ERROR] 1,000원 단위로 입력해 주세요.`        |
-| 로또 번호 리스트가 null인 경우     | `[ERROR] 로또 번호는 null일 수 없습니다.`       |
-| 비교할 로또 번호 리스트가 null인 경우 | `[ERROR] 비교할 로또가 null일 수 없습니다.`      |
-| 로또 번호가 6개가 아닌 경우        | `[ERROR] 로또 번호는 6개여야 합니다.`           |
-| 로또 번호에 중복이 있는 경우        | `[ERROR] 로또 번호는 중복될 수 없습니다.`         |
-| 로또 번호가 1~45 범위를 벗어나는 경우 | `[ERROR] 로또 번호는 1부터 45 사이여야 합니다.`    |
-| 보너스 번호가 1~45 범위를 벗어난 경우 | `[ERROR] 보너스 번호는 1부터 45 사이여야 합니다.`   |
-| 보너스 번호가 당첨 번호와 중복되는 경우  | `[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.` |
+| 예외 상황                      | 에러 메시지                                    |
+|----------------------------|-------------------------------------------|
+| 당첨 결과를 계산할 로또 목록이 null인 경우 | `[ERROR] 당첨 결과를 계산할 로또 목록은 null일 수 없습니다.` |
+| 로또 목록에 null이 포함된 경우        | `[ERROR] 로또 목록에 null이 포함될 수 없습니다.`        |
+| 당첨 번호가 null인 경우            | `[ERROR] 당첨 번호는 null일 수 없습니다.`            |
+| 수익률 계산시 구입금액이 0 이하인 경우     | `[ERROR] 구입 금액은 0보다 커야 합니다.`              |
+| 구입 금액이 0 이하인 경우            | `[ERROR] 구입 금액은 0보다 커야 합니다.`              |
+| 구입 금액이 1,000원 단위가 아닌 경우    | `[ERROR] 1,000원 단위로 입력해 주세요.`             |
+| 로또 번호 리스트가 null인 경우        | `[ERROR] 로또 번호는 null일 수 없습니다.`            |
+| 비교할 로또 번호 리스트가 null인 경우    | `[ERROR] 비교할 로또가 null일 수 없습니다.`           |
+| 로또 번호가 6개가 아닌 경우           | `[ERROR] 로또 번호는 6개여야 합니다.`                |
+| 로또 번호에 중복이 있는 경우           | `[ERROR] 로또 번호는 중복될 수 없습니다.`              |
+| 로또 번호가 1~45 범위를 벗어나는 경우    | `[ERROR] 로또 번호는 1부터 45 사이여야 합니다.`         |
+| 보너스 번호가 1~45 범위를 벗어난 경우    | `[ERROR] 보너스 번호는 1부터 45 사이여야 합니다.`        |
+| 보너스 번호가 당첨 번호와 중복되는 경우     | `[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.`      |
 
 <br>
 <br>
@@ -218,9 +222,9 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
 구현 과정에서 배우고 고민했던 것들을 기록하는 공간입니다.
 
 - [도메인 설계시 고려했던 것](https://github.com/JohnPrk/java-lotto-8/issues/1)
-- **[Inside-Out vs Outside-In TDD 선택 이유](**https://github.com/JohnPrk/java-lotto-8/issues/2**)**
-- **[Supplier는 무엇인가?](**https://github.com/JohnPrk/java-lotto-8/issues/3**)**
-- **[2023년 구현 vs 지금 구현 비교[회고]](**https://github.com/JohnPrk/java-lotto-8/issues/4**)**
+- [Inside-Out vs Outside-In TDD 선택 이유](https://github.com/JohnPrk/java-lotto-8/issues/2**)
+- [Supplier는 무엇인가?](https://github.com/JohnPrk/java-lotto-8/issues/3**)
+- [2023년 구현 vs 지금 구현 비교[회고]](https://github.com/JohnPrk/java-lotto-8/issues/4**)
 
 <br>
 <br>
diff --git a/src/main/java/lotto/domain/LottoResults.java b/src/main/java/lotto/domain/LottoResults.java
new file mode 100644
index 0000000000..9a512b497c
--- /dev/null
+++ b/src/main/java/lotto/domain/LottoResults.java
@@ -0,0 +1,71 @@
+package lotto.domain;
+
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+
+public class LottoResults {
+
+    private final Map<LottoRank, Integer> results = new EnumMap<>(LottoRank.class);
+    private long totalPrize;
+
+    public LottoResults(List<Lotto> lottos, WinningNumbers winningNumbers) {
+        validateLottos(lottos);
+        validateLottoElements(lottos);
+        validateWinningNumbers(winningNumbers);
+        countResults(lottos, winningNumbers);
+    }
+
+    public int getCountOf(LottoRank rank) {
+        return results.getOrDefault(rank, 0);
+    }
+
+    public long getTotalPrize() {
+        return totalPrize;
+    }
+
+    public double calculateYield(long purchaseAmount) {
+        if (purchaseAmount <= 0) {
+            throw new IllegalArgumentException("[ERROR] 구입 금액은 0보다 커야 합니다.");
+        }
+        return (double) totalPrize / purchaseAmount;
+    }
+
+    private void validateLottos(List<Lotto> lottos) {
+        if (lottos == null) {
+            throw new IllegalArgumentException("[ERROR] 당첨 결과를 계산할 로또 목록은 null일 수 없습니다.");
+        }
+    }
+
+    private void validateLottoElements(List<Lotto> lottos) {
+        for (Lotto lotto : lottos) {
+            if (lotto == null) {
+                throw new IllegalArgumentException("[ERROR] 로또 목록에 null이 포함될 수 없습니다.");
+            }
+        }
+    }
+
+    private void validateWinningNumbers(WinningNumbers winningNumbers) {
+        if (winningNumbers == null) {
+            throw new IllegalArgumentException("[ERROR] 당첨 번호는 null일 수 없습니다.");
+        }
+    }
+
+    private void countResults(List<Lotto> lottos, WinningNumbers winningNumbers) {
+        for (Lotto lotto : lottos) {
+            LottoRank rank = toRank(lotto, winningNumbers);
+            incrementRankCount(rank);
+            totalPrize += rank.getPrize();
+        }
+    }
+
+    private LottoRank toRank(Lotto lotto, WinningNumbers winningNumbers) {
+        int matchCount = winningNumbers.countMatchingNumbers(lotto);
+        boolean bonusMatched = winningNumbers.containsBonusNumber(lotto);
+        return LottoRank.from(matchCount, bonusMatched);
+    }
+
+    private void incrementRankCount(LottoRank rank) {
+        results.put(rank, results.getOrDefault(rank, 0) + 1);
+    }
+}
diff --git a/src/test/java/lotto/domain/LottoResultsTest.java b/src/test/java/lotto/domain/LottoResultsTest.java
new file mode 100644
index 0000000000..fbd85777bf
--- /dev/null
+++ b/src/test/java/lotto/domain/LottoResultsTest.java
@@ -0,0 +1,157 @@
+package lotto.domain;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class LottoResultsTest {
+
+    @Test
+    void 주어진_로또들과_당첨_번호_로또를_비교하여_순위를_올리고_집계할_수_있다() {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        Lotto first = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+        Lotto second = new Lotto(List.of(1, 2, 3, 4, 5, 7));
+        Lotto third = new Lotto(List.of(1, 2, 3, 4, 5, 45));
+        Lotto fourth = new Lotto(List.of(1, 2, 3, 4, 11, 45));
+        Lotto fifth = new Lotto(List.of(1, 2, 3, 7, 11, 45));
+        Lotto none = new Lotto(List.of(10, 11, 12, 13, 14, 15));
+        List<Lotto> lottos = List.of(first, second, third, fourth, fifth, none);
+
+        // when
+        LottoResults results = new LottoResults(lottos, winningNumbers);
+
+        // then
+        assertThat(results.getCountOf(LottoRank.FIRST)).isEqualTo(1);
+        assertThat(results.getCountOf(LottoRank.SECOND)).isEqualTo(1);
+        assertThat(results.getCountOf(LottoRank.THIRD)).isEqualTo(1);
+        assertThat(results.getCountOf(LottoRank.FOURTH)).isEqualTo(1);
+        assertThat(results.getCountOf(LottoRank.FIFTH)).isEqualTo(1);
+        assertThat(results.getCountOf(LottoRank.NONE)).isEqualTo(1);
+    }
+
+    @Test
+    void 주어진_로또들과_당첨_번호_로또의_일치_개수가_2_이하라면_NONE만_증가한다() {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        List<Lotto> lottos = List.of(
+                new Lotto(List.of(10, 11, 12, 13, 14, 15)),
+                new Lotto(List.of(20, 21, 22, 23, 24, 25)),
+                new Lotto(List.of(1, 2, 22, 23, 24, 25)),
+                new Lotto(List.of(20, 21, 3, 23, 24, 25)),
+                new Lotto(List.of(20, 21, 3, 4, 24, 25)),
+                new Lotto(List.of(20, 21, 10, 11, 5, 25)),
+                new Lotto(List.of(20, 21, 10, 11, 5, 6))
+        );
+
+        // when
+        LottoResults results = new LottoResults(lottos, winningNumbers);
+
+        // then
+        for (LottoRank rank : LottoRank.values()) {
+            if (rank == LottoRank.NONE) {
+                assertThat(results.getCountOf(rank)).isEqualTo(7);
+                continue;
+            }
+            assertThat(results.getCountOf(rank)).isEqualTo(0);
+        }
+    }
+
+    @Test
+    void 당첨된_로또들의_총_당첨금을_합산한다() {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        Lotto first = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+        Lotto fifth = new Lotto(List.of(1, 2, 3, 40, 41, 42));
+        List<Lotto> lottos = List.of(first, fifth);
+
+        // when
+        LottoResults results = new LottoResults(lottos, winningNumbers);
+
+        // then
+        assertThat(results.getTotalPrize()).isEqualTo(2_000_005_000L);
+    }
+
+    @Test
+    void 수익률을_구입금액으로_계산한다() {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        Lotto first = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+        Lotto third = new Lotto(List.of(1, 2, 3, 4, 17, 6));
+        List<Lotto> lottos = List.of(first, third);
+        LottoResults results = new LottoResults(lottos, winningNumbers);
+
+        // when
+        double yield = results.calculateYield(lottos.size() * 1000);
+
+        // then
+        assertThat(yield).isEqualTo(2_001_500_000D / 2_000D);
+    }
+
+    @ParameterizedTest
+    @NullSource
+    void 로또_목록이_null이면_예외가_발생한다(List<Lotto> lottos) {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+
+        // when & then
+        assertThatThrownBy(() -> new LottoResults(lottos, winningNumbers))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 당첨 결과를 계산할 로또 목록은 null일 수 없습니다.");
+    }
+
+    @Test
+    void 로또_목록에_null이_포함되면_예외가_발생한다() {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        List<Lotto> lottos = new ArrayList<>();
+        lottos.add(new Lotto(List.of(1, 2, 3, 4, 5, 6)));
+        lottos.add(null);
+
+        // when & then
+        assertThatThrownBy(() -> new LottoResults(lottos, winningNumbers))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 목록에 null이 포함될 수 없습니다.");
+    }
+
+    @Test
+    void 당첨번호가_null이면_예외가_발생한다() {
+        // given
+        List<Lotto> lottos = List.of(new Lotto(List.of(1, 2, 3, 4, 5, 6)));
+
+        // when & then
+        assertThatThrownBy(() -> new LottoResults(lottos, null))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 당첨 번호는 null일 수 없습니다.");
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {0, -10})
+    void 수익률_계산시_구입금액이_0_이하이면_예외가_발생한다(int purchaseAmount) {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        LottoResults results = new LottoResults(
+                List.of(new Lotto(List.of(1, 2, 3, 4, 5, 6))),
+                winningNumbers
+        );
+
+        // when & then
+        assertThatThrownBy(() -> results.calculateYield(purchaseAmount))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 구입 금액은 0보다 커야 합니다.");
+    }
+}

From 1cae4118be792e982302caade5d1b292d4d136f9 Mon Sep 17 00:00:00 2001
From: JohnPrk <uo3641493@gmail.com>
Date: Mon, 3 Nov 2025 22:35:18 +0900
Subject: [PATCH 08/10] =?UTF-8?q?feat:=20=EB=A1=9C=EB=98=90=20=EC=83=9D?=
 =?UTF-8?q?=EC=84=B1=20=EC=B1=85=EC=9E=84=20=EB=B0=8F=20=EA=B2=80=EC=A6=9D?=
 =?UTF-8?q?=EC=9D=84=20=EB=8B=B4=EB=8B=B9=ED=95=98=EB=8A=94=20LottoFactory?=
 =?UTF-8?q?=20=EB=B0=8F=20LottoGenerator=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 로또 생성 로직을 LottoGenerator 인터페이스로 추상화
- Randoms 유틸을 사용하는 RandomLottoGenerator 구현
- LottoFactory가 LottoGenerator에 의존하도록 수정 (DIP)
- LottoFactory의 생성 개수(count) 유효성 검증
- 테스트 더블 FakeLottoGenerator 구현
- FakeLottoGenerator를 사용한 LottoFactory 단위 테스트 작성
- LottoGenerator 인터페이스의 구현 클래스 관련 단위 테스트 작성
- README.md 예외 처리 표에 LottoGenerator, LottoFactory 관련 예외 메시지 추가
- README.md 시퀀스 다이어그램 및 객체 역할 요약 추가
---
 README.md                                     | 61 ++++++++++--------
 src/main/java/lotto/domain/LottoFactory.java  | 30 +++++++++
 .../java/lotto/domain/LottoGenerator.java     |  9 +++
 .../lotto/domain/RandomLottoGenerator.java    | 23 +++++++
 .../lotto/domain/FakeLottoGeneratorTest.java  | 62 +++++++++++++++++++
 .../java/lotto/domain/LottoFactoryTest.java   | 61 ++++++++++++++++++
 .../domain/RandomLottoGeneratorTest.java      | 25 ++++++++
 .../domain/testDouble/FakeLottoGenerator.java | 31 ++++++++++
 8 files changed, 276 insertions(+), 26 deletions(-)
 create mode 100644 src/main/java/lotto/domain/LottoFactory.java
 create mode 100644 src/main/java/lotto/domain/LottoGenerator.java
 create mode 100644 src/main/java/lotto/domain/RandomLottoGenerator.java
 create mode 100644 src/test/java/lotto/domain/FakeLottoGeneratorTest.java
 create mode 100644 src/test/java/lotto/domain/LottoFactoryTest.java
 create mode 100644 src/test/java/lotto/domain/RandomLottoGeneratorTest.java
 create mode 100644 src/test/java/lotto/domain/testDouble/FakeLottoGenerator.java

diff --git a/README.md b/README.md
index f3c7d6e20e..b4ed73b18e 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,7 @@ sequenceDiagram
     participant C as LottoController
     participant M as Money
     participant F as LottoFactory
+    participant G as LottoGenerator
     participant L as Lotto
     participant W as WinningNumbers
     participant R as LottoResults
@@ -41,19 +42,24 @@ Note over U,C: 🎫 1단계: 로또 구매
             M-->>C: 유효한 Money 객체
         else 검증 실패
             M-->>C: IllegalArgumentException
-            C->>O: 메시지 출력
+            C->>O: 에러 메시지 출력
             O->>U: 에러 표시
         end
     end
 
     C->>M: getLottoCount() 호출
-    M-->>C: 구매 가능한 로또 개수
-    loop N번 (로또 개수만큼)
-        C->>F: generateLotto() 호출
-        F->>F: Randoms.pickUniqueNumbersInRange(1,45,6)
-        F-->>C: 생성된 번호 목록
-        C->>L: Lotto 객체 생성
+    M-->>C: 구매 가능한 로또 개수(count)
+
+    C->>F: generate(count) 호출
+    F->>G: generate(count) 위임
+
+    loop count번
+        G->>G: Randoms.pickUniqueNumbersInRange(1,45,6)
+        G->>L: Lotto(numbers) 생성
     end
+    G-->>F: List<Lotto> 반환
+    F-->>C: List<Lotto> 반환
+
     C->>O: 구매한 로또 목록 출력
     O->>U: 로또 목록 표시
     		
@@ -66,7 +72,7 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
             W-->>C: 당첨 번호 객체 생성됨
         else 검증 실패
             W-->>C: IllegalArgumentException
-            C->>O: 메시지 출력
+            C->>O: 에러 메시지 출력
             O->>U: 에러 표시
         end
     end
@@ -79,19 +85,18 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
             W-->>C: 최종 당첨 번호 객체 완성
         else 검증 실패
             W-->>C: IllegalArgumentException
-            C->>O: 메시지 출력
+            C->>O: 에러 메시지 출력
             O->>U: 에러 표시
         end
     end
     Note over U,C: 📊 3단계: 결과 분석 및 출력
     C->>R: LottoResults 생성 (List<Lotto>, WinningNumbers)
     loop 각 로또에 대해
-        R->>R: calculateRank(lotto, winningNumbers)
         R->>R: 등수별 카운트 증가
         R->>R: 총 상금 누적
     end
-    R->>R: 수익률 계산
-    R-->>C: 분석 결과
+    C->>R: calculateYield(구입 금액) 호출
+    R-->>C: 수익률 반환
     C->>O: 당첨 통계 출력
     O->>U: 통계 표시
     C->>O: 수익률 출력
@@ -103,17 +108,19 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
 
 ## **🧱 객체 역할 요약**
 
-| 객체 이름             | 역할(책임)                                      | 보유 값(상태)                           | 주요 행위                                                                       |
-|-------------------|---------------------------------------------|------------------------------------|-----------------------------------------------------------------------------|
-| `Money`           | 구입 금액을 표현하고 관련 규칙을 검증하는 값 객체                | * 구입 금액                            | - 금액 유효성 검사, 구매 가능한 로또 수 계산                                                 |
-| `Lotto`           | 로또 한 장을 표현하며 번호 규칙(개수, 범위, 중복)의 불변성을 보장     | * 6개의 로또 번호                        | - 번호 정렬 및 중복 검사, 당첨 번호와 일치 개수 계산, 보너스 포함 여부 확인                              |
-| `LottoFactory`    | 로또 규칙에 맞는 랜덤 번호를 생성하여 `Lotto` 객체를 만드는 책임을 짐 |                                    | -`Randoms.pickUniqueNumbersInRange()`를 사용해 로또 번호 생성                         |
-| `WinningNumbers`  | 당첨 번호와 보너스 번호를 가지며 관련 규칙(개수, 범위, 중복)을 책임짐   | * 6개 당첨 번호, 1개 보너스 번호              | - 당첨 번호 유효성 검사, 보너스 번호 유효성 검사 및 중복 확인                                       |
-| `LottoRank`       | 당첨 등수(1~5등, 꽝)의 조건(일치 개수, 보너스)과 상금을 정의      | *Enum class(일치 개수, 보너스 포함여부,당첨 금액) | - 일치 수/보너스 포함 여부로 등수 반환, 상금 반환                                              |
-| `LottoResults`    | 전체 당첨 결과를 집계하고 최종 수익률을 계산                   | * 등수별 당첨 횟수, 누적 상금                 | - 각 로또에 대한 등수 계산, 당첨 결과 누적, 수익률 계산                                          |
-| `InputView`       | 사용자로부터 입력을 받는 모든 로직을 담당                     | * 입력 접두사                           | - 사용자로부터 입력을 받음, `camp.nextstep.edu.missionutils.Console`의 `readLine()`을 사용 |
-| `OutputView`      | 사용자에게 정보를 출력하는 모든 로직을 담당                    | * 출력 접두사                           | - 구매한 로또 목록 출력, 당첨 결과 출력, 수익률 출력                                            |
-| `LottoController` | 애플리케이션의 전체 실행 흐름을 조율. View와 Domain 객체들을 연결  |                                    | - 전체 흐름 제어                                                                  |
+| 객체 이름                  | 역할(책임)                                      | 보유 값(상태)                        | 주요 행위                                                            |
+|------------------------|---------------------------------------------|---------------------------------|------------------------------------------------------------------|
+| `Money`                | 구입 금액을 표현하고 관련 규칙을 검증하는 값 객체                | * 구입 금액                         | - 금액 유효성 검사, 구매 가능한 로또 수 계산                                      |
+| `Lotto`                | 로또 한 장을 표현하며 번호 규칙(개수, 범위, 중복)의 불변성을 보장     | * 6개의 로또 번호                     | - 번호 정렬 및 중복 검사, 당첨 번호와 일치 개수 계산, 보너스 포함 여부 확인                   |
+| `LottoGenerator`       | 로또 번호 생성 전략을 추상화하는 인터페이스                    |                                 | - 요청된 개수만큼 `Lotto` 리스트 생성                                        |
+| `RandomLottoGenerator` | 랜덤 전략으로 로또 규칙에 맞는 번호를 생성                    |                                 | - `Randoms.pickUniqueNumbersInRange()`를 사용해 번호 생성, `Lotto` 객체 생성 |
+| `LottoFactory`         | 로또 생성 전략(`LottoGenerator`)에 생성 요청을 위임하는 팩토리 | * `LottoGenerator` 구현체          | - 생성기 null 검증, 생성 개수 검증, 생성기에 로또 생성 위임                           |
+| `WinningNumbers`       | 당첨 번호와 보너스 번호를 가지며 관련 규칙(개수, 범위, 중복)을 책임짐   | * 6개 당첨 번호, 1개 보너스 번호           | - 당첨 번호 유효성 검사, 보너스 번호 유효성 검사 및 중복 확인                            |
+| `LottoRank`            | 당첨 등수(1~5등, 꽝)의 조건(일치 개수, 보너스)과 상금을 정의      | * Enum(일치 개수, 보너스 포함 여부, 당첨 금액) | - 일치 수/보너스 포함 여부로 등수 반환, 상금 반환                                   |
+| `LottoResults`         | 전체 당첨 결과를 집계하고 최종 수익률을 계산                   | * 등수별 당첨 횟수, 누적 상금              | - 각 로또에 대한 등수 계산, 당첨 결과 누적, 수익률 계산                               |
+| `InputView`            | 사용자로부터 입력을 받는 모든 로직을 담당                     | * 입력 접두사                        | - 사용자로부터 입력을 받음, `Console.readLine()` 사용                         |
+| `OutputView`           | 사용자에게 정보를 출력하는 모든 로직을 담당                    | * 출력 접두사                        | - 구매한 로또 목록 출력, 당첨 결과 출력, 수익률 출력                                 |
+| `LottoController`      | 애플리케이션의 전체 실행 흐름을 조율. View와 Domain 객체들을 연결  |                                 | - 전체 흐름 제어                                                       |
 
 <br>
 <br>
@@ -197,6 +204,8 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
 | 로또 번호가 1~45 범위를 벗어나는 경우    | `[ERROR] 로또 번호는 1부터 45 사이여야 합니다.`         |
 | 보너스 번호가 1~45 범위를 벗어난 경우    | `[ERROR] 보너스 번호는 1부터 45 사이여야 합니다.`        |
 | 보너스 번호가 당첨 번호와 중복되는 경우     | `[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.`      |
+| 로또 생성기가 null인 경우           | `[ERROR] 로또 생성기는 null일 수 없습니다.`           |
+| 로또 생성 개수가 0 이하인 경우         | `[ERROR] 로또 생성 개수는 1개 이상이어야 합니다.`         |
 
 <br>
 <br>
@@ -222,9 +231,9 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
 구현 과정에서 배우고 고민했던 것들을 기록하는 공간입니다.
 
 - [도메인 설계시 고려했던 것](https://github.com/JohnPrk/java-lotto-8/issues/1)
-- [Inside-Out vs Outside-In TDD 선택 이유](https://github.com/JohnPrk/java-lotto-8/issues/2**)
-- [Supplier는 무엇인가?](https://github.com/JohnPrk/java-lotto-8/issues/3**)
-- [2023년 구현 vs 지금 구현 비교[회고]](https://github.com/JohnPrk/java-lotto-8/issues/4**)
+- [Inside-Out vs Outside-In TDD 선택 이유](https://github.com/JohnPrk/java-lotto-8/issues/2)
+- [Supplier는 무엇인가?](https://github.com/JohnPrk/java-lotto-8/issues/3)
+- [2023년 구현 vs 지금 구현 비교[회고]](https://github.com/JohnPrk/java-lotto-8/issues/4)
 
 <br>
 <br>
diff --git a/src/main/java/lotto/domain/LottoFactory.java b/src/main/java/lotto/domain/LottoFactory.java
new file mode 100644
index 0000000000..8315a0c24b
--- /dev/null
+++ b/src/main/java/lotto/domain/LottoFactory.java
@@ -0,0 +1,30 @@
+package lotto.domain;
+
+import java.util.List;
+
+public class LottoFactory {
+
+    private final LottoGenerator generator;
+
+    public LottoFactory(LottoGenerator generator) {
+        validateGenerator(generator);
+        this.generator = generator;
+    }
+
+    public List<Lotto> generate(int count) {
+        validateCount(count);
+        return generator.generate(count);
+    }
+
+    private void validateGenerator(LottoGenerator generator) {
+        if (generator == null) {
+            throw new IllegalArgumentException("[ERROR] 로또 생성기는 null일 수 없습니다.");
+        }
+    }
+
+    private void validateCount(int count) {
+        if (count <= 0) {
+            throw new IllegalArgumentException("[ERROR] 로또 생성 개수는 1개 이상이어야 합니다.");
+        }
+    }
+}
diff --git a/src/main/java/lotto/domain/LottoGenerator.java b/src/main/java/lotto/domain/LottoGenerator.java
new file mode 100644
index 0000000000..d3e9241185
--- /dev/null
+++ b/src/main/java/lotto/domain/LottoGenerator.java
@@ -0,0 +1,9 @@
+package lotto.domain;
+
+import java.util.List;
+
+public interface LottoGenerator {
+
+    List<Lotto> generate(int count);
+
+}
diff --git a/src/main/java/lotto/domain/RandomLottoGenerator.java b/src/main/java/lotto/domain/RandomLottoGenerator.java
new file mode 100644
index 0000000000..4897ff372b
--- /dev/null
+++ b/src/main/java/lotto/domain/RandomLottoGenerator.java
@@ -0,0 +1,23 @@
+package lotto.domain;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RandomLottoGenerator implements LottoGenerator {
+
+    private static final int LOTTO_NUMBER_MIN = 1;
+    private static final int LOTTO_NUMBER_MAX = 45;
+    private static final int LOTTO_SIZE = 6;
+
+    @Override
+    public List<Lotto> generate(int count) {
+        List<Lotto> lottos = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            List<Integer> numbers = Randoms.pickUniqueNumbersInRange(LOTTO_NUMBER_MIN, LOTTO_NUMBER_MAX, LOTTO_SIZE);
+            lottos.add(new Lotto(numbers));
+        }
+        return lottos;
+    }
+}
diff --git a/src/test/java/lotto/domain/FakeLottoGeneratorTest.java b/src/test/java/lotto/domain/FakeLottoGeneratorTest.java
new file mode 100644
index 0000000000..13a66540ee
--- /dev/null
+++ b/src/test/java/lotto/domain/FakeLottoGeneratorTest.java
@@ -0,0 +1,62 @@
+package lotto.domain;
+
+import lotto.domain.testDouble.FakeLottoGenerator;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.NoSuchElementException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class FakeLottoGeneratorTest {
+
+    @Test
+    void 준비된_번호_시퀀스를_사용해_요청한_개수만큼_로또를_생성한다() {
+
+        // given
+        List<List<Integer>> numbersSequences = List.of(
+                List.of(1, 2, 3, 4, 5, 6),
+                List.of(7, 8, 9, 10, 11, 12)
+        );
+        LottoGenerator generator = new FakeLottoGenerator(numbersSequences);
+
+        // when
+        List<Lotto> lottos = generator.generate(2);
+
+        // then
+        assertThat(lottos).hasSize(2);
+        assertThat(lottos.get(0).getNumbers()).containsExactly(1, 2, 3, 4, 5, 6);
+        assertThat(lottos.get(1).getNumbers()).containsExactly(7, 8, 9, 10, 11, 12);
+    }
+
+    @Test
+    void 준비된_번호보다_많은_개수를_요청하면_NoSuchElementException이_발생한다() {
+
+        // given
+        List<List<Integer>> numbersSequences = List.of(
+                List.of(1, 2, 3, 4, 5, 6)
+        );
+        LottoGenerator generator = new FakeLottoGenerator(numbersSequences);
+
+        // when & then
+        assertThatThrownBy(() -> generator.generate(2))
+                .isInstanceOf(NoSuchElementException.class);
+    }
+
+    @Test
+    void of_정적_팩터리_메서드는_단일_번호_세트로_로또를_생성한다() {
+
+        // given
+        FakeLottoGenerator generator = FakeLottoGenerator.of(
+                List.of(1, 2, 3, 4, 5, 6)
+        );
+
+        // when
+        List<Lotto> lottos = generator.generate(1);
+
+        // then
+        assertThat(lottos).hasSize(1);
+        assertThat(lottos.get(0).getNumbers()).containsExactly(1, 2, 3, 4, 5, 6);
+    }
+}
diff --git a/src/test/java/lotto/domain/LottoFactoryTest.java b/src/test/java/lotto/domain/LottoFactoryTest.java
new file mode 100644
index 0000000000..a2f0bd5791
--- /dev/null
+++ b/src/test/java/lotto/domain/LottoFactoryTest.java
@@ -0,0 +1,61 @@
+package lotto.domain;
+
+import lotto.domain.testDouble.FakeLottoGenerator;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class LottoFactoryTest {
+
+    @Test
+    void 유효한_생성기와_개수로_로또_목록을_생성한다() {
+
+        // given
+        FakeLottoGenerator generator = new FakeLottoGenerator(
+                List.of(
+                        List.of(1, 2, 3, 4, 5, 6),
+                        List.of(7, 8, 9, 10, 11, 12),
+                        List.of(13, 14, 15, 16, 17, 18)
+                )
+        );
+        LottoFactory factory = new LottoFactory(generator);
+        int count = 3;
+
+        // when
+        List<Lotto> lottos = factory.generate(count);
+
+        // then
+        assertThat(lottos).hasSize(count);
+        assertThat(lottos).allSatisfy(lotto -> assertThat(lotto).isNotNull());
+    }
+
+    @ParameterizedTest
+    @NullSource
+    void 생성기가_null이면_예외가_발생한다(LottoGenerator generator) {
+
+        // when & then
+        assertThatThrownBy(() -> new LottoFactory(generator))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 생성기는 null일 수 없습니다.");
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {0, -1, -10})
+    void 생성_개수가_0_이하이면_예외가_발생한다(int count) {
+
+        // given
+        LottoGenerator generator = FakeLottoGenerator.of(List.of(1, 2, 3, 4, 5, 6));
+        LottoFactory factory = new LottoFactory(generator);
+
+        // when & then
+        assertThatThrownBy(() -> factory.generate(count))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 생성 개수는 1개 이상이어야 합니다.");
+    }
+}
diff --git a/src/test/java/lotto/domain/RandomLottoGeneratorTest.java b/src/test/java/lotto/domain/RandomLottoGeneratorTest.java
new file mode 100644
index 0000000000..18d47aa941
--- /dev/null
+++ b/src/test/java/lotto/domain/RandomLottoGeneratorTest.java
@@ -0,0 +1,25 @@
+package lotto.domain;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class RandomLottoGeneratorTest {
+
+    @Test
+    void 로또_생성_요청_개수만큼_랜덤_로또를_생성한다() {
+
+        // given
+        LottoGenerator generator = new RandomLottoGenerator();
+        int count = 5;
+
+        // when
+        List<Lotto> lottos = generator.generate(count);
+
+        // then
+        assertThat(lottos).hasSize(count)
+                .doesNotContainNull();
+    }
+}
diff --git a/src/test/java/lotto/domain/testDouble/FakeLottoGenerator.java b/src/test/java/lotto/domain/testDouble/FakeLottoGenerator.java
new file mode 100644
index 0000000000..012f2aed3c
--- /dev/null
+++ b/src/test/java/lotto/domain/testDouble/FakeLottoGenerator.java
@@ -0,0 +1,31 @@
+package lotto.domain.testDouble;
+
+import lotto.domain.Lotto;
+import lotto.domain.LottoGenerator;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class FakeLottoGenerator implements LottoGenerator {
+
+    private final Iterator<List<Integer>> numbersIterator;
+
+    public FakeLottoGenerator(List<List<Integer>> numbersSequences) {
+        this.numbersIterator = numbersSequences.iterator();
+    }
+
+    @Override
+    public List<Lotto> generate(int count) {
+        List<Lotto> lottos = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            List<Integer> numbers = numbersIterator.next();
+            lottos.add(new Lotto(numbers));
+        }
+        return lottos;
+    }
+
+    public static FakeLottoGenerator of(List<Integer> numbers) {
+        return new FakeLottoGenerator(List.of(numbers));
+    }
+}

From e4cd27c750a04949163455ed758eb68d0c299b1f Mon Sep 17 00:00:00 2001
From: JohnPrk <uo3641493@gmail.com>
Date: Mon, 3 Nov 2025 23:03:42 +0900
Subject: [PATCH 09/10] =?UTF-8?q?feat:=20=EC=82=AC=EC=9A=A9=EC=9E=90=20?=
 =?UTF-8?q?=EC=9E=85=EC=B6=9C=EB=A0=A5=EC=9D=84=20=EB=8B=B4=EB=8B=B9?=
 =?UTF-8?q?=ED=95=98=EB=8A=94=20View=20=EB=B0=8F=20InputValidator=20?=
 =?UTF-8?q?=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- InputView: 구입 금액, 당첨 번호, 보너스 번호 입력 기능 구현
- OutputView: 구매 로또, 당첨 통계, 수익률, 에러 메시지 출력 기능 구현
- InputValidator: View로부터 받은 입력의 형식(공백, 숫자) 검증 로직 분리
- InputValidator 관련 단위 테스트 작성
- README.md 예외 처리 표에 InputValidator 관련 예외 메시지 추가
---
 README.md                                     |   7 +-
 src/main/java/lotto/view/InputValidator.java  |  54 +++++++
 src/main/java/lotto/view/InputView.java       |  29 ++++
 src/main/java/lotto/view/OutputView.java      |  41 ++++++
 .../java/lotto/view/InputValidatorTest.java   | 132 ++++++++++++++++++
 5 files changed, 262 insertions(+), 1 deletion(-)
 create mode 100644 src/main/java/lotto/view/InputValidator.java
 create mode 100644 src/main/java/lotto/view/InputView.java
 create mode 100644 src/main/java/lotto/view/OutputView.java
 create mode 100644 src/test/java/lotto/view/InputValidatorTest.java

diff --git a/README.md b/README.md
index b4ed73b18e..b90b672af2 100644
--- a/README.md
+++ b/README.md
@@ -120,6 +120,7 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
 | `LottoResults`         | 전체 당첨 결과를 집계하고 최종 수익률을 계산                   | * 등수별 당첨 횟수, 누적 상금              | - 각 로또에 대한 등수 계산, 당첨 결과 누적, 수익률 계산                               |
 | `InputView`            | 사용자로부터 입력을 받는 모든 로직을 담당                     | * 입력 접두사                        | - 사용자로부터 입력을 받음, `Console.readLine()` 사용                         |
 | `OutputView`           | 사용자에게 정보를 출력하는 모든 로직을 담당                    | * 출력 접두사                        | - 구매한 로또 목록 출력, 당첨 결과 출력, 수익률 출력                                 |
+| `InputValidator`       | 문자열 입력을 숫자/리스트로 변환하고 형식을 검증하는 유틸리티          | -                               | - 구입 금액/당첨 번호/보너스 번호 문자열 파싱, 공백 및 숫자 형식 검증                       |
 | `LottoController`      | 애플리케이션의 전체 실행 흐름을 조율. View와 Domain 객체들을 연결  |                                 | - 전체 흐름 제어                                                       |
 
 <br>
@@ -155,7 +156,7 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
 > 도메인 규칙에 따라 로또를 생성하는 책임을 구현합니다.
 >
 
-- `LottoFactory`: `Randoms` 유틸리티를 사용하여 로또 번호를 생성하고, 검증된 `Lotto` 객체를 생성하여 반환합니다.
+- `LottoFactory`: `LottoGenerator`를 사용해 규칙에 맞는 로또 목록을 생성합니다.
 
 ### **5단계: 입출력(UI) 계층 구현**
 
@@ -206,6 +207,10 @@ Note over U,C: 🏆 2단계: 당첨 번호 입력
 | 보너스 번호가 당첨 번호와 중복되는 경우     | `[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.`      |
 | 로또 생성기가 null인 경우           | `[ERROR] 로또 생성기는 null일 수 없습니다.`           |
 | 로또 생성 개수가 0 이하인 경우         | `[ERROR] 로또 생성 개수는 1개 이상이어야 합니다.`         |
+| 입력 문자열이 null 또는 공백인 경우     | `[ERROR] 입력은 비어 있을 수 없습니다.`               |
+| 구입 금액 입력이 숫자가 아닌 경우        | `[ERROR] 구입 금액은 숫자여야 합니다.`                |
+| 당첨 번호 입력에 숫자가 아닌 값이 포함된 경우 | `[ERROR] 당첨 번호는 숫자여야 합니다.`                |
+| 보너스 번호 입력이 숫자가 아닌 경우       | `[ERROR] 보너스 번호는 숫자여야 합니다.`               |
 
 <br>
 <br>
diff --git a/src/main/java/lotto/view/InputValidator.java b/src/main/java/lotto/view/InputValidator.java
new file mode 100644
index 0000000000..17c772e86b
--- /dev/null
+++ b/src/main/java/lotto/view/InputValidator.java
@@ -0,0 +1,54 @@
+package lotto.view;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class InputValidator {
+
+    private static final String NUMBER_DELIMITER = ",";
+
+    private InputValidator() {
+    }
+
+    public static int parsePurchaseAmount(String input) {
+        validateNotBlank(input);
+        String trimmed = input.trim();
+        try {
+            return Integer.parseInt(trimmed);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("[ERROR] 구입 금액은 숫자여야 합니다.");
+        }
+    }
+
+    public static List<Integer> parseWinningNumbers(String input) {
+        validateNotBlank(input);
+        String[] parts = input.split(NUMBER_DELIMITER);
+        return Arrays.stream(parts)
+                .map(String::trim)
+                .map(part -> parseNumber(part, "[ERROR] 당첨 번호는 숫자여야 합니다."))
+                .toList();
+    }
+
+    public static int parseBonusNumber(String input) {
+        validateNotBlank(input);
+        String trimmed = input.trim();
+        return parseNumber(trimmed, "[ERROR] 보너스 번호는 숫자여야 합니다.");
+    }
+
+    private static void validateNotBlank(String input) {
+        if (input == null) {
+            throw new IllegalArgumentException("[ERROR] 입력은 비어 있을 수 없습니다.");
+        }
+        if (input.trim().isEmpty()) {
+            throw new IllegalArgumentException("[ERROR] 입력은 비어 있을 수 없습니다.");
+        }
+    }
+
+    private static int parseNumber(String value, String errorMessage) {
+        try {
+            return Integer.parseInt(value);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException(errorMessage);
+        }
+    }
+}
diff --git a/src/main/java/lotto/view/InputView.java b/src/main/java/lotto/view/InputView.java
new file mode 100644
index 0000000000..6d48cbfb6f
--- /dev/null
+++ b/src/main/java/lotto/view/InputView.java
@@ -0,0 +1,29 @@
+package lotto.view;
+
+import camp.nextstep.edu.missionutils.Console;
+
+import java.util.List;
+
+public class InputView {
+
+    public static int readPurchaseAmount() {
+        System.out.println("구입금액을 입력해 주세요.");
+        String input = Console.readLine();
+        System.out.println();
+        return InputValidator.parsePurchaseAmount(input);
+    }
+
+    public static List<Integer> readWinningNumbers() {
+        System.out.println("당첨 번호를 입력해 주세요.");
+        String input = Console.readLine();
+        System.out.println();
+        return InputValidator.parseWinningNumbers(input);
+    }
+
+    public static int readBonusNumber() {
+        System.out.println("보너스 번호를 입력해 주세요.");
+        String input = Console.readLine();
+        System.out.println();
+        return InputValidator.parseBonusNumber(input);
+    }
+}
diff --git a/src/main/java/lotto/view/OutputView.java b/src/main/java/lotto/view/OutputView.java
new file mode 100644
index 0000000000..60569371a9
--- /dev/null
+++ b/src/main/java/lotto/view/OutputView.java
@@ -0,0 +1,41 @@
+package lotto.view;
+
+import lotto.domain.Lotto;
+import lotto.domain.LottoRank;
+import lotto.domain.LottoResults;
+
+import java.util.List;
+
+public class OutputView {
+
+    public static void printLottos(List<Lotto> lottos) {
+        System.out.printf("%d개를 구매했습니다.%n", lottos.size());
+        for (Lotto lotto : lottos) {
+            System.out.println(lotto.getNumbers());
+        }
+    }
+
+    public static void printStatistics(LottoResults results) {
+        System.out.println("당첨 통계");
+        System.out.println("---");
+        printRankResult(results, LottoRank.FIFTH, "3개 일치 (5,000원) - %d개");
+        printRankResult(results, LottoRank.FOURTH, "4개 일치 (50,000원) - %d개");
+        printRankResult(results, LottoRank.THIRD, "5개 일치 (1,500,000원) - %d개");
+        printRankResult(results, LottoRank.SECOND, "5개 일치, 보너스 볼 일치 (30,000,000원) - %d개");
+        printRankResult(results, LottoRank.FIRST, "6개 일치 (2,000,000,000원) - %d개");
+    }
+
+    private static void printRankResult(LottoResults results, LottoRank rank, String format) {
+        int count = results.getCountOf(rank);
+        System.out.printf(format + "%n", count);
+    }
+
+    public static void printYield(double yield) {
+        double percentage = yield * 100;
+        System.out.printf("총 수익률은 %.1f%%입니다.%n", percentage);
+    }
+
+    public static void printError(String message) {
+        System.out.println(message);
+    }
+}
diff --git a/src/test/java/lotto/view/InputValidatorTest.java b/src/test/java/lotto/view/InputValidatorTest.java
new file mode 100644
index 0000000000..e6da7d9c90
--- /dev/null
+++ b/src/test/java/lotto/view/InputValidatorTest.java
@@ -0,0 +1,132 @@
+package lotto.view;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class InputValidatorTest {
+
+    @Test
+    void 구입_금액_문자열을_정수로_파싱한다() {
+
+        // given
+        String input = "3000";
+
+        // when
+        int amount = InputValidator.parsePurchaseAmount(input);
+
+        // then
+        assertThat(amount).isEqualTo(3000);
+    }
+
+    @ParameterizedTest
+    @NullSource
+    @ValueSource(strings = {"", " ", "   "})
+    void 구입_금액_입력이_null_또는_공백이면_예외가_발생한다(String input) {
+
+        // when & then
+        assertThatThrownBy(() -> InputValidator.parsePurchaseAmount(input))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 입력은 비어 있을 수 없습니다.");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"abc", "1000원", "1 000", "1,000"})
+    void 구입_금액에_숫자가_아닌_값이_포함되면_예외가_발생한다(String input) {
+
+        // when & then
+        assertThatThrownBy(() -> InputValidator.parsePurchaseAmount(input))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 구입 금액은 숫자여야 합니다.");
+    }
+
+    @Test
+    void 쉼표로_구분된_당첨_번호를_정수_리스트로_파싱한다() {
+
+        // given
+        String input = "1,2,3,4,5,6";
+
+        // when
+        List<Integer> numbers = InputValidator.parseWinningNumbers(input);
+
+        // then
+        assertThat(numbers).containsExactly(1, 2, 3, 4, 5, 6);
+    }
+
+    @Test
+    void 당첨_번호_파싱시_공백을_무시한다() {
+
+        // given
+        String input = " 1,  2 ,3 , 4,5 ,6 ";
+
+        // when
+        List<Integer> numbers = InputValidator.parseWinningNumbers(input);
+
+        // then
+        assertThat(numbers).containsExactly(1, 2, 3, 4, 5, 6);
+    }
+
+    @ParameterizedTest
+    @NullSource
+    @ValueSource(strings = {"", " ", "   "})
+    void 당첨_번호_입력이_null_또는_공백이면_예외가_발생한다(String input) {
+
+        // when & then
+        assertThatThrownBy(() -> InputValidator.parseWinningNumbers(input))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 입력은 비어 있을 수 없습니다.");
+    }
+
+    @Test
+    void 당첨_번호에_숫자가_아닌_값이_포함되면_예외가_발생한다() {
+
+        // given
+        String input = "1, 2, 세, 4, 5, 6";
+
+        // when & then
+        assertThatThrownBy(() -> InputValidator.parseWinningNumbers(input))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 당첨 번호는 숫자여야 합니다.");
+    }
+
+    @Test
+    void 보너스_번호_문자열을_정수로_파싱한다() {
+
+        // given
+        String input = "7";
+
+        // when
+        int bonus = InputValidator.parseBonusNumber(input);
+
+        // then
+        assertThat(bonus).isEqualTo(7);
+    }
+
+    @ParameterizedTest
+    @NullSource
+    @ValueSource(strings = {"", " ", "   "})
+    void 보너스_번호_입력이_null_또는_공백이면_예외가_발생한다(String input) {
+
+        // when & then
+        assertThatThrownBy(() -> InputValidator.parseBonusNumber(input))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 입력은 비어 있을 수 없습니다.");
+    }
+
+    @Test
+    void 보너스_번호에_숫자가_아닌_값이_들어오면_예외가_발생한다() {
+        // given
+        String input = "보너스";
+
+        // when & then
+        assertThatThrownBy(() -> InputValidator.parseBonusNumber(input))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 보너스 번호는 숫자여야 합니다.");
+    }
+}

From a6c5c18dae9633a04ebba72f6d3a3f85345ca0fa Mon Sep 17 00:00:00 2001
From: JohnPrk <uo3641493@gmail.com>
Date: Mon, 3 Nov 2025 23:38:27 +0900
Subject: [PATCH 10/10] =?UTF-8?q?feat:=20=EB=A1=9C=EB=98=90=20=EA=B2=8C?=
 =?UTF-8?q?=EC=9E=84=20=EC=A0=84=EC=B2=B4=20=EC=8B=A4=ED=96=89=20=ED=9D=90?=
 =?UTF-8?q?=EB=A6=84=EC=9D=84=20=EC=A0=9C=EC=96=B4=ED=95=98=EB=8A=94=20Lot?=
 =?UTF-8?q?toController=20=EB=B0=8F=20Application=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- LottoController에서 구입 금액 입력 → 로또 생성 → 당첨 번호 입력 → 결과 집계 → 수익률 출력까지 전체 시나리오 제어
- 잘못된 입력, 금액, 당첨 번호, 보너스 번호에 대해 예외 메시지 출력 후 재입력 받도록 반복 처리
- Money 값을 활용해 구매 가능 로또 수 계산 및 수익률 계산 시 구입 금액 전달
- Application main에서 LottoFactory, RandomLottoGenerator, LottoController를 조립해 프로그램 실행 진입점 구성
---
 src/main/java/lotto/Application.java          |  9 ++-
 .../lotto/controller/LottoController.java     | 71 +++++++++++++++++++
 src/main/java/lotto/domain/Money.java         |  4 ++
 3 files changed, 83 insertions(+), 1 deletion(-)
 create mode 100644 src/main/java/lotto/controller/LottoController.java

diff --git a/src/main/java/lotto/Application.java b/src/main/java/lotto/Application.java
index d190922ba4..14e77be8a8 100644
--- a/src/main/java/lotto/Application.java
+++ b/src/main/java/lotto/Application.java
@@ -1,7 +1,14 @@
 package lotto;
 
+import lotto.controller.LottoController;
+import lotto.domain.LottoFactory;
+import lotto.domain.RandomLottoGenerator;
+
 public class Application {
+
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        LottoFactory lottoFactory = new LottoFactory(new RandomLottoGenerator());
+        LottoController controller = new LottoController(lottoFactory);
+        controller.run();
     }
 }
diff --git a/src/main/java/lotto/controller/LottoController.java b/src/main/java/lotto/controller/LottoController.java
new file mode 100644
index 0000000000..5864bd78c5
--- /dev/null
+++ b/src/main/java/lotto/controller/LottoController.java
@@ -0,0 +1,71 @@
+package lotto.controller;
+
+import lotto.domain.*;
+import lotto.view.InputView;
+import lotto.view.OutputView;
+
+import java.util.List;
+
+public class LottoController {
+
+    private final LottoFactory lottoFactory;
+
+    public LottoController(LottoFactory lottoFactory) {
+        this.lottoFactory = lottoFactory;
+    }
+
+    public void run() {
+        Money money = readMoney();
+        int lottoCount = money.getLottoCount();
+        List<Lotto> lottos = lottoFactory.generate(lottoCount);
+        OutputView.printLottos(lottos);
+        WinningNumbers winningNumbers = readWinningNumbers();
+        LottoResults results = new LottoResults(lottos, winningNumbers);
+        OutputView.printStatistics(results);
+        double yield = results.calculateYield(money.getAmount());
+        OutputView.printYield(yield);
+    }
+
+    private Money readMoney() {
+        while (true) {
+            try {
+                int purchaseAmount = InputView.readPurchaseAmount();
+                return new Money(purchaseAmount);
+            } catch (IllegalArgumentException e) {
+                OutputView.printError(e.getMessage());
+            }
+        }
+    }
+
+    private WinningNumbers readWinningNumbers() {
+        while (true) {
+            try {
+                List<Integer> numbers = readWinningNumberList();
+                int bonus = readBonusNumber();
+                return new WinningNumbers(numbers, bonus);
+            } catch (IllegalArgumentException e) {
+                OutputView.printError(e.getMessage());
+            }
+        }
+    }
+
+    private List<Integer> readWinningNumberList() {
+        while (true) {
+            try {
+                return InputView.readWinningNumbers();
+            } catch (IllegalArgumentException e) {
+                OutputView.printError(e.getMessage());
+            }
+        }
+    }
+
+    private int readBonusNumber() {
+        while (true) {
+            try {
+                return InputView.readBonusNumber();
+            } catch (IllegalArgumentException e) {
+                OutputView.printError(e.getMessage());
+            }
+        }
+    }
+}
diff --git a/src/main/java/lotto/domain/Money.java b/src/main/java/lotto/domain/Money.java
index a564f220e7..257fdfee61 100644
--- a/src/main/java/lotto/domain/Money.java
+++ b/src/main/java/lotto/domain/Money.java
@@ -11,6 +11,10 @@ public Money(int amount) {
         this.amount = amount;
     }
 
+    public int getAmount() {
+        return amount;
+    }
+
     private void validatePositive(int amount) {
         if (amount <= 0) {
             throw new IllegalArgumentException("[ERROR] 구입 금액은 0보다 커야 합니다.");