[Tany / Ader] 로또 3단계 - 수동구매 기능 추가

README.md

@@ -41,3 +41,16 @@
 ### 결과출력
 > ![1_결과출력](https://user-images.githubusercontent.com/29879110/155278106-3f5717ed-1885-43ba-a2ec-dcb4f10c6c4a.JPG)
 <br>
+
+## Mission3 - 수동구매 기능 추가
+### 기능요구사항
+- [x] 현재 로또 생성기는 자동 생성 기능만 제공한다. 사용자가 수동으로 추첨 번호를 입력할 수 있도록 해야 한다.
+- [x] 입력한 금액, 자동 생성 숫자, 수동 생성 번호를 입력하도록 해야 한다.
+### 프로그래밍 요구사항
+- [x] 예외가 발생하는 부분에 대해 자바 Exception을 적용해 예외처리한다.
+- [x] 사용자가 입력한 값에 대한 예외 처리를 철저히 한다.
+- [x] 상속과 인터페이스를 통해 구현을 간결히 할 수 없는지 고민해 본다.
+
+### 결과출력
+> ![1_결과출력](https://user-images.githubusercontent.com/29879110/155676112-fd7ccf8e-9a3e-48c1-9473-20863e490827.JPG)
+<br>

src/main/java/lotto/controller/LottoGame.java

@@ -1,15 +1,14 @@
 package lotto.controller;
 
-import lotto.domain.LottoPaper;
-import lotto.domain.LottoStore;
-import lotto.domain.WinningStrategy;
+import lotto.domain.*;
 import lotto.view.InputView;
 import lotto.view.OutputView;
 
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
-import java.util.stream.IntStream;
 
 public class LottoGame {
 
@@ -19,74 +18,53 @@ public void start() {
         InputView.init();
 
         int purchaseAmount = InputView.getPurchaseAmount();
-        LottoPaper lottoPaper = purchase(purchaseAmount);
+        int manualLottoCount = InputView.getManualLottoCount();
 
-        List<WinningStrategy> winningStrategies = checkWinning(lottoPaper);
+        LottoPaper lottoPaper = purchase(
+                purchaseAmount,
+                manualLottoCount,
+                getManualNumbers(InputView.getManualLottoNumbers(manualLottoCount)));
 
-        calculateWinningStats(winningStrategies, purchaseAmount);
+        calculateWinningStats(checkWinning(lottoPaper), purchaseAmount);
 
         InputView.close();
     }
 
-    private LottoPaper purchase(int purchaseAmount) {
-        LottoStore lottoStore = new LottoStore();
-        LottoPaper lottoPaper = lottoStore.purchase(purchaseAmount);
+    private LottoPaper purchase(int purchaseAmount, int manualLottoCount, Map<Integer, List<Integer>> numbers) {
+        LottoPaper lottoPaper = new LottoStore().purchase(purchaseAmount, manualLottoCount, numbers);
 
-        OutputView.printPurchaseCount(lottoPaper.getLottoSize());
+        OutputView.printPurchaseCount(manualLottoCount, lottoPaper.getLottoSize() - manualLottoCount);
         OutputView.printLottoPaper(lottoPaper.showLottoPaper());
 
         return lottoPaper;
     }
 
     private List<WinningStrategy> checkWinning(LottoPaper lottoPaper) {
-        String inputWinningNumbers = InputView.getRequiredWinningNumber();
-        String inputBonusNumber = InputView.getBonusBallNumber();
+        List<Integer> winningNumbers = getNumbers(InputView.getRequiredWinningNumber());
+        int bonusNumber = getBonusNumber(InputView.getBonusBallNumber(winningNumbers));
 
-        List<Integer> winningNumbers = getWinningNumbers(inputWinningNumbers);
-        int bonusNumber = getBonusNumber(inputBonusNumber);
-
-        List<Integer> correctNumberCounts = lottoPaper.judgeWinning(winningNumbers);
-        List<Boolean> hasBonusNumbers = lottoPaper.hasBonusNumbers(bonusNumber);
-
-        return IntStream.range(0, correctNumberCounts.size())
-                .mapToObj(index -> convertMatchNumberToWinningStrategy(correctNumberCounts.get(index), hasBonusNumbers.get(index)))
-                .collect(Collectors.toList());
+        return lottoPaper.checkWinning(new WinningLotto(winningNumbers, bonusNumber));
     }
 
-    private List<Integer> getWinningNumbers(String inputWinningNumbers) {
-        return Arrays.stream(inputWinningNumbers.split(NUMBER_DELIMITER))
+    private List<Integer> getNumbers(String inputNumbers) {
+        return Arrays.stream(inputNumbers.split(NUMBER_DELIMITER))
                 .mapToInt(Integer::parseInt)
                 .boxed()
                 .collect(Collectors.toList());
     }
 
-    private int getBonusNumber(String inputBonusNumber) {
-        return Integer.parseInt(inputBonusNumber);
-    }
+    private Map<Integer, List<Integer>> getManualNumbers(Map<Integer, String> inputNumbers) {
+        Map<Integer, List<Integer>> manualNumbers = new HashMap<>();
 
-    private WinningStrategy convertMatchNumberToWinningStrategy(int matchNumber, boolean hasBonusNumber) {
-        if (matchNumber == WinningStrategy.ZERO_MATCHES.getCorrectNumber()) {
-            return WinningStrategy.ZERO_MATCHES;
-        }
-        if (matchNumber == WinningStrategy.ONE_MATCHES.getCorrectNumber()) {
-            return WinningStrategy.ONE_MATCHES;
-        }
-        if (matchNumber == WinningStrategy.TWO_MATCHES.getCorrectNumber()) {
-            return WinningStrategy.TWO_MATCHES;
-        }
-        if (matchNumber == WinningStrategy.THREE_MATCHES.getCorrectNumber()) {
-            return WinningStrategy.THREE_MATCHES;
+        for (int i = 0; i < inputNumbers.size(); i++) {
+             manualNumbers.put(i, getNumbers(inputNumbers.get(i)));
         }
-        if (matchNumber == WinningStrategy.FOUR_MATCHES.getCorrectNumber()) {
-            return WinningStrategy.FOUR_MATCHES;
-        }
-        if (matchNumber == WinningStrategy.FIVE_MATCHES.getCorrectNumber() && hasBonusNumber) {
-            return WinningStrategy.FIVE_WITH_BONUS_MATCHES;
-        }
-        if (matchNumber == WinningStrategy.FIVE_MATCHES.getCorrectNumber()) {
-            return WinningStrategy.FIVE_MATCHES;
-        }
-        return WinningStrategy.SIX_MATCHES;
+
+        return manualNumbers;
+    }
+
+    private int getBonusNumber(String inputBonusNumber) {
+        return Integer.parseInt(inputBonusNumber);
     }
 
     private void calculateWinningStats(List<WinningStrategy> winningStrategies, int purchaseAmount) {

src/main/java/lotto/domain/AutoLotto.java

@@ -0,0 +1,27 @@
+package lotto.domain;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class AutoLotto extends Lotto {
+    private static final int PICK_NUMBER_LENGTH = 6;
+
+    public AutoLotto(List<Integer> numbers) {
+        super(numbers);
+    }
+
+    @Override
+    public List<Integer> createLotto(List<Integer> numbers) {
+        return pickSixNumbers(numbers);
+    }
+
+    private List<Integer> pickSixNumbers(List<Integer> numbers) {
+        Collections.shuffle(numbers);
+
+        return numbers.stream()
+                .limit(PICK_NUMBER_LENGTH)
+                .sorted()
+                .collect(Collectors.toList());
+    }
+}

src/main/java/lotto/domain/Lotto.java

@@ -1,35 +1,23 @@
 package lotto.domain;
 
-import java.util.Collections;
 import java.util.List;
-import java.util.stream.Collectors;
 
-public class Lotto {
+public abstract class Lotto {
+
     private final List<Integer> numbers;
 
     public Lotto(List<Integer> numbers) {
-        this.numbers = pickSixNumbers(numbers);
+        this.numbers = createLotto(numbers);
     }
 
-    private List<Integer> pickSixNumbers(List<Integer> numbers) {
-        int pickNumberLength = 6;
-
-        Collections.shuffle(numbers);
-
-        return numbers.stream()
-                .limit(pickNumberLength)
-                .sorted()
-                .collect(Collectors.toList());
-    }
+    public abstract List<Integer> createLotto(List<Integer> numbers);
 
     public String showLottoNumbers() {
         return numbers.toString();
     }
 
-    public int getCorrectNumberCount(List<Integer> winningNumbers) {
-        return winningNumbers.stream()
-                .mapToInt(this::correctNumber)
-                .sum();
+    public boolean hasNumber(int number) {
+        return numbers.contains(number);
     }
 
     private int correctNumber(int number) {
@@ -39,7 +27,11 @@ private int correctNumber(int number) {
         return 0;
     }
 
-    public boolean hasBonusNumber(int bonusNumber) {
-        return numbers.contains(bonusNumber);
+    public MatchLottoResult match(WinningLotto winningLotto) {
+        int matchCount = (int)numbers.stream()
+                .filter(value -> winningLotto.hasNumber(value))
+                .count();
+
+        return new MatchLottoResult(matchCount, numbers.contains(winningLotto.getBonusNumber()));
     }
 }

src/main/java/lotto/domain/LottoPaper.java

@@ -25,16 +25,12 @@ public String showLottoPaper() {
         return sb.toString();
     }
 
-    public List<Integer> judgeWinning(List<Integer> winningNumbers) {
+    public List<WinningStrategy> checkWinning(WinningLotto winningLotto) {
         return lottos.stream()
-                .mapToInt(lotto -> lotto.getCorrectNumberCount(winningNumbers))
-                .boxed()
-                .collect(Collectors.toList());
-    }
-
-    public List<Boolean> hasBonusNumbers(int bonusNumber) {
-        return lottos.stream()
-                .map(lotto -> lotto.hasBonusNumber(bonusNumber))
+                .map(lotto -> lotto.match(winningLotto))
+                .map(result -> WinningStrategy.convertMatchNumberToWinningStrategy(
+                        result.getMatchNumberCount(),
+                        result.hasBonus()))
                 .collect(Collectors.toList());
     }
 }

src/main/java/lotto/domain/LottoStore.java

@@ -2,6 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 public class LottoStore {
     private static final int LOTTO_PRICE = 1_000;
@@ -24,23 +25,27 @@ private List<Integer> getAllLottoNumber() {
         return this.allLottoNumber;
     }
 
-    private int getLottoCount(int purchaseAmount) {
-        return purchaseAmount / LOTTO_PRICE;
-    }
-
-    public LottoPaper purchase(int purchaseAmount) {
+    public LottoPaper purchase(int purchaseAmount, int manualLottoCount, Map<Integer, List<Integer>> numbers) {
         int lottoCount = getLottoCount(purchaseAmount);
 
-        List<Lotto> lottos = createLottos(lottoCount);
+        List<Lotto> lottos = createLottos(manualLottoCount, lottoCount - manualLottoCount, numbers);
 
         return new LottoPaper(lottos);
     }
 
-    private List<Lotto> createLottos(int lottoCount) {
+    private int getLottoCount(int purchaseAmount) {
+        return purchaseAmount / LOTTO_PRICE;
+    }
+
+    private List<Lotto> createLottos(int manualLottoCount, int autoLottoCount, Map<Integer, List<Integer>> numbers) {
         List<Lotto> lottos = new ArrayList<>();
 
-        for (int i = 0; i < lottoCount; i++) {
-            lottos.add(new Lotto(allLottoNumber));
+        for (int i = 0; i < manualLottoCount; i++) {
+            lottos.add(new ManualLotto(numbers.get(i)));
+        }
+
+        for (int i = 0; i < autoLottoCount; i++) {
+            lottos.add(new AutoLotto(allLottoNumber));
         }
 
         return lottos;

src/main/java/lotto/domain/ManualLotto.java

@@ -0,0 +1,18 @@
+package lotto.domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ManualLotto extends Lotto {
+
+    public ManualLotto(List<Integer> numbers) {
+        super(numbers);
+    }
+
+    @Override
+    public List<Integer> createLotto(List<Integer> numbers) {
+        return numbers.stream()
+                .sorted()
+                .collect(Collectors.toList());
+    }
+}

src/main/java/lotto/domain/MatchLottoResult.java

@@ -0,0 +1,19 @@
+package lotto.domain;
+
+public class MatchLottoResult {
+    private int matchNumberCount;
+    private boolean hasBonus;
+
+    public MatchLottoResult(int matchNumberCount, boolean hasBonus) {
+        this.matchNumberCount = matchNumberCount;
+        this.hasBonus = hasBonus;
+    }
+
+    public int getMatchNumberCount() {
+        return matchNumberCount;
+    }
+
+    public boolean hasBonus() {
+        return hasBonus;
+    }
+}

src/main/java/lotto/domain/WinningLotto.java

@@ -0,0 +1,25 @@
+package lotto.domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class WinningLotto extends Lotto {
+
+    private final int bonusNumber;
+
+    public WinningLotto(List<Integer> numbers, int bonusNumber) {
+        super(numbers);
+        this.bonusNumber = bonusNumber;
+    }
+
+    @Override
+    public List<Integer> createLotto(List<Integer> numbers) {
+        return numbers.stream()
+                .sorted()
+                .collect(Collectors.toList());
+    }
+
+    public int getBonusNumber() {
+        return bonusNumber;
+    }
+}

src/main/java/lotto/domain/WinningStrategy.java

@@ -26,4 +26,29 @@ public int getWinningPrice() {
     public int getCorrectNumber() {
         return this.correctNumber;
     }
+
+    public static WinningStrategy convertMatchNumberToWinningStrategy(int matchNumber, boolean hasBonusNumber) {
+        if (matchNumber == WinningStrategy.ZERO_MATCHES.getCorrectNumber()) {
+            return WinningStrategy.ZERO_MATCHES;
+        }
+        if (matchNumber == WinningStrategy.ONE_MATCHES.getCorrectNumber()) {
+            return WinningStrategy.ONE_MATCHES;
+        }
+        if (matchNumber == WinningStrategy.TWO_MATCHES.getCorrectNumber()) {
+            return WinningStrategy.TWO_MATCHES;
+        }
+        if (matchNumber == WinningStrategy.THREE_MATCHES.getCorrectNumber()) {
+            return WinningStrategy.THREE_MATCHES;
+        }
+        if (matchNumber == WinningStrategy.FOUR_MATCHES.getCorrectNumber()) {
+            return WinningStrategy.FOUR_MATCHES;
+        }
+        if (matchNumber == WinningStrategy.FIVE_MATCHES.getCorrectNumber() && hasBonusNumber) {
+            return WinningStrategy.FIVE_WITH_BONUS_MATCHES;
+        }
+        if (matchNumber == WinningStrategy.FIVE_MATCHES.getCorrectNumber()) {
+            return WinningStrategy.FIVE_MATCHES;
+        }
+        return WinningStrategy.SIX_MATCHES;
+    }
 }