Step4

README.md

@@ -12,7 +12,7 @@
 - [x] 로또 래퍼 클래스 구현
   - [x] 로또 생성자 빈값 입력 예외 처리 검증
 - [x] 구입금액 입력 기능
-  - [ ] 구입금액 최소 단위 제한(백원 이하 오류 처리)
+  - [X] 구입금액 최소 단위 제한(백원 이하 오류 처리)
 - [X] 랜덤 로또 번호 발급 기능
   - [x] 로또 래퍼 클래스 반환
   - [x] 로또 번호 6자리 생성
@@ -28,3 +28,5 @@
 - [x] 수익률 산출 기능
 - [X] 보너스 번호 입력 기능
 - [X] 2등 상금 추가
+- [X] 수동 발급 추가
+- [x] 예산 지불 추가

src/main/java/lotto/controller/LottoController.java

@@ -11,22 +11,43 @@ public void simulateLotto() {
     }
 
     private Statistics getStatistics() {
-        return getLottos().computeStatistic(getWinLotto());
+        return getLottos(getBudget()).computeStatistic(getWinLotto());
     }
 
     private WinLotto getWinLotto() {
-        return InputView.inputLastWinLotto();
+        return InputView.retryableInputLastWinLotto();
     }
 
-    private Lottos getLottos() {
-        Lottos lottos = new Lottos(getBudget());
-        ResultView.showGeneratedLottos(lottos);
+    private Lottos getLottos(Budget budget) {
+        SelfIssueCount count = getManualIssueCount();
+
+        budget = budget.spend(Price.LOTTO, count);
+
+        Lottos manualLottos = getManualIssuedLottos(count);
+        Lottos autoLottos = getAutoIssuedLottos(budget);
+
+        ResultView.showLottoQuantity(manualLottos, autoLottos);
+
+        Lottos allLottos = manualLottos.combine(autoLottos);
+        ResultView.showGeneratedLottos(allLottos);
+
+        return allLottos;
+    }
+
+    private SelfIssueCount getManualIssueCount() {
+        return InputView.retryableInputSelfIssueCount();
+    }
+
+    private Lottos getManualIssuedLottos(SelfIssueCount count) {
+        return InputView.inputSelfIssueLottos(count);
+    }
+    private Lottos getAutoIssuedLottos(Budget budget) {
+        Lottos lottos = new Lottos(budget);
         return lottos;
     }
 
     private Budget getBudget() {
-        Budget budget = InputView.inputBuyBudget();
-        ResultView.showLottoQuantity(budget.divide(Lotto.LOTTO_PRICE));
+        Budget budget = InputView.retryableInputBuyBudget();
         return budget;
     }
 

src/main/java/lotto/domain/Budget.java

@@ -1,18 +1,32 @@
 package lotto.domain;
 
-public class Budget {
+public class Budget{
 
-    private int value;
+    private int budget;
 
     public Budget(int budget) {
-        this.value = budget;
+        validMinValue(budget);
+        this.budget = budget;
     }
 
-    public int getValue() {
-        return value;
+    private void validMinValue(int budget) {
+        if(budget % 1000 != 0)
+            throw new IllegalArgumentException("100원 단위는 입력할 수 없습니다: " + budget);
     }
 
-    public int divide(int lottoPrice) {
-        return value / lottoPrice;
+    public int purchasableQuantity(Price price) {
+        return price.divide(budget);
+    }
+
+    public boolean isEnoughToPay(Price price) {
+        return budget > price.getValue();
+    }
+
+    public Budget spend(Price price) {
+        return new Budget(budget - price.getValue());
+    }
+
+    public Budget spend(Price price, SelfIssueCount issueCount) {
+        return new Budget(budget - price.multiple(issueCount));
     }
 }

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

@@ -15,6 +15,7 @@ public Lotto() {
 
     public Lotto(List<LottoNumber> lotto) {
         validEmpty(lotto);
+        validLottoSize(lotto);
         this.lotto = lotto;
     }
 
@@ -29,6 +30,12 @@ private static void validEmpty(List<?> lotto) {
         }
     }
 
+    private static void validLottoSize(List<?> lotto) {
+        if(lotto.size() != 6) {
+            throw new IllegalArgumentException("유효한 Lotto size가 아닙니다: " + lotto.size());
+        }
+    }
+
     public List<LottoNumber> getLotto() {
         return lotto;
     }
@@ -39,8 +46,12 @@ public int size() {
 
     @Override
     public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
         Lotto lotto1 = (Lotto) o;
         return Objects.equals(lotto, lotto1.lotto);
     }
@@ -49,4 +60,8 @@ public boolean equals(Object o) {
     public int hashCode() {
         return Objects.hash(lotto);
     }
+
+    protected boolean isContainBonus(LottoNumber bonus) {
+        return lotto.contains(bonus);
+    }
 }

src/main/java/lotto/domain/Lottos.java

@@ -4,6 +4,8 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
+import static lotto.domain.Price.LOTTO;
+
 public class Lottos {
 
     private List<Lotto> lottos;
@@ -12,15 +14,21 @@ public Lottos(Budget budget) {
         this(generateLottosBy(budget));
     }
 
+    public Lottos(Lotto lotto) {
+        this(List.of(lotto));
+    }
+
     public Lottos(List<Lotto> lottos) {
         this.lottos = lottos;
     }
 
     private static List<Lotto> generateLottosBy(Budget budget) {
         List<Lotto> lottos = new ArrayList<>();
 
-        for (int i = 0; i < budget.divide(Lotto.LOTTO_PRICE); i++) {
+        if (budget.isEnoughToPay(LOTTO)) {
+            lottos.addAll(generateLottosBy(budget.spend(LOTTO)));
             lottos.add(new Lotto());
+            return lottos;
         }
         return lottos;
     }
@@ -29,6 +37,10 @@ public List<Lotto> getLottos() {
         return lottos;
     }
 
+    public int getLottoSize() {
+        return lottos.size();
+    }
+
     public Statistics computeStatistic(WinLotto winLotto) {
         return new Statistics(checkStatisticNumberMatch(winLotto));
     }
@@ -45,4 +57,11 @@ private static Statistic getStatistic(WinLotto winLotto, Lotto lotto) {
                 winLotto.isContainBonus(lotto)
         );
     }
+
+    public Lottos combine(Lottos lottos) {
+        List<Lotto> newLottos = new ArrayList<>(this.lottos);
+        List<Lotto> combineLottos = lottos.getLottos();
+        newLottos.addAll(combineLottos);
+        return new Lottos(newLottos);
+    }
 }

src/main/java/lotto/domain/Price.java

@@ -0,0 +1,24 @@
+package lotto.domain;
+
+public enum Price {
+
+    LOTTO(1000);
+
+    private final int value;
+
+    Price(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public int multiple(SelfIssueCount count) {
+        return count.getCount() * value;
+    }
+
+    public int divide(int budget) {
+        return budget / value;
+    }
+}

src/main/java/lotto/domain/SelfIssueCount.java

@@ -0,0 +1,33 @@
+package lotto.domain;
+
+public class SelfIssueCount implements Comparable<SelfIssueCount>{
+
+    private int count;
+
+    public SelfIssueCount(int count) {
+        validPositiveValue(count);
+        this.count = count;
+    }
+
+    private void validPositiveValue(int count) {
+        if (count < 0)
+            throw new IllegalArgumentException("양수 값만 입력할 수 있습니다: " + count);
+    }
+
+    public int getCount() {
+        return count;
+    }
+
+    public boolean isPositive() {
+        return count > 0;
+    }
+
+    public SelfIssueCount decrease() {
+        return new SelfIssueCount(count - 1);
+    }
+
+    @Override
+    public int compareTo(SelfIssueCount that) {
+        return this.count - that.count;
+    }
+}

src/main/java/lotto/domain/WinLotto.java

@@ -4,63 +4,46 @@
 import java.util.Objects;
 import java.util.stream.Collectors;
 
-public class WinLotto {
+public class WinLotto extends Lotto {
 
-    private List<LottoNumber> winLotto;
     private LottoNumber bonus;
 
-    public WinLotto(List<LottoNumber> winLotto, LottoNumber bonus) {
-        validEmpty(winLotto);
-        this.winLotto = winLotto;
-        this.bonus = bonus;
+    public WinLotto(List<Integer> lottoNumbers, Integer bonus) {
+        this(lottoNumbers.stream().map(LottoNumber::new).collect(Collectors.toList()));
+        this.bonus = new LottoNumber(bonus);
     }
 
-    public static WinLotto ofNumbers(List<Integer> lottoNumbers, int bonus) {
-        validEmpty(lottoNumbers);
-        return new WinLotto(createLottoNumber(lottoNumbers), createLottoNumber(bonus));
-    }
-
-    private static List<LottoNumber> createLottoNumber(List<Integer> lottoNumbers) {
-        return lottoNumbers
-            .stream()
-            .map(LottoNumber::new)
-            .collect(Collectors.toList());
-    }
-
-    private static LottoNumber createLottoNumber(int bonus) {
-        return new LottoNumber(bonus);
-    }
-
-    private static void validEmpty(List<?> lotto) {
-        if (lotto == null || lotto.isEmpty()) {
-            throw new IllegalArgumentException("입력값이 없습니다");
-        }
-    }
-
-    public int size() {
-        return winLotto.size();
+    private WinLotto(List<LottoNumber> lottoNumbers) {
+        super(lottoNumbers);
     }
 
     public int getFeatNumberCount(Lotto lotto) {
         return (int) lotto.getLotto().stream()
-                .filter(value -> this.winLotto.contains(value))
-                .count();
+            .filter(value -> super.getLotto().contains(value))
+            .count();
     }
 
     public boolean isContainBonus(Lotto lotto) {
-        return lotto.getLotto().contains(bonus);
+        return lotto.isContainBonus(bonus);
     }
 
     @Override
     public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        WinLotto lotto1 = (WinLotto) o;
-        return Objects.equals(winLotto, lotto1.winLotto);
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        if (!super.equals(o)) {
+            return false;
+        }
+        WinLotto winLotto = (WinLotto) o;
+        return Objects.equals(bonus, winLotto.bonus);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(winLotto);
+        return Objects.hash(super.hashCode(), bonus);
     }
 }