[로또 미션] 김명지 미션 제출합니다.

README.md

@@ -13,12 +13,12 @@
 - `LottoNumber` : 로또 번호 VO
 - `Lotto` : 로또 객체
 - `Lottos` : 여러 개의 Lotto 객체를 관리하는 일급 컬렉션
-- `LottoResult` : 로또 결과 VO
+- `LottoStatistics` : 로또 당첨 통계 객체
+- `LottoCount` : 로또 구매 개수 VO
 
 #### constant
 
-- `LottoBoundary` : 로또 경계값 상수
-- `LottoMatch` : 로또 당첨 결과 상수
+- `WinningRank` : 당첨 순위 Enum
 
 ## view
 
@@ -132,7 +132,8 @@
 - 당첨 통계에 2등을 추가한다.
   - 2등 당첨 조건은 당첨 번호 5개 일치 + 보너스 볼 일치다.
 
-실행 결과
+
+- 실행 결과
 
 위 요구사항에 따라 14000원 어치 로또를 구매하였을 경우 프로그램을 실행한 결과는 다음과 같다.
 
@@ -174,3 +175,61 @@
 
 ### 새로운 프로그래밍 요구사항
 Java Enum을 적용한다.
+
+### 4단계 - 로또 수동 구매
+
+- 현재 로또 생성기는 자동 생성 기능만 제공한다. 사용자가 수동으로 추첨 번호를 입력할 수 있도록 해야 한다.
+- 입력한 금액, 자동 생성 숫자, 수동 생성 번호를 입력하도록 해야 한다.
+
+
+실행 결과
+
+- 위 요구사항에 따라 14000원 어치 중 수동 3개, 자동 11개를 구매한 경우 프로그램을 실행한 결과는 다음과 같다.
+
+```java
+구입금액을 입력해 주세요.
+14000
+
+수동으로 구매할 로또 수를 입력해 주세요.
+3
+
+수동으로 구매할 번호를 입력해 주세요.
+8, 21, 23, 41, 42, 43
+3, 5, 11, 16, 32, 38
+7, 11, 16, 35, 36, 44
+
+수동으로 3장, 자동으로 11개를 구매했습니다.
+[8, 21, 23, 41, 42, 43]
+[3, 5, 11, 16, 32, 38]
+[7, 11, 16, 35, 36, 44]
+[1, 8, 11, 31, 41, 42]
+[13, 14, 16, 38, 42, 45]
+[7, 11, 30, 40, 42, 43]
+[2, 13, 22, 32, 38, 45]
+[23, 25, 33, 36, 39, 41]
+[1, 3, 5, 14, 22, 45]
+[5, 9, 38, 41, 43, 44]
+[2, 8, 9, 18, 19, 21]
+[13, 14, 18, 21, 23, 35]
+[17, 21, 29, 37, 42, 45]
+[3, 8, 27, 30, 35, 44]
+
+지난 주 당첨 번호를 입력해 주세요.
+1, 2, 3, 4, 5, 6
+
+보너스 볼을 입력해 주세요.
+7
+
+당첨 통계
+---------
+3개 일치 (5000원)- 1개
+4개 일치 (50000원)- 0개
+5개 일치 (1500000원)- 0개
+5개 일치, 보너스 볼 일치(30000000원) - 0개
+6개 일치 (2000000000원)- 0개
+총 수익률은 0.35입니다.(기준이 1이기 때문에 결과적으로 손해라는 의미임)
+```
+
+### 5단계 - 리팩터링
+
+- 기존 프로그래밍 요구사항을 다시 한번 확인하고, 학습 테스트를 통해 학습한 내용을 반영한다.

src/main/java/org/duckstudy/Application.java

@@ -10,7 +10,7 @@ public class Application {
     public static void main(String[] args) {
         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
         OutputView outputView = new OutputView();
-        InputView inputView = new InputView(bufferedReader, outputView);
+        InputView inputView = new InputView(bufferedReader);
 
         LottoController lottoController = new LottoController(outputView, inputView);
         lottoController.run();

src/main/java/org/duckstudy/controller/LottoController.java

@@ -1,9 +1,12 @@
 package org.duckstudy.controller;
 
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 import org.duckstudy.model.Price;
 import org.duckstudy.model.lotto.Lotto;
+import org.duckstudy.model.lotto.LottoCount;
 import org.duckstudy.model.lotto.LottoNumber;
-import org.duckstudy.model.lotto.LottoResult;
+import org.duckstudy.model.lotto.LottoStatistics;
 import org.duckstudy.model.lotto.Lottos;
 import org.duckstudy.view.InputView;
 import org.duckstudy.view.OutputView;
@@ -13,23 +16,36 @@ public class LottoController {
     private final OutputView outputView;
     private final InputView inputView;
 
-    public LottoController(OutputView outputView, InputView inputView) {
+    public LottoController(final OutputView outputView, final InputView inputView) {
         this.outputView = outputView;
         this.inputView = inputView;
     }
 
     public void run() {
         Price price = createPrice();
-        Lottos lottos = Lottos.generateLottosByPrice(price);
-        outputView.printLottos(lottos);
+        Lottos totalLottos = createTotalLottos(price);
 
         Lotto winningLotto = createWinningLotto();
         LottoNumber bonusNumber = createBonusNumber(winningLotto);
 
-        getWinningResult(price, lottos, winningLotto, bonusNumber);
+        printWinningResult(price, totalLottos, winningLotto, bonusNumber);
+    }
+
+    private Lottos createTotalLottos(final Price price) {
+        LottoCount totalLottoCount = price.calculateLottoCount();
+        LottoCount manualLottoCount = createManualLottoCount(totalLottoCount);
+        Lottos manualLottos = createManualLottos(manualLottoCount.getCount());
+
+        LottoCount autoLottoCount = totalLottoCount.subtract(manualLottoCount);
+        Lottos autoLottos = Lottos.generateLottos(autoLottoCount.getCount());
+        Lottos totalLottos = manualLottos.merge(autoLottos);
+
+        outputView.printLottos(manualLottoCount.getCount(), autoLottoCount.getCount(), totalLottos);
+        return totalLottos;
     }
 
     private Price createPrice() {
+        outputView.printInputPrice();
         try {
             Price price = new Price(inputView.inputPrice());
             price.validateInputPrice();
@@ -40,7 +56,37 @@ private Price createPrice() {
         }
     }
 
+    private Lottos createManualLottos(final int manualLottoCount) {
+        outputView.printInputManualLotto();
+
+        return new Lottos(IntStream.range(0, manualLottoCount)
+                .mapToObj(i -> createManualLotto())
+                .collect(Collectors.toList()));
+    }
+
+    private LottoCount createManualLottoCount(final LottoCount lottoCount) {
+        outputView.printInputManualLottoCount();
+        try {
+            LottoCount manualLottoCount = new LottoCount(inputView.inputManualLottoCount());
+            manualLottoCount.validateManualLottoCount(lottoCount.getCount());
+            return manualLottoCount;
+        } catch (IllegalArgumentException e) {
+            outputView.printException(e);
+            return createManualLottoCount(lottoCount);
+        }
+    }
+
+    private Lotto createManualLotto() {
+        try {
+            return Lotto.from(inputView.inputManualLotto());
+        } catch (IllegalArgumentException e) {
+            outputView.printException(e);
+            return createManualLotto();
+        }
+    }
+
     private Lotto createWinningLotto() {
+        outputView.printInputWinningLotto();
         try {
             return Lotto.from(inputView.inputWinningLotto());
         } catch (IllegalArgumentException e) {
@@ -49,30 +95,29 @@ private Lotto createWinningLotto() {
         }
     }
 
-    private LottoNumber createBonusNumber(Lotto winningLotto) {
-        LottoNumber bonusNumber = LottoNumber.valueOf(inputView.inputBonusNumber());
-        if (winningLotto.containsNumber(bonusNumber)) {
-            outputView.printExceptionForBonusNumber();
+    private LottoNumber createBonusNumber(final Lotto winningLotto) {
+        outputView.printInputBonusNumber();
+        try {
+            LottoNumber bonusNumber = LottoNumber.valueOf(inputView.inputBonusNumber());
+            validateBonusNumber(winningLotto, bonusNumber);
+            return bonusNumber;
+        } catch (IllegalArgumentException e) {
+            outputView.printException(e);
             return createBonusNumber(winningLotto);
         }
-        outputView.printExceptionForBonusNumber();
-        return bonusNumber;
     }
 
-    private void getWinningResult(Price price, Lottos lottos, Lotto winningLotto, LottoNumber bonusNumber) {
-        LottoResult result = createLottoResult(lottos, winningLotto, bonusNumber);
-
-        calculateProfitRate(price, result);
+    private void validateBonusNumber(final Lotto winningLotto, final LottoNumber bonusNumber) {
+        if (winningLotto.containsNumber(bonusNumber)) {
+            throw new IllegalArgumentException("당첨 번호와 중복되는 보너스 볼은 입력할 수 없습니다.");
+        }
     }
 
-    private LottoResult createLottoResult(Lottos lottos, Lotto winningLotto, LottoNumber bonusNumber) {
-        LottoResult result = lottos.accumulateLottoResult(winningLotto, bonusNumber);
-        outputView.printLottoResult(result);
-        return result;
-    }
+    private void printWinningResult(Price price, Lottos totalLottos, Lotto winningLotto, LottoNumber bonusNumber) {
+        LottoStatistics statistics = totalLottos.accumulateLottoResult(winningLotto, bonusNumber);
+        outputView.printLottoStatistics(statistics);
 
-    private void calculateProfitRate(Price price, LottoResult result) {
-        double profitRate = price.calculateProfitRate(result);
+        double profitRate = price.calculateProfitRate(statistics);
         outputView.printTotalProfit(profitRate);
     }
 }

src/main/java/org/duckstudy/model/Price.java

@@ -1,7 +1,8 @@
 package org.duckstudy.model;
 
 import java.util.Objects;
-import org.duckstudy.model.lotto.LottoResult;
+import org.duckstudy.model.lotto.LottoCount;
+import org.duckstudy.model.lotto.LottoStatistics;
 import org.duckstudy.model.lotto.constant.WinningRank;
 
 public class Price {
@@ -13,16 +14,16 @@ public class Price {
 
     private final int value;
 
-    public Price(int price) {
+    public Price(final int price) {
         validatePrice(price);
         this.value = price;
     }
 
-    public static Price initialize() {
+    public static Price zero() {
         return new Price(INCLUSIVE_MIN_PRICE);
     }
 
-    private void validatePrice(int price) {
+    private void validatePrice(final int price) {
         if (price < INCLUSIVE_MIN_PRICE) {
             throw new IllegalArgumentException(String.format("가격은 %d원 이상이어야 합니다.", INCLUSIVE_MIN_PRICE));
         }
@@ -34,41 +35,36 @@ public void validateInputPrice() {
         }
     }
 
-    public Price addPrice(int value) {
+    public Price addPrice(final int value) {
         return new Price(this.value + value);
     }
 
-    public Price multiplyTimes(int times) {
-        return new Price(value * times);
-    }
-
-    public double divideByPrice(Price divisor) {
+    public double divideByPrice(final Price divisor) {
         checkIfZero(divisor.getValue());
         return (double) value / divisor.getValue();
     }
 
-    private void checkIfZero(int divisor) {
+    private void checkIfZero(final int divisor) {
         if (divisor == ZERO) {
             throw new IllegalArgumentException(String.format("%d으로 나눌 수 없습니다.", ZERO));
         }
     }
 
-    public int calculateLottoCount() {
+    public LottoCount calculateLottoCount() {
         checkIfZero(LOTTO_PRICE);
-        return value / LOTTO_PRICE;
+        return new LottoCount(value / LOTTO_PRICE);
     }
 
-    public double calculateProfitRate(LottoResult result) {
-        Price profit = Price.initialize();
+    public double calculateProfitRate(final LottoStatistics result) {
+        Price profit = Price.zero();
         for (WinningRank winningRank : WinningRank.values()) {
             profit = profit.accumulateProfit(winningRank, result.getMatchingCount(winningRank.getKey()));
         }
         return profit.divideByPrice(this) * PERCENT_BASE;
     }
 
-    private Price accumulateProfit(WinningRank winningRank, int count) {
-        return this.addPrice(winningRank.getPrice())
-                .multiplyTimes(count);
+    private Price accumulateProfit(final WinningRank winningRank, final int count) {
+        return this.addPrice(winningRank.getPrice() * count);
     }
 
     public int getValue() {