🎰로또 게임 (MVC 패턴) #2022.02.21~2022.03.05

🚀 기능 요구사항

• 로또 게임 기능을 구현해야 한다. 규칙을 모르면 검색해 로또 규칙을 찾아본다.
• 로또 구입 금액을 입력하면 구입 금액에 해당하는 로또를 발급해야 한다.
• 로또 1장의 가격은 1000원이다.
• 로또 당첨 금액은 고정되어 있는 것으로 가정한다.
• 수익률을 계산해 출력해야 한다.

 

✍🏻 입출력 요구사항

⌨️ 입력

• 로또 구입 금액
• 로또 당첨번호
• 로또 보너스 번호

🖥 출력

• 구입한 로또 개수만큼 생성된 로또번호 목록

3개를 구매했습니다.
[8, 21, 23, 41, 42, 43]
[1, 3, 6, 7, 33, 37]
[6, 16, 25, 29, 39, 45]

• 당첨 통계

당첨 통계
--------------
3개 일치 (5000원) - 1개
4개 일치 (50000원) - 0개
5개 일치 (1500000원) - 0개
5개 일치, 보너스 볼 일치 (30000000원) - 0개
총 수익률은 1.66입니다.

💻 프로그래밍 실행 결과 예시

구입금액을 입력해 주세요.
3000

3개를 구매했습니다.
[8, 21, 23, 41, 42, 43]
[1, 3, 6, 7, 33, 37]
[6, 16, 25, 29, 39, 45]

지난 주 당첨번호를 입력해 주세요.
1,2,3,4,5,6
보너스 볼을 입력해주세요.
7

당첨 통계
--------------
3개 일치 (5000원) - 1개
4개 일치 (50000원) - 0개
5개 일치 (1500000원) - 0개
5개 일치, 보너스 볼 일치 (30000000원) - 0개
총 수익률은 1.66입니다.
… 

 

### MVC 패턴 분리 

###

- 같은 클래스 내에서 호출되는 메서드는 private으로 선언

- controller가 view 영역에게 요청해서 받은 값을 model영역으로 넘겨주는 방식

 

main controller

public class MainController {
    public void play() {
        List<Lotto> userLotto = createUserLotto(); // 사용자 로또 생성
        WinningLotto winningLotto = createWinningLotto(); // 당첨 로또 생성
        printLottoGameResult(userLotto, winningLotto); // 로또 게임 결과 출력
    }

    // 사용자 로또 생성
    private List<Lotto> createUserLotto() {
        int cost = InputController.inputCost(); // view 호출, 사용자 로또 구입 금액 입력
        int count = User.getCount(cost); // model 호출, 사용자 로또 구입 갯수 구하기
        OutputView.printPurchaseMessage(count); // view 호출, 사용자 로또 구입 갯수 안내 메세지 출력

        List<Lotto> userLotto = User.getTotalLotto(count); // model 호출, 사용자 구입 로또 리스트 구하기
        OutputView.printUserLotto(userLotto); // view 호출, 사용자 구입 로또 리스트 출력

        return userLotto;
    }

    // 당첨 로또 생성
    private WinningLotto createWinningLotto() {
        String[] winningNumber = InputController.inputWinningNumber(); // view 호출, 지난주 당첨 번호 입력
        int bonusNumber = InputController.inputBonusNumber(); // view 호출, 지난주 보너스 번호 입력

        List<Integer> winningNumbers = Convert.changeStringArrayToList(winningNumber); // string[] > list<Integer>
        Lotto lotto = Lotto.getLotto(winningNumbers); // model 호출, 당첨 로또 생성

        return new WinningLotto(lotto, bonusNumber);
    }

    // 로또 게임 결과 출력
    private void printLottoGameResult(List<Lotto> userLotto, WinningLotto winningLotto) {
        Map<Rank, Integer> statistics = Statistics.getWinningStatistics(userLotto, winningLotto); // model 호출, 당첨 통계 구하기
        OutputView.printWinningStatistics(statistics); // view 호출, 당첨 통계 출력

        int winningMoney = Statistics.getTotalWinningMoney(statistics); // model 호출, 당첨 금액 구하기
        double yield = Statistics.getTotalYield(winningMoney, userLotto.size()); // model 호출, 총 수익률 구하기
        OutputView.printTotalYield(yield); // view 호출, 총 수익률 출력
    }
}

model.Lotto

public class Lotto {
    private final List<Integer> numbers;

    public Lotto(List<Integer> numbers) {
        this.numbers = numbers;
    }

    // 매개변수로 받은 숫자로 생성된 로또 반환
    public static Lotto getLotto(List<Integer> numbers) {
        return new Lotto(numbers);
    }

    public List<Integer> getNumber() {
        return this.numbers;
    }

    // 당첨 번호와 사용자 로또 번호 중 일치하는 번호가 몇개인지 반환
    public int getMatchCount(Lotto winningLotto) {
        List<Integer> user = numbers;
        List<Integer> winning = winningLotto.getNumber();
        List<Integer> win = new ArrayList<>();

        for (Integer i : winning) {
            win.add(Integer.valueOf(String.valueOf(i)));
        }

        user.retainAll(win);

        return user.size();
    }

    // 보너스 번호를 포함하고 있는지 true/false 반환
    public boolean isContainsBonusNumber(int bonusNo) {
        return numbers.contains(bonusNo);
    }
}

model.Rank

public enum Rank {
	FIRST(6, 2_000_000_000), // 1등
	SECOND(5, 30_000_000), // 2등
	THIRD(5, 1_500_000), // 3등
	FOURTH(4, 50_000), // 4등
	FIFTH(3, 5_000), // 5등
	MISS(0, 0);

	private static final int WINNING_MIN_COUNT = 3;

	private int countOfMatch;
	private int winningMoney;

	private Rank(int countOfMatch, int winningMoney) {
		this.countOfMatch = countOfMatch;
		this.winningMoney = winningMoney;
	}

	public int getCountOfMatch() {
		return countOfMatch;
	}

	public int getWinningMoney() {
		return winningMoney;
	}

	public static Rank valueOf(int countOfMatch, boolean matchBonus) {
		if (countOfMatch < WINNING_MIN_COUNT) {
			return MISS;
		}

		if (SECOND.matchCount(countOfMatch) && matchBonus) {
			return SECOND;
		}

		for (Rank rank : values()) {
			if (rank.matchCount(countOfMatch) && rank != SECOND) {
				return rank;
			}
		}

		throw new IllegalArgumentException(countOfMatch + "는 유효하지 않은 값입니다.");
	}

	private boolean matchCount(int countOfMatch) {
		return this.countOfMatch == countOfMatch;
	}
}

model.Statistics

public class Statistics {
    private static final int LOTTO_TICKET_PRICE = 1000;

    // 당첨 통계 구하기
    public static Map<Rank, Integer> getWinningStatistics(List<Lotto> userLotto, WinningLotto winningLotto) {
        Map<Rank, Integer> statistics = initStatistics();
        registerMatchStatistics(userLotto, winningLotto, statistics);

        return statistics;
    }

    // 총 당첨 금액 반환
    public static int getTotalWinningMoney(Map<Rank, Integer> statistics) {
        int totalWinningMoney = 0;

        for (Rank rank : Rank.values()) {
            int winningMoney = rank.getWinningMoney();
            int amount = statistics.get(rank);

            totalWinningMoney += winningMoney * amount;
        }

        return totalWinningMoney;
    }

    // 총 수익률 반환
    public static double getTotalYield(double winningMoney, int amount) {
        double amountPaid = (amount * LOTTO_TICKET_PRICE);

        return winningMoney / amountPaid;
    }

    // 통계 초기화
    private static Map<Rank, Integer> initStatistics() {
        Map<Rank, Integer> statistics = new HashMap<>();

        for (Rank rank : Rank.values()) {
            statistics.put(rank, 0);
        }

        return statistics;
    }

    // 매치 통계 결과 등록
    private static void registerMatchStatistics(List<Lotto> userLotto, WinningLotto winningLotto, Map<Rank, Integer> statistics) {
        for (Lotto lotto : userLotto) {
            Rank rank = winningLotto.match(lotto);
            statistics.put(rank, statistics.getOrDefault(rank, 0) + 1);
        }
    }
}

model.User

public class User {
    private static final int LOTTO_TICKET_PRICE = 1000;

    // 사용자 랜덤 로또 리스트 반환
    public static List<Lotto> getTotalLotto(int count) {
        List<Lotto> userLotto = new ArrayList<>();

        // 랜덤 로또 생성
        for (int i = 0; i < count; i++) {
            Lotto lotto = RandomLottoNumber.getRandomLotto();
            userLotto.add(lotto);
        }

        return userLotto;
    }

    // 로또 구입 갯수 계산 메소드
    public static int getCount(int cost) {
        return cost / LOTTO_TICKET_PRICE;
    }
}

model.Validator

public class Validator {
    private static final String ERROR_COST_MESSAGE = "[ERROR] 로또 한장 당 1000원 입니다.\n1000원 이상, 1000원 단위로 입력해 주세요. \n";
    private static final String ERROR_BONUS_NUMBER_MESSAGE = "[ERROR] 1~45 사이의 보너스 숫자를 입력해 주세요. \n";
    private static final String ERROR_WINNING_NUMBER_LENGTH_MESSAGE = "[ERROR] 6개의 당첨 번호를 입력해 주세요. \n";
    private static final int MIN_LOTTO_COST = 1000;
    private static final int MIN_RANDOM_NUMBER = 1;
    private static final int MAX_RANDOM_NUMBER = 45;
    private static final int LOTTO_COST_REMAINDER = 0;

    // 보너스 넘버_범위_1~45_체크
    public static boolean isValidBonusNumber(int bonusNumber) {
        boolean check = true;

        if (bonusNumber < MIN_RANDOM_NUMBER || bonusNumber > MAX_RANDOM_NUMBER) {
            System.out.println(ERROR_BONUS_NUMBER_MESSAGE);
            check = false;
        }

        return check;
    }

    // 당첨 번호 split 최대 6개
    public static boolean isValidNumberLength(String[] numbers) {
        boolean check = true;

        if (numbers.length != 6) {
            System.out.println(ERROR_WINNING_NUMBER_LENGTH_MESSAGE);
            check = false;
        }

        return check;
    }

    // 구입 금액 체크
    public static boolean isValidCost(int cost) {
        boolean check = true;

        if (!(isValidCostMinCost(cost)) || !(isValidCostUnit(cost))) {
            System.out.println(ERROR_COST_MESSAGE);
            check = false;
        }

        return check;
    }

    // 구입 금액_단위_1000원 단위인지
    private static boolean isValidCostUnit(int cost) {
        return ((cost % MIN_LOTTO_COST) == LOTTO_COST_REMAINDER);
    }

    // 구입 금액_최소금액_1000원인지
    private static boolean isValidCostMinCost(int cost) {
        return cost >= MIN_LOTTO_COST;
    }
}

model.WinningLotto

public class WinningLotto {
    private final Lotto lotto;
    private final int bonusNo;

    public WinningLotto(Lotto lotto, int bonusNo) {
        this.lotto = lotto;
        this.bonusNo = bonusNo;
    }

    public Rank match(Lotto userLotto) {
        int matchCount = userLotto.getMatchCount(lotto);
        boolean matchBonus = userLotto.isContainsBonusNumber(bonusNo);

        return Rank.valueOf(matchCount, matchBonus);
    }
}