java-racingcar mission 제출합니다

README.md

@@ -1,5 +1,22 @@
 # 미션 - 자동차 경주 게임
 
+## 구현할 기능 목록 
+- [x] 차의 이름과 위치를 관리하는 클래스를 구현한다.
+- [x] 0부터 9사이의 정수값을 랜덤하게 생성
+- [x] 난수가 4이상이면 전진
+- [x] 난수가 3이하이면 이동하지 않는다
+- [x] 턴이 모두 지났을 때 가장 앞에 있는 차의 이름을 출력한다.
+- [x] 턴이 모두 지났을 때 앞에 있는 차가 2개 이상일 경우 전부 출력한다.
+- [x] 차의 이름에 대한 입력값을 쉼표로 구분할 수 있다.
+- [x] 시도할 횟수를 입력 받을 수 있다.  
+- [x] 현재 자동차의 위치상황을 이름과 함께 출력할 수 있다.
+
+## 예외 처리 목록
+- [x] 빈 문자열 입력은 허용하지 않는다.
+- [x] 중복되는 이름의 차를 입력했을 때 허용하지 않는다.
+- [x] 시도할 횟수로 숫자가 아닌 값을 입력했을 때 허용하지 않는다.
+- [x] 5글자 이상의 차 이름을 입력했을 때 허용하지 않는다.
+
 ## 🚀 기능 요구사항
 
 - 주어진 횟수 동안 n대의 자동차는 전진 또는 멈출 수 있다.

src/main/java/racingcar/RacingGameApplication.java

@@ -0,0 +1,46 @@
+package racingcar;
+
+import racingcar.domain.Round;
+import racingcar.repository.validator.CarManagerValidator;
+import racingcar.dto.CarDto;
+import racingcar.repository.CarManager;
+import racingcar.ui.Printer;
+
+import java.util.List;
+
+public class RacingGameApplication {
+
+    private final Printer printer = new Printer();
+    private final CarManager carManager = new CarManager();
+    private final CarManagerValidator carManagerValidator = new CarManagerValidator();
+    public void run() {
+        printer.requestCarName();
+        carManagerValidator.ValidateAddCars(carManager);
+
+        printer.requestNumberOfRounds();
+        Round rounds = receiveRounds();
+        proceedRound(rounds);
+
+        printer.printWinner(carManager.createWinnerMessage());
+    }
+
+    private void proceedRound(Round rounds) {
+        printer.printResultHeader();
+        for (int i = 0; i < rounds.getRounds(); i++) {
+            List<CarDto> CarDtos = carManager.generateCarDtos();
+            carManager.moveAllCars(CarDtos);
+            carManager.printCarState(printer);
+        }
+    }
+
+    private Round receiveRounds() {
+        Round roundObject = new Round();
+        return roundObject;
+    }
+
+    public static void main(String[] args) {
+        RacingGameApplication app = new RacingGameApplication();
+        app.run();
+    }
+}
+

src/main/java/racingcar/domain/Round.java

@@ -0,0 +1,17 @@
+package racingcar.domain;
+
+import racingcar.ui.validator.ReceiverValidator;
+
+public class Round {
+    private final int rounds;
+    private final ReceiverValidator receiverValidator = new ReceiverValidator();
+
+    public Round() {
+        int round = receiverValidator.getValidateReceiveNumberOfRounds();
+        this.rounds = round;
+    }
+
+    public int getRounds() {
+        return rounds;
+    }
+}

src/main/java/racingcar/domain/Winner.java

@@ -0,0 +1,26 @@
+package racingcar.domain;
+
+import racingcar.domain.car.Car;
+
+import java.util.List;
+
+public class Winner {
+    private static final String DELIMITER = ", ";
+    private final List<Car> winnerNames;
+
+    public Winner(List<Car> winnerNames) {
+        this.winnerNames = winnerNames;
+    }
+
+    public String getWinnerGroups() {
+        StringBuilder winnerGroups = new StringBuilder();
+        winnerGroups.append(winnerNames.get(0).getName());
+
+        for (int i = 1; i < winnerNames.size(); i++) {
+            Car winner = winnerNames.get(i);
+            winnerGroups.append(DELIMITER);
+            winnerGroups.append(winner.getName());
+        }
+        return winnerGroups.toString();
+    }
+}

src/main/java/racingcar/domain/car/Car.java

@@ -0,0 +1,48 @@
+package racingcar.domain.car;
+
+import java.util.Objects;
+
+public class Car {
+    private final String name;
+    private int position = 0;
+    private static final int MOVE_INTERVAL = 1;
+
+    public Car(String name) {
+        CarName carName = new CarName(name);
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getPosition() {
+        return position;
+    }
+
+    public void move() {
+        position += MOVE_INTERVAL;
+    }
+
+    @Override
+    public String toString() {
+        return name + " : " + "-".repeat(Math.max(0, position));
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Car car = (Car) o;
+        return name.equals(car.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name);
+    }
+
+    public boolean isWinnerPosition(int winnerPosition) {
+        return winnerPosition == position;
+    }
+}

src/main/java/racingcar/domain/car/CarName.java

@@ -0,0 +1,27 @@
+package racingcar.domain.car;
+
+import racingcar.domain.exception.NotBlankException;
+import racingcar.domain.exception.NotValidNameLengthException;
+
+public class CarName {
+    private static final int CAR_NAME_MAX_LENGTH = 4;
+    private final String name;
+
+    public CarName(String name) {
+        checkBlankName(name);
+        checkNameLength(name);
+        this.name = name;
+    }
+
+    private void checkBlankName(String name) {
+        if (name.isBlank()) {
+            throw new NotBlankException();
+        }
+    }
+
+    private void checkNameLength(String name) {
+        if (name.length() > CAR_NAME_MAX_LENGTH) {
+            throw new NotValidNameLengthException();
+        }
+    }
+}

src/main/java/racingcar/domain/exception/NotBlankException.java

@@ -0,0 +1,9 @@
+package racingcar.domain.exception;
+
+public class NotBlankException extends RuntimeException {
+    private static final String MESSAGE = "빈 문자열 이름의 차를 생성할 수는 없습니다.";
+
+    public NotBlankException() {
+        super(MESSAGE);
+    }
+}

src/main/java/racingcar/domain/exception/NotValidNameLengthException.java

@@ -0,0 +1,9 @@
+package racingcar.domain.exception;
+
+public class NotValidNameLengthException extends RuntimeException {
+    private static final String Message = "5자 이상의 이름을 가진 차는 생설할 수 없습니다.";
+
+    public NotValidNameLengthException() {
+        super(Message);
+    }
+}

src/main/java/racingcar/dto/CarDto.java

@@ -0,0 +1,17 @@
+package racingcar.dto;
+
+import racingcar.domain.car.Car;
+
+public class CarDto {
+    private final Car car;
+
+    public CarDto(Car car) {
+        this.car = car;
+
+    }
+
+    public Car getCar() {
+        return car;
+    }
+
+}

src/main/java/racingcar/exception/NotZeroRoundException.java

@@ -0,0 +1,9 @@
+package racingcar.exception;
+
+public class NotZeroRoundException extends IllegalArgumentException {
+    private static final String NOT_ZERO_ROUND_EXCEPTION_MESSAGE = "라운드 회수로 0은 입력하실 수 없습니다.";
+
+    public NotZeroRoundException() {
+        super(NOT_ZERO_ROUND_EXCEPTION_MESSAGE);
+    }
+}

src/main/java/racingcar/repository/CarManager.java

@@ -0,0 +1,88 @@
+package racingcar.repository;
+
+import racingcar.domain.Winner;
+import racingcar.domain.car.Car;
+import racingcar.dto.CarDto;
+import racingcar.repository.Strategy.ForwardMoveStrategy;
+import racingcar.repository.exception.NotDuplicateNameException;
+import racingcar.ui.Printer;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class CarManager {
+    private List<Car> cars;
+    private final ForwardMoveStrategy forwardMoveStrategy = new ForwardMoveStrategy();
+
+    public CarManager() {
+        cars = new ArrayList<>();
+    }
+
+    private void checkDuplicateName(Car car) {
+        if (cars.contains(car)) {
+            throw new NotDuplicateNameException("중복되는 이름의 차를 입력하실 수 없습니다.");
+        }
+    }
+
+    public int size() {
+        return cars.size();
+    }
+
+    public void addAllCars(List<Car> carGroups) {
+        cars = new ArrayList<>();
+        for (Car car : carGroups) {
+            checkDuplicateName(car);
+            this.cars.add(car);
+        }
+    }
+
+    public List<Car> createAllCars(List<String> carNames) {
+        List<Car> carGroups = new ArrayList<>();
+
+        for (String name : carNames) {
+            carGroups.add(new Car(name));
+        }
+        return carGroups;
+    }
+
+    public List<CarDto> generateCarDtos() {
+        List<CarDto> dtos = new ArrayList<>();
+        for (Car car: cars) {
+            dtos.add(new CarDto(car));
+        }
+
+        return dtos;
+    }
+
+    public void moveAllCars(List<CarDto> carNumberList) {
+        for (CarDto dto : carNumberList) {
+            forwardMoveStrategy.forwardDeciding(dto.getCar());
+        }
+    }
+
+    public void printCarState(Printer printer) {
+        for (Car car : cars) {
+            printer.printCarState(car);
+        }
+        printer.printNewLine();
+    }
+
+    public String createWinnerMessage() {
+        List<Car> winners = winnerList();
+        Winner winner = new Winner(winners);
+
+        return winner.getWinnerGroups();
+    }
+
+    private List<Car> winnerList() {
+        int winnerPosition = cars.stream()
+                .mapToInt(Car::getPosition)
+                .max()
+                .orElseThrow(IllegalArgumentException::new);
+
+        return cars.stream()
+                .filter(car -> car.isWinnerPosition(winnerPosition))
+                .collect(Collectors.toList());
+    }
+}

src/main/java/racingcar/repository/Strategy/ForwardMoveStrategy.java

@@ -0,0 +1,11 @@
+package racingcar.repository.Strategy;
+
+import racingcar.domain.car.Car;
+
+public class ForwardMoveStrategy extends RandomMoveStrategy{
+    public void forwardDeciding(Car car){
+        if(decideMoving() >= getThreshold()){
+            car.move();
+        }
+    }
+}

src/main/java/racingcar/repository/Strategy/MoveStrategy.java

@@ -0,0 +1,5 @@
+package racingcar.repository.Strategy;
+
+interface MoveStrategy {
+    int decideMoving();
+}

src/main/java/racingcar/repository/Strategy/RandomMoveStrategy.java

@@ -0,0 +1,17 @@
+package racingcar.repository.Strategy;
+
+import java.util.Random;
+
+public class RandomMoveStrategy implements MoveStrategy{
+    private final int UPPER_BOUND = 10;
+    private static final int THRESHOLD = 4;
+
+    @Override
+    public int decideMoving(){
+        return new Random().nextInt(UPPER_BOUND);
+    }
+
+    public int getThreshold(){
+        return THRESHOLD;
+    }
+}

src/main/java/racingcar/repository/exception/NotDuplicateNameException.java

@@ -0,0 +1,7 @@
+package racingcar.repository.exception;
+
+public class NotDuplicateNameException extends RuntimeException {
+    public NotDuplicateNameException(String message) {
+        super(message);
+    }
+}