Step3 리뷰요청드립니다

README.md

@@ -32,8 +32,15 @@
 
 ## 기능 구현 목록
 * domain
-  * LottoGenerator
-  * LottoChecker
+  * LottoFactory - 로또 생성 담당
+  * LottoGame - 당첨 복권 & 수익률 계산
+    * Lottos
+      * Lotto - 로또 복권 하나
+        * LottoNumber - 기본 로또 번호
+      * WinningLotto - Lotto + 보너스번호
+        * Money - 금액에 관련된 책임 수행
+    * LottoResult - 게임의 결과
+      * Rank - 당첨 순위 & 당첨금에 대한 역할
 * view
-  * InputView
-  * ResultView
+  * InputView - 입력 담당
+  * ResultView - 출력 담당

src/main/java/lotto/Main.java

@@ -1,20 +1,20 @@
 package lotto;
 
-import lotto.domain.Lotto;
 import lotto.domain.LottoGame;
 import lotto.domain.LottoResult;
+import lotto.domain.Money;
+import lotto.domain.WinningLotto;
 import lotto.view.InputView;
 import lotto.view.ResultView;
 
 public class Main {
     public static void main(String[] args) {
         long price = InputView.initLottoPrice();
         LottoGame lottoGame = new LottoGame(price);
-        ResultView.printLottos(lottoGame.lottos());
-
-        Lotto winningLotto = new Lotto(InputView.initWinningLotto());
-        LottoResult result = lottoGame.check(winningLotto);
-        ResultView.printResult(result, lottoGame);
+        ResultView.printLottos(lottoGame);
 
+        WinningLotto winningLotto = new WinningLotto(InputView.initWinningLotto(), InputView.initBonusNumber());
+        LottoResult result = lottoGame.findWinner(winningLotto);
+        ResultView.printResult(result, new Money(price));
     }
 }

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

@@ -1,28 +1,48 @@
 package lotto.domain;
 
 import java.util.*;
+import java.util.stream.Collectors;
 
 public class Lotto {
     public static final int LOTTO_NUMBER_SIZE = 6;
 
-    private final Set<Integer> numbers;
+    private final Set<LottoNumber> numbers;
 
     public Lotto() {
-        this(new TreeSet<>(LottoFactory.generateLotto()));
+        this(LottoFactory.generateLotto());
     }
 
     public Lotto(String value) {
         this(splitAndParseInt(value));
     }
 
-    private static Set<Integer> splitAndParseInt(String value) {
+    public Lotto(Integer... numbers) {
+        this(Arrays.asList(numbers));
+    }
+
+    public Lotto(List<Integer> numbers) {
+        this(convert(numbers));
+    }
+
+    public Lotto(Set<LottoNumber> numbers) {
+        validate(numbers);
+        this.numbers = Collections.unmodifiableSet(numbers);
+    }
+
+    private static Set<LottoNumber> convert(List<Integer> numbers) {
+        return numbers.stream()
+                .map(LottoNumber::from)
+                .collect(Collectors.toSet());
+    }
+
+    private static List<Integer> splitAndParseInt(String value) {
         String[] split = getSplit(value);
-        Set<Integer> numbers = strToIntSet(split);
+        List<Integer> numbers = strToIntSet(split);
         return numbers;
     }
 
-    private static Set<Integer> strToIntSet(String[] split) {
-        Set<Integer> numbers = new TreeSet<>();
+    private static List<Integer> strToIntSet(String[] split) {
+        List<Integer> numbers = new ArrayList<>();
         for (String s : split) {
             numbers.add(Integer.parseInt(s));
         }
@@ -33,39 +53,24 @@ private static String[] getSplit(String value) {
         return value.split(",");
     }
 
-    public Lotto(Integer... numbers) {
-        this(new TreeSet<>(Arrays.asList(numbers)));
-    }
-
-    public Lotto(Set<Integer> numbers) {
-        validate(numbers);
-        this.numbers = Collections.unmodifiableSet(numbers);
-    }
-
-    private void validate(Set<Integer> numbers) {
+    private void validate(Set<LottoNumber> numbers) {
         if (numbers.size() != LOTTO_NUMBER_SIZE) {
             throw new IllegalArgumentException();
         }
-
-        boolean invalidNumber = numbers.stream()
-                .anyMatch(n -> n < 1 || n > 45);
-        if (invalidNumber) {
-            throw new IllegalArgumentException();
-        }
     }
 
     public int match(Lotto winningLotto) {
         int count = 0;
-        for (Integer number : numbers) {
-            if (winningLotto.numbers().contains(number)) {
+        for (LottoNumber number : numbers) {
+            if (winningLotto.contains(number)) {
                 count++;
             }
         }
         return count;
     }
 
-    private Set<Integer> numbers() {
-        return numbers;
+    public boolean contains(LottoNumber number) {
+        return numbers.contains(number);
     }
 
     @Override

src/main/java/lotto/domain/LottoGame.java

@@ -1,6 +1,6 @@
 package lotto.domain;
 
-import java.util.List;
+import java.util.stream.Collectors;
 
 public class LottoGame {
     private final Lottos lottos;
@@ -19,15 +19,18 @@ public LottoGame(Lottos lottos, Money money) {
         this.money = money;
     }
 
-    public List<Lotto> lottos() {
-        return lottos.values();
+    public LottoResult findWinner(WinningLotto winningLotto) {
+        return lottos.findResult(winningLotto);
     }
 
-    public LottoResult check(Lotto winningLotto) {
-        return lottos.findResult(winningLotto);
+    public int lottoCount() {
+        return lottos.size();
     }
 
-    public double rateOfReturn(LottoResult result) {
-        return money.rateOfReturn(result.getTotal());
+    @Override
+    public String toString() {
+        return lottos.values().stream()
+                .map(Lotto::toString)
+                .collect(Collectors.joining("\n"));
     }
 }

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

@@ -0,0 +1,53 @@
+package lotto.domain;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.IntStream;
+
+public class LottoNumber {
+    public static final int MIN_NUMBER = 1;
+    public static final int MAX_NUMBER = 45;
+
+    private static final Map<Integer, LottoNumber> CACHE = new HashMap<>();
+
+    static {
+        IntStream.rangeClosed(MIN_NUMBER, MAX_NUMBER)
+                .forEach(i -> CACHE.put(i, new LottoNumber(i)));
+    }
+
+    private final int lottoNumber;
+
+    private LottoNumber(int lottoNumber) {
+        this.lottoNumber = lottoNumber;
+    }
+
+    public static LottoNumber from(int lottoNumber) {
+        validate(lottoNumber);
+        return CACHE.get(lottoNumber);
+    }
+
+    private static void validate(int lottoNumber) {
+        if (lottoNumber < MIN_NUMBER || lottoNumber > MAX_NUMBER) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (this == object) return true;
+        if (object == null || getClass() != object.getClass()) return false;
+        LottoNumber that = (LottoNumber) object;
+        return lottoNumber == that.lottoNumber;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(lottoNumber);
+    }
+
+    @Override
+    public String toString() {
+        return String.valueOf(lottoNumber);
+    }
+}

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

@@ -12,8 +12,7 @@ public LottoResult() {
         }
     }
 
-    public void addMatch(int match) {
-        Rank rank = Rank.from(match);
+    public void addMatch(Rank rank) {
         lottoResult.put(rank, lottoResult.get(rank) + 1);
     }
 
@@ -26,4 +25,8 @@ public long getTotal() {
                 .mapToLong(entry -> entry.getKey().prize() * entry.getValue())
                 .sum();
     }
+
+    public double profitRate(Money money) {
+        return getTotal() / money.getMoney();
+    }
 }

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

@@ -17,12 +17,15 @@ public List<Lotto> values() {
         return lottos;
     }
 
-    public LottoResult findResult(Lotto winningLotto) {
+    public LottoResult findResult(WinningLotto winningLotto) {
         LottoResult result = new LottoResult();
         for (Lotto lotto : lottos) {
-            int match = lotto.match(winningLotto);
-            result.addMatch(match);
+            result.addMatch(winningLotto.match(lotto));
         }
         return result;
     }
+
+    public int size() {
+        return lottos.size();
+    }
 }

src/main/java/lotto/domain/Money.java

@@ -20,7 +20,7 @@ public int buyCount() {
         return (int) (money / LOTTO_PRICE);
     }
 
-    public double rateOfReturn(long getTotal) {
-        return Math.round((double) (getTotal / money) * 100) / 100.0;
+    public double getMoney() {
+        return money;
     }
 }

src/main/java/lotto/domain/Rank.java

@@ -4,6 +4,7 @@
 
 public enum Rank {
     FIRST(6, 2_000_000_000),
+    SECOND(5, 30_000_000),
     THIRD(5, 1_500_000),
     FOURTH(4, 50_000),
     FIFTH(3, 5_000),
@@ -29,10 +30,18 @@ public boolean isMatch(int match) {
         return this.match == match;
     }
 
-    public static Rank from(int matchCount) {
+    public static Rank from(int matchCount, boolean matchBonus) {
         return Arrays.stream(values())
                 .filter(rank -> rank.isMatch(matchCount))
                 .findFirst()
+                .map(rank -> bonusCheck(rank, matchBonus))
                 .orElse(NONE);
     }
+
+    private static Rank bonusCheck(Rank rank, boolean matchBonus) {
+        if (rank == Rank.THIRD && matchBonus) {
+            return Rank.SECOND;
+        }
+        return rank;
+    }
 }

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

@@ -0,0 +1,30 @@
+package lotto.domain;
+
+public class WinningLotto {
+    private final Lotto winningLotto;
+    private final LottoNumber bonusNumber;
+
+    public WinningLotto(String lotto, int bonusNumber) {
+        this(new Lotto(lotto), bonusNumber);
+    }
+
+    public WinningLotto(Lotto lotto, int bonusNumber) {
+        this(lotto, LottoNumber.from(bonusNumber));
+    }
+
+    public WinningLotto(Lotto lotto, LottoNumber bonusNumber) {
+        validateBonusNumber(lotto, bonusNumber);
+        this.winningLotto = lotto;
+        this.bonusNumber = bonusNumber;
+    }
+
+    private void validateBonusNumber(Lotto lotto, LottoNumber bonusNumber) {
+        if (lotto.contains(bonusNumber)) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public Rank match(Lotto lotto) {
+        return Rank.from(winningLotto.match(lotto), lotto.contains(bonusNumber));
+    }
+}

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

@@ -14,4 +14,9 @@ public static String initWinningLotto() {
         System.out.println("지난 주 당첨 번호를 입력해 주세요.");
         return SCANNER.nextLine();
     }
+
+    public static int initBonusNumber() {
+        System.out.println("보너스 볼을 입력해 주세요.");
+        return SCANNER.nextInt();
+    }
 }