diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 000000000..70842ae7e
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,97 @@
+# 🚀 구현할 기능 목록
+
+## 입력
+- 메뉴나 기능 선택시 입력값이 범위 안의 입력인지 검증한다.
+### 입력 예외 상황
+- 메인과 관리 화면에서 보여주는 기능이 아닌경우
+- 등록할 지하철 역 관련
+  - 이름의 길이가 2자 미만인 경우
+  - 이름이 '역'으로 끝나지 않는 경우
+  - 이름에 공백이 들어가는 경우
+  - 이름이 숫자와 한글이 아닌 경우
+  - 중복된 이름인 경우
+- 등록할 노선 관련
+  - 이름의 길이가 2자 미만인 경우
+  - 이름이 '선'으로 끝나지 않는 경우
+  - 이름이 숫자와 한글이 아닌 경우
+  - 상행 종점역과 하행 종점역의 이름이 같은 경우
+- 등록할 구간 관련
+  - 선택한 노선이 등록되지 않은 노선인 경우
+  - 역이름이 등록되지 않은 경우
+
+<br>
+
+## 출력
+- 어플리케이션 화면 레이아웃 구성
+    1. 주 메뉴 화면
+    2. 기능 선택 화면
+        - 세부 기능 포함
+    3. 입력 안내 화면
+    4. 입력 결과 출력
+- 입력 유도 메시지 출력
+- 입력 반응 메시지 출력
+    - 기대 출력 결과시 '[INFO] ...'
+    - 에러시 '[ERROR] ...'
+
+<br>
+
+## 주요 로직
+### 메인화면
+- 선택한 메뉴로 이동 또는 기능을 실행한다.
+  - 역 관리, 노선 관리, 구간 관리 -> 세부 기능 선택 안내
+  - 지하철 노선도 출력 -> 기능 실행
+  - 종료 -> 어플리케이션 종료
+
+### 역 관리 관련
+- 역 등록
+  - 입력받은 역을 검증
+  - 검증 결과에 따라 저장소에 역 저장 후 [INFO]또는 [ERROR] 메시지 출력
+- 역 삭제
+  - 입력받은 역을 검증
+  - 검증 결과에 따라 저장소에서 삭제 후 [INFO]또는 [ERROR] 메시지 출력
+- 역 조회
+  - 저장소 모든 역을 호출하여 출력
+- 돌아가기
+  - 메인 화면 호출
+
+### 노선 관리 관련
+- 노선 등록
+  1. 등록할 노선 이름 입력 검증
+  2. 노선의 상행 종점역 이름 입력 검증
+  3. 노선의 하행 종점역 이름 입력 검증
+  4. 검증 후 결과에 따라 저장소에 저장 후 [INFO]또는 [ERROR] 메시지 출력
+- 노선 삭제
+  - 입력받은 노선 검증
+  - 검증 결과에 따라 저장소에서 삭제 후 [INFO]또는 [ERROR] 메시지 출력
+- 노선 조회
+  - 저장소 모든 노선 호출하여 출력
+- 돌아가기
+  - 메인 화면 호출
+
+### 구간 관리 관련
+- 구간 등록(노선에 역을 추가)
+  - 구간 등록할 노선 검증
+  - 역 이름 검증
+  - 순서 검증
+  - 검증 후 결과에 따라 저장소에 저장 및 역 재배열 후 [INFO]또는 [ERROR] 메시지 출력
+- 구간 삭제
+  - 삭제할 구간 노선 검증
+  - 역 이름 검증
+  - 검증 후 결과에 따라 저장소에서 삭제 및 역 재배열 후 [INFO]또는 [ERROR] 메시지 출력
+- 돌아가기
+  - 메인 화면 호출
+
+### 지하철 노선도 출력 관련
+- 노선도는 이름 순으로 출력한다
+- 각 노선도는 노선의 이름과 등록된 역을 포함한다
+- 등록된 역은 순서대로 출력한다
+
+<br>
+
+## 초기 설정
+- 역 등록
+  - 교대역, 강남역, 역삼역, 남부터미널역, 양재역, 양재시민의숲역, 매봉역
+- 노선 등록(왼쪽 끝이 상행 종점)
+  - 2호선: 교대역 - 강남역 - 역삼역
+  - 3호선: 교대역 - 남부터미널역 - 양재역 - 매봉역
+  - 신분당선: 강남역 - 양재역 - 양재시민의숲역
\ No newline at end of file
diff --git a/src/main/java/subway/Application.java b/src/main/java/subway/Application.java
index 0bcf786cc..8ee3d2246 100644
--- a/src/main/java/subway/Application.java
+++ b/src/main/java/subway/Application.java
@@ -1,10 +1,15 @@
 package subway;
 
+import subway.controller.SubwayMap;
+
 import java.util.Scanner;
 
 public class Application {
     public static void main(String[] args) {
         final Scanner scanner = new Scanner(System.in);
         // TODO: 프로그램 구현
+        DummyDataSetting.run();
+        SubwayMap subwayMap = new SubwayMap();
+        subwayMap.Run(scanner);
     }
 }
diff --git a/src/main/java/subway/DummyDataSetting.java b/src/main/java/subway/DummyDataSetting.java
new file mode 100644
index 000000000..f434e51ce
--- /dev/null
+++ b/src/main/java/subway/DummyDataSetting.java
@@ -0,0 +1,46 @@
+package subway;
+
+import subway.domain.Line;
+import subway.domain.LineRepository;
+import subway.domain.Station;
+import subway.domain.StationRepository;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class DummyDataSetting {
+
+    public static void run() {
+        /*
+         * 역: 교대역, 강남역, 역삼역, 남부터미널역, 양재역, 양재시민의숲역, 매봉역
+         * 노선: 2호선, 3호선, 신분당선
+         * 노선에 역
+         * - 2호선: 교대역 - 강남역 - 역삼역
+         * - 3호선: 교대역 - 남부터미널역 - 양재역 - 매봉역
+         * - 신분당선: 강남역 - 양재역 - 양재시민의숲역
+         */
+        List<String> stationNames = Arrays.asList("교대역", "강남역", "역삼역", "남부터미널역", "양재역",
+                "양재시민의숲역", "매봉역");
+        for (String name : stationNames) {
+            StationRepository.addStation(new Station(name));
+        }
+
+        List<String> lineNames = Arrays.asList("2호선", "3호선", "신분당선");
+        for (String name : lineNames) {
+            LineRepository.addLine(new Line(name));
+        }
+
+        LineRepository.getLine("2호선").addSectionByStation(StationRepository.getStation("교대역"));
+        LineRepository.getLine("2호선").addSectionByStation(StationRepository.getStation("강남역"));
+        LineRepository.getLine("2호선").addSectionByStation(StationRepository.getStation("역삼역"));
+
+        LineRepository.getLine("3호선").addSectionByStation(StationRepository.getStation("교대역"));
+        LineRepository.getLine("3호선").addSectionByStation(StationRepository.getStation("남부터미널역"));
+        LineRepository.getLine("3호선").addSectionByStation(StationRepository.getStation("양재역"));
+        LineRepository.getLine("3호선").addSectionByStation(StationRepository.getStation("매봉역"));
+
+        LineRepository.getLine("신분당선").addSectionByStation(StationRepository.getStation("강남역"));
+        LineRepository.getLine("신분당선").addSectionByStation(StationRepository.getStation("양재역"));
+        LineRepository.getLine("신분당선").addSectionByStation(StationRepository.getStation("양재시민의숲역"));
+    }
+}
diff --git a/src/main/java/subway/LineManagementSign.java b/src/main/java/subway/LineManagementSign.java
new file mode 100644
index 000000000..032f34dd9
--- /dev/null
+++ b/src/main/java/subway/LineManagementSign.java
@@ -0,0 +1,27 @@
+package subway;
+
+import java.util.Arrays;
+
+public enum LineManagementSign {
+    ADD_LINE("1"),
+    DELETE_LINE("2"),
+    SHOW_LINES("3"),
+    BACK_TO_MAIN("B");
+
+    private String sign;
+
+    LineManagementSign(String sign) {
+        this.sign = sign;
+    }
+
+    public String getSign() {
+        return sign;
+    }
+
+    public static LineManagementSign validateSign(String inputData) {
+        return Arrays.stream(LineManagementSign.values())
+                .filter(sign -> inputData.toUpperCase().equals(sign.getSign()))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("없는 기능"));
+    }
+}
diff --git a/src/main/java/subway/MainSign.java b/src/main/java/subway/MainSign.java
new file mode 100644
index 000000000..1be879320
--- /dev/null
+++ b/src/main/java/subway/MainSign.java
@@ -0,0 +1,28 @@
+package subway;
+
+import java.util.Arrays;
+
+public enum MainSign {
+    STATION_MANAGEMENT("1"),
+    LINE_MANAGEMENT("2"),
+    SECTION_MANAGEMENT("3"),
+    PRINT_SUBWAY_ROUTE("4"),
+    CLOSE_MAIN("Q");
+
+    private String sign;
+
+    MainSign(String sign) {
+        this.sign = sign;
+    }
+
+    public String getSign() {
+        return sign;
+    }
+
+    public static MainSign validateSign(String inputData) {
+        return Arrays.stream(MainSign.values())
+                .filter(sign -> inputData.toUpperCase().equals(sign.getSign()))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("없는 기능"));
+    }
+}
diff --git a/src/main/java/subway/SectionManagementSign.java b/src/main/java/subway/SectionManagementSign.java
new file mode 100644
index 000000000..af4811e42
--- /dev/null
+++ b/src/main/java/subway/SectionManagementSign.java
@@ -0,0 +1,26 @@
+package subway;
+
+import java.util.Arrays;
+
+public enum SectionManagementSign {
+    ADD_SECTION("1"),
+    DELETE_SECTION("2"),
+    BACK_TO_MAIN("B");
+
+    private String sign;
+
+    SectionManagementSign(String sign) {
+        this.sign = sign;
+    }
+
+    public String getSign() {
+        return sign;
+    }
+
+    public static SectionManagementSign validateSign(String inputData) {
+        return Arrays.stream(SectionManagementSign.values())
+                .filter(sign -> inputData.toUpperCase().equals(sign.getSign()))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("없는 기능"));
+    }
+}
diff --git a/src/main/java/subway/StationManagementSign.java b/src/main/java/subway/StationManagementSign.java
new file mode 100644
index 000000000..bfe9154d2
--- /dev/null
+++ b/src/main/java/subway/StationManagementSign.java
@@ -0,0 +1,27 @@
+package subway;
+
+import java.util.Arrays;
+
+public enum StationManagementSign {
+    ADD_STATION("1"),
+    DELETE_STATION("2"),
+    SHOW_STATIONS("3"),
+    BACK_TO_MAIN("B");
+
+    private String sign;
+
+    StationManagementSign(String sign) {
+        this.sign = sign;
+    }
+
+    public String getSign() {
+        return sign;
+    }
+
+    public static StationManagementSign validateSign(String inputData) {
+        return Arrays.stream(StationManagementSign.values())
+                .filter(sign -> inputData.toUpperCase().equals(sign.getSign()))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("없는 기능"));
+    }
+}
diff --git a/src/main/java/subway/controller/ErrorHandler.java b/src/main/java/subway/controller/ErrorHandler.java
new file mode 100644
index 000000000..b757e8793
--- /dev/null
+++ b/src/main/java/subway/controller/ErrorHandler.java
@@ -0,0 +1,78 @@
+package subway.controller;
+
+import subway.domain.Line;
+import subway.domain.LineRepository;
+import subway.domain.Station;
+import subway.domain.StationRepository;
+
+import java.util.Objects;
+import java.util.regex.Pattern;
+
+public class ErrorHandler {
+    private static final String STATION_NAME_END = "역";
+    private static final String LINE_NAME_END = "선";
+    private static final int NAME_MIN_LENGTH = 2;
+    private static final int LENGTH_TO_INDEX = 1;
+
+    public static void validateStationNameFormat(String inputData) {
+        if (inputData.length() < NAME_MIN_LENGTH
+                || !Pattern.matches("^[0-9가-힣]*$", inputData)
+                || !inputData.substring(inputData.length() - LENGTH_TO_INDEX).equals(STATION_NAME_END)) {
+            throw new IllegalArgumentException("format error");
+        }
+    }
+
+    public static void validateStationDuplicate(String inputData) {
+        if (StationRepository.isDuplicate(inputData)) {
+            throw new IllegalArgumentException("duplicate error");
+        }
+    }
+
+    public static void validateStationRegistered(String inputData) {
+        if (!StationRepository.isDuplicate(inputData)) {
+            throw new IllegalArgumentException("not registered error");
+        }
+    }
+
+    public static void validateLineNameFormat(String inputData) {
+        if (inputData.length() < NAME_MIN_LENGTH
+                || !Pattern.matches("^[0-9가-힣]*$", inputData)
+                || !inputData.substring(inputData.length() - LENGTH_TO_INDEX).equals(LINE_NAME_END)) {
+            throw new IllegalArgumentException("format error");
+        }
+    }
+
+    public static void validateLineDuplicate(String inputData) {
+        if (LineRepository.isDuplicate(inputData)) {
+            throw new IllegalArgumentException("duplicate error");
+        }
+    }
+
+    public static void validateLineRegistered(String inputData) {
+        if (!LineRepository.isDuplicate(inputData)) {
+            throw new IllegalArgumentException("not registered error");
+        }
+    }
+
+    public static void validateStationDuplicateInLine(Station targetStation, Line line) {
+        if (line.getSections().stream()
+                .anyMatch(station -> Objects.equals(station, targetStation))) {
+            throw new IllegalArgumentException("duplicate error");
+        }
+    }
+
+    public static void validateStationRegisteredInLine(Station targetStation, Line line) {
+        if (line.getSections().stream()
+                .noneMatch(station -> Objects.equals(station, targetStation))) {
+            throw new IllegalArgumentException("not registered error");
+        }
+    }
+
+    public static void validateOrder(String targetOrder, Line line) {
+        int order = Integer.parseInt(targetOrder);
+        if (order < 1 || order > line.getSections().size()) {
+            throw new IllegalArgumentException("inbound error");
+        }
+    }
+
+}
diff --git a/src/main/java/subway/controller/SubwayMap.java b/src/main/java/subway/controller/SubwayMap.java
new file mode 100644
index 000000000..4e555c36c
--- /dev/null
+++ b/src/main/java/subway/controller/SubwayMap.java
@@ -0,0 +1,345 @@
+package subway.controller;
+
+import subway.LineManagementSign;
+import subway.MainSign;
+import subway.SectionManagementSign;
+import subway.StationManagementSign;
+import subway.domain.*;
+import subway.view.InputView;
+import subway.view.OutputView;
+
+import java.util.Scanner;
+import java.util.function.Consumer;
+
+public class SubwayMap {
+    private boolean isRun = true;
+    private OutputView outputView;
+    private InputView inputView;
+    private Scanner scanner;
+
+    public void Run(Scanner scanner) {
+        this.scanner = scanner;
+        while (isRun) {
+            outputView = new OutputView();
+            inputView = new InputView();
+            startMain();
+        }
+    }
+
+    private void startMain() {
+        outputView.printMainScreen();
+        inputView.scanData(scanner);
+        validateSign(inputView.getInputData(),
+                t -> MainSign.validateSign(t),
+                () -> startMain());
+        chooseFunctionInMain(inputView.getInputData());
+    }
+
+    private void chooseFunctionInMain(String inputData) {
+        if (inputData.equals(MainSign.STATION_MANAGEMENT.getSign())) {
+            startStationManagement();
+        }
+        if (inputData.equals(MainSign.LINE_MANAGEMENT.getSign())) {
+            startLineManagement();
+        }
+        if (inputData.equals(MainSign.SECTION_MANAGEMENT.getSign())) {
+            startSectionManagement();
+        }
+        if (inputData.equals(MainSign.PRINT_SUBWAY_ROUTE.getSign())) {
+            outputView.printSubwaySections();
+        }
+        if (inputData.equalsIgnoreCase(MainSign.CLOSE_MAIN.getSign())) {
+            isRun = false;
+        }
+    }
+
+
+    private void startStationManagement() {
+        outputView.printStationManagementScreen();
+        inputView.scanData(scanner);
+        validateSign(inputView.getInputData(),
+                t -> StationManagementSign.validateSign(t),
+                () -> startStationManagement());
+        chooseFunctionInStationManagement(inputView.getInputData());
+
+    }
+
+    private void chooseFunctionInStationManagement(String inputData) {
+        if (inputData.equals(StationManagementSign.ADD_STATION.getSign())) {
+            addStation();
+            System.out.println("addStation 끝");
+            outputView.infoAddStation();
+        }
+        if (inputData.equals(StationManagementSign.DELETE_STATION.getSign())) {
+            deleteStation();
+            outputView.infoDeleteStation();
+        }
+        if (inputData.equals(StationManagementSign.SHOW_STATIONS.getSign())) {
+            outputView.printAllStations();
+        }
+        if (inputData.equalsIgnoreCase(StationManagementSign.BACK_TO_MAIN.getSign())) {
+            startMain();
+        }
+    }
+
+    private void addStation() {
+        outputView.guideAddStation();
+        inputView.scanData(scanner);
+        String name = inputView.getInputData();
+        validateStationName(name, () -> addStation());
+        validateStationDuplicate(name, () -> addStation());
+        StationRepository.addStation(new Station(name));
+    }
+
+    private void validateSign(String inputData, Consumer<String> tryExpression, Runnable catchExpression) {
+        try {
+            tryExpression.accept(inputData);
+        } catch (IllegalArgumentException E) {
+            outputView.errorChooseFunction();
+            catchExpression.run();
+        }
+    }
+
+    private void validateStationName(String inputData, Runnable catchExpression) {
+        try {
+            ErrorHandler.validateStationNameFormat(inputData);
+        } catch (IllegalArgumentException E) {
+            outputView.errorStationFormat();
+            catchExpression.run();
+        }
+    }
+
+    private void validateStationDuplicate(String inputData, Runnable catchExpression) {
+        try {
+            ErrorHandler.validateStationDuplicate(inputData);
+        } catch (IllegalArgumentException E) {
+            outputView.errorStationDuplicate();
+            catchExpression.run();
+        }
+    }
+
+    private void validateStationRegistered(String inputData, Runnable catchExpression) {
+        try {
+            ErrorHandler.validateStationRegistered(inputData);
+        } catch (IllegalArgumentException E) {
+            outputView.errorDeleteStationNotRegistered();
+            catchExpression.run();
+        }
+    }
+
+    private void deleteStation() {
+        outputView.guideDeleteStation();
+        inputView.scanData(scanner);
+        validateStationName(inputView.getInputData(), () -> deleteStation());
+        validateStationRegistered(inputView.getInputData(), () -> deleteStation());
+        StationRepository.deleteStation(inputView.getInputData());
+        LineRepository.deleteStationInLine(inputView.getInputData());
+
+    }
+
+    private void startLineManagement() {
+        outputView.printLineManagementScreen();
+        inputView.scanData(scanner);
+        validateSign(inputView.getInputData(),
+                t -> LineManagementSign.validateSign(t),
+                () -> startLineManagement());
+        chooseFunctionInLineManagement(inputView.getInputData());
+    }
+
+    private void chooseFunctionInLineManagement(String inputData) {
+        if (inputData.equals(LineManagementSign.ADD_LINE.getSign())) {
+            addLine();
+            addUpwardTerminal();
+            addDownwardTerminal();
+            outputView.infoAddLine();
+        }
+        if (inputData.equals(LineManagementSign.DELETE_LINE.getSign())) {
+            deleteLine();
+            outputView.infoDeleteLine();
+        }
+        if (inputData.equals(LineManagementSign.SHOW_LINES.getSign())) {
+            outputView.printAllLines();
+        }
+        if (inputData.equalsIgnoreCase(LineManagementSign.BACK_TO_MAIN.getSign())) {
+            startMain();
+        }
+    }
+
+    private void addLine() {
+        outputView.guideAddLineName();
+        inputView.scanData(scanner);
+        String name = inputView.getInputData();
+        validateLineName(name, () -> addLine());
+        validateLineDuplicate(name, () -> addLine());
+        LineRepository.addLine(new Line(name));
+    }
+
+    private void addUpwardTerminal() {
+        outputView.guideAddLineUpwardTerminal();
+        inputView.scanData(scanner);
+        String name = inputView.getInputData();
+        validateStationName(name, () -> addUpwardTerminal());
+        validateStationRegistered(name, () -> addUpwardTerminal());
+        LineRepository.getNewLine().addSectionByStation(StationRepository.getStation(name));
+    }
+
+    private void addDownwardTerminal() {
+        outputView.guideAddLineDownwardTerminal();
+        inputView.scanData(scanner);
+        String name = inputView.getInputData();
+        validateStationName(name, () -> addDownwardTerminal());
+        validateStationRegistered(name, () -> addDownwardTerminal());
+        LineRepository.getNewLine().addSectionByStation(StationRepository.getStation(name));
+    }
+
+    private void deleteLine() {
+        outputView.guideDeleteLine();
+        inputView.scanData(scanner);
+        String name = inputView.getInputData();
+        validateLineName(name, () -> deleteLine());
+        validateLineRegistered(name, () -> deleteLine());
+        LineRepository.deleteLineByName(inputView.getInputData());
+    }
+
+    private void validateLineName(String inputData, Runnable catchExpression) {
+        try {
+            ErrorHandler.validateLineNameFormat(inputData);
+        } catch (IllegalArgumentException E) {
+            outputView.errorLineFormat();
+            catchExpression.run();
+        }
+    }
+
+    private void validateLineDuplicate(String inputData, Runnable catchExpression) {
+        try {
+            ErrorHandler.validateLineDuplicate(inputData);
+        } catch (IllegalArgumentException E) {
+            outputView.errorLineDuplicate();
+            catchExpression.run();
+        }
+    }
+
+    private void validateLineRegistered(String inputData, Runnable catchExpression) {
+        try {
+            ErrorHandler.validateLineRegistered(inputData);
+        } catch (IllegalArgumentException E) {
+            outputView.errorDeleteLineNotRegistered();
+            catchExpression.run();
+        }
+    }
+
+    private void startSectionManagement() {
+        outputView.printSectionManagementScreen();
+        inputView.scanData(scanner);
+        validateSign(inputView.getInputData(),
+                t -> SectionManagementSign.validateSign(t),
+                () -> startSectionManagement());
+        chooseFunctionInSectionManagement(inputView.getInputData());
+    }
+
+    private void chooseFunctionInSectionManagement(String inputData) {
+        if (inputData.equals(SectionManagementSign.ADD_SECTION.getSign())) {
+            addSection();
+            outputView.infoAddSection();
+        }
+        if (inputData.equals(SectionManagementSign.DELETE_SECTION.getSign())) {
+            deleteSection();
+            outputView.infoDeleteSection();
+        }
+        if (inputData.equalsIgnoreCase(SectionManagementSign.BACK_TO_MAIN.getSign())) {
+            startMain();
+        }
+    }
+
+    private void addSection() {
+        Line line;
+        Station station;
+        int order;
+        line = addCheckLine();
+        station = addCheckStation(line);
+        order = addcheckOrder(line);
+        line.addSectionByOrderAndStation(order, station);
+    }
+
+    private Line addCheckLine() {
+        outputView.guideCheckLine();
+        inputView.scanData(scanner);
+        String name = inputView.getInputData();
+        validateLineName(name, () -> addSection());
+        validateLineRegistered(name, () -> addSection());
+        return LineRepository.getLine(name);
+    }
+
+    private Station addCheckStation(Line line) {
+        outputView.guideCheckSectionStation();
+        inputView.scanData(scanner);
+        String name = inputView.getInputData();
+        validateStationName(name, () -> addSection());
+        validateStationRegistered(name, () -> addSection());
+        validateStationDuplicateInLine(StationRepository.getStation(name), line, () -> addSection());
+        return StationRepository.getStation(name);
+    }
+
+    private int addcheckOrder(Line line) {
+        outputView.guideCheckSectionOrder();
+        inputView.scanData(scanner);
+        String order = inputView.getInputData();
+        validateOrder(order, line, () -> addSection());
+        return Integer.parseInt(order);
+    }
+
+    private void validateStationDuplicateInLine(Station station, Line line, Runnable expression) {
+        try {
+            ErrorHandler.validateStationDuplicateInLine(station, line);
+        } catch (IllegalArgumentException E) {
+            outputView.errorStationDuplicate();
+            expression.run();
+        }
+    }
+
+    private void validateOrder(String order, Line line, Runnable expression) {
+        try {
+            ErrorHandler.validateOrder(order, line);
+        } catch (NumberFormatException E) {
+            outputView.errorParseIntOrder();
+            expression.run();
+        } catch (IllegalArgumentException E) {
+            outputView.errorInBoundOrder();
+            expression.run();
+        }
+    }
+
+    private void deleteSection() {
+        Line line = deleteCheckLine();
+        Station station = deleteCheckStation(line);
+        line.deleteSectionByName(station.getName());
+    }
+
+    private Line deleteCheckLine() {
+        outputView.guideDeleteSectionLine();
+        inputView.scanData(scanner);
+        String name = inputView.getInputData();
+        validateLineName(name, () -> deleteSection());
+        validateLineRegistered(name, () -> deleteSection());
+        return LineRepository.getLine(name);
+    }
+
+    private Station deleteCheckStation(Line line) {
+        outputView.guideDeleteSectionStation();
+        inputView.scanData(scanner);
+        String name = inputView.getInputData();
+        validateStationName(name, () -> deleteSection());
+        validateStationRegistered(name, () -> deleteSection());
+        validateStationRegisteredInLine(StationRepository.getStation(name), line, () -> deleteSection());
+        return StationRepository.getStation(name);
+    }
+
+    private void validateStationRegisteredInLine(Station station, Line line, Runnable expression) {
+        try {
+            ErrorHandler.validateStationRegisteredInLine(station, line);
+        } catch (IllegalArgumentException E) {
+            outputView.errorStationDuplicate();
+            expression.run();
+        }
+    }
+}
diff --git a/src/main/java/subway/domain/Line.java b/src/main/java/subway/domain/Line.java
index f4d738d5a..2f1cc75e9 100644
--- a/src/main/java/subway/domain/Line.java
+++ b/src/main/java/subway/domain/Line.java
@@ -1,5 +1,9 @@
 package subway.domain;
 
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
+
 public class Line {
     private String name;
 
@@ -12,4 +16,22 @@ public String getName() {
     }
 
     // 추가 기능 구현
+    private static final int FROM_ORDER_TO_INDEX = 1;
+    private List<Station> sections = new LinkedList<>();
+
+    public List<Station> getSections() {
+        return sections;
+    }
+
+    public void addSectionByStation(Station station) {
+        sections.add(station);
+    }
+
+    public void addSectionByOrderAndStation(int orderOfRoute, Station station) {
+        sections.add(orderOfRoute - FROM_ORDER_TO_INDEX, station);
+    }
+
+    public boolean deleteSectionByName(String name) {
+        return sections.removeIf(station -> Objects.equals(station.getName(), name));
+    }
 }
diff --git a/src/main/java/subway/domain/LineRepository.java b/src/main/java/subway/domain/LineRepository.java
index 49132ddb6..ba95b24ec 100644
--- a/src/main/java/subway/domain/LineRepository.java
+++ b/src/main/java/subway/domain/LineRepository.java
@@ -19,4 +19,32 @@ public static void addLine(Line line) {
     public static boolean deleteLineByName(String name) {
         return lines.removeIf(line -> Objects.equals(line.getName(), name));
     }
+
+    private static final int FROM_ORDER_TO_INDEX = 1;
+
+    public static Line getLine(String name) {
+        return lines.stream()
+                .filter(station -> station.getName().equals(name))
+                .findAny()
+                .get();
+    }
+
+    public static Line getNewLine() {
+        return lines.get(lines.size() - FROM_ORDER_TO_INDEX);
+    }
+
+    public static void deleteStationInLine(String name) {
+        for (Line line : lines) {
+            line.getSections().removeIf(station -> Objects.equals(station.getName(), name));
+        }
+    }
+
+    public static boolean isDuplicate(String name) {
+        return lines.stream()
+                .anyMatch(station -> station.getName().equals(name));
+    }
+
+    public static List<Line> getLines() {
+        return lines;
+    }
 }
diff --git a/src/main/java/subway/domain/StationRepository.java b/src/main/java/subway/domain/StationRepository.java
index b7245c0f3..5a7dc09c2 100644
--- a/src/main/java/subway/domain/StationRepository.java
+++ b/src/main/java/subway/domain/StationRepository.java
@@ -19,4 +19,20 @@ public static void addStation(Station station) {
     public static boolean deleteStation(String name) {
         return stations.removeIf(station -> Objects.equals(station.getName(), name));
     }
+
+    public static Station getStation(String name) {
+        return stations.stream()
+                .filter(station -> station.getName().equals(name))
+                .findAny()
+                .get();
+    }
+
+    public static boolean isDuplicate(String name) {
+        return stations.stream()
+                .anyMatch(station -> station.getName().equals(name));
+    }
+
+    public static List<Station> getStations() {
+        return stations;
+    }
 }
diff --git a/src/main/java/subway/view/InputView.java b/src/main/java/subway/view/InputView.java
new file mode 100644
index 000000000..5bda58b72
--- /dev/null
+++ b/src/main/java/subway/view/InputView.java
@@ -0,0 +1,16 @@
+package subway.view;
+
+import java.util.Scanner;
+
+public class InputView {
+    private String inputData;
+
+    public String getInputData() {
+        return inputData;
+    }
+
+    public void scanData(Scanner scanner) {
+        inputData = scanner.nextLine();
+        System.out.println();
+    }
+}
diff --git a/src/main/java/subway/view/OutputView.java b/src/main/java/subway/view/OutputView.java
new file mode 100644
index 000000000..b393a7238
--- /dev/null
+++ b/src/main/java/subway/view/OutputView.java
@@ -0,0 +1,229 @@
+package subway.view;
+
+import subway.domain.Line;
+import subway.domain.LineRepository;
+import subway.domain.Station;
+import subway.domain.StationRepository;
+
+public class OutputView {
+    private static final String NEXT_LINE = "\n";
+    private static final String GUIDE_MESSAGE_START = "##";
+    private static final String GUIDE_MESSAGE_END_CHOOSE_FUNCTION = "원하는 기능을 선택하세요.";
+    private static final String GUIDE_MESSAGE_END_ADD_STATION = "등록할 역 이름을 입력하세요.";
+    private static final String GUIDE_MESSAGE_END_DELETE_STATION = "삭제할 역 이름을 입력하세요.";
+    private static final String GUIDE_MESSAGE_END_ADD_LINE_NAME = "등록할 노선 이름을 입력하세요.";
+    private static final String GUIDE_MESSAGE_END_ADD_LINE_UPWARD_TERMINAL = "등록할 노선의 상행 종점역 이름을 입력하세요.";
+    private static final String GUIDE_MESSAGE_END_ADD_LINE_DOWNWARD_TERMINAL = "둥록할 노선의 하행 종점역 이름을 입력하세요.";
+    private static final String GUIDE_MESSAGE_END_DELETE_LINE = "삭제할 노선 이름을 입력하세요.";
+    private static final String GUIDE_MESSAGE_END_CKECK_SECTION_LINE = "노선을 입력하세요.";
+    private static final String GUIDE_MESSAGE_END_CHECK_SECTION_STATION = "역 이름을 입력하세요.";
+    private static final String GUIDE_MESSAGE_END_CHECK_SECTION_ORDER = "순서를 입력하세요.";
+    private static final String GUIDE_MESSAGE_END_DELETE_SECTION_LINE = "삭제할 구간의 노선을 입력하세요.";
+    private static final String GUIDE_MESSAGE_END_DELETE_SECTION_STATION = "삭제할 구간의 역을 입력하세요.";
+
+    private static final String INFO_MESSAGE_START = "[INFO]";
+    private static final String INFO_MESSAGE_END_ADD_STATION = "지하철 역이 등록되었습니다.";
+    private static final String INFO_MESSAGE_END_DELETE_STATION = "지하철 역이 삭제되었습니다.";
+    private static final String INFO_MESSAGE_END_ADD_LINE = "지하철 노선이 등록되었습니다.";
+    private static final String INFO_MESSAGE_END_DELETE_LINE = "지하철 노선이 삭제되었습니다.";
+    private static final String INFO_MESSAGE_END_ADD_SECTION = "구간이 등록되었습니다.";
+    private static final String INFO_MESSAGE_END_DELETE_SECTION = "구간이 삭제되었습니다.";
+
+    private static final String ERROR_MESSAGE_START = "[ERROR]";
+    private static final String ERROR_MESSAGE_END_CHOOSE_FUNCTION = "선택할 수 없는 기능입니다.";
+    private static final String ERROR_MESSAGE_END_ADD_STATION_FORMAT = "역 이름은 2글자 이상, 한글과 숫자 조합이며, '-역'으로 끝나야 합니다.";
+    private static final String ERROR_MESSAGE_END_ADD_STATION_DUPLICATE = "이미 등록된 역 이름입니다.";
+    private static final String ERROR_MESSAGE_END_DELETE_STATION_NOT_REGISTERED = "등록되지 않은 역입니다.";
+    private static final String ERROR_MESSAGE_END_ADD_LINE_FORMAT = "노선 이름은 2글자 이상, 한글과 숫자 조합이며, '-선'으로 끝나야 합니다.";
+    private static final String ERROR_MESSAGE_END_ADD_LINE_DUPLICATE = "이미 등록된 노선 이름입니다.";
+    private static final String ERROR_MESSAGE_END_DELETE_LINE_NOT_REGISTERED = "등록되지 않은 노선입니다.";
+    private static final String ERROR_MESSAGE_END_PARSEINT_ORDER = "구간 순서는 숫자여야 합니다.";
+    private static final String ERROR_MESSAGE_END_INBOUND_ORDER = "구간 순서는 1이상이며 해당 노선 구간의 길이 이하입니다.";
+
+    public void guideChooseFunction() {
+        System.out.println(String.join(" ", GUIDE_MESSAGE_START, GUIDE_MESSAGE_END_CHOOSE_FUNCTION));
+    }
+
+    public void guideAddStation() {
+        System.out.println(String.join(" ", GUIDE_MESSAGE_START, GUIDE_MESSAGE_END_ADD_STATION));
+    }
+
+    public void guideDeleteStation() {
+        System.out.println(String.join(" ", GUIDE_MESSAGE_START, GUIDE_MESSAGE_END_DELETE_STATION));
+    }
+
+    public void guideAddLineName() {
+        System.out.println(String.join(" ", GUIDE_MESSAGE_START, GUIDE_MESSAGE_END_ADD_LINE_NAME));
+    }
+
+    public void guideAddLineUpwardTerminal() {
+        System.out.println(String.join(" ", GUIDE_MESSAGE_START, GUIDE_MESSAGE_END_ADD_LINE_UPWARD_TERMINAL));
+    }
+
+    public void guideAddLineDownwardTerminal() {
+        System.out.println(String.join(" ", GUIDE_MESSAGE_START, GUIDE_MESSAGE_END_ADD_LINE_DOWNWARD_TERMINAL));
+    }
+
+    public void guideDeleteLine() {
+        System.out.println(String.join(" ", GUIDE_MESSAGE_START, GUIDE_MESSAGE_END_DELETE_LINE));
+    }
+
+    public void guideCheckLine() {
+        System.out.println(String.join(" ", GUIDE_MESSAGE_START, GUIDE_MESSAGE_END_CKECK_SECTION_LINE));
+    }
+
+    public void guideCheckSectionStation() {
+        System.out.println(String.join(" ", GUIDE_MESSAGE_START, GUIDE_MESSAGE_END_CHECK_SECTION_STATION));
+    }
+
+    public void guideCheckSectionOrder() {
+        System.out.println(String.join(" ", GUIDE_MESSAGE_START, GUIDE_MESSAGE_END_CHECK_SECTION_ORDER));
+    }
+
+    public void guideDeleteSectionLine() {
+        System.out.println(String.join(" ", GUIDE_MESSAGE_START, GUIDE_MESSAGE_END_DELETE_SECTION_LINE));
+    }
+
+    public void guideDeleteSectionStation() {
+        System.out.println(String.join(" ", GUIDE_MESSAGE_START, GUIDE_MESSAGE_END_DELETE_SECTION_STATION));
+    }
+
+    public void errorChooseFunction() {
+        System.out.println(String.join(" ", ERROR_MESSAGE_START, ERROR_MESSAGE_END_CHOOSE_FUNCTION));
+        System.out.println();
+    }
+
+    public void infoAddStation() {
+        System.out.println(String.join(" ", INFO_MESSAGE_START, INFO_MESSAGE_END_ADD_STATION));
+        System.out.println();
+    }
+
+    public void errorStationFormat() {
+        System.out.println(String.join(" ", ERROR_MESSAGE_START, ERROR_MESSAGE_END_ADD_STATION_FORMAT));
+        System.out.println();
+    }
+
+    public void errorStationDuplicate() {
+        System.out.println(String.join(" ", ERROR_MESSAGE_START, ERROR_MESSAGE_END_ADD_STATION_DUPLICATE));
+        System.out.println();
+    }
+
+    public void infoDeleteStation() {
+        System.out.println(String.join(" ", INFO_MESSAGE_START, INFO_MESSAGE_END_DELETE_STATION));
+        System.out.println();
+    }
+
+    public void errorDeleteStationNotRegistered() {
+        System.out.println(String.join(" ", ERROR_MESSAGE_START, ERROR_MESSAGE_END_DELETE_STATION_NOT_REGISTERED));
+        System.out.println();
+    }
+
+    public void infoAddLine() {
+        System.out.println(String.join(" ", INFO_MESSAGE_START, INFO_MESSAGE_END_ADD_LINE));
+        System.out.println();
+    }
+
+    public void errorLineFormat() {
+        System.out.println(String.join(" ", ERROR_MESSAGE_START, ERROR_MESSAGE_END_ADD_LINE_FORMAT));
+        System.out.println();
+    }
+
+    public void errorLineDuplicate() {
+        System.out.println(String.join(" ", ERROR_MESSAGE_START, ERROR_MESSAGE_END_ADD_LINE_DUPLICATE));
+        System.out.println();
+    }
+
+    public void infoDeleteLine() {
+        System.out.println(String.join(" ", INFO_MESSAGE_START, INFO_MESSAGE_END_DELETE_LINE));
+        System.out.println();
+    }
+
+    public void errorDeleteLineNotRegistered() {
+        System.out.println(String.join(" ", ERROR_MESSAGE_START, ERROR_MESSAGE_END_DELETE_LINE_NOT_REGISTERED));
+        System.out.println();
+    }
+
+    public void infoAddSection() {
+        System.out.println(String.join(" ", INFO_MESSAGE_START, INFO_MESSAGE_END_ADD_SECTION));
+        System.out.println();
+    }
+
+    public void errorParseIntOrder() {
+        System.out.println(String.join(" ", ERROR_MESSAGE_START, ERROR_MESSAGE_END_PARSEINT_ORDER));
+        System.out.println();
+    }
+
+    public void errorInBoundOrder() {
+        System.out.println(String.join(" ", ERROR_MESSAGE_START, ERROR_MESSAGE_END_INBOUND_ORDER));
+        System.out.println();
+    }
+
+    public void infoDeleteSection() {
+        System.out.println(String.join(" ", INFO_MESSAGE_START, INFO_MESSAGE_END_DELETE_SECTION));
+        System.out.println();
+    }
+
+    public void printMainScreen() {
+        System.out.println("## 메인 화면");
+        System.out.println("1. 역 관리");
+        System.out.println("2. 노선 관리");
+        System.out.println("3. 구간 관리");
+        System.out.println("4. 지하철 노선도 출력");
+        System.out.println("Q. 종료" + NEXT_LINE);
+        guideChooseFunction();
+    }
+
+    public void printStationManagementScreen() {
+        System.out.println("## 역 관리 화면");
+        System.out.println("1. 역 등록");
+        System.out.println("2. 역 삭제");
+        System.out.println("3. 역 조회");
+        System.out.println("B. 돌아가기" + NEXT_LINE);
+        guideChooseFunction();
+    }
+
+    public void printLineManagementScreen() {
+        System.out.println("## 노선 관리 화면");
+        System.out.println("1. 노선 등록");
+        System.out.println("2. 노선 삭제");
+        System.out.println("3. 노선 조회");
+        System.out.println("B. 돌아가기" + NEXT_LINE);
+        guideChooseFunction();
+    }
+
+    public void printSectionManagementScreen() {
+        System.out.println("## 구간 관리 화면");
+        System.out.println("1. 구간 등록");
+        System.out.println("2. 구간 삭제");
+        System.out.println("B. 돌아가기" + NEXT_LINE);
+        guideChooseFunction();
+    }
+
+    public void printAllStations() {
+        System.out.println(String.join(" ", GUIDE_MESSAGE_START, "역 목록"));
+        for (Station station : StationRepository.getStations()) {
+            System.out.println(String.join(" ", INFO_MESSAGE_START, station.getName()));
+        }
+        System.out.println();
+    }
+
+    public void printAllLines() {
+        System.out.println(String.join(" ", GUIDE_MESSAGE_START, "노선 목록"));
+        for (Line line : LineRepository.getLines()) {
+            System.out.println(String.join(" ", INFO_MESSAGE_START, line.getName()));
+        }
+        System.out.println();
+    }
+
+    public void printSubwaySections() {
+        System.out.println(String.join(" ", GUIDE_MESSAGE_START, "지하철 노선도"));
+        for (Line line : LineRepository.getLines()) {
+            System.out.println(String.join(" ", INFO_MESSAGE_START, line.getName()));
+            System.out.println(String.join(" ", INFO_MESSAGE_START, "---"));
+            for (Station station : line.getSections()) {
+                System.out.println(String.join(" ", INFO_MESSAGE_START, station.getName()));
+            }
+            System.out.println();
+        }
+    }
+}