diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 000000000..cbac84731 --- /dev/null +++ b/docs/README.md @@ -0,0 +1,103 @@ +# Subway System + +## Entire System +1. 지하철 역 Model 생성 및 오류 체크, 이름 조회 기능 추가. +2. 지하철 역 리스트 생성 및 오류 체크, 중복 체크 기능 추가. +a. 해당하는 이름의 역이 포함되어 있는지 체크 +3. 지하철 노선 생성 및 오류, 이름 조회 기능 추가. +a. 노선에 특정 역이 속해져있는지 체크. +b. 노선에 포함된 역의 갯수 체크 +4. 지하철 노선 리스트 생성 및 오류 체크. 중복 체크 기능 추가. +a. 산하 노선들의 이름 체크 +5. 입력값에 대한 InputViewer 추가. +6. 결과값에 대한 OutputViewer 추가. +7. Initiator 및 전체 시스템 관리자 생성 +8. 역 관리 Controller 생성. +a. 등록 및 삭제 시, 두 글자 이상인[역]으로 끝나는지 유효성 체크 +b. 등록 시, 해당하는 역이 등록이 되어 있는지 체크 +c. 삭제 시, 전체 역 리스트에서 들어가있는지 유효성 체크 +d. 삭제 시, 해당하는 역이 2개의 역만으로 구성되어있는 노선에 들어가 있는지 체크 +e. 삭제 시, 노선에 등록되어 있는지에 대한 유효성 체크 +9. 노선 관리 Controller 생성. +a. 등록 및 삭제 시, [역] 및 [선]으로 끝나는지 유효성 체크 +b. 등록 및 삭제시 이미 등록된 노선인지 체크 +c. 등록 시 역이 등록이 되어있는지 체크 +d. 등록 시 출발역과 종착역 중복 입력됬는지 체크 +10. 구간 관리 Controller 생성. +a. 등록 및 삭제 시, [역] 및 [선]으로 끝나는지 유효성 체크 +b. 등록 및 삭제 시, 해당 노선 및 역이 존재하는지 체크 +c. 등록 시, 이미 등록된 역인지 체크 +d. 등록 시, 순서가 밖으로 나가는지 체크 +e. 삭제 시, 2개 미만으로 떨어지는지 유효성 체크 +11. 지하철 노선도 출력 Controller 생성. +12. 전체 관리 Controller 생성. + +### SubwaySystem +- 전체 관리하는 시스템 +- 생성 시에 기본 요구 조건 맞추면서 시작 +- 번호를 받으면 처리 + +### domain +#### Station +- 지하철역 생성 및 생성 시 오류 체크. +- 2글자 이상이야 한다. +- 지하철역 이름 보여주기. +#### StationRepository +- 지하철역 모음 중복 체크 해주기. +- 지하철역 전체 리스트에서 삭제 및 추가. +- 역 등록시에 순서 정렬 +- 역 삭제시 노선에서도 전체 삭제, 노선이 역을 가진 갯수가 2개 미만 발생시 삭제 취소 +#### Line +- 지하철 노선 생성 및 생성 시 오류 체크. +- 2글자 이상이야 한다. +- 노선에 지하철역 추가 및 삭제. +- 중복된 역이 들어가 있으지 확인. +- 노선 안 지하철 역 삭제시 최소 2개의 역 있는지 확인. +- 노선에 등록 전 역이 실제로 등록되어 있는지 확인 +#### LineRepository +- 노선 모음 및 중복 체크 해주기. +- 노선 등록시 순서 정렬 +- 노선 자체에 중복이 있으면 안된다. +- 노선 전체 리스트에서 삭제 및 추가. +#### Constants +- domain에서 자주 쓰이는 상수 모음 + +### Viewer +#### SystemInputViewer +- 전체 시스템 관련 인풋을 받아오는 객체. +#### StationInputViewer +- 역 관련 인풋 받아오는 객체. +#### LineInputViewer +- 노선 관련 인풋 받아오는 객체. +#### IntervalInputViewer +- 구간 관련 인풋을 받아오는 객체. +#### StationOutputViewer +- 역 관련 아웃풋을 보여주는 객체. +#### LineOutputViewer +- 노선 관련 아웃풋을 보여주는 객체. +#### IntervalOutputViewer +- 구간 관련 아웃풋을 보여주는 객체. +#### SystemOutputViewer +- 전체 시스템 관련 아웃풋을 보여주는 객체. +#### Constants +- Viewer에서 자수 쓰이는 상수 모음 + + +### Controller +공통적으로 Input을 받을 시에 해당 항목 벗어나면 Error 발생. +각각의 컨트롤러의 경우, Set, Sector, Unit 순으로 세부 기능이 쪼개지게 됨. +#### EntireSystem +- 전체 시스템을 관장하는 객체. +#### Initiator +- 초기 값들을 생성해주는 객체. +#### StationManager +- 역 관리를 맡고 있는 객체. +#### LineManager +- 노선 관리를 맡고 있는 객체. +#### IntervalManager +- 구간 관리를 맡고 있는 객체. +#### EntireShowManager +- 전체 노선을 보여주는 객체. +#### Constants +- Controller에서 자주 쓰이는 상수 모음 + diff --git a/src/main/java/subway/Application.java b/src/main/java/subway/Application.java index 0bcf786cc..be2473761 100644 --- a/src/main/java/subway/Application.java +++ b/src/main/java/subway/Application.java @@ -5,6 +5,7 @@ public class Application { public static void main(String[] args) { final Scanner scanner = new Scanner(System.in); - // TODO: 프로그램 구현 + SubwaySystem subwaySystem = new SubwaySystem(scanner); + subwaySystem.process(); } } diff --git a/src/main/java/subway/SubwaySystem.java b/src/main/java/subway/SubwaySystem.java new file mode 100644 index 000000000..5513a43ac --- /dev/null +++ b/src/main/java/subway/SubwaySystem.java @@ -0,0 +1,20 @@ +package subway; + +import subway.controller.EntireSystem; +import subway.controller.Initiator; + +import java.util.Scanner; + +public class SubwaySystem { + private final Scanner scanner; + + SubwaySystem(Scanner scanner) { + Initiator.intiate(); + this.scanner = scanner; + } + + public void process() { + EntireSystem entireSystem = new EntireSystem(scanner); + entireSystem.runProgram(); + } +} diff --git a/src/main/java/subway/controller/EntireSet.java b/src/main/java/subway/controller/EntireSet.java new file mode 100644 index 000000000..101382873 --- /dev/null +++ b/src/main/java/subway/controller/EntireSet.java @@ -0,0 +1,47 @@ +package subway.controller; + +import subway.controller.constants.QuestionNumber; + +import java.util.Scanner; + +public enum EntireSet { + STATION(QuestionNumber.ONE.getOption()) { + public void processSet(Scanner scanner) { + StationManager stationManager = new StationManager(scanner); + stationManager.processSector(); + } + }, + LINE(QuestionNumber.TWO.getOption()) { + public void processSet(Scanner scanner) { + LineManager lineManager = new LineManager(scanner); + lineManager.processSector(); + } + }, + INTERVAL(QuestionNumber.THREE.getOption()) { + public void processSet(Scanner scanner) { + IntervalManager intervalManager = new IntervalManager(scanner); + intervalManager.processSector(); + } + }, + ENTIRE_MAP(QuestionNumber.FOUR.getOption()) { + public void processSet(Scanner scanner) { + EntireShowManager entireShowManager = new EntireShowManager(); + entireShowManager.processSector(); + } + }, + QUIT(QuestionNumber.TERMINATE.getOption()) { + public void processSet(Scanner scanner) {} + }; + + private String option; + + private EntireSet(String option) { + this.option = option; + } + + abstract public void processSet(Scanner scanner); + + public String getOption() { + return option; + } +} diff --git a/src/main/java/subway/controller/EntireShowManager.java b/src/main/java/subway/controller/EntireShowManager.java new file mode 100644 index 000000000..d679b2342 --- /dev/null +++ b/src/main/java/subway/controller/EntireShowManager.java @@ -0,0 +1,10 @@ +package subway.controller; + +import subway.domain.LineRepository; +import subway.viewer.EntireMapOutputViewer; + +public class EntireShowManager { + public void processSector() { + EntireMapOutputViewer.showEntireMap(LineRepository.lines()); + } +} diff --git a/src/main/java/subway/controller/EntireSystem.java b/src/main/java/subway/controller/EntireSystem.java new file mode 100644 index 000000000..39cd1ba9c --- /dev/null +++ b/src/main/java/subway/controller/EntireSystem.java @@ -0,0 +1,52 @@ +package subway.controller; + +import subway.controller.constants.QuestionNumber; +import subway.controller.constants.SelectOptionConstants; +import subway.viewer.SystemInputViewer; + +import java.util.Scanner; + +public class EntireSystem { + private Scanner scanner; + + public EntireSystem(Scanner scanner) { + this.scanner = scanner; + } + + public void runProgram() { + String sector; + do { + SystemInputViewer.askMainScreen(); + sector = scanner.nextLine(); + isValidSector(sector); + goSector(sector); + } while (!sector.equals(QuestionNumber.TERMINATE.getOption())); + } + + private void isValidSector(String sector) { + try { + isContainSectorList(sector); + } catch (Exception error) { + System.out.println(); + System.out.println(SelectOptionConstants.OPTION_ERROR); + } + } + + private void isContainSectorList(String sector) { + if (!SelectOptionConstants.ENTIRE_SECTOR.contains(sector)) { + throw new IllegalArgumentException(SelectOptionConstants.OPTION_ERROR); + } + } + + private void goSector(String sector) { + for (EntireSet entireOption : EntireSet.values()) { + filterSector(entireOption, scanner, sector); + } + } + + private void filterSector(EntireSet candidate, Scanner scanner, String option) { + if (candidate.getOption().equals(option)) { + candidate.processSet(scanner); + } + } +} diff --git a/src/main/java/subway/controller/Initiator.java b/src/main/java/subway/controller/Initiator.java new file mode 100644 index 000000000..83cd47e54 --- /dev/null +++ b/src/main/java/subway/controller/Initiator.java @@ -0,0 +1,64 @@ +package subway.controller; + +import subway.controller.constants.InitialNewBoonDangLine; +import subway.controller.constants.InitialSecondLine; +import subway.controller.constants.InitialStations; +import subway.controller.constants.InitialThirdLine; +import subway.domain.Line; +import subway.domain.LineRepository; +import subway.domain.Station; +import subway.domain.StationRepository; + +public class Initiator { + private static final String SECOND_LINE = "2호선"; + private static final String THIRD_LINE = "3호선"; + private static final String NEW_BOONDANG_LINE = "신분당선"; + + public static void intiate() { + initiateStation(); + initiateLine(); + } + + private static void initiateLine() { + initiateSecondLine(); + initiateThirdLine(); + initiateNewBoonDangLine(); + } + + private static void initiateSecondLine() { + Line secondLine = new Line(SECOND_LINE); + for (InitialSecondLine eachStation : InitialSecondLine.values()) { + int order = eachStation.getOrder(); + Station insertedStation = new Station(eachStation.getName()); + secondLine.insertStation(order, insertedStation); + } + LineRepository.addLine(secondLine); + } + + private static void initiateThirdLine() { + Line thirdLine = new Line(THIRD_LINE); + for (InitialThirdLine eachStation : InitialThirdLine.values()) { + int order = eachStation.getOrder(); + Station insertedStation = new Station(eachStation.getName()); + thirdLine.insertStation(order, insertedStation); + } + LineRepository.addLine(thirdLine); + } + + private static void initiateNewBoonDangLine() { + Line newBoonDangLine = new Line(NEW_BOONDANG_LINE); + for (InitialNewBoonDangLine eachStation : InitialNewBoonDangLine.values()) { + int order = eachStation.getOrder(); + Station insertedStation = new Station(eachStation.getName()); + newBoonDangLine.insertStation(order, insertedStation); + } + LineRepository.addLine(newBoonDangLine); + } + + private static void initiateStation() { + for (InitialStations initialStation : InitialStations.values()) { + Station insertedStation = new Station(initialStation.getName()); + StationRepository.addStation(insertedStation); + } + } +} diff --git a/src/main/java/subway/controller/IntervalManager.java b/src/main/java/subway/controller/IntervalManager.java new file mode 100644 index 000000000..c6a2bd1a0 --- /dev/null +++ b/src/main/java/subway/controller/IntervalManager.java @@ -0,0 +1,53 @@ +package subway.controller; + +import subway.controller.constants.SelectOptionConstants; +import subway.viewer.IntervalInputViewer; + +import java.util.Scanner; + +public class IntervalManager { + private Scanner scanner; + + IntervalManager(Scanner scanner) { + this.scanner = scanner; + } + + public void processSector() { + boolean happenedError; + do { + IntervalInputViewer.askMainScreen(); + happenedError = checkSectorStatus(); + } while (happenedError); + } + + private boolean checkSectorStatus() { + try { + String unit = scanner.nextLine(); + isValidUnit(unit); + goUnit(scanner, unit); + return false; + } catch (Exception error) { + return true; + } + } + + private void isValidUnit(String unit) { + if (!SelectOptionConstants.INTERVAL_OPTION.contains(unit)) { + System.out.println(); + System.out.println(SelectOptionConstants.OPTION_ERROR); + throw new IllegalArgumentException(SelectOptionConstants.OPTION_ERROR); + } + } + + private void goUnit(Scanner scanner, String unit) { + for (IntervalSectors intervalSector : IntervalSectors.values()) { + filterUnit(intervalSector, scanner, unit); + } + } + + private void filterUnit(IntervalSectors candidate, Scanner scanner, String unit) { + if (candidate.getOption().equals(unit)) { + candidate.processUnit(scanner); + } + } +} diff --git a/src/main/java/subway/controller/IntervalSectors.java b/src/main/java/subway/controller/IntervalSectors.java new file mode 100644 index 000000000..ab1f9eb62 --- /dev/null +++ b/src/main/java/subway/controller/IntervalSectors.java @@ -0,0 +1,88 @@ +package subway.controller; + +import subway.controller.constants.ControllerErrorMessage; +import subway.controller.constants.QuestionNumber; +import subway.domain.LineRepository; +import subway.domain.StationRepository; +import subway.viewer.IntervalInputViewer; +import subway.viewer.IntervalOutputViewer; + +import java.util.Scanner; + +public enum IntervalSectors { + ADD(QuestionNumber.ONE.getOption()) { + public void processUnit(Scanner scanner) { + IntervalInputViewer.askEnrollLine(); + String lineTitle = getLineTitle(scanner); + IntervalInputViewer.askEnrollStation(); + String stationTitle = getStationTitle(scanner); + int order = getOrder(scanner, lineTitle); + LineRepository.insertStationToLine(lineTitle, stationTitle, order); + IntervalOutputViewer.showEnrollInterval(); + } + }, + DELETE(QuestionNumber.TWO.getOption()) { + public void processUnit(Scanner scanner) { + IntervalInputViewer.deleteLine(); + String lineTitle = getLineTitle(scanner); + IntervalInputViewer.deleteStation(); + String stationTitle = getStationTitle(scanner); + LineRepository.deleteStationToLine(lineTitle, stationTitle); + IntervalOutputViewer.showDeleteInterval(); + } + }, + BACK(QuestionNumber.BACK.getOption()) { + public void processUnit(Scanner scanner) {} + }; + + private String option; + + private IntervalSectors(String option) { + this.option = option; + } + + abstract public void processUnit(Scanner scanner); + + public String getOption() { + return option; + } + + private static String getLineTitle(Scanner scanner) { + String lineTitle = scanner.nextLine(); + if (!LineRepository.isExistedLine(lineTitle)) { + System.out.println(); + System.out.println(ControllerErrorMessage.NO_EXIST_LINE); + throw new IllegalArgumentException(ControllerErrorMessage.NO_EXIST_LINE); + } + return lineTitle; + } + + private static String getStationTitle(Scanner scanner) { + String stationTitle = scanner.nextLine(); + if (!StationRepository.isExistedStation(stationTitle)) { + System.out.println(); + System.out.println(ControllerErrorMessage.NO_EXIST_STATION); + throw new IllegalArgumentException(ControllerErrorMessage.NO_EXIST_STATION); + } + return stationTitle; + } + + private static int getOrder(Scanner scanner, String lineTitle) { + IntervalInputViewer.askEnrollOrder(); + String orderString = scanner.nextLine(); + checkInteger(orderString); + int order = Integer.parseInt(orderString); + LineRepository.checkOutOrder(lineTitle, order); + return order; + } + + private static void checkInteger(String order) { + try { + Integer.parseInt(order); + } catch (Exception error) { + System.out.println(); + System.out.println(ControllerErrorMessage.NO_INTEGER); + throw new IllegalArgumentException(ControllerErrorMessage.NO_INTEGER); + } + } +} diff --git a/src/main/java/subway/controller/LineManager.java b/src/main/java/subway/controller/LineManager.java new file mode 100644 index 000000000..b7092abef --- /dev/null +++ b/src/main/java/subway/controller/LineManager.java @@ -0,0 +1,53 @@ +package subway.controller; + +import subway.controller.constants.SelectOptionConstants; +import subway.viewer.LineInputViewer; + +import java.util.Scanner; + +public class LineManager { + private Scanner scanner; + + LineManager(Scanner scanner) { + this.scanner = scanner; + } + + public void processSector() { + boolean happenedError; + do { + LineInputViewer.askMainScreen(); + happenedError = checkSectorStatus(); + } while (happenedError); + } + + private boolean checkSectorStatus() { + try { + String unit = scanner.nextLine(); + isValidUnit(unit); + goUnit(scanner, unit); + return false; + } catch (Exception error) { + return true; + } + } + + private void isValidUnit(String unit) { + if (!SelectOptionConstants.LINE_OPTION.contains(unit)) { + System.out.println(); + System.out.println(SelectOptionConstants.OPTION_ERROR); + throw new IllegalArgumentException(SelectOptionConstants.OPTION_ERROR); + } + } + + private void goUnit(Scanner scanner, String unit) { + for (LineSectors lineSector : LineSectors.values()) { + filterUnit(lineSector, scanner, unit); + } + } + + private void filterUnit(LineSectors candidate, Scanner scanner, String unit) { + if (candidate.getOption().equals(unit)) { + candidate.processUnit(scanner); + } + } +} diff --git a/src/main/java/subway/controller/LineSectors.java b/src/main/java/subway/controller/LineSectors.java new file mode 100644 index 000000000..862176ef9 --- /dev/null +++ b/src/main/java/subway/controller/LineSectors.java @@ -0,0 +1,99 @@ +package subway.controller; + +import subway.controller.constants.ControllerErrorMessage; +import subway.controller.constants.QuestionNumber; +import subway.controller.constants.StationOrderConstants; +import subway.domain.Line; +import subway.domain.LineRepository; +import subway.domain.Station; +import subway.domain.StationRepository; +import subway.viewer.LineInputViewer; +import subway.viewer.LineOutputViewer; + +import java.util.Scanner; + +public enum LineSectors { + ADD(QuestionNumber.ONE.getOption()) { + public void processUnit(Scanner scanner) { + enrollLine(scanner); + LineOutputViewer.showEnrollLine(); + } + }, + DELETE(QuestionNumber.TWO.getOption()) { + public void processUnit(Scanner scanner) { + deleteLine(scanner); + LineOutputViewer.showDeleteLine(); + } + }, + CHECK(QuestionNumber.THREE.getOption()) { + public void processUnit(Scanner scanner) { + LineOutputViewer.showLineList(LineRepository.lines()); + } + }, + BACK(QuestionNumber.BACK.getOption()) { + public void processUnit(Scanner scanner) {} + }; + + private String option; + + private LineSectors(String option) { + this.option = option; + } + + abstract public void processUnit(Scanner scanner); + + public String getOption() { + return option; + } + + private static void enrollLine(Scanner scanner) { + LineInputViewer.askEnrollLine(); + String lineTitle = getValidatedLine(scanner); + LineRepository.checkOverlappedLine(lineTitle); + LineInputViewer.askDepartureStation(); + String departure = getValidatedStation(scanner); + LineInputViewer.askTerminalStation(); + String terminal = getValidatedStation(scanner); + insertLine(lineTitle, departure, terminal); + } + + private static String getValidatedLine(Scanner scanner) { + String lineTitle = scanner.nextLine(); + LineRepository.checkOverlappedLine(lineTitle); + return lineTitle; + } + + private static String getValidatedStation(Scanner scanner) { + String stationTitle = scanner.nextLine(); + if (!StationRepository.isExistedStation(stationTitle)) { + System.out.println(); + System.out.println(ControllerErrorMessage.NO_EXIST_STATION); + throw new IllegalArgumentException(ControllerErrorMessage.NO_EXIST_STATION); + } + return stationTitle; + } + + private static void insertLine(String lineTitle, String departure, String terminal) { + isSameDepartureTerminal(departure, terminal); + int departureLocation = StationOrderConstants.INITIAL.getLocation(); + int terminalLocation = StationOrderConstants.TERMINAL.getLocation(); + Line line = new Line(lineTitle); + line.insertStation(departureLocation, new Station(departure)); + line.insertStation(terminalLocation, new Station(terminal)); + LineRepository.addLine(line); + } + + private static void isSameDepartureTerminal(String departure, String terminal) { + if (departure.equals(terminal)) { + System.out.println(); + System.out.println(ControllerErrorMessage.SAME_DEPARTURE_TERMINAL); + throw new IllegalArgumentException(ControllerErrorMessage.SAME_DEPARTURE_TERMINAL); + } + } + + private static void deleteLine(Scanner scanner) { + LineInputViewer.askDeleteLine(); + String lineTitle = scanner.nextLine(); + LineRepository.deleteLineByName(lineTitle); + } +} diff --git a/src/main/java/subway/controller/StationManager.java b/src/main/java/subway/controller/StationManager.java new file mode 100644 index 000000000..ac465d889 --- /dev/null +++ b/src/main/java/subway/controller/StationManager.java @@ -0,0 +1,53 @@ +package subway.controller; + +import subway.controller.constants.SelectOptionConstants; +import subway.viewer.StationInputViewer; + +import java.util.Scanner; + +public class StationManager { + private Scanner scanner; + + StationManager(Scanner scanner) { + this.scanner = scanner; + } + + public void processSector() { + boolean happenedError; + do { + StationInputViewer.showMainScreen(); + happenedError = checkSectorStatus(); + } while (happenedError); + } + + private boolean checkSectorStatus() { + try { + String unit = scanner.nextLine(); + isValidUnit(unit); + goUnit(scanner, unit); + return false; + } catch (Exception error) { + return true; + } + } + + private void isValidUnit(String unit) { + if (!SelectOptionConstants.STATION_OPTION.contains(unit)) { + System.out.println(); + System.out.println(SelectOptionConstants.OPTION_ERROR); + throw new IllegalArgumentException(SelectOptionConstants.OPTION_ERROR); + } + } + + private void goUnit(Scanner scanner, String unit) { + for (StationSectors stationOption : StationSectors.values()) { + filterUnit(stationOption, scanner, unit); + } + } + + private void filterUnit(StationSectors candidate, Scanner scanner, String unit) { + if (candidate.getOption().equals(unit)) { + candidate.processUnit(scanner); + } + } +} diff --git a/src/main/java/subway/controller/StationSectors.java b/src/main/java/subway/controller/StationSectors.java new file mode 100644 index 000000000..3ac6a1710 --- /dev/null +++ b/src/main/java/subway/controller/StationSectors.java @@ -0,0 +1,50 @@ +package subway.controller; + +import subway.controller.constants.QuestionNumber; +import subway.domain.Station; +import subway.domain.StationRepository; +import subway.viewer.StationInputViewer; +import subway.viewer.StationOutputViewer; + +import java.util.List; +import java.util.Scanner; + +public enum StationSectors { + ADD(QuestionNumber.ONE.getOption()) { + public void processUnit(Scanner scanner) { + StationInputViewer.askEnrollStation(); + String stationName = scanner.nextLine(); + StationRepository.addStation(new Station(stationName)); + StationOutputViewer.showEnrollStation(); + } + }, + DELETE(QuestionNumber.TWO.getOption()) { + public void processUnit(Scanner scanner) { + StationInputViewer.askDeleteStation(); + String stationName = scanner.nextLine(); + StationRepository.deleteStation(stationName); + StationOutputViewer.showDeleteStation(); + } + }, + CHECK(QuestionNumber.THREE.getOption()) { + public void processUnit(Scanner scanner) { + List stations = StationRepository.stations(); + StationOutputViewer.showStationList(stations); + } + }, + BACK(QuestionNumber.BACK.getOption()) { + public void processUnit(Scanner scanner) {} + }; + + private String option; + + private StationSectors(String option) { + this.option = option; + } + + abstract public void processUnit(Scanner scanner); + + public String getOption() { + return option; + } +} diff --git a/src/main/java/subway/controller/constants/ControllerErrorMessage.java b/src/main/java/subway/controller/constants/ControllerErrorMessage.java new file mode 100644 index 000000000..63c3079a7 --- /dev/null +++ b/src/main/java/subway/controller/constants/ControllerErrorMessage.java @@ -0,0 +1,8 @@ +package subway.controller.constants; + +public class ControllerErrorMessage { + public static final String NO_EXIST_LINE = "[ERROR] 존재하지 않는 노선입니다."; + public static final String NO_EXIST_STATION = "[ERROR] 존재하지 않는 역입니다."; + public static final String NO_INTEGER = "[ERROR] 정수 값을 입력해주세요."; + public static final String SAME_DEPARTURE_TERMINAL = "[ERROR] 시작점과 종착역이 같으면 안됩니다."; +} diff --git a/src/main/java/subway/controller/constants/InitialNewBoonDangLine.java b/src/main/java/subway/controller/constants/InitialNewBoonDangLine.java new file mode 100644 index 000000000..90ec37d90 --- /dev/null +++ b/src/main/java/subway/controller/constants/InitialNewBoonDangLine.java @@ -0,0 +1,23 @@ +package subway.controller.constants; + +public enum InitialNewBoonDangLine { + ONE(1, "강남역"), + TWO(2, "양재역"), + THREE(3, "양재시민의숲역"); + + private final int order; + private final String stationName; + + private InitialNewBoonDangLine(int order, String stationName) { + this.order = order; + this.stationName = stationName; + } + + public int getOrder() { + return order; + } + + public String getName() { + return stationName; + } +} diff --git a/src/main/java/subway/controller/constants/InitialSecondLine.java b/src/main/java/subway/controller/constants/InitialSecondLine.java new file mode 100644 index 000000000..680f7f7b7 --- /dev/null +++ b/src/main/java/subway/controller/constants/InitialSecondLine.java @@ -0,0 +1,23 @@ +package subway.controller.constants; + +public enum InitialSecondLine { + ONE(1, "교대역"), + TWO(2, "강남역"), + THREE(3, "역삼역"); + + private final int order; + private final String stationName; + + private InitialSecondLine(int order, String stationName) { + this.order = order; + this.stationName = stationName; + } + + public int getOrder() { + return order; + } + + public String getName() { + return stationName; + } +} diff --git a/src/main/java/subway/controller/constants/InitialStations.java b/src/main/java/subway/controller/constants/InitialStations.java new file mode 100644 index 000000000..f187ae077 --- /dev/null +++ b/src/main/java/subway/controller/constants/InitialStations.java @@ -0,0 +1,21 @@ +package subway.controller.constants; + +public enum InitialStations { + ONE("교대역"), + TWO("강남역"), + THREE("역삼역"), + FOUR("남부터미널역"), + FIVE("양재역"), + SIX("양재시민의숲역"), + SEVEN("매봉역"); + + private final String stationName; + + private InitialStations(String stationName) { + this.stationName = stationName; + } + + public String getName() { + return stationName; + } +} diff --git a/src/main/java/subway/controller/constants/InitialThirdLine.java b/src/main/java/subway/controller/constants/InitialThirdLine.java new file mode 100644 index 000000000..4bab4c619 --- /dev/null +++ b/src/main/java/subway/controller/constants/InitialThirdLine.java @@ -0,0 +1,24 @@ +package subway.controller.constants; + +public enum InitialThirdLine { + ONE(1, "교대역"), + TWO(2, "남부터미널역"), + THREE(3, "양재역"), + FOUR(4, "매봉역"); + + private final int order; + private final String stationName; + + private InitialThirdLine(int order, String stationName) { + this.order = order; + this.stationName = stationName; + } + + public int getOrder() { + return order; + } + + public String getName() { + return stationName; + } +} diff --git a/src/main/java/subway/controller/constants/QuestionNumber.java b/src/main/java/subway/controller/constants/QuestionNumber.java new file mode 100644 index 000000000..337213cae --- /dev/null +++ b/src/main/java/subway/controller/constants/QuestionNumber.java @@ -0,0 +1,22 @@ +package subway.controller.constants; + +import java.util.Scanner; + +public enum QuestionNumber { + ONE("1"), + TWO("2"), + THREE("3"), + FOUR("4"), + BACK("B"), + TERMINATE("Q"); + + private String option; + + private QuestionNumber(String option) { + this.option = option; + } + + public String getOption() { + return option; + } +} diff --git a/src/main/java/subway/controller/constants/SelectOptionConstants.java b/src/main/java/subway/controller/constants/SelectOptionConstants.java new file mode 100644 index 000000000..7df4cfd4e --- /dev/null +++ b/src/main/java/subway/controller/constants/SelectOptionConstants.java @@ -0,0 +1,12 @@ +package subway.controller.constants; + +import java.util.Arrays; +import java.util.List; + +public class SelectOptionConstants { + public static final String OPTION_ERROR = "[ERROR] 선택할 수 없는 기능입니다."; + public static final List ENTIRE_SECTOR = Arrays.asList("1", "2", "3", "4", "Q"); + public static final List INTERVAL_OPTION = Arrays.asList("1", "2", "B"); + public static final List LINE_OPTION = Arrays.asList("1", "2", "3", "B"); + public static final List STATION_OPTION = Arrays.asList("1", "2", "3", "B"); +} diff --git a/src/main/java/subway/controller/constants/StationOrderConstants.java b/src/main/java/subway/controller/constants/StationOrderConstants.java new file mode 100644 index 000000000..dff3f6edc --- /dev/null +++ b/src/main/java/subway/controller/constants/StationOrderConstants.java @@ -0,0 +1,16 @@ +package subway.controller.constants; + +public enum StationOrderConstants { + INITIAL(1), + TERMINAL(2); + + private int location; + + private StationOrderConstants(int location) { + this.location = location; + } + + public int getLocation() { + return location; + } +} diff --git a/src/main/java/subway/domain/Line.java b/src/main/java/subway/domain/Line.java index f4d738d5a..5318a9f70 100644 --- a/src/main/java/subway/domain/Line.java +++ b/src/main/java/subway/domain/Line.java @@ -1,9 +1,20 @@ package subway.domain; -public class Line { +import subway.domain.constants.DomainConstant; +import subway.domain.constants.DomainErrorMessage; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Objects; + +public class Line implements Comparable { private String name; + private List stations = new ArrayList<>(); public Line(String name) { + checkNameLength(name); + checkEndName(name); this.name = name; } @@ -11,5 +22,84 @@ public String getName() { return name; } - // 추가 기능 구현 + public List getStations() { + return Collections.unmodifiableList(stations); + } + + public boolean compareName(String compareName) { + if (name.equals(compareName)) { + return true; + } + return false; + } + + public void insertStation(int location, Station station) { + checkOverlappedStation(station.getName()); + stations.add(location - DomainConstant.HUMAN_NUMBER_CALIBRATION, station); + } + + public void deleteStation(String name) { + checkAbleDeleteStation(); + stations.removeIf(station -> Objects.equals(station.getName(), name)); + } + + public int getStationNumber() { + return stations.size(); + } + + public boolean isContainedStation(String target) { + long checkOverlapped = stations.stream() + .map(Station::getName) + .filter(station -> station.equals(target)) + .count(); + if (checkOverlapped == DomainConstant.ZERO_LONG_NUMBER) { + return false; + } + return true; + } + + private void checkOverlappedStation(String target) { + if (isContainedStation(target)) { + System.out.println(); + System.out.println(DomainErrorMessage.OVERLAP_STATION); + throw new IllegalArgumentException(DomainErrorMessage.OVERLAP_STATION); + } + } + + private void checkNameLength(String name) { + if (name.length() < DomainConstant.NAME_LIMIT_LENGTH) { + System.out.println(); + System.out.println(DomainErrorMessage.LINE_LENGTH); + throw new IllegalArgumentException(DomainErrorMessage.LINE_LENGTH); + } + } + + /** 해당 역 삭제시에 문제가 없는지 체크하는 메소드 **/ + private void checkAbleDeleteStation() { + if (stations.size() <= DomainConstant.MINIMUM_STATION) { + System.out.println(); + System.out.println(DomainErrorMessage.MINIMUM_STATION); + throw new IllegalArgumentException(DomainErrorMessage.MINIMUM_STATION); + } + } + + /** 문자 마지막이 선으로 끝나는지 확인하는 메소드 **/ + private void checkEndName(String name) { + String last = name.substring(name.length() - DomainConstant.LAST_LOCATION); + if (!last.equals(DomainConstant.LINE_STRING)) { + System.out.println(); + System.out.println(DomainErrorMessage.LINE_FORMAT); + throw new IllegalArgumentException(DomainErrorMessage.LINE_FORMAT); + } + } + + /** + * 노선 정렬을 위해 오버라이딩한 메소드 + * @param line 노선 + * @return 노선과의 순서 정렬을 위한 정수 + */ + @Override + public int compareTo(Line line) { + return this.name.compareTo(line.name); + } } diff --git a/src/main/java/subway/domain/LineRepository.java b/src/main/java/subway/domain/LineRepository.java index 49132ddb6..182e9979f 100644 --- a/src/main/java/subway/domain/LineRepository.java +++ b/src/main/java/subway/domain/LineRepository.java @@ -1,5 +1,8 @@ package subway.domain; +import subway.domain.constants.DomainConstant; +import subway.domain.constants.DomainErrorMessage; + import java.util.ArrayList; import java.util.Collections; import java.util.List; @@ -13,10 +16,93 @@ public static List lines() { } public static void addLine(Line line) { + checkOverlappedLine(line.getName()); lines.add(line); } - public static boolean deleteLineByName(String name) { - return lines.removeIf(line -> Objects.equals(line.getName(), name)); + public static void deleteLineByName(String name) { + if (isExistedLine(name)) { + lines.removeIf(line -> Objects.equals(line.getName(), name)); + return; + } + System.out.println(); + System.out.println(DomainErrorMessage.NO_CONTAIN_LINE); + throw new IllegalArgumentException(DomainErrorMessage.NO_CONTAIN_LINE); + } + + public static void checkOverlappedLine(String target) { + if (isExistedLine(target)) { + System.out.println(); + System.out.println(DomainErrorMessage.OVERLAP_LINE); + throw new IllegalArgumentException(DomainErrorMessage.OVERLAP_LINE); + } + } + + public static boolean isExistedLine(String target) { + long isOverlap = lines.stream() + .filter(line -> line.compareName(target)) + .count(); + if (isOverlap == DomainConstant.ZERO_LONG_NUMBER) { + return false; + } + return true; + } + + public static void insertStationToLine(String lineTitle, String stationTitle, int order) { + if (isContainedStationOnLine(lineTitle, stationTitle)) { + System.out.println(); + System.out.println(DomainErrorMessage.EXISTED_ON_INTERVAL); + throw new IllegalArgumentException(DomainErrorMessage.EXISTED_ON_INTERVAL); + } + lines.stream() + .filter(line -> line.compareName(lineTitle)) + .forEach(line -> line.insertStation(order, new Station(stationTitle))); + } + + public static void deleteStationToLine(String lineTitle, String stationTitle) { + if (!isContainedStationOnLine(lineTitle, stationTitle)) { + System.out.println(); + System.out.println(DomainErrorMessage.NO_EXISTED_ON_INTERVAL); + throw new IllegalArgumentException(DomainErrorMessage.NO_EXISTED_ON_INTERVAL); + } + lines.stream() + .filter(line -> line.compareName(lineTitle)) + .forEach((line -> line.deleteStation(stationTitle))); + } + + /** 구간 편집시에 삽입하려는 역의 위치가 범위를 넘었는지 확인하는 메소드 **/ + public static void checkOutOrder(String lineTitle, int targetOrder) { + int order = targetOrder - DomainConstant.HUMAN_NUMBER_CALIBRATION; + long checkOrderCriteria = lines.stream() + .filter(line -> line.compareName(lineTitle)) + .filter(line -> (line.getStationNumber() <= order)) + .count(); + if (checkOrderCriteria != DomainConstant.ZERO_LONG_NUMBER) { + System.out.println(); + System.out.println(DomainErrorMessage.OUT_ORDER); + throw new IllegalArgumentException(DomainErrorMessage.OUT_ORDER); + } + } + + /** 역 삭제 시도시, 노선에 등록되어있는지 확인하는 메소드 **/ + public static boolean isValidDeleteStationOnData(String stationTitle) { + long unavailableLineNumber = lines.stream() + .filter(line -> line.isContainedStation(stationTitle)) + .count(); + if (unavailableLineNumber == DomainConstant.ZERO_LONG_NUMBER) { + return true; + } + return false; + } + + private static boolean isContainedStationOnLine(String lineTitle, String stationTitle) { + long overlappStationNumber = lines.stream() + .filter(line -> line.compareName(lineTitle)) + .filter(line -> line.isContainedStation(stationTitle)) + .count(); + if (overlappStationNumber == DomainConstant.ZERO_LONG_NUMBER) { + return false; + } + return true; } } diff --git a/src/main/java/subway/domain/Station.java b/src/main/java/subway/domain/Station.java index bdb142590..a476b3b0a 100644 --- a/src/main/java/subway/domain/Station.java +++ b/src/main/java/subway/domain/Station.java @@ -1,9 +1,13 @@ package subway.domain; -public class Station { +import subway.domain.constants.DomainConstant; +import subway.domain.constants.DomainErrorMessage; + +public class Station implements Comparable { private String name; public Station(String name) { + checkValidName(name); this.name = name; } @@ -11,5 +15,42 @@ public String getName() { return name; } - // 추가 기능 구현 + public boolean compareName(String targetName) { + if (name.equals(targetName)) { + return true; + } + return false; + } + + private void checkValidName(String name) { + checkNameLength(name); + checkEndName(name); + } + + private void checkNameLength(String name) { + if (name.length() < DomainConstant.NAME_LIMIT_LENGTH) { + System.out.println(); + System.out.println(DomainErrorMessage.STATION_LENGTH); + throw new IllegalArgumentException(DomainErrorMessage.STATION_LENGTH); + } + } + + private void checkEndName(String name) { + String last = name.substring(name.length() - DomainConstant.LAST_LOCATION); + if (!last.equals(DomainConstant.STATION_STRING)) { + System.out.println(); + System.out.println(DomainErrorMessage.STATION_FORMAT); + throw new IllegalArgumentException(DomainErrorMessage.STATION_FORMAT); + } + } + + /** + * 역 이름 순서대로 정렬을 위해서 역 이름을 비교하여 정수로 반환하는 메소드 오버라이딩 + * @param station 타겟 역 + * @return 비교했을 때의 결과 값을 정수로 반환 + */ + @Override + public int compareTo(Station station) { + return this.name.compareTo(station.name); + } } diff --git a/src/main/java/subway/domain/StationRepository.java b/src/main/java/subway/domain/StationRepository.java index b7245c0f3..7bffc387d 100644 --- a/src/main/java/subway/domain/StationRepository.java +++ b/src/main/java/subway/domain/StationRepository.java @@ -1,5 +1,8 @@ package subway.domain; +import subway.domain.constants.DomainConstant; +import subway.domain.constants.DomainErrorMessage; + import java.util.ArrayList; import java.util.Collections; import java.util.List; @@ -13,10 +16,39 @@ public static List stations() { } public static void addStation(Station station) { + checkOverlappedStation(station.getName()); stations.add(station); + Collections.sort(stations); + } + + public static void deleteStation(String name) { + if (!isExistedStation(name)) { + System.out.println(); + System.out.println(DomainErrorMessage.NO_CONTAIN_STATION); + throw new IllegalArgumentException(DomainErrorMessage.NO_CONTAIN_STATION); + } + if (!LineRepository.isValidDeleteStationOnData(name)){ + System.out.println(); + System.out.println(DomainErrorMessage.EXISTED_ON_LINES); + throw new IllegalArgumentException(DomainErrorMessage.EXISTED_ON_LINES); + } + stations.removeIf(station -> Objects.equals(station.getName(), name)); + } + + public static void checkOverlappedStation(String target) { + if (isExistedStation(target)) { + System.out.println(DomainErrorMessage.OVERLAP_STATION); + throw new IllegalArgumentException(DomainErrorMessage.OVERLAP_STATION); + } } - public static boolean deleteStation(String name) { - return stations.removeIf(station -> Objects.equals(station.getName(), name)); + public static boolean isExistedStation(String target) { + long checkOverlapped = stations.stream() + .filter(station -> station.compareName(target)) + .count(); + if (checkOverlapped == DomainConstant.ZERO_LONG_NUMBER) { + return false; + } + return true; } } diff --git a/src/main/java/subway/domain/constants/DomainConstant.java b/src/main/java/subway/domain/constants/DomainConstant.java new file mode 100644 index 000000000..cb0539f26 --- /dev/null +++ b/src/main/java/subway/domain/constants/DomainConstant.java @@ -0,0 +1,11 @@ +package subway.domain.constants; + +public class DomainConstant { + public static final int HUMAN_NUMBER_CALIBRATION = 1; + public static final int LAST_LOCATION = 1; + public static final int MINIMUM_STATION = 2; + public static final int NAME_LIMIT_LENGTH = 2; + public static final long ZERO_LONG_NUMBER = 0L; + public static final String STATION_STRING = "역"; + public static final String LINE_STRING = "선"; +} diff --git a/src/main/java/subway/domain/constants/DomainErrorMessage.java b/src/main/java/subway/domain/constants/DomainErrorMessage.java new file mode 100644 index 000000000..689139fa9 --- /dev/null +++ b/src/main/java/subway/domain/constants/DomainErrorMessage.java @@ -0,0 +1,17 @@ +package subway.domain.constants; + +public class DomainErrorMessage { + public static final String EXISTED_ON_LINES = "[ERROR] 해당 역은 노선에 등록되어 있습니다."; + public static final String EXISTED_ON_INTERVAL = "[ERROR] 해당 구간에 이미 등록되어 있습니다."; + public static final String LINE_LENGTH = "[ERROR] 노선의 이름은 2글자 이상이어야 합니다."; + public static final String LINE_FORMAT = "[ERROR] 노선의 이름은 선으로 끝나야 합니다."; + public static final String MINIMUM_STATION = "[ERROR] 역은 최소 2개 이상이어야 합니다."; + public static final String NO_CONTAIN_STATION = "[ERROR] 존재하지 않는 역 이름입니다."; + public static final String NO_CONTAIN_LINE = "[ERROR] 존재하지 않는 노선 이름입니다."; + public static final String NO_EXISTED_ON_INTERVAL = "[ERROR] 해당 구간에 존재하지 않습니다."; + public static final String STATION_FORMAT = "[ERROR] 역의 이름은 역으로 끝나야합니다."; + public static final String STATION_LENGTH = "[ERROR] 역의 이름은 2글자 이상이어야 합니다."; + public static final String OUT_ORDER = "[ERROR] 범위를 벗어나는 순서입니다."; + public static final String OVERLAP_LINE = "[ERROR] 이미 등록된 노선입니다."; + public static final String OVERLAP_STATION = "[ERROR] 이미 등록된 역입니다."; +} diff --git a/src/main/java/subway/viewer/EntireMapOutputViewer.java b/src/main/java/subway/viewer/EntireMapOutputViewer.java new file mode 100644 index 000000000..ac3a2518c --- /dev/null +++ b/src/main/java/subway/viewer/EntireMapOutputViewer.java @@ -0,0 +1,29 @@ +package subway.viewer; + +import subway.domain.Line; +import subway.domain.Station; + +import java.util.List; + +public class EntireMapOutputViewer { + private static final String DASH_LINE = "---"; + private static final String INFO_MESSAGE = "[INFO] %s\n"; + private static final String SUBWAY_MAP = "## 지하철 노선도"; + + public static void showEntireMap(List lines) { + System.out.println(); + System.out.println(SUBWAY_MAP); + for (Line line : lines) { + System.out.printf(INFO_MESSAGE, line.getName()); + System.out.printf(INFO_MESSAGE, DASH_LINE); + showStationUnderLine(line); + System.out.println(); + } + } + + private static void showStationUnderLine(Line line) { + for (Station station : line.getStations()) { + System.out.printf(INFO_MESSAGE, station.getName()); + } + } +} diff --git a/src/main/java/subway/viewer/IntervalInputViewer.java b/src/main/java/subway/viewer/IntervalInputViewer.java new file mode 100644 index 000000000..8275a37f3 --- /dev/null +++ b/src/main/java/subway/viewer/IntervalInputViewer.java @@ -0,0 +1,43 @@ +package subway.viewer; + +import subway.viewer.constants.IntervalInputInitiator; + +public class IntervalInputViewer { + private static final String ASK_ENROLL_LINE = "## 노선을 입력하세요."; + private static final String ASK_ENROLL_STATION = "## 역이름을 입력하세요."; + private static final String ASK_ENROLL_ORDER = "## 순서를 입력하세요."; + private static final String DELETE_LINE = "## 삭제할 구간의 노선을 입력하세요."; + private static final String DELETE_STATION = "## 삭제할 구간의 역을 입력하세요."; + + /* 처음 가능한 기능 리스트를 보여주는 메소드 */ + public static void askMainScreen() { + for (IntervalInputInitiator oneMessage : IntervalInputInitiator.values()) { + System.out.println(oneMessage.getMessage()); + } + } + + public static void askEnrollLine() { + System.out.println(); + System.out.println(ASK_ENROLL_LINE); + } + + public static void askEnrollStation() { + System.out.println(); + System.out.println(ASK_ENROLL_STATION); + } + + public static void askEnrollOrder() { + System.out.println(); + System.out.println(ASK_ENROLL_ORDER); + } + + public static void deleteLine() { + System.out.println(); + System.out.println(DELETE_LINE); + } + + public static void deleteStation() { + System.out.println(); + System.out.println(DELETE_STATION); + } +} diff --git a/src/main/java/subway/viewer/IntervalOutputViewer.java b/src/main/java/subway/viewer/IntervalOutputViewer.java new file mode 100644 index 000000000..025cdad44 --- /dev/null +++ b/src/main/java/subway/viewer/IntervalOutputViewer.java @@ -0,0 +1,16 @@ +package subway.viewer; + +public class IntervalOutputViewer { + private static final String COMPLETE_DELETE_MESSAGE = "[INFO] 구간이 삭제되었습니다."; + private static final String COMPLETE_ENROLL_MESSAGE = "[INFO] 구간이 등록되었습니다."; + + public static void showDeleteInterval() { + System.out.println(); + System.out.println(COMPLETE_DELETE_MESSAGE); + } + + public static void showEnrollInterval() { + System.out.println(); + System.out.println(COMPLETE_ENROLL_MESSAGE); + } +} diff --git a/src/main/java/subway/viewer/LineInputViewer.java b/src/main/java/subway/viewer/LineInputViewer.java new file mode 100644 index 000000000..299695aad --- /dev/null +++ b/src/main/java/subway/viewer/LineInputViewer.java @@ -0,0 +1,37 @@ +package subway.viewer; + +import subway.viewer.constants.LineInputInitiator; + +public class LineInputViewer { + private static final String ASK_ENROLL_LINE = "## 등록할 노선 이름을 입력하세요."; + private static final String ASK_DEPARTURE_STATION = "## 등록할 노선의 상행 종점역 이름을 입력하세요."; + private static final String ASK_TERMINAL_STATION = "## 등록할 노선의 하행 종점역 이름을 입력하세요."; + private static final String DELETE_ENROLL_LINE = "## 삭제할 노선 이름을 입력하세요."; + + /* 처음 가능한 기능 리스트를 보여주는 메소드 */ + public static void askMainScreen() { + for (LineInputInitiator oneMessage : LineInputInitiator.values()) { + System.out.println(oneMessage.getMessage()); + } + } + + public static void askEnrollLine() { + System.out.println(); + System.out.println(ASK_ENROLL_LINE); + } + + public static void askDeleteLine() { + System.out.println(); + System.out.println(DELETE_ENROLL_LINE); + } + + public static void askDepartureStation() { + System.out.println(); + System.out.println(ASK_DEPARTURE_STATION); + } + + public static void askTerminalStation() { + System.out.println(); + System.out.println(ASK_TERMINAL_STATION); + } +} diff --git a/src/main/java/subway/viewer/LineOutputViewer.java b/src/main/java/subway/viewer/LineOutputViewer.java new file mode 100644 index 000000000..9e652152a --- /dev/null +++ b/src/main/java/subway/viewer/LineOutputViewer.java @@ -0,0 +1,30 @@ +package subway.viewer; + +import subway.domain.Line; + +import java.util.List; + +public class LineOutputViewer { + private static final String COMPLETE_DELETE_MESSAGE = "[INFO] 지하철 노선이 삭제 되었습니다."; + private static final String COMPLETE_ENROLL_MESSAGE = "[INFO] 지하철 노선이 등록되었습니다."; + private static final String LINE_LIST = "노선 목록"; + private static final String SHOW_LINE_UNIT = "[INFO] %s\n"; + + public static void showDeleteLine() { + System.out.println(); + System.out.println(COMPLETE_DELETE_MESSAGE); + } + + public static void showEnrollLine() { + System.out.println(); + System.out.println(COMPLETE_ENROLL_MESSAGE); + } + + public static void showLineList(List lines) { + System.out.println(); + System.out.printf(SHOW_LINE_UNIT, LINE_LIST); + for (Line line : lines) { + System.out.printf(SHOW_LINE_UNIT, line.getName()); + } + } +} diff --git a/src/main/java/subway/viewer/StationInputViewer.java b/src/main/java/subway/viewer/StationInputViewer.java new file mode 100644 index 000000000..14ab0ba76 --- /dev/null +++ b/src/main/java/subway/viewer/StationInputViewer.java @@ -0,0 +1,24 @@ +package subway.viewer; + +import subway.viewer.constants.StationInputInitiator; + +public class StationInputViewer { + private static final String ASK_ENROLL_STATION = "## 등록할 역 이름을 입력하세요."; + private static final String DELETE_ENROLL_STATION = "## 삭제할 역 이름을 입력하세요."; + + public static void showMainScreen() { + for (StationInputInitiator oneMessage : StationInputInitiator.values()) { + System.out.println(oneMessage.getMessage()); + } + } + + public static void askEnrollStation() { + System.out.println(); + System.out.println(ASK_ENROLL_STATION); + } + + public static void askDeleteStation() { + System.out.println(); + System.out.println(DELETE_ENROLL_STATION); + } +} diff --git a/src/main/java/subway/viewer/StationOutputViewer.java b/src/main/java/subway/viewer/StationOutputViewer.java new file mode 100644 index 000000000..4f0f5d26d --- /dev/null +++ b/src/main/java/subway/viewer/StationOutputViewer.java @@ -0,0 +1,31 @@ +package subway.viewer; + +import subway.domain.Station; + +import java.util.List; + +public class StationOutputViewer { + private static final String COMPLETE_ENROLL_MESSAGE = "[INFO] 지하철 역이 등록되었습니다."; + private static final String COMPLETE_DELETE_MESSAGE = "[INFO] 지하철 역이 삭제 되었습니다."; + private static final String SHOW_STATION_LIST = "## 역 목록"; + private static final String SHOW_STATION_UNIT = "[INFO] %s\n"; + + public static void showEnrollStation() { + System.out.println(); + System.out.println(COMPLETE_ENROLL_MESSAGE); + } + + public static void showDeleteStation() { + System.out.println(); + System.out.println(COMPLETE_DELETE_MESSAGE); + } + + public static void showStationList(List stations) { + System.out.println(); + System.out.println(SHOW_STATION_LIST); + for (Station station : stations) { + System.out.printf(SHOW_STATION_UNIT, station.getName()); + } + System.out.println(); + } +} diff --git a/src/main/java/subway/viewer/SystemInputViewer.java b/src/main/java/subway/viewer/SystemInputViewer.java new file mode 100644 index 000000000..c3dac5818 --- /dev/null +++ b/src/main/java/subway/viewer/SystemInputViewer.java @@ -0,0 +1,11 @@ +package subway.viewer; + +import subway.viewer.constants.SystemInputInitiator; + +public class SystemInputViewer { + public static void askMainScreen() { + for (SystemInputInitiator oneMessage : SystemInputInitiator.values()) { + System.out.println(oneMessage.getMessage()); + } + } +} diff --git a/src/main/java/subway/viewer/constants/IntervalInputInitiator.java b/src/main/java/subway/viewer/constants/IntervalInputInitiator.java new file mode 100644 index 000000000..4d43b41be --- /dev/null +++ b/src/main/java/subway/viewer/constants/IntervalInputInitiator.java @@ -0,0 +1,21 @@ +package subway.viewer.constants; + +public enum IntervalInputInitiator { + INITIAL_BLANK(""), + MAIN_INTERVAL_MANAGE("## 구간 관리 화면"), + ENROLL_INTERVAL("1. 구간 등록"), + DELETE_INTERVAL("2. 구간 삭제"), + BACK_MAIN("B. 돌아가기"), + BLANK(""), + ASK_FUNCTION("## 원하는 기능을 선택하세요."); + + final private String message; + + private IntervalInputInitiator(String message) { + this.message = message; + } + + public String getMessage() { + return message; + } +} diff --git a/src/main/java/subway/viewer/constants/LineInputInitiator.java b/src/main/java/subway/viewer/constants/LineInputInitiator.java new file mode 100644 index 000000000..a117dab4f --- /dev/null +++ b/src/main/java/subway/viewer/constants/LineInputInitiator.java @@ -0,0 +1,22 @@ +package subway.viewer.constants; + +public enum LineInputInitiator { + INITIAL_BLANK(""), + MAIN_LINE_MANAGE("## 노선 관리 화면"), + ENROLL_LINE("1. 노선 등록"), + DELETE_LINE("2. 노선 삭제"), + CHECK_LINE("3. 노선 조회"), + BACK_MAIN("B. 돌아가기"), + BLANK(" "), + ASK_FUNCTION("## 원하는 기능을 선택하세요."); + + final private String message; + + private LineInputInitiator(String message) { + this.message = message; + } + + public String getMessage() { + return message; + } +} diff --git a/src/main/java/subway/viewer/constants/StationInputInitiator.java b/src/main/java/subway/viewer/constants/StationInputInitiator.java new file mode 100644 index 000000000..3430715e9 --- /dev/null +++ b/src/main/java/subway/viewer/constants/StationInputInitiator.java @@ -0,0 +1,22 @@ +package subway.viewer.constants; + +public enum StationInputInitiator { + INITIAL_BLANK(""), + MAIN_STATION_MANAGE("## 역 관리 화면"), + ENROLL_STATION("1. 역 등록"), + DELETE_STATION("2. 역 삭제"), + CHECK_STATION("3. 역 조회"), + BACK_MAIN("B. 돌아가기"), + BLANK(""), + ASK_FUNCTION("## 원하는 기능을 선택하세요."); + + final private String message; + + private StationInputInitiator(String message) { + this.message = message; + } + + public String getMessage() { + return message; + } +} diff --git a/src/main/java/subway/viewer/constants/SystemInputInitiator.java b/src/main/java/subway/viewer/constants/SystemInputInitiator.java new file mode 100644 index 000000000..7ac51c902 --- /dev/null +++ b/src/main/java/subway/viewer/constants/SystemInputInitiator.java @@ -0,0 +1,23 @@ +package subway.viewer.constants; + +public enum SystemInputInitiator { + INITIAL_BLANK(""), + MAIN_SCREEN("## 메인화면"), + MANAGE_STATION("1. 역 관리"), + MANAGE_LINE("2. 노선 관리"), + MANAGE_INTERVAL("3. 구간 관리"), + SHOW_LINE_MAP("4. 지하철 노선도 출력"), + END_SYSTEM("Q. 종료"), + BLANK(""), + ASK_FUNCTION("## 원하는 기능을 선택하세요."); + + final private String message; + + private SystemInputInitiator(String message) { + this.message = message; + } + + public String getMessage() { + return message; + } +}