[로또 게임 1단계] 리뷰 부탁드립니다

README.md

@@ -1 +1,30 @@
-# java-lotto 게임
+# java-Lotto 게임
+
+# 구현 기능 목록
+
+- [x] 구입금액 입력받기
+    - [x] 1000원 미만 입력 시 처리
+    - [x] 1000의 배수 아닌 값 입력 시 처리
+    - [x] 숫자가 아닌 값 (문자열)
+    - [x] 정상값 처리
+    - [x] 공백 처리
+- [x] 구매 개수 구하기
+- [x] 랜덤 로또번호 구매 개수만큼 만들기
+    - [x] defaultNumberSet 1번만 생성되도록 변경
+    - [x] RandomLottoTest 상수 리팩토링
+    - [x] PurchaseCount의 1000 접근
+- [x] 지난 주 당첨 번호 입력받기
+    - [x] WinningNumbers 멤버변수 ArrayList 클래스 확인
+    - [x] 숫자 개수 6개 확인
+    - [x] 숫자가 아닌 값 포함
+    - [x] 범위 (1~45) 확인
+    - [x] 공백 처리
+- [x] 보너스 볼 입력받기
+- [x] 당첨 통계
+    - [x] 당첨 조건을 enum 처리
+    - [x] 일치 개수 찾기
+    - [x] 5개 일치 시 보너스 볼 일치 여부 확인
+    - [x] 로또 당첨 개수 구하기
+    - [x] 당첨값의 합 구하기
+    - [x] 수익률 구하기
+    - [x] 결과 출력

build.gradle

@@ -10,6 +10,13 @@ repositories {
 dependencies {
     testImplementation('org.junit.jupiter:junit-jupiter:5.6.0')
     testImplementation('org.assertj:assertj-core:3.15.0')
+
+    compileOnly 'org.projectlombok:lombok:1.18.20'
+    annotationProcessor 'org.projectlombok:lombok:1.18.20'
+
+    testCompileOnly 'org.projectlombok:lombok:1.18.20'
+    testAnnotationProcessor 'org.projectlombok:lombok:1.18.20'
+
 }
 
 test {

src/main/java/lotto/LottoApplication.java

@@ -0,0 +1,18 @@
+package lotto;
+
+import lotto.controller.LottoController;
+import lotto.view.ConsoleInputView;
+import lotto.view.ConsoleOutputView;
+import lotto.view.View;
+
+public class LottoApplication {
+
+    public static void main(String[] args) {
+        View view = View.builder()
+                .inputView(new ConsoleInputView())
+                .outputView(new ConsoleOutputView())
+                .build();
+        LottoController lottoController = new LottoController(view);
+        lottoController.start();
+    }
+}

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

@@ -0,0 +1,33 @@
+package lotto.controller;
+
+import lotto.domain.dto.PurchasePriceInputDTO;
+import lotto.domain.dto.PurchaseResultDTO;
+import lotto.domain.dto.StatisticsResultDTO;
+import lotto.domain.dto.WinningLottoInputDTO;
+import lotto.service.LottoService;
+import lotto.view.View;
+
+public class LottoController {
+
+    private final View view;
+    private final LottoService lottoService;
+
+    public LottoController(View view) {
+        this.view = view;
+        this.lottoService = new LottoService();
+    }
+
+    public void start() throws IllegalArgumentException {
+        try {
+            PurchasePriceInputDTO purchasePriceInputDTO = view.getPurchaseCost();
+            PurchaseResultDTO purchaseResultDTO = lottoService.purchase(purchasePriceInputDTO);
+            view.printLottoPurchaseResult(purchaseResultDTO);
+
+            WinningLottoInputDTO winningLottoInputDTO = view.getWinningLottoAndBonus();
+            StatisticsResultDTO statisticsResultDTO = lottoService.calculateResult(purchaseResultDTO, winningLottoInputDTO);
+            view.printLottoStatistics(statisticsResultDTO);
+        } catch (IllegalArgumentException e) {
+            view.printException(e.getMessage());
+        }
+    }
+}

src/main/java/lotto/domain/DefaultNumbers.java

@@ -0,0 +1,17 @@
+package lotto.domain;
+
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class DefaultNumbers {
+
+    @Getter
+    private static final List<Integer> defaultNumbers = Collections.unmodifiableList(new ArrayList<Integer>() {{
+        IntStream.range(LottoNumber.LOWER_BOUND, LottoNumber.UPPER_BOUND)
+                .forEach(this::add);
+    }});
+}

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

@@ -0,0 +1,18 @@
+package lotto.domain;
+
+import lombok.Getter;
+
+import java.util.List;
+
+public class Lotto {
+
+    public static final int PRICE = 1000;
+    public static final int LOTTO_NUMBER_SIZE = 6;
+
+    @Getter
+    protected List<LottoNumber> lottoNumbers;
+
+    public Lotto(List<LottoNumber> lottoNumbers) {
+        this.lottoNumbers = lottoNumbers;
+    }
+}

src/main/java/lotto/domain/LottoNumber.java

@@ -0,0 +1,56 @@
+package lotto.domain;
+
+import lombok.Getter;
+
+import java.util.Objects;
+
+import static lotto.exception.ExceptionMessage.NON_INTEGER_INPUT_FOR_LOTTO_NUMBER;
+import static lotto.exception.ExceptionMessage.OUT_OF_BOUND_INPUT_FOR_LOTTO_NUMBER;
+import static lotto.util.NumberValidateUtils.isInteger;
+
+public class LottoNumber {
+
+    public static final int LOWER_BOUND = 1;
+    public static final int UPPER_BOUND = 45;
+
+    @Getter
+    private final int lottoNumber;
+
+    public LottoNumber(String input) throws IllegalArgumentException {
+        validate(input);
+
+        this.lottoNumber = Integer.parseInt(input);
+    }
+
+    private void validate(String input) throws IllegalArgumentException {
+        if (!isInteger(input)) {
+            throw new IllegalArgumentException(NON_INTEGER_INPUT_FOR_LOTTO_NUMBER.getMessage());
+        }
+
+        int lottoNumber = Integer.parseInt(input);
+        if (isOutOfBound(lottoNumber)) {
+            throw new IllegalArgumentException(OUT_OF_BOUND_INPUT_FOR_LOTTO_NUMBER.getMessage());
+        }
+    }
+
+    private boolean isOutOfBound(int lottoNumber) {
+        return lottoNumber < LOWER_BOUND || lottoNumber > UPPER_BOUND;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        LottoNumber that = (LottoNumber) o;
+        return lottoNumber == that.lottoNumber;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(lottoNumber);
+    }
+}

src/main/java/lotto/domain/LottoSet.java

@@ -0,0 +1,16 @@
+package lotto.domain;
+
+import lombok.Getter;
+
+import java.util.Collections;
+import java.util.Set;
+
+public class LottoSet {
+
+    @Getter
+    private final Set<Lotto> lottoSet;
+
+    public LottoSet(Set<Lotto> lottoSet) {
+        this.lottoSet = Collections.unmodifiableSet(lottoSet);
+    }
+}

src/main/java/lotto/domain/LottoStatistics.java

@@ -0,0 +1,22 @@
+package lotto.domain;
+
+import lombok.Builder;
+import lombok.Getter;
+
+public class LottoStatistics {
+
+    @Getter
+    private final PrizeCount prizeCount;
+    private final PurchaseCount purchaseCount;
+
+    @Builder
+    public LottoStatistics(PrizeCount prizeCount, PurchaseCount purchaseCount) {
+        this.prizeCount = prizeCount;
+        this.purchaseCount = purchaseCount;
+    }
+
+    public double calculateProfitRate() {
+        return (double) Prize.sumOfPrizeMoney(prizeCount)
+                / (purchaseCount.getPurchaseCount() * Lotto.PRICE);
+    }
+}

src/main/java/lotto/domain/Prize.java

@@ -0,0 +1,55 @@
+package lotto.domain;
+
+import lombok.Getter;
+
+@Getter
+public enum Prize {
+
+    FIRST(6, false, 2000000000),
+    SECOND(5, true, 30000000),
+    THIRD(5, false, 1500000),
+    FOURTH(4, false, 50000),
+    FIFTH(3, false, 5000),
+    LOSE(2, false, 0);
+
+    private final int matchNumbersCount;
+    private final boolean isBonus;
+    private final long prizeMoney;
+
+    Prize(int matchNumbersCount, boolean isBonus, long prizeMoney) {
+        this.matchNumbersCount = matchNumbersCount;
+        this.isBonus = isBonus;
+        this.prizeMoney = prizeMoney;
+    }
+
+    public static Prize findPrize(int matchNumbersCount, boolean isBonus) {
+        if (matchNumbersCount <= LOSE.matchNumbersCount) {
+            return LOSE;
+        }
+        if (matchNumbersCount == FIFTH.matchNumbersCount) {
+            return FIFTH;
+        }
+        if (matchNumbersCount == FOURTH.matchNumbersCount) {
+            return FOURTH;
+        }
+        if (matchNumbersCount == FIRST.matchNumbersCount) {
+            return FIRST;
+        }
+        return dissolveSecondOrThird(isBonus);
+    }
+
+    private static Prize dissolveSecondOrThird(boolean isBonus) {
+        if (isBonus) {
+            return Prize.SECOND;
+        }
+        return Prize.THIRD;
+    }
+
+    public static long sumOfPrizeMoney(PrizeCount prizeCount) {
+        return prizeCount.getCountFirst() * FIRST.prizeMoney
+                + prizeCount.getCountSecond() * SECOND.prizeMoney
+                + prizeCount.getCountThird() * THIRD.prizeMoney
+                + prizeCount.getCountFourth() * FOURTH.prizeMoney
+                + prizeCount.getCountFifth() * FIFTH.prizeMoney;
+    }
+}

src/main/java/lotto/domain/PrizeCount.java

@@ -0,0 +1,43 @@
+package lotto.domain;
+
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+public class PrizeCount {
+
+    private int countFirst;
+    private int countSecond;
+    private int countThird;
+    private int countFourth;
+    private int countFifth;
+
+    @Builder
+    public PrizeCount(LottoSet lottoset, WinningLotto winningLotto) {
+        for (Lotto lotto : lottoset.getLottoSet()) {
+            updateCounts(winningLotto.findPrizeCondition(lotto));
+        }
+    }
+
+    private void updateCounts(Prize prize) {
+        if (prize.equals(Prize.FIRST)) {
+            countFirst++;
+            return;
+        }
+        if (prize.equals(Prize.SECOND)) {
+            countSecond++;
+            return;
+        }
+        if (prize.equals(Prize.THIRD)) {
+            countThird++;
+            return;
+        }
+        if (prize.equals(Prize.FOURTH)) {
+            countFourth++;
+            return;
+        }
+        if (prize.equals(Prize.FIFTH)) {
+            countFifth++;
+        }
+    }
+}

src/main/java/lotto/domain/PurchaseCount.java

@@ -0,0 +1,43 @@
+package lotto.domain;
+
+import lombok.Builder;
+import lombok.Getter;
+
+import static lotto.exception.ExceptionMessage.NON_INTEGER_INPUT_FOR_PURCHASE_MONEY;
+import static lotto.exception.ExceptionMessage.NON_MULTIPLE_OF_LOTTO_PRICE_INPUT_FOR_PURCHASE_MONEY;
+import static lotto.util.NumberValidateUtils.isInteger;
+
+public class PurchaseCount {
+
+    private static final int MINIMUM_INPUT = 1000;
+
+    @Getter
+    private final int purchaseCount;
+
+    @Builder
+    public PurchaseCount(String input) {
+        input = input.trim();
+        validate(input);
+
+        this.purchaseCount = Integer.parseInt(input) / Lotto.PRICE;
+    }
+
+    private void validate(String input) {
+        if (!isInteger(input)) {
+            throw new IllegalArgumentException(NON_INTEGER_INPUT_FOR_PURCHASE_MONEY.getMessage());
+        }
+
+        int purchaseCount = Integer.parseInt(input);
+        if (notMatchesCondition(purchaseCount)) {
+            throw new IllegalArgumentException(NON_MULTIPLE_OF_LOTTO_PRICE_INPUT_FOR_PURCHASE_MONEY.getMessage());
+        }
+    }
+
+    private boolean notMatchesCondition(int input) {
+        return input < MINIMUM_INPUT || notMultipleOfLottoPrice(input);
+    }
+
+    private boolean notMultipleOfLottoPrice(int input) {
+        return input % Lotto.PRICE != 0;
+    }
+}