🚀 3단계 - 로또(2등)

src/main/java/lotto/LottoApplication.java

@@ -1,9 +1,6 @@
 package lotto;
 
-import lotto.domain.Lotto;
-import lotto.domain.LottoCalculator;
-import lotto.domain.LottoMachine;
-import lotto.domain.LottoResult;
+import lotto.domain.*;
 import lotto.view.InputView;
 import lotto.view.ResultView;
 
@@ -16,8 +13,10 @@ public static void main(String[] args) {
         List<Lotto> lottoList = machine.buy(purchaseAmount);
         ResultView.printLotto(lottoList);
         List<Integer> winningNumbers = InputView.getWinningNumbers();
+        int bonusNumber = InputView.getBonusNumber();
+        LottoWinnings lottoWinnings = new LottoWinnings(winningNumbers, bonusNumber);
         LottoCalculator calculator = new LottoCalculator();
-        LottoResult result = calculator.calculate(purchaseAmount, lottoList, winningNumbers);
+        LottoResult result = calculator.calculate(purchaseAmount, lottoList, lottoWinnings);
         ResultView.printResult(result);
     }
 }

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

@@ -3,18 +3,20 @@
 import java.util.*;
 
 public class Lotto {
-    private final List<Integer> numbers;
-    public final int MIN_NUMBER = 1;
-    public final int MAX_NUMBER = 45;
+    private final List<LottoNumber> numbers;
 
     public Lotto(List<Integer> numbers) {
-        validateNumbers(numbers);
-        this.numbers = numbers;
+        this.numbers = validateNumbers(numbers);
     }
 
-    private void validateNumbers(List<Integer> numbers) {
+    private List<LottoNumber> validateNumbers(List<Integer> numbers) {
         Objects.requireNonNull(numbers, "numbers must not be null");
 
+        List<LottoNumber> lottoNumbers = new ArrayList<>();
+        for (Integer number : numbers) {
+            lottoNumbers.add(new LottoNumber(number));
+        }
+
         if (numbers.size() != 6) {
             throw new IllegalArgumentException("Lotto numbers must contain exactly 6 numbers.");
         }
@@ -24,25 +26,11 @@ private void validateNumbers(List<Integer> numbers) {
             throw new IllegalArgumentException("Lotto numbers must be unique.");
         }
 
-        for (Integer number : numbers) {
-            if (number < MIN_NUMBER || number > MAX_NUMBER) {
-                throw new IllegalArgumentException("Lotto number " + number + " is out of valid range (1-45).");
-            }
-        }
+        return lottoNumbers;
     }
 
-    public int countMatches(List<Integer> winningNumbers) {
-        validateNumbers(winningNumbers);
-        int count = 0;
-        for (Integer number : this.numbers) {
-            if (winningNumbers.contains(number)) {
-                count++;
-            }
-        }
-        return count;
-    }
-
-    public List<Integer> getNumbers() {
+    public List<LottoNumber> getNumbers() {
         return numbers;
     }
+
 }

src/main/java/lotto/domain/LottoCalculator.java

@@ -6,17 +6,13 @@
 
 public class LottoCalculator {
 
-    public LottoResult calculate(int purchaseAmount, List<Lotto> lottoList, List<Integer> winningNumbers) {
-        long totalPrize = 0;
-        Map<Integer, Integer> matchCounts = new HashMap<>();
+    public LottoResult calculate(int purchaseAmount, List<Lotto> lottoList, LottoWinnings lottoWinnings) {
+        Map<LottoPrize, Integer> lottoPrizes = new HashMap<>();
         for (Lotto lotto : lottoList) {
-            int matchCount = lotto.countMatches(winningNumbers);
-            long prize = LottoPrize.getPrizeByMatchCount(matchCount);
-            totalPrize += prize;
-            matchCounts.put(matchCount, matchCounts.getOrDefault(matchCount, 0) + 1);
+            LottoPrize lottoPrize = lottoWinnings.countMatches(lotto);
+            lottoPrizes.put(lottoPrize, lottoPrizes.getOrDefault(lottoPrize, 0) + 1);
         }
-        double rate = (double) totalPrize / purchaseAmount;
-        return new LottoResult(matchCounts, rate);
+        return new LottoResult(lottoPrizes, purchaseAmount);
     }
 
 }

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

@@ -0,0 +1,40 @@
+package lotto.domain;
+
+import java.util.Objects;
+
+public class LottoNumber {
+    public static final int MIN_NUMBER = 1;
+    public static final int MAX_NUMBER = 45;
+
+    private final int value;
+
+    public LottoNumber(int value) {
+        if (value < MIN_NUMBER || value > MAX_NUMBER) {
+            throw new IllegalArgumentException("Lotto number " + value + " is out of valid range (" + MIN_NUMBER + "-" + MAX_NUMBER + ").");
+        }
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof LottoNumber)) return false;
+        LottoNumber that = (LottoNumber) o;
+        return value == that.value;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+
+    @Override
+    public String toString() {
+        return String.valueOf(value);
+    }
+
+}

src/main/java/lotto/domain/LottoPrize.java

@@ -1,33 +1,44 @@
 package lotto.domain;
 
 public enum LottoPrize {
-    THREE(3, 5000),
-    FOUR(4, 50000),
-    FIVE(5, 1500000),
-    SIX(6, 2000000000L);
+    FIRST(6, false, 2_000_000_000),
+    SECOND(5, true, 30_000_000),
+    THIRD(5, false, 1_500_000),
+    FOURTH(4, false, 50_000),
+    FIFTH(3, false, 5_000),
+    MISS(0, false, 0);
 
     private final int matchCount;
-    private final long prize;
+    private final boolean bonus;
+    private final int winningMoney;
 
-    LottoPrize(int matchCount, long prize) {
+    LottoPrize(int matchCount, boolean bonus, int winningMoney) {
         this.matchCount = matchCount;
-        this.prize = prize;
+        this.bonus = bonus;
+        this.winningMoney = winningMoney;
     }
 
     public int getMatchCount() {
         return matchCount;
     }
 
-    public long getPrize() {
-        return prize;
+    public int getWinningMoney() {
+        return winningMoney;
     }
 
-    public static long getPrizeByMatchCount(int count) {
-        for (LottoPrize lottoPrize : values()) {
-            if (lottoPrize.getMatchCount() == count) {
-                return lottoPrize.getPrize();
-            }
+    public static LottoPrize from(int matchCount, boolean bonusMatch) {
+        if (matchCount == 6) {
+            return FIRST;
         }
-        return 0;
+        if (matchCount == 5) {
+            return bonusMatch ? SECOND : THIRD;
+        }
+        if (matchCount == 4) {
+            return FOURTH;
+        }
+        if (matchCount == 3) {
+            return FIFTH;
+        }
+        return MISS;
     }
 }

src/main/java/lotto/domain/LottoResult.java

@@ -3,16 +3,28 @@
 import java.util.Map;
 
 public class LottoResult {
-    private final Map<Integer, Integer> matchCounts;
+    private final Map<LottoPrize, Integer> lottoPrizes;
     private final double rate;
 
-    public LottoResult(Map<Integer, Integer> matchCounts, double rate) {
-        this.matchCounts = matchCounts;
-        this.rate = rate;
+    public LottoResult(Map<LottoPrize, Integer> lottoPrizes, int purchaseAmount) {
+        this.lottoPrizes = lottoPrizes;
+        this.rate = calculateRate(purchaseAmount);
     }
 
-    public Map<Integer, Integer> getMatchCounts() {
-        return matchCounts;
+    private long calculateTotalWinningMoney() {
+        return lottoPrizes.entrySet()
+                .stream()
+                .mapToLong(entry -> (long) entry.getKey().getWinningMoney() * entry.getValue())
+                .sum();
+    }
+
+    public double calculateRate(int purchaseAmount) {
+        long totalWinningMoney = calculateTotalWinningMoney();
+        return (double) totalWinningMoney / purchaseAmount;
+    }
+
+    public Map<LottoPrize, Integer> getLottoPrizes() {
+        return lottoPrizes;
     }
 
     public double getRate() {

src/main/java/lotto/domain/LottoWinnings.java

@@ -0,0 +1,37 @@
+package lotto.domain;
+
+import java.util.List;
+
+public class LottoWinnings extends Lotto {
+    private final LottoNumber bonusNumber;
+
+    public LottoWinnings(List<Integer> numbers, int bonusNumber) {
+        super(numbers);
+        validateBonusNumber(numbers, bonusNumber);
+        this.bonusNumber = new LottoNumber(bonusNumber);
+    }
+
+    private void validateBonusNumber(List<Integer> numbers, int bonusNumber) {
+        if (numbers.contains(bonusNumber)) {
+            throw new IllegalArgumentException("Bonus number must not be one of the winning numbers.");
+        }
+    }
+
+    public boolean isBonusMatch(LottoNumber number) {
+        return bonusNumber.equals(number);
+    }
+
+    public LottoPrize countMatches(Lotto lotto) {
+        int count = 0;
+        boolean bonusMatch = false;
+        for (LottoNumber number : lotto.getNumbers()) {
+            if (getNumbers().contains(number)) {
+                count++;
+            }
+            if (isBonusMatch(number)) {
+                bonusMatch = true;
+            }
+        }
+        return LottoPrize.from(count, bonusMatch);
+    }
+}

src/main/java/lotto/view/InputView.java

@@ -18,6 +18,12 @@ public static List<Integer> getWinningNumbers() {
         return parseNumbers(input);
     }
 
+    public static int getBonusNumber() {
+        System.out.println("보너스 볼을 입력해 주세요.");
+        String input = scanner.nextLine();
+        return Integer.parseInt(input.trim());
+    }
+
     private static List<Integer> parseNumbers(String input) {
         String[] parts = input.split(",");
         List<Integer> numbers = new ArrayList<>();

src/main/java/lotto/view/ResultView.java

@@ -5,6 +5,7 @@
 import lotto.domain.LottoResult;
 
 import java.util.List;
+import java.util.Map;
 
 public class ResultView {
 
@@ -16,10 +17,20 @@ public static void printLotto(List<Lotto> lottoList) {
     }
 
     public static void printResult(LottoResult result) {
+        Map<LottoPrize, Integer> lottoPrizes = result.getLottoPrizes();
         System.out.println("당첨 통계");
         System.out.println("---------");
-        for (int i = 3; i <= 6; i++) {
-            System.out.println(i + "개 일치 (" + LottoPrize.getPrizeByMatchCount(i) + "원)- " + result.getMatchCounts().getOrDefault(i, 0) + "개");
+        for (Map.Entry<LottoPrize, Integer> entry : lottoPrizes.entrySet()) {
+            LottoPrize lottoPrize = entry.getKey();
+            int lottoPrizeCount = entry.getValue();
+            if (lottoPrize == LottoPrize.MISS) {
+                continue;
+            }
+            if (lottoPrize == LottoPrize.SECOND) {
+                System.out.println(lottoPrize.getMatchCount() + "개 일치, 보너스 볼 일치 (" + lottoPrize.getWinningMoney() + "원)- " + lottoPrizeCount + "개");
+                continue;
+            }
+            System.out.println(lottoPrize.getMatchCount() + "개 일치 (" + lottoPrize.getWinningMoney() + "원)- " + lottoPrizeCount + "개");
         }
         System.out.printf("총 수익률은 %,.2f입니다.%n", result.getRate());
     }

src/test/java/lotto/domain/LottoPrizeTest.java

@@ -0,0 +1,48 @@
+package lotto.domain;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class LottoPrizeTest {
+
+    @Test
+    @DisplayName("매치 6개일 경우 FIRST 반환 확인")
+    public void testFirstPrize() {
+        assertEquals(LottoPrize.FIRST, LottoPrize.from(6, false));
+    }
+
+    @Test
+    @DisplayName("매치 5개 + 보너스 매치일 경우 SECOND 반환 확인")
+    public void testSecondPrize() {
+        assertEquals(LottoPrize.SECOND, LottoPrize.from(5, true));
+    }
+
+    @Test
+    @DisplayName("매치 5개이나 보너스 미매치일 경우 THIRD 반환 확인")
+    public void testThirdPrize() {
+        assertEquals(LottoPrize.THIRD, LottoPrize.from(5, false));
+    }
+
+    @Test
+    @DisplayName("매치 4개일 경우 FOURTH 반환 확인")
+    public void testFourthPrize() {
+        assertEquals(LottoPrize.FOURTH, LottoPrize.from(4, true));
+        assertEquals(LottoPrize.FOURTH, LottoPrize.from(4, false));
+    }
+
+    @Test
+    @DisplayName("매치 3개일 경우 FIFTH 반환 확인")
+    public void testFifthPrize() {
+        assertEquals(LottoPrize.FIFTH, LottoPrize.from(3, true));
+        assertEquals(LottoPrize.FIFTH, LottoPrize.from(3, false));
+    }
+
+    @Test
+    @DisplayName("매치가 2개 이하인 경우 MISS 반환 확인")
+    public void testMissPrize() {
+        assertEquals(LottoPrize.MISS, LottoPrize.from(2, false));
+        assertEquals(LottoPrize.MISS, LottoPrize.from(0, false));
+    }
+}

src/test/java/lotto/domain/LottoTest.java

@@ -37,7 +37,6 @@ public void testDuplicateNumbers() {
     @Test
     @DisplayName("범위를 벗어난 번호가 있을 때 IllegalArgumentException 발생 확인")
     public void testOutOfRangeNumbers() {
-        // 0은 유효 범위(1~45)를 벗어남
         List<Integer> numbers = Arrays.asList(0, 2, 3, 4, 5, 6);
         assertThrows(IllegalArgumentException.class, () -> new Lotto(numbers));
     }