[행성 로또] 최용준 미션 제출합니다.

README.md

@@ -1 +1,102 @@
 # java-planetlotto-precourse
+
+# 🪐🔢 행성 로또 - 기능 목록
+
+## 도전 목표!!
+- OOP를 최대한 지키면서 코딩하는 것!
+- 기존 긴 시간 동안 못한 것을 짧은 시간에 해결하는 훈련
+- 20,000원이라는 금액 한계 설정
+- 객체에서 null을 개발자가 주었을 때, 잘 대처할 수 있게 예외를 더 틈틈히 잡는다.
+
+- 단위 테스트를 만드는 것과 1~3주차, 오픈미션은 모두 긴 시간 동안 로직을 구현했습니다.
+- 이렇게 주어진 4시간 안에 난잡해지는 코드가 아닌 명확한 OOP를 지키면서 코드를 만드려고 더욱 더 노력했습니다.
+
+### 0️⃣ 규칙
+- 사용자 입력에 대한 예외가 발생한 경우 **재입력**
+- 사용자 입력은 **엄격히 검증**되며, 형식 오류는 모두 예외로 처리한다.
+    - 공백, 불필요한 0, 범위 초과 입력 등은 허용되지 않는다.
+- 모든 예외에 대한 에러 문구 `"[ERROR] ..."`로 시작
+- **로또 규칙**
+    - 로또 1회 구입금액: 500원
+    - 로또 1인당 최대 구입금액: 20,000원
+    - 로또 번호 범위 1 ~ 30
+    - 로또 1개당 총 5개 번호 소유
+    - 당첨 번호(5자리)와 보너스 번호가 중복이라면 보너스 번호를 다시 입력 받는다
+
+---
+### 1️⃣ 로또 구입금액 입력 받기
+- [x] `"구입금액을 입력해 주세요."` 메시지 출력 (정수 변환 포함)
+    - [x] 로또 구입금액 입력
+    - 구입금액 입력 예외 처리
+
+---
+### 2️⃣ 로또 구매 갯수
+- [x] 로또 한장의 가격은 500원 `(구입금액 / 500 = 로또 발행 횟수)`
+- 나머지가 생길 시 예외 처리
+
+---
+### 3️⃣ 로또 발행
+- [x] `"%d개를 구매했습니다."` 메시지 출력
+- [x] 로또 번호를 나타내는 5개의 랜덤 숫자, 범위(1 ~ 30), 중복 X
+    - `Randoms.pickUniqueNumbersInRange(1, 30 ,5)`
+- [x] 로또 발행 수 `ex) 1000원 구입 금액이면 2번 로또를 발행`
+    - [x] 로또 번호를 리스트에 오름차순으로 저장
+    - [x] 저장된 로또 리스트 출력
+- [x] 로또 번호 예외 처리
+
+---
+### 4️⃣ 당첨 번호 입력 및 파싱
+- [x] `당첨 번호를 입력해 주세요.` 메시지 출력
+- [x] 당첨 번호 입력
+- [x] 당첨 번호 입력 예외 처리
+- [x] 당첨 번호 저장
+
+---
+### 5️⃣ 보너스 번호 입력
+- [x] `보너스 번호 번호를 입력해 주세요.` 메시지 출력
+- [x] 보너스 번호 입력
+- [x] 입력 예외 처리
+
+---
+### 6️⃣ 로또 당첨 통계
+- [x] `"당첨 통계"` 메시지 출력
+- [x] `---` 메시지 출력
+- [x] 로또 번호와 당첨 번호 비교하여 일치한 번호 수 구하기
+- [x] 일치한 번호 수가 1등 ~ 5등 중에 해당하면 해당 등수 +1
+    - ex) 비교 결과 3개 일치이면 5등 개수 0 -> 1 증가
+- [x] 당첨 내역 메시지 출력
+
+```text
+5개 일치 (100,000,000원) - 0개
+4개 일치, 보너스 번호 일치 (10,000,000원) - 0개
+4개 일치 (1,500,000원) - 0개
+3개 일치, 보너스 번호 일치 (500,000원) - 0개
+2개 일치, 보너스 번호 일치 (5,000원) - 1개
+0개 일치 (0원) - 1개
+  ```
+
+---
+### ⚠️ 예외 처리
+
+> **`구입금액 입력` 예외 처리**
+> - [x] 입력값이 비어있는지, 숫자인지, 정수형 범위를 넘었는지 전부 InputView의 NumberFormatException 예외로 잡음
+> - [x] 구입금액 % 500 = 나머지 값 존재 시 예외
+> - [x] 1인당 구입금액은 최소 500원에서 최대 20,000원
+
+> **`5개의 랜덤 로또 번호` 예외 처리**
+> - [x] 로또 번호가 5개인지
+> - [x] 로또 번호 5개가 중복이 아닌지
+> - [x] 로또 번호가 1 ~ 30 사이인지
+
+> **`당첨 번호 입력` 예외 처리**
+> - [x] 입력이 비어있는지
+> - [x] 문자열 리스트 -> 정수형 리스트 변환 시 숫자에 해당하는지
+> - [x] 입력값이 정수형 범위를 넘었는지 (예시: 9999999999999)
+> - [x] 당첨 번호 객체 만들면서 PlanetLotto를 생성하여 로또 번호 검증 같이함
+
+> **`보너스 번호 입력` 예외 처리**
+> - [x] 입력값이 비어있는지, 구입금액 입력값이 정수형 범위를 넘었는지 (예시: 9999999999999), 숫자인지 InputView에서 예외를 다 잡음
+> - [x] 1 ~ 30 범위에 속하는지
+> - [x] 보너스 번호와 당첨 번호가 중복일 경우
+
+---

src/main/java/planetlotto/Application.java

@@ -1,7 +1,13 @@
 package planetlotto;
 
+
+import planetlotto.view.InputView;
+import planetlotto.view.OutputView;
+
 public class Application {
     public static void main(String[] args) {
         // TODO: 프로그램 구현
+        PlanetLottoController planetLottoController = new PlanetLottoController();
+        planetLottoController.run();
     }
 }

src/main/java/planetlotto/PlanetLottoController.java

@@ -0,0 +1,99 @@
+package planetlotto;
+
+import java.util.List;
+import planetlotto.common.retry.RetryExecutor;
+import planetlotto.domain.BonusNumber;
+import planetlotto.domain.PlanetLottoMachine;
+import planetlotto.domain.PlanetLottoTickets;
+import planetlotto.domain.PurchaseAmount;
+import planetlotto.domain.WinningNumbers;
+import planetlotto.domain.policy.PlanetLottoResult;
+import planetlotto.infra.MissionUtilsPlanetLottoNumberGenerator;
+import planetlotto.view.InputView;
+import planetlotto.view.OutputView;
+
+public class PlanetLottoController {
+
+    public PlanetLottoController() {
+    }
+
+    public void run() {
+        PurchaseAmount purchaseAmount = getPurchasedAmount();
+
+        PlanetLottoTickets lottoTickets = getPlanetLottoTickets(createPlanetLottoMachine(),
+                getTicketCount(purchaseAmount));
+
+        WinningNumbers winningNumbers = getWinningNumbers();
+
+        BonusNumber bonusNumber = getBonusNumber(winningNumbers);
+
+        PlanetLottoResult planetLottoResult = getLottoResult(lottoTickets, winningNumbers, bonusNumber);
+
+        printPlanetLottoResult(planetLottoResult);
+    }
+
+    private PurchaseAmount getPurchasedAmount() {
+        return RetryExecutor.retryUntilValid(() -> {
+            int purchaseAmount = getUserInput();
+
+            return PurchaseAmount.of(purchaseAmount);
+        });
+    }
+
+    private int getUserInput() {
+        return InputView.askAmount();
+    }
+
+    private PlanetLottoMachine createPlanetLottoMachine() {
+        return PlanetLottoMachine.withGenerator(new MissionUtilsPlanetLottoNumberGenerator());
+    }
+
+    private int getTicketCount(PurchaseAmount purchaseAmount) {
+        return purchaseAmount.toTicketCount();
+    }
+
+    private PlanetLottoTickets getPlanetLottoTickets(PlanetLottoMachine planetLottoMachine, int ticketCount) {
+        List<List<Integer>> tickets = planetLottoMachine.issueTickets(ticketCount);
+        printTicketCountAndPurchasedLotto(tickets);
+        return PlanetLottoTickets.of(tickets);
+    }
+
+    private static void printTicketCountAndPurchasedLotto(List<List<Integer>> tickets) {
+        OutputView.printPurchasedLottos(tickets);
+        lineChange();
+    }
+
+    private WinningNumbers getWinningNumbers() {
+        return RetryExecutor.retryUntilValid(() -> {
+            List<Integer> winningLotto = InputView.askWinningLotto();
+            return WinningNumbers.of(winningLotto);
+        });
+    }
+
+    private BonusNumber getBonusNumber(WinningNumbers winningNumbers) {
+        return RetryExecutor.retryUntilValid(() -> {
+            lineChange();
+            int bonusNumber = InputView.askBonusNumber();
+            return BonusNumber.of(winningNumbers, bonusNumber);
+        });
+    }
+
+    private PlanetLottoResult getLottoResult(PlanetLottoTickets lottoTickets, WinningNumbers winningNumbers,
+                                             BonusNumber bonusNumber) {
+        return PlanetLottoResult.of(getRanks(lottoTickets, winningNumbers, bonusNumber));
+    }
+
+    private List<Integer> getRanks(PlanetLottoTickets lottoTickets, WinningNumbers winningNumbers,
+                                   BonusNumber bonusNumber) {
+        return lottoTickets.evaluateRanks(winningNumbers, bonusNumber);
+    }
+
+    private static void printPlanetLottoResult(PlanetLottoResult planetLottoResult) {
+        lineChange();
+        OutputView.printResult(planetLottoResult.getPlanetLottoResult());
+    }
+
+    private static void lineChange() {
+        System.out.print(System.lineSeparator());
+    }
+}

src/main/java/planetlotto/common/retry/RetryExecutor.java

@@ -0,0 +1,24 @@
+package planetlotto.common.retry;
+
+import java.util.function.Supplier;
+import planetlotto.message.developer.DeveloperErrorMessage;
+import planetlotto.view.OutputView;
+
+public class RetryExecutor {
+
+    private static final String ERROR_MESSAGE = "[ERROR] ";
+
+    private RetryExecutor() {
+        throw new AssertionError(DeveloperErrorMessage.CANNOT_INSTANCE_CLASS.format(RetryExecutor.class.getName()));
+    }
+
+    public static <T> T retryUntilValid(Supplier<T> supplier) {
+        do {
+            try {
+                return supplier.get();
+            } catch (IllegalArgumentException e) {
+                OutputView.printErrorMessage(e.getMessage());
+            }
+        } while (true);
+    }
+}

src/main/java/planetlotto/domain/BonusNumber.java

@@ -0,0 +1,33 @@
+package planetlotto.domain;
+
+import planetlotto.domain.policy.PlanetLottoPolicy;
+import planetlotto.message.user.PlanetLottoErrorMessage;
+
+public class BonusNumber {
+
+    private final int number;
+
+    private BonusNumber(WinningNumbers winningNumbers, int number) {
+        validate(winningNumbers, number);
+        this.number = number;
+    }
+
+    public static BonusNumber of(WinningNumbers winningNumbers, int number) {
+        return new BonusNumber(winningNumbers, number);
+    }
+
+    private void validate(WinningNumbers winningNumbers, int number) {
+        validateRange(number);
+        winningNumbers.validateNoDuplicateBonusNumber(number);
+    }
+
+    private void validateRange(int number) {
+        if ((number < PlanetLottoPolicy.MIN_NUMBER) || (number > PlanetLottoPolicy.MAX_NUMBER)) {
+            throw new IllegalArgumentException(PlanetLottoErrorMessage.OUT_OF_RANGE_NUMBER.getMessage());
+        }
+    }
+
+    public int number() {
+        return number;
+    }
+}

src/main/java/planetlotto/domain/PlanetLotto.java

@@ -0,0 +1,90 @@
+package planetlotto.domain;
+
+import java.util.List;
+import java.util.Objects;
+import planetlotto.domain.policy.PlanetLottoPolicy;
+import planetlotto.message.developer.DeveloperErrorMessage;
+import planetlotto.message.user.PlanetLottoErrorMessage;
+
+public class PlanetLotto {
+
+    private static final class LottoValidator {
+
+        private LottoValidator(List<Integer> numbers) {
+            throw new AssertionError(
+                    DeveloperErrorMessage.CANNOT_INSTANCE_CLASS.format(LottoValidator.class.getName()));
+        }
+
+        public static void validate(List<Integer> numbers) {
+            validateNotNullOrEmpty(numbers);
+            validateCount(numbers);
+            validateNoDuplicate(numbers);
+            validateRange(numbers);
+        }
+
+        private static void validateNotNullOrEmpty(List<Integer> numbers) {
+            if (numbers == null || numbers.isEmpty()) {
+                throw new IllegalArgumentException(DeveloperErrorMessage.NULL_VALUE.getMessage());
+            }
+        }
+
+        private static void validateCount(List<Integer> numbers) {
+            if (numbers.size() != PlanetLottoPolicy.NUMBER_COUNT) {
+                throw new IllegalArgumentException(PlanetLottoErrorMessage.INVALID_NUMBER_COUNT.getMessage());
+            }
+        }
+
+        private static void validateNoDuplicate(List<Integer> numbers) {
+            if (numbers.stream().distinct().count() != PlanetLottoPolicy.NUMBER_COUNT) {
+                throw new IllegalArgumentException(PlanetLottoErrorMessage.DUPLICATED_NUMBER.getMessage());
+            }
+        }
+
+        private static void validateRange(List<Integer> numbers) {
+            if (numbers.stream()
+                    .anyMatch(number -> (number < PlanetLottoPolicy.MIN_NUMBER) || (number > PlanetLottoPolicy.MAX_NUMBER))) {
+                throw new IllegalArgumentException(PlanetLottoErrorMessage.OUT_OF_RANGE_NUMBER.getMessage());
+            }
+        }
+    }
+
+    private final List<Integer> numbers;
+
+    private PlanetLotto(List<Integer> numbers) {
+        LottoValidator.validate(numbers);
+        this.numbers = List.copyOf(numbers);
+    }
+
+    public static PlanetLotto of(List<Integer> numbers) {
+        return new PlanetLotto(numbers);
+    }
+
+    public int countMatchWith(PlanetLotto winningLotto) {
+        return (int) numbers.stream()
+                .filter(winningLotto::isContain)
+                .count();
+    }
+
+    public boolean isContain(int number) {
+        return numbers.contains(number);
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (object == null || getClass() != object.getClass()) {
+            return false;
+        }
+        PlanetLotto lotto = (PlanetLotto) object;
+        return Objects.equals(numbers, lotto.numbers);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(numbers);
+    }
+
+    @Override
+    public String toString() {
+        return numbers.toString();
+    }
+}