🚀 4단계 - 로또(수동)

src/main/java/lotto/LottoGameApplication.java

@@ -1,7 +1,8 @@
 package lotto;
 
-import lotto.domain.game.LottoGame;
+import java.util.List;
 import lotto.domain.game.LottoMachine;
+import lotto.domain.lotto.LottoTickets;
 import lotto.domain.lotto.Money;
 import lotto.domain.lotto.Purchase;
 import lotto.domain.lotto.WinningTicket;
@@ -15,16 +16,20 @@ public static void main(String[] args) {
     LottoMachine machine = new LottoMachine();
 
     int purchaseAmount = InputView.inputPurchaseAmount();
-    Purchase purchase = machine.purchase(new Money(purchaseAmount));
+    int manualCount = InputView.inputManualLottoCount();
+    List<String> manualTickets = InputView.inputManualLottoTickets(manualCount);
+
+    Purchase purchase = machine.createPurchase(new Money(purchaseAmount), manualCount);
     ResultView.printPurchase(purchase);
 
+    LottoTickets tickets = machine.generateTickets(manualTickets, purchase.getAutoCount());
+    ResultView.printTickets(tickets);
+
     String winningLottoNumbers = InputView.inputWinningLottoNumbers();
     int bonusNumber = InputView.inputBonusNumber();
     WinningTicket winning = new WinningTicket(winningLottoNumbers, bonusNumber);
 
-    LottoGame game = new LottoGame(winning);
-    GameResult gameResult = game.check(purchase);
-
-    ResultView.printResult(gameResult, purchase.getPurchaseAmount());
+    GameResult result = tickets.match(winning);
+    ResultView.printResult(result, purchase.getSpentAmount());
   }
-}
+}

src/main/java/lotto/README.md

@@ -1,11 +1,13 @@
 # 기능 요구사항
 
-> 입력한 금액만큼 로또 자동으로 발급해주는 기능
+> 입력한 금액만큼 로또를 수동/자동으로 발급해주는 기능
 
 1. 구입 금액 입력 기능
-2. N개의 로또 구매 기능 (자동)
-3. 당첨 번호 입력 기능 (당첨 번호 6개 + 보너스볼 1개)
-4. 당첨 통계 조회 기능
+2. 수동 구매 로또 개수 입력 기능
+3. 수동 로또 번호 입력 기능
+4. N개의 로또 구매 기능 (수동 + 자동)
+5. 당첨 번호 입력 기능 (당첨 번호 6개 + 보너스볼 1개)
+6. 당첨 통계 조회 기능
     - 몇 개의 번호가 일치하는지, 몇 개인지
     - 보너스볼 일치 여부 (5개 일치 시)
     - 수익률
@@ -17,25 +19,37 @@
 - 무엇인가? : 구매금에 따라 로또를 생성해주는 머신
 - 역할
     - 로또 발급 개수 계산
-    - 랜덤 로또 티켓 생성
+    - 수동 로또 티켓 변환
+    - 자동 로또 티켓 생성
+    - 구매 정보(Purchase) 생성
+
+## 로또 티켓들 (LottoTickets)
+
+- 무엇인가? : 여러 로또 티켓을 관리하는 일급 컬렉션
+- 역할
+    - 로또 티켓 목록 보관
+    - 당첨 티켓과 비교하여 게임 결과 생성
 
 ## 로또 (LottoTicket)
 
 - 무엇인가? : 6개의 고유한 숫자를 담은 로또 티켓
 - 역할
     - 6개의 숫자 보관
-    - 일치 갯수 비교
+    - 문자열/숫자 배열로부터 티켓 생성
+    - 일치 개수 비교
+    - 특정 번호 포함 여부 확인
 
 ## 로또 숫자 (LottoNumber)
 
 - 무엇인가? : 로또 내 숫자
 - 역할
     - 번호 유효성 보장 (1 ~ 45)
+    - 캐싱을 통한 객체 재사용
     - 숫자 객체 비교
 
 ## 금액 (Money)
 
-- 무엇인가? : 금액을 표현하는 일급 컬렉션
+- 무엇인가? : 금액을 표현하는 값 객체
 - 역할
     - 금액 유효성 보장 (0 이상)
     - 금액 연산 (덧셈, 곱셈, 나눗셈)
@@ -45,25 +59,17 @@
 
 - 무엇인가? : 로또 구매 정보를 담은 객체
 - 역할
-    - 구매한 로또 티켓 목록 관리
-    - 티켓 개수 조회
+    - 수동/자동 구매 개수 관리
     - 총 구매 금액 계산
+    - 수동 구매 수 유효성 검증
 
 ## 당첨 티켓 (WinningTicket)
 
 - 무엇인가? : 당첨 번호 6개와 보너스볼 1개를 담은 티켓
 - 역할
     - 당첨 번호 6개 보관
     - 보너스볼 보관
-    - 구매 티켓의 보너스볼 포함 여부 확인
-
-## 로또 게임 (LottoGame)
-
-- 무엇인가? : 당첨 번호와 구매한 티켓들을 비교하여 결과를 생성하는 객체
-- 역할
-    - 당첨 번호 보관
-    - 구매한 티켓들의 당첨 결과 계산
-    - 게임 결과 생성
+    - 구매 티켓과 비교하여 등수(Rank) 반환
 
 ## 당첨 등수 (Rank)
 
@@ -75,12 +81,14 @@
 
 ## 로또 게임 결과 (GameResult)
 
-- 무엇인가? : 전체 로또 구매 결과 (당첨 통계, 수익률)를 나타내는 객체
+- 무엇인가? : 전체 로또 구매 결과 (당첨 통계)를 나타내는 객체
 - 역할
     - 등수별 당첨 통계 관리
-    - 수익률 계산 (당첨 금액 / 구입 금액)
-    - 손익 판정 (기준: 1.0)
-
-
+    - 총 당첨 금액 계산
 
+## 랜덤 번호 생성기 (Random)
 
+- 무엇인가? : 로또 번호를 랜덤으로 생성하는 유틸리티
+- 역할
+    - 1~45 범위에서 중복 없이 6개 번호 생성
+    - 정렬된 LottoNumber 리스트 반환

src/main/java/lotto/domain/game/LottoMachine.java

@@ -1,5 +1,8 @@
 package lotto.domain.game;
 
+import java.util.ArrayList;
+import java.util.List;
+import lotto.domain.lotto.LottoTicket;
 import lotto.domain.lotto.LottoTickets;
 import lotto.domain.lotto.Money;
 import lotto.domain.lotto.Purchase;
@@ -18,16 +21,28 @@ public LottoMachine(Money lottoTicketPrice) {
     this.lottoTicketPrice = lottoTicketPrice;
   }
 
-  public Purchase purchase(Money money) {
-    return new Purchase(lottoTicketPrice, generateTickets(calculate(money)));
+  public Purchase createPurchase(Money budget, int manualCount) {
+    return new Purchase(budget, lottoTicketPrice, manualCount);
   }
 
-  private int calculate(Money money) {
-    return money.divideForCount(lottoTicketPrice);
+  public LottoTickets generateTickets(List<String> manualTickets, int autoCount) {
+    List<LottoTicket> manual = convert(manualTickets);
+    List<LottoTicket> auto = generate(autoCount);
+
+    List<LottoTicket> allTickets = new ArrayList<>(manual);
+    allTickets.addAll(auto);
+    return new LottoTickets(allTickets);
   }
 
-  LottoTickets generateTickets(int cnt) {
-    return new LottoTickets(cnt);
+  private List<LottoTicket> convert(List<String> tickets) {
+    return tickets.stream().map(LottoTicket::new).toList();
   }
 
+  private List<LottoTicket> generate(int count) {
+    List<LottoTicket> tickets = new ArrayList<>();
+    for (int i = 0; i < count; i++) {
+      tickets.add(new LottoTicket(Random.generate()));
+    }
+    return tickets;
+  }
 }

src/main/java/lotto/domain/game/Rank.java

@@ -32,8 +32,8 @@ public static Rank valueOf(int matched, boolean bonusMatched) {
         .orElse(NONE);
   }
 
-  public int getPrize() {
-    return prize;
+  public int calculatePrize(int count) {
+    return prize * count;
   }
 
   private static boolean isMatch(Rank rank, int matched,

src/main/java/lotto/domain/lotto/LottoTickets.java

@@ -1,47 +1,28 @@
 package lotto.domain.lotto;
 
-import java.util.ArrayList;
 import java.util.List;
-import lotto.domain.game.Random;
 import lotto.domain.result.GameResult;
 
 public class LottoTickets {
   private final List<LottoTicket> tickets;
 
-  public LottoTickets(int cnt) {
-    this(generate(cnt));
-  }
-
   public LottoTickets(List<LottoTicket> tickets){
     this.tickets = tickets;
   }
 
-  private static List<LottoTicket> generate(int cnt){
-    List<LottoTicket> tickets = new ArrayList<>();
-    for (int i = 0; i < cnt; i++) {
-      tickets.add(new LottoTicket(Random.generate()));
-    }
-    return tickets;
-  }
-
-  public Money calculate(Money pricePerTicket) {
-    return pricePerTicket.multiply(tickets.size());
-  }
-
-  public GameResult updateRank(WinningTicket winningTicket) {
+  public GameResult match(WinningTicket winning) {
     GameResult gameResult = new GameResult();
     for(LottoTicket ticket : tickets){
-      gameResult.updateRank(winningTicket.match(ticket));
+      gameResult.updateRank(winning.match(ticket));
     }
     return gameResult;
   }
 
   @Override
-  public String toString(){
+  public String toString() {
     StringBuilder sb = new StringBuilder();
-    sb.append(tickets.size()+"개를 구매했습니다.");
-    for (int i = 0; i < tickets.size(); i++) {
-      sb.append(tickets.get(i) + "\n");
+    for (LottoTicket ticket : tickets) {
+      sb.append(ticket).append("\n");
     }
     return sb.toString();
   }

src/main/java/lotto/domain/lotto/Money.java

@@ -31,14 +31,18 @@ public Money multiply(int multiplier) {
     return new Money(this.amount.multiply(BigDecimal.valueOf(multiplier)));
   }
 
-  public BigDecimal divideBy(Money divisor) {
+  public BigDecimal calculateRatio(Money divisor) {
     validateDivisor(divisor);
     return this.amount.divide(divisor.amount, 2, RoundingMode.HALF_UP);
   }
 
-  public int divideForCount(Money divisor) {
-    validateDivisor(divisor);
-    return this.amount.divide(divisor.amount, 0, RoundingMode.DOWN).intValue();
+  public int countUnits(Money unit) {
+    validateDivisor(unit);
+    return this.amount.divide(unit.amount, 0, RoundingMode.DOWN).intValue();
+  }
+
+  public boolean isLessThan(Money other) {
+    return this.amount.compareTo(other.amount) < 0;
   }
 
   private void validateDivisor(Money divisor) {

src/main/java/lotto/domain/lotto/Purchase.java

@@ -2,24 +2,44 @@
 
 public class Purchase {
 
-  private final Money pricePerTicket;
-  private final LottoTickets tickets;
+  private final Money budget;
+  private final Money ticketPrice;
+  private final int manualCount;
+  private final int autoCount;
 
-  public Purchase(Money pricePerTicket, LottoTickets tickets) {
-    this.pricePerTicket = pricePerTicket;
-    this.tickets = tickets;
+  public Purchase(Money budget, Money ticketPrice, int manualCount) {
+    validateBudget(budget, ticketPrice);
+    int totalCount = budget.countUnits(ticketPrice);
+    validateManualCount(manualCount, totalCount);
+    this.budget = budget;
+    this.ticketPrice = ticketPrice;
+    this.manualCount = manualCount;
+    this.autoCount = totalCount - manualCount;
   }
 
-  public LottoTickets getTickets(){
-    return this.tickets;
+  private static void validateBudget(Money budget, Money ticketPrice) {
+    if (budget.isLessThan(ticketPrice)) {
+      throw new IllegalArgumentException("예산이 티켓 가격보다 적습니다");
+    }
   }
 
-  public Money getPurchaseAmount() {
-    return tickets.calculate(this.pricePerTicket);
+  private static void validateManualCount(int manualCount, int totalCount) {
+    if (manualCount > totalCount) {
+      throw new IllegalArgumentException("수동 구매 수가 총 구매 가능 수를 초과합니다");
+    }
+  }
+
+  public Money getSpentAmount() {
+    return ticketPrice.multiply(manualCount + autoCount);
+  }
+
+
+  public int getAutoCount() {
+    return autoCount;
   }
 
   @Override
   public String toString() {
-    return tickets.toString();
+    return "수동으로 " + manualCount + "장, 자동으로 " + autoCount + "개를 구매했습니다.";
   }
 }

src/main/java/lotto/domain/lotto/WinningTicket.java

@@ -11,10 +11,14 @@ public WinningTicket(String numbers, int bonus){
   }
 
   public WinningTicket(LottoTicket ticket, LottoNumber bonus) {
+    validate(ticket, bonus);
     this.ticket = ticket;
     this.bonus = bonus;
   }
+  private static void validate(LottoTicket ticket, LottoNumber bonus){
+    if(ticket.contains(bonus))throw new IllegalArgumentException("당첨 번호와 중복됩니다.");
 
+  }
   public Rank match(LottoTicket ticket) {
     return Rank.valueOf(this.ticket.matchCount(ticket), ticket.contains(this.bonus));
   }