ewhk9887/korean_code_reviews_from_github huggingface dataset:
@@ -0,0 +1,42 @@
+package blackjack.domain.card;
+
+import blackjack.domain.score.ScoreCalculator;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class CardBundle {
+
+    private static final int BLACK_JACK_SCORE = 21;
+
+    private final List<Card> cards;
+
+    private CardBundle() {
+        this.cards = new ArrayList<>();
+    }
+
+    public static CardBundle emptyBundle() {
+        return new CardBundle();
+    }
+
+    public void addCard(Card card) {
+        cards.add(card);
+    }
+
+    public int calculateScore() {
+        return ScoreCalculator.findByCards(cards)
+            .calculateScore(cards);
+    }
+
+    public List<Card> getCards() {
+        return Collections.unmodifiableList(cards);
+    }
+
+    public boolean isBurst() {
+        return calculateScore() > BLACK_JACK_SCORE;
+    }
+
+    public boolean isBlackJack() {
+        return calculateScore() == BLACK_JACK_SCORE;
+    }
+}

리뷰: `CardBundle` 객체는 **카드의 점수를 합산하는 역할**을 수행한다고 생각해요. 🤔 
`ScoreCalculator` enum class 내부 코드는 매우 흥미롭게 봤어요. 😃 👍
하지만 `AceScoreStrategy`, `DefaultScoreStrategy`의 내부 코드를 보았을 때, 이런 식으로 (카드 점수 합산) 전략을 구분하여 구현하는 것보다 카드 점수 합산 로직이 필요한 `CardBundle 객체 내부`에 직접 구현하는 것이 더 응집성이 높다고 생각해요. 😃 

지금의 코드에서 `점수를 합산`하는 기능을 파악하기가 어려운 것 같아요. 🤔 (아래와 같이 코드를 탐색해야 해요. 😱)
`calculateScore()` -> `ScoreCalculator#findByCards(cards)` ->  `ScoreCalculator#isSupportable(cards)` -> `ScoreCalculator#calculateScore(cards)` -> (AceScoreStrategy & DefaultScoreStrategy)`scoreStrategy.calculateScore(cards)`

또한 `ScoreCalculator`의 함수를 호출할 때마다, 계속해서 메서드 파라미터(= 외부)로 cards를 전달하고 있어요. 👀
이런 부분에서 `카드 점수를 합산`하는 기능은 객체의 역할이 아니라 CardBundle의 역할이라고 생각돼요. 🤔
@@ -0,0 +1,51 @@
+package blackjack.domain.report;
+
+import java.util.Objects;
+
+public class GameReport {
+
+    private final String name;
+    private final GameResult result;
+
+    public GameReport(String name, GameResult result) {
+        this.name = name;
+        this.result = result;
+    }
+
+    public String name() {
+        return name;
+    }
+
+    public String message() {
+        return result.message();
+    }
+
+    public boolean isWin() {
+        return result == GameResult.WIN;
+    }
+
+    public boolean isDraw() {
+        return result == GameResult.DRAW;
+    }
+
+    public boolean isLose() {
+        return result == GameResult.LOSE;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        GameReport report = (GameReport) o;
+        return Objects.equals(name, report.name) && result == report.result;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, result);
+    }
+}

리뷰: GameReport 객체의 `동등성`을 정의할 필요가 있나요? 🤔  
혹시 필요한 위치가 있을까요? 👀 (제가 못 찾는 걸까요? 🙄)
@@ -0,0 +1,52 @@
+package blackjack.domain.report;
+
+import blackjack.domain.card.CardBundle;
+import java.util.Arrays;
+
+public enum GameResult {
+
+    WIN(1, "승"),
+    DRAW(0, "무"),
+    LOSE(-1, "패");
+
+    private final int result;
+    private final String message;
+
+    GameResult(int result, String message) {
+        this.result = result;
+        this.message = message;
+    }
+
+    public static GameResult comparing(CardBundle playerCardBundle, CardBundle dealerCardBundle) {
+        isComparable(playerCardBundle, dealerCardBundle);
+        if (playerCardBundle.isBurst()) {
+            return GameResult.LOSE;
+        }
+        if (dealerCardBundle.isBurst()) {
+            return GameResult.WIN;
+        }
+        int result = Integer.compare(playerCardBundle.calculateScore(),
+            dealerCardBundle.calculateScore());
+        return findResult(result);
+    }
+
+    public String message() {
+        return message;
+    }
+
+    private static void isComparable(CardBundle dealerCardBundle, CardBundle playerCardBundle) {
+        if (dealerCardBundle == null) {
+            throw new IllegalArgumentException("[ERROR] 딜러의 카드가 비었습니다");
+        }
+        if (playerCardBundle == null) {
+            throw new IllegalArgumentException("[ERROR] 플레이어의 카드가 비었습니다.");
+        }
+    }
+
+    private static GameResult findResult(int result) {
+        return Arrays.stream(values())
+            .filter(gameResult -> gameResult.result == result)
+            .findFirst()
+            .orElseThrow(() -> new IllegalArgumentException("[ERROR] 올바르지 않은 값 입니다"));
+    }
+}

리뷰: getter (getter 역할을 하는 메서드), setter, compareTo, toString 등의 메서드는 클래스의 최하단에 위치시켜주세요!
@@ -0,0 +1,52 @@
+package blackjack.domain.report;
+
+import blackjack.domain.card.CardBundle;
+import java.util.Arrays;
+
+public enum GameResult {
+
+    WIN(1, "승"),
+    DRAW(0, "무"),
+    LOSE(-1, "패");
+
+    private final int result;
+    private final String message;
+
+    GameResult(int result, String message) {
+        this.result = result;
+        this.message = message;
+    }
+
+    public static GameResult comparing(CardBundle playerCardBundle, CardBundle dealerCardBundle) {
+        isComparable(playerCardBundle, dealerCardBundle);
+        if (playerCardBundle.isBurst()) {
+            return GameResult.LOSE;
+        }
+        if (dealerCardBundle.isBurst()) {
+            return GameResult.WIN;
+        }
+        int result = Integer.compare(playerCardBundle.calculateScore(),
+            dealerCardBundle.calculateScore());
+        return findResult(result);
+    }
+
+    public String message() {
+        return message;
+    }
+
+    private static void isComparable(CardBundle dealerCardBundle, CardBundle playerCardBundle) {
+        if (dealerCardBundle == null) {
+            throw new IllegalArgumentException("[ERROR] 딜러의 카드가 비었습니다");
+        }
+        if (playerCardBundle == null) {
+            throw new IllegalArgumentException("[ERROR] 플레이어의 카드가 비었습니다.");
+        }
+    }
+
+    private static GameResult findResult(int result) {
+        return Arrays.stream(values())
+            .filter(gameResult -> gameResult.result == result)
+            .findFirst()
+            .orElseThrow(() -> new IllegalArgumentException("[ERROR] 올바르지 않은 값 입니다"));
+    }
+}

리뷰: 두 CardBundle (사실상 두 번째, 파라미터로 받는 CardBundle은 Dealer의 CardBundle로 고정되는 것 같아요. 👀)을 받아서 `게임 결과`를 반환하는 역할은 `Dealer`의 역할이라고 볼 수 있지 않을까요? 🤔 (그러면 첫 번째 파라미터와 두 번째 파라미터의 순서를 잘못 대입한다거나 하는 실수를 막을 수도 있을 것 같아요. 😃)
@@ -0,0 +1,45 @@
+package blackjack.domain.request;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class UserNamesRequest {
+
+    private static final String USER_NAME_DELIMITER = ",";
+
+    private final List<String> userNames;
+
+    private UserNamesRequest(List<String> userNames) {
+        this.userNames = userNames;
+    }
+
+    public static UserNamesRequest from(String userNames) {
+        validateUserNames(userNames);
+        List<String> splitUserNames = Arrays.stream(userNames.split(USER_NAME_DELIMITER))
+            .map(String::trim)
+            .collect(Collectors.toList());
+        validateDuplicate(splitUserNames);
+        return new UserNamesRequest(splitUserNames);
+    }
+
+    public List<String> userNames() {
+        return Collections.unmodifiableList(userNames);
+    }
+
+    private static void validateUserNames(String userNames) {
+        if (userNames == null || userNames.trim().isEmpty()) {
+            throw new IllegalArgumentException("[ERROR] 이름을 입력해 주세요");
+        }
+    }
+
+    private static void validateDuplicate(List<String> splitUserNames) {
+        Set<String> removeDuplicate = new HashSet<>(splitUserNames);
+        if (removeDuplicate.size() != splitUserNames.size()) {
+            throw new IllegalArgumentException("[ERROR] 플레이어 이름은 중복될 수 없습니다");
+        }
+    }
+}

리뷰: 이 유효성 검증 로직은 블랙잭 도메인 모델에 꼭 필요한 유효성 검증인 것 같아요. 👀
먼저 Player의 상태 값인 원시 값 name을 포장해보면 어떨까요? 🤗
@@ -0,0 +1,55 @@
+package blackjack.domain.user;
+
+import blackjack.domain.card.Card;
+import blackjack.domain.card.CardBundle;
+import java.util.List;
+
+public class Player {
+
+    protected final CardBundle cardBundle;
+    private final String name;
+
+    public Player(String name) {
+        validateName(name);
+        this.name = name;
+        this.cardBundle = CardBundle.emptyBundle();
+    }
+
+    private void validateName(String name) {
+        if (name == null || name.trim().length() == 0) {
+            throw new IllegalArgumentException("[ERROR] 올바르지 않은 이름의 입력 값입니다.");
+        }
+    }
+
+    public void drawCard(Card card) {
+        this.cardBundle.addCard(card);
+    }
+
+    public String name() {
+        return name;
+    }
+
+    public boolean isPlayer() {
+        return true;
+    }
+
+    public boolean isDealer() {
+        return false;
+    }
+
+    public int score() {
+        return cardBundle.calculateScore();
+    }
+
+    public boolean isDrawable() {
+        return !cardBundle.isBlackJack() && !cardBundle.isBurst();
+    }
+
+    public List<Card> getCardBundle() {
+        return cardBundle.getCards();
+    }
+
+    public boolean isBlackJack() {
+        return cardBundle.isBlackJack();
+    }
+}

리뷰: String의 `isEmpty` 함수를 대신 사용해보면 어떨까요? 😃
```suggestion
        if (name == null || name.trim().isEmpty()) {
```
@@ -0,0 +1,33 @@
+package blackjack.domain.user;
+
+import blackjack.domain.report.GameResult;
+import blackjack.domain.report.GameReport;
+
+public class Dealer extends Player {
+
+    private static final int DEALER_MUST_DRAW_SCORE = 16;
+
+    public Dealer() {
+        super("딜러");
+    }
+
+    public GameReport createReport(Player player) {
+        GameResult gameResult = GameResult.comparing(player.cardBundle, this.cardBundle);
+        return new GameReport(player.name(), gameResult);
+    }
+
+    @Override
+    public boolean isPlayer() {
+        return false;
+    }
+
+    @Override
+    public boolean isDealer() {
+        return true;
+    }
+
+    @Override
+    public boolean isDrawable() {
+        return score() <= DEALER_MUST_DRAW_SCORE;
+    }
+}

리뷰: Dealer가 온전한 Player 클래스를 바로 상속받았기 때문에 어떤 메서드를 재정의해야 하는지 파악하기 어려운 것 같아요. 🤔
공통으로 사용하는 메서드는 그대로 사용할 수 있게 하되, 하위 구현체에 따라 달라지는 기능들은 `추상 메서드`로 정의해서 하위 구현체에서는 재정의를 강제하도록 하면 좋지 않을까요? 😃
@@ -0,0 +1,33 @@
+package blackjack.domain.user;
+
+import blackjack.domain.report.GameResult;
+import blackjack.domain.report.GameReport;
+
+public class Dealer extends Player {
+
+    private static final int DEALER_MUST_DRAW_SCORE = 16;
+
+    public Dealer() {
+        super("딜러");
+    }
+
+    public GameReport createReport(Player player) {
+        GameResult gameResult = GameResult.comparing(player.cardBundle, this.cardBundle);
+        return new GameReport(player.name(), gameResult);
+    }
+
+    @Override
+    public boolean isPlayer() {
+        return false;
+    }
+
+    @Override
+    public boolean isDealer() {
+        return true;
+    }
+
+    @Override
+    public boolean isDrawable() {
+        return score() <= DEALER_MUST_DRAW_SCORE;
+    }
+}

리뷰: GameReport 객체의 상태 값으로 Player의 이름을 받는게 아니라 `Player`를 가지면 어떨까요? 🤔
@@ -0,0 +1,82 @@
+package blackjack.view;
+
+import static blackjack.domain.user.Players.START_CARD_INIT_SIZE;
+
+import blackjack.domain.report.GameReports;
+import blackjack.domain.card.Card;
+import blackjack.domain.user.Player;
+import blackjack.domain.user.Players;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class OutputView {
+
+    private OutputView() {
+    }
+
+    public static void printAllPlayersCard(Players players) {
+        List<Player> candiates = players.findOnlyPlayers();
+        Player dealer = players.findDealer();
+        System.out.printf("\n딜러와 %s에게 %d장 나누었습니다.\n", collectPlayerNames(candiates),
+            START_CARD_INIT_SIZE);
+        System.out.printf("%s : %s\n", dealer.name(), collectDealerCard(dealer));
+        candiates.forEach(OutputView::printEachCardInfo);
+        System.out.println();
+    }
+
+    public static void printEachCardInfo(Player player) {
+        System.out.printf("%s : %s\n", player.name(), collectPlayerCard(player));
+    }
+
+    public static void printDealerGetCard() {
+        System.out.println("\n딜러는 16이하라 한장의 카드를 더 받았습니다.");
+    }
+
+    public static void printResultStatus(List<Player> players) {
+        System.out.println();
+        players.forEach(OutputView::showEachResult);
+    }
+
+    public static void printReports(GameReports reports) {
+        System.out.println("\n## 최종 승패");
+        showDealerReports(reports);
+        reports.reports()
+            .stream()
+            .map(report -> String.format("%s: %s", report.name(), report.message()))
+            .forEach(System.out::println);
+    }
+
+    private static void showDealerReports(GameReports reports) {
+        int dealerWinCount = reports.getPlayerLoseCount();
+        int drawCount = reports.getPlayerDrawCount();
+        int dealerLoseCount = reports.getPlayerWinCount();
+        System.out.printf("딜러: %d승 %d무 %d패\n", dealerWinCount, drawCount, dealerLoseCount);
+    }
+
+    private static String collectPlayerNames(List<Player> candiates) {
+        return candiates.stream()
+            .map(Player::name)
+            .collect(Collectors.joining(","));
+    }
+
+    private static String collectDealerCard(Player dealer) {
+        List<Card> cards = dealer.getCardBundle();
+        return makeCardInfo(cards.get(0));
+    }
+
+    private static String makeCardInfo(Card card) {
+        return String.join("", card.message(), card.suit());
+    }
+
+    private static String collectPlayerCard(Player player) {
+        List<Card> cards = player.getCardBundle();
+        return cards.stream()
+            .map(OutputView::makeCardInfo)
+            .collect(Collectors.joining(", "));
+    }
+
+    private static void showEachResult(Player player) {
+        System.out.printf("%s카드: %s - 결과 : %d\n", player.name(), collectPlayerCard(player),
+            player.score());
+    }
+}

리뷰: `findOnlyPlayers`와 `findDealer`는 비즈니스 로직이기 때문에 Model의 영역이라고 볼 수 있어요. 👀
Controller에서 두 메서드를 호출한 뒤, 메서드 파라미터로 그 결과 값들을 전달받도록 변경해주세요! 🙏
@@ -0,0 +1,34 @@
+package blackjack.domain.card;
+
+public enum Number {
+
+    ACE(1, "A"),
+    TWO(2, "2"),
+    THREE(3, "3"),
+    FOUR(4, "4"),
+    FIVE(5, "5"),
+    SIX(6, "6"),
+    SEVEN(7, "7"),
+    EIGHT(8, "8"),
+    NINE(9, "9"),
+    TEN(10, "10"),
+    JACK(10, "J"),
+    QUEEN(10, "Q"),
+    KING(10, "K");
+
+    private final int score;
+    private final String message;
+
+    Number(int score, String message) {
+        this.score = score;
+        this.message = message;
+    }
+
+    public int score() {
+        return score;
+    }
+
+    public String message() {
+        return message;
+    }
+}

리뷰: 저는 `getXXX`과 같은 네이밍이 오히려 내부 속성을 노출한다고 생각해서
`의미있는 네이밍의 메서드를 사용하는게 더 낫지 않을까?` 라는 생각으로 메서드의 네이밍을 작성해보았는데

해당에 대해서도 `getXXX`으로 통일하는게 더 좋을까요?
@@ -0,0 +1,42 @@
+package blackjack.domain.card;
+
+import blackjack.domain.score.ScoreCalculator;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class CardBundle {
+
+    private static final int BLACK_JACK_SCORE = 21;
+
+    private final List<Card> cards;
+
+    private CardBundle() {
+        this.cards = new ArrayList<>();
+    }
+
+    public static CardBundle emptyBundle() {
+        return new CardBundle();
+    }
+
+    public void addCard(Card card) {
+        cards.add(card);
+    }
+
+    public int calculateScore() {
+        return ScoreCalculator.findByCards(cards)
+            .calculateScore(cards);
+    }
+
+    public List<Card> getCards() {
+        return Collections.unmodifiableList(cards);
+    }
+
+    public boolean isBurst() {
+        return calculateScore() > BLACK_JACK_SCORE;
+    }
+
+    public boolean isBlackJack() {
+        return calculateScore() == BLACK_JACK_SCORE;
+    }
+}

리뷰: `empty()`도 괜찮은 네이밍이라고 생각했지만,
해당 번들이 비어있다는 의미(`isEmpty()`)와 유사하게 해석될 수도 있다고 생각했습니다.
@@ -0,0 +1,51 @@
+package blackjack.domain.report;
+
+import java.util.Objects;
+
+public class GameReport {
+
+    private final String name;
+    private final GameResult result;
+
+    public GameReport(String name, GameResult result) {
+        this.name = name;
+        this.result = result;
+    }
+
+    public String name() {
+        return name;
+    }
+
+    public String message() {
+        return result.message();
+    }
+
+    public boolean isWin() {
+        return result == GameResult.WIN;
+    }
+
+    public boolean isDraw() {
+        return result == GameResult.DRAW;
+    }
+
+    public boolean isLose() {
+        return result == GameResult.LOSE;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        GameReport report = (GameReport) o;
+        return Objects.equals(name, report.name) && result == report.result;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, result);
+    }
+}

리뷰: 아 처음에 GameReports의 `Set`을 의도하고 구현했는데 지금은 불필요한 메서드라고 생각되어 삭제하겠습니다!
@@ -0,0 +1,21 @@
+package lotto.constants;
+
+public enum ErrorMessage {
+    DUPLICATION("[ERROR] 값이 중복되었습니다"),
+    ISNOTINTEGER("[ERROR] 숫자를 입력해주세요"),
+    SIXNUMBER("[ERROR] 번호 6개를 입력해주세요"),
+    OUTFRANGE("[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다."),
+    ONENUMBER("[ERROR] 숫자 번호 1개를 입력해주세요"),
+    NOTTHOUSAND("[ERROR] 1000원 단위로 입력해 주세요");
+
+
+    private final String message;
+
+    ErrorMessage(String message) {
+        this.message = message;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+}

리뷰: 중복되는 부분에 대해서 상수처리 해줘도 좋을거같아요
@@ -0,0 +1,50 @@
+package lotto.controller;
+
+import lotto.model.Lotto;
+import lotto.model.LottoNumberMaker;
+import lotto.model.LottoPercentageCalculation;
+import lotto.model.constants.LottoPrize;
+import lotto.view.LottoInput;
+import lotto.view.LottoOutput;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.util.Arrays.asList;
+import static lotto.model.constants.LottoPrize.*;
+
+public class LottoController {
+    private static final LottoNumberMaker lottoNumberMaker = new LottoNumberMaker();
+    private static final LottoInput lottoInput = new LottoInput();
+    private static final LottoOutput lottoOutput = new LottoOutput();
+    private static final LottoPercentageCalculation lottoPercentageCalculation = new LottoPercentageCalculation();
+    public static void setPrice() {
+        lottoNumberMaker.checkInt();
+    }
+
+//    static List<LottoPrize> LottoPrizelist= asList(FIFTH_PRIZE,FOURTH_PRIZE,THIRD_PRIZE,SECOND_PRIZE,FIRST_PRIZE);
+    public static void setBuyLottoNumberPrint() {
+        lottoOutput.buyLottoNumberPrint(lottoNumberMaker.getLottoNumber());
+    }
+
+    public static void setPrizeNumberInput() {
+        Lotto lotto = new Lotto(lottoInput.prizeNumberInput());
+        lotto.checkSame(lottoInput.bonusNumberInput(),lottoNumberMaker.getLottoNumber());
+    }
+
+    public static void winningStatistic() {
+        List<String> lottoPrizes = new ArrayList<>();
+        for(LottoPrize lottoPrize: LottoPrize.values()){
+            lottoPrizes.add(lottoPrize.getText()+lottoPrize.getWinCount()+lottoPrize.getUnit());
+        }
+        LottoOutput.seeWinningStatstic(lottoPrizes);
+    }
+
+    public static void PerformanceCalculation() {
+        lottoOutput.seePercentage(lottoPercentageCalculation.percentageCalculation(LottoPrize.values(),lottoNumberMaker.getBuyPrice()));
+    }
+
+    public String askPrice() {
+        return lottoInput.askPrice();
+    }
+}
\ No newline at end of file

리뷰: 컨트롤러 안에 대부분의 메서드와 변수를 static 처리한 별도의 이유가 있나요?
@@ -0,0 +1,79 @@
+package lotto.model;
+
+import lotto.model.constants.LottoPrize;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Predicate;
+
+import static lotto.constants.ErrorMessage.DUPLICATION;
+import static lotto.constants.ErrorMessage.SIXNUMBER;
+import static lotto.model.constants.LottoPrize.*;
+public class Lotto {
+    private final List<Integer> numbers;
+
+    public Lotto(List<Integer> numbers) {
+        validate(numbers);
+        duplicate(numbers);
+        this.numbers = numbers;
+    }
+
+    private void duplicate(List<Integer> numbers) {
+                List<Integer> duplication = numbers.stream()
+                        .distinct()
+                        .toList();
+                if (duplication.size() != numbers.size()) {
+                    throw new IllegalArgumentException(DUPLICATION.getMessage());
+                }
+    }
+
+    private void validate(List<Integer> numbers) {
+                if (numbers.size() != 6) {
+                    throw new IllegalArgumentException(SIXNUMBER.getMessage());
+        }
+    }
+    public void checkSame(Integer bonusNumber, List<List<Integer>> lottoNumber) {
+        bonusDuplication(bonusNumber);
+        for (List<Integer> integers : lottoNumber) {
+            List<Integer> Result = integers.stream()
+                    .filter(i -> this.numbers.stream().anyMatch(Predicate.isEqual(i)))
+                    .toList();
+            long bonusResult = integers.stream()
+                    .filter(bonusNumber::equals).count();
+            CheckPrize(Result.size(), bonusResult).addWinCount();
+
+        }
+    }
+
+    private void bonusDuplication(Integer bonusNumber) {
+        List<Integer> Result = this.numbers.stream()
+                .filter(i-> !Objects.equals(i, bonusNumber))
+                .toList();
+        if(Result.size()!=6){
+            throw new IllegalArgumentException(DUPLICATION.getMessage());
+        }
+
+    }
+
+    public LottoPrize CheckPrize(int result, long bonusResult){
+        if(result==6){
+            return FIRST_PRIZE;
+        }
+        if(result==5&&bonusResult==1){
+            return SECOND_PRIZE;
+        }
+        if(result==5&&bonusResult==0){
+            return THIRD_PRIZE;
+        }
+        if(result==4){
+            return FOURTH_PRIZE;
+        }
+        if(result==3){
+            return FIFTH_PRIZE;
+        }
+        if(result<3){
+            return LOOSE;
+        }
+        throw new IllegalArgumentException("존재 하지 않는 순위입니다.");
+    }
+}

리뷰: bonus의 경우 long형을 사용한 이유가 있나요?
그리고 해당 메서드가 lotto 도메인에서 꼭 선언되야 하는 이유가 있는지 궁금합니다 !!(lotto객체가 가지는 변수를 사용하지 않은거 같아서요 !!)