[3주차] 객체지향 코드 연습(서아영)

docs/README.md

@@ -0,0 +1,50 @@
+# 구현할 기능 목록
+
+## Model
+
+### Domain
+- RacingCar (하나의 레이싱 카)
+  - 차 이름 출력을 위한 getter
+  - 차 위치 이동 메서드
+- AllRacingCars (모든 레이싱 카들)
+  - 최종 우승자 반환 메서드
+- FullGame (전체 경기)
+- Game (단일 경기)
+- GameRecords (경기 기록)
+- FinalWinners (최종 우승자)
+  - 최종 우승자 계산 메서드
+  - 최종 우승자 출력을 위한 getter
+
+### Service
+- RacingCarService (객체 생성과 메서드 호출 담당, 없애고 싶다.)
+
+1. 컨트롤러로부터 전달 받은 자동차 이름으로 RacingCar 객체 생성 
+2. RacingCar 객체들로 AllRacingCars 객체 생성
+2. AllRacingCars 객체와 컨트롤러로부터 전달 받은 시도 횟수로 FullGame 객체 생성
+3. FullGame 객체 내에서 GameResult 생성
+4. AllGameResults의 각 GameResult가 반환한 우승자들을 모아 FinalWinners 객체 생성
+    - 각 GameResult 객체 내에서 하이픈 개수 비교
+6. GameResult에서 단일 경기 우승자 Winners 객체로 반환 
+7. 반환한 Winners 객체들을 WinnerCounts로 생성
+8. WinnerCounts에서 최종 우승자 FinalWinners로 생성 및 반환
+
+
+## View
+
+### Input
+1. 경주할 자동차 이름 입력 받기
+2. 시도할 횟수 입력 받기
+
+### Output
+1. 각 차수별 실행 결과 출력 하기
+2. 단독 우승자 안내 문구 출력 하기 or 공동 우승자 안내 문구 출력 하기
+
+## Controller
+1. 뷰에서 입력 받은 경주할 자동차 이름 파싱 및 검증
+2. 서비스 객체에 자동차 이름 전달
+3. 뷰에서 입력 받은 시도 횟수 파싱 및 검증
+4. 서비스 객체에 시도 횟수 전달
+5. 서비스 객체로부터 AllGameResults 객체 받아 와서 변환
+6. 변환한 AllGameResults 뷰에게 전달
+7. 서비스 객체로부터 FinalWinners 받아 와서 변환
+8. 변환한 FinalWinners 뷰에게 전달

src/main/java/racingcar/AppConfig.java

@@ -0,0 +1,22 @@
+package racingcar;
+
+import racingcar.controller.Controller;
+import racingcar.view.InputView;
+import racingcar.view.OutputView;
+import racingcar.view.TextInputView;
+import racingcar.view.TextOutputView;
+
+public final class AppConfig {
+
+    public Controller controller() {
+        return new Controller(inputView(), outputView());
+    }
+
+    private InputView inputView() {
+        return new TextInputView();
+    }
+
+    private OutputView outputView() {
+        return new TextOutputView();
+    }
+}

src/main/java/racingcar/Application.java

@@ -1,7 +1,11 @@
 package racingcar;
 
+import racingcar.controller.Controller;
+
 public class Application {
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        AppConfig appConfig = new AppConfig();
+        Controller controller = appConfig.controller();
+        controller.run();
     }
 }

src/main/java/racingcar/common/ErrorMessage.java

@@ -0,0 +1,11 @@
+package racingcar.common;
+
+public class ErrorMessage {
+    private static final String ERROR_MESSAGE = "[ERROR]";
+
+    public static final String ERROR_EMPTY_RACING_CAR_NAME = ERROR_MESSAGE + "입력된 자동차 이름이 없습니다.";
+    public static final String ERROR_SINGLE_RACING_CAR_NAME = ERROR_MESSAGE + "한 대의 자동차로는 경기할 수 없습니다.";
+    public static final String ERROR_EMPTY_GAME_COUNT = ERROR_MESSAGE + "입력된 경기 횟수가 없습니다.";
+    public static final String ERROR_GAME_COUNT_FORMAT = ERROR_MESSAGE + "경기 횟수는 정수여야 합니다.";
+    public static final String ERROR_TOO_SMALL_GAME_COUNT = ERROR_MESSAGE + "시도 횟수는 0보다 커야 합니다.";
+}

src/main/java/racingcar/controller/Controller.java

@@ -0,0 +1,79 @@
+package racingcar.controller;
+
+import static racingcar.common.ErrorMessage.ERROR_EMPTY_GAME_COUNT;
+import static racingcar.common.ErrorMessage.ERROR_EMPTY_RACING_CAR_NAME;
+import static racingcar.common.ErrorMessage.ERROR_GAME_COUNT_FORMAT;
+
+import java.util.List;
+import racingcar.model.domain.AllRacingCars;
+import racingcar.model.domain.FullGame;
+import racingcar.model.domain.GameRecords;
+import racingcar.view.InputView;
+import racingcar.view.OutputView;
+
+public class Controller {
+
+    public static final String DELIMITER = ",";
+    public static final String NUMERIC_REGEX = "\\d+";
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public Controller(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run() {
+        AllRacingCars allRacingCars = createAllRacingCars();
+
+        FullGame fullGame = createFullGame(allRacingCars);
+
+        getGameRecords(fullGame);
+
+        getFinalWinners(allRacingCars);
+    }
+
+    private void getFinalWinners(AllRacingCars allRacingCars) {
+        outputView.outputFinalWinners(allRacingCars.getFinalWinners().toDto());
+    }
+
+    private void getGameRecords(FullGame fullGame) {
+        GameRecords gameRecords = fullGame.playAllRounds();
+        outputView.outputGameRecords(gameRecords.toDto());
+    }
+
+    private FullGame createFullGame(AllRacingCars allRacingCars) {
+        String inputCount = inputView.inputGameCount();
+        validateInputCount(inputCount);
+        int gameCount = Integer.parseInt(inputCount);
+        return FullGame.of(allRacingCars, gameCount);
+    }
+
+    private AllRacingCars createAllRacingCars() {
+        String inputNames = inputView.inputRacingCarNames();
+        validateInputNames(inputNames);
+        List<String> carNames = splitCarNames(inputNames);
+        return AllRacingCars.from(carNames);
+    }
+
+    private void validateInputCount(String inputCount) {
+        if (inputCount.trim().isEmpty() || inputCount == null) {
+            throw new IllegalArgumentException(ERROR_EMPTY_GAME_COUNT);
+        }
+        if (!inputCount.matches(NUMERIC_REGEX)) {
+            throw new IllegalArgumentException(ERROR_GAME_COUNT_FORMAT);
+        }
+    }
+
+    private static List<String> splitCarNames(String racingCarNames) {
+        return List.of(racingCarNames.split(DELIMITER));
+    }
+
+    private static void validateInputNames(String inputNames) {
+        if (inputNames.trim().isEmpty() || inputNames == null) {
+            throw new IllegalArgumentException(ERROR_EMPTY_RACING_CAR_NAME);
+        }
+    }
+
+}

src/main/java/racingcar/model/domain/AllRacingCars.java

@@ -0,0 +1,62 @@
+package racingcar.model.domain;
+
+import static racingcar.common.ErrorMessage.ERROR_SINGLE_RACING_CAR_NAME;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+
+public final class AllRacingCars {
+
+    public static final int MIN_CAR_COUNT = 2;
+
+    private final List<RacingCar> cars;
+
+    private AllRacingCars(List<RacingCar> cars) {
+        validate(cars);
+        this.cars = cars;
+    }
+
+    public static AllRacingCars from(List<String> carNames) {
+        return new AllRacingCars(convertToRacingCar(carNames));
+    }
+
+    public Round playOneRound() {
+        return Round.from(moveAllRacingCars());
+    }
+
+    public FinalWinners getFinalWinners() {
+        return FinalWinners.of(cars, calculateMaxPosition());
+    }
+
+    private void validate(List<RacingCar> cars) {
+        if (cars.size() < MIN_CAR_COUNT) {
+            throw new IllegalArgumentException(ERROR_SINGLE_RACING_CAR_NAME);
+        }
+    }
+
+    private static List<RacingCar> convertToRacingCar(List<String> carNames) {
+        return carNames.stream().map(RacingCar::from).toList();
+    }
+
+    private int calculateMaxPosition() {
+        return cars.stream()
+                .mapToInt(RacingCar::getPosition)
+                .max()
+                .orElse(0);
+    }
+
+    private Map<RacingCar, Integer> moveAllRacingCars() {
+        return cars.stream()
+                .map(car -> {
+                    car.move();
+                    return car;
+                })
+                .collect(Collectors.toMap(
+                        Function.identity(),
+                        RacingCar::getPosition
+                ));
+    }
+}

src/main/java/racingcar/model/domain/FinalWinners.java

@@ -0,0 +1,30 @@
+package racingcar.model.domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import racingcar.model.dto.FinalWinnersDto;
+
+public final class FinalWinners {
+
+    private final List<RacingCar> finalWinners;
+
+    private FinalWinners(final List<RacingCar> finalWinners) {
+        this.finalWinners = finalWinners;
+    }
+
+    public static FinalWinners of(List<RacingCar> cars, int maxPosition) {
+        List<RacingCar> result = calculateFinalWinners(cars, maxPosition);
+        return new FinalWinners(result);
+    }
+
+    private static List<RacingCar> calculateFinalWinners(List<RacingCar> cars, int maxPosition) {
+        return cars.stream()
+                .filter(car -> car.isSamePosition(maxPosition))
+                .collect(Collectors.toList());
+    }
+
+    public FinalWinnersDto toDto() {
+        return FinalWinnersDto.from(finalWinners.stream().map(RacingCar::getName).toList());
+    }
+
+}

src/main/java/racingcar/model/domain/FullGame.java

@@ -0,0 +1,39 @@
+package racingcar.model.domain;
+
+import java.util.HashMap;
+import java.util.Map;
+import racingcar.common.ErrorMessage;
+
+public final class FullGame {
+
+    public static final int START_ROUND = 1;
+    public static final int MIN_GAME_COUNT = 0;
+
+    private final AllRacingCars allRacingCars;
+    private final int gameCount;
+
+    private FullGame(AllRacingCars allRacingCars, int gameCount) {
+        validate(gameCount);
+        this.allRacingCars = allRacingCars;
+        this.gameCount = gameCount;
+    }
+
+    public static FullGame of(AllRacingCars allRacingCars, int gameCount) {
+        return new FullGame(allRacingCars, gameCount);
+    }
+
+    public GameRecords playAllRounds() {
+        Map<Integer, Round> gameResult = new HashMap<>();
+        for (int roundCount = START_ROUND; roundCount <= gameCount; roundCount++) {
+            Round round = allRacingCars.playOneRound();
+            gameResult.put(roundCount, round);
+        }
+        return GameRecords.from(gameResult);
+    }
+
+    private void validate(int gameCount) {
+        if (gameCount <= MIN_GAME_COUNT) {
+            throw new IllegalArgumentException(ErrorMessage.ERROR_TOO_SMALL_GAME_COUNT);
+        }
+    }
+}

src/main/java/racingcar/model/domain/GameRecords.java

@@ -0,0 +1,29 @@
+package racingcar.model.domain;
+
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+import racingcar.model.dto.GameResultDto;
+import racingcar.model.dto.RoundResultDto;
+
+public final class GameRecords {
+
+    private final Map<Integer, Round> gameRecords;
+
+    private GameRecords(Map<Integer, Round> gameRecords) {
+        this.gameRecords = gameRecords;
+    }
+
+    public static GameRecords from(Map<Integer, Round> gameRecords) {
+        return new GameRecords(gameRecords);
+    }
+
+    public GameResultDto toDto() {
+        Map<Integer, RoundResultDto> result = gameRecords.entrySet().stream()
+                .collect(Collectors.toMap(
+                        Entry::getKey,
+                        entry -> entry.getValue().toDto()
+                ));
+        return GameResultDto.from(result);
+    }
+}

src/main/java/racingcar/model/domain/RacingCar.java

@@ -0,0 +1,39 @@
+package racingcar.model.domain;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+final class RacingCar {
+
+    public static final int MIN_NUMBER = 0;
+    public static final int MAX_NUMBER = 9;
+    public static final int JUDGE_NUMBER = 4;
+
+    private final String name;
+    private int position = 0;
+
+    private RacingCar(String name) {
+        this.name = name;
+    }
+
+    public static RacingCar from(String name) {
+        return new RacingCar(name);
+    }
+
+    public void move() {
+        if (Randoms.pickNumberInRange(MIN_NUMBER, MAX_NUMBER) > JUDGE_NUMBER) {
+            position++;
+        }
+    }
+
+    public boolean isSamePosition(int otherPosition) {
+        return this.position == otherPosition;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public Integer getPosition() {
+        return position;
+    }
+}