[내일배움캠프 Spring_3기] CH2 계산기과제 Step3

 

오늘은 Step3(도전과제)를 진행해보았다.

---

OperatorType.java 구현 과정

Step2까지의 계산기에서는
연산자를 char 타입(+, -, *, /)으로 입력받아
switch 문으로 분기 처리했다.

switch (operator) {
    case '+': ...
    case '-': ...
}

이 방식은 동작에는 문제가 없지만
연산자 종류가 늘어나면 관리가 어려워지고,
잘못된 연산자 입력에 대한 처리가 분산되며
하나의 개념으로 관리한다는 느낌이 부족하다고 생각했다.

그래서 Step3에서는
Enum을 활용해 연산자 타입을 관리하도록 요구하고 있다.

---

OperatorType enum 설계

사칙연산은 고정된 값을 가지므로
Enum을 사용하기에 적합하다고 판단했다.

package com.example.calculator.step3;

public enum OperatorType {
    ADD('+'),
    SUB('-'),
    MUL('*'),
    DIV('/');

    private final char symbol;

    OperatorType(char symbol) {
        this.symbol = symbol;
    }

    public char getSymbol() {
        return symbol;
    }

    public static OperatorType fromSymbol(char symbol) {
        for (OperatorType type : values()) {
            if (type.symbol == symbol) return type;
        }
        throw new IllegalArgumentException("지원하지 않는 연산자입니다.");
    }
}

---

enum 상수 정의

ADD('+'),
SUB('-'),
MUL('*'),
DIV('/');

• 사칙연산을 영어 이름으로 정의했다.
• 연산자는 실제 입력되는 기호를 함께 가진다.

---

필드와 생성자

private final char symbol;

OperatorType(char symbol) {
    this.symbol = symbol;
}

• enum도 클래스이기 때문에 필드와 생성자를 가질 수 있다.
• 각 연산 타입은 자신이 어떤 기호와 연결되어 있는지 알 수 있다.

---

fromSymbol 메서드

public static OperatorType fromSymbol(char symbol) {
    for (OperatorType type : values()) {
        if (type.symbol == symbol) return type;
    }
    throw new IllegalArgumentException("지원하지 않는 연산자입니다.");
}

• 사용자가 입력한 연산자를 대응되는 OperatorType으로 변환하는 역할을 한다.

입력은 char지만
내부 계산 로직은 enum 기반으로 동작하게 만든다.

이 구조 덕분에
잘못된 연산자 입력에 대한 예외 처리를 한 곳에서 관리할 수 있고,
계산 로직에서는 enum만 신경 쓰면 된다.

---

기존 Step2의 calculate 메서드는 다음과 같은 형태였다.

calculate(int num1, int num2, char operator)

Step3에서는 다음과 같은 흐름으로 변경했다.

1. 연산자를 char로 입력받고
2. OperatorType.fromSymbol()로 enum으로 변환한 뒤
3. 계산기 클래스에 enum을 전달한다.

---

Enum 적용의 장점

• 연산자 타입을 하나의 개념으로 묶어 관리할 수 있다.
• switch 분기의 기준이 명확해진다.
• 잘못된 연산자 예외 처리가 깔끔해진다.
• 이후 연산이 추가되더라도 확장성이 좋아진다.

---

트러블슈팅

OperatorType.java를 커밋한 뒤
git push origin main을 실행했지만 오류가 발생했다.

해결을 시도하기 위해
git pull origin main을 실행했지만
이 역시 오류가 발생했다.

해결 방법: rebase 사용

rebase 과정에서 충돌은 발생하지 않았고,
정상적으로 push까지 완료할 수 있었다.

---

Calculator.java 구현

calculator.java를 수정하여
Enum 기반 연산, 제네릭으로 다양한 숫자 타입 처리,
Stream / Lambda를 활용한 조회 기능까지 구현했다.

---

Step2와 Step3 비교

Step2

• calculate(int, int, char)
• 결과 저장: List<Integer>

Step3

• 연산자: OperatorType(Enum)
• 숫자 타입 확장: <T extends Number>
• 결과 조건 조회: Stream, Lambda 사용

---

결과 저장 컬렉션

private final List<Double> results = new ArrayList<>();

• Step2에서는 List<Integer>였지만 Step3에서는 Double로 변경했다.
• final을 사용해 리스트 자체는 변경하지 못하도록 했다.

---

calculate 메서드 (제네릭)

public <T extends Number> double calculate(T num1, T num2, OperatorType operator)

• T extends Number로 설정해 다양한 숫자 타입을 받을 수 있다.

---

doubleValue()

double a = num1.doubleValue();
double b = num2.doubleValue();

• Number가 제공하는 doubleValue()를 통해 계산 가능한 상태로 변환했다.
• 제네릭 타입 T는 직접 연산이 불가능하기 때문에 변환이 필요하다.

---

Enum 기반 연산

switch (operator) {
    case ADD: ...
}

• Step2에서는 char 기준이었지만
• Step3에서는 OperatorType(enum)을 기준으로 분기한다.

---

예외 처리

if (b == 0) {
    throw new IllegalArgumentException("0으로 나눌 수 없습니다.");
}

• 0으로 나누는 상황을 방지한다.
• 예외는 App에서 잡아 메시지를 출력하도록 구성했다.

---

결과 저장

results.add(result);

• Step2와 동일하게 연산 결과는 리스트에 저장한다.

---

Stream / Lambda 조회

return results.stream()
        .filter(r -> r > value)
        .collect(Collectors.toList());

• stream()으로 리스트를 흐름으로 변환
• filter로 조건에 맞는 값만 추출
• collect로 다시 리스트로 반환

---

Calculator.java 전체 코드

package com.example.calculator.step3;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class Calculator {

    private final List<Double> results = new ArrayList<>();

    public <T extends Number> double calculate(T num1, T num2, OperatorType operator) {

        double result = 0;

        double a = num1.doubleValue();
        double b = num2.doubleValue();

        switch (operator) {
            case ADD:
                result = a + b;
                break;
            case SUB:
                result = a - b;
                break;
            case MUL:
                result = a * b;
                break;
            case DIV:
                if (b == 0) {
                    throw new IllegalArgumentException("0으로 나눌 수 없습니다.");
                }
                result = a / b;
                break;
            default:
                throw new IllegalArgumentException("지원하지 않는 연산자입니다.");
        }

        results.add(result);
        return result;
    }

    public List<Double> getResults() {
        return new ArrayList<>(results);
    }

    public void setResults(List<Double> newResults) {
        results.clear();
        results.addAll(newResults);
    }

    public void removeResult() {
        if (!results.isEmpty()) {
            results.remove(0);
        }
    }

    public List<Double> getResultsGreaterThan(double value) {
        return results.stream()
                .filter(r -> r > value)
                .collect(Collectors.toList());
    }
}

---

App.java 구현 과정

calculator 인스턴스 생성

Calculator calculator = new Calculator();

• App은 입력과 출력만 담당한다.

---

반복 실행 구조

while (true) { ... }

exit 입력 전까지 계산이 반복된다.

---

OperatorType 변환

OperatorType opType = OperatorType.fromSymbol(operator);

• 사용자 입력(char)을 enum으로 변환해 내부 로직을 통일했다.

---

calculate 호출 (제네릭)

double result = calculator.calculate(num1, num2, opType);

• int뿐 아니라 double 타입도 처리할 수 있다.

---

예외 처리 트러블슈팅

오류(0으로 나누기, 잘못된 연산자)가 발생해도
프로그램이 종료되지 않고
기준값을 계속 물어보는 문제가 발생했다.

catch (IllegalArgumentException e) {
    System.out.println("오류: " + e.getMessage());
    continue;
}

• catch에서 continue를 사용해
  오류 발생 시 기준값 입력 로직이 실행되지 않도록 수정했다.

---

기준값 조회 (람다, 스트림)

System.out.println(calculator.getResultsGreaterThan(value));

---

App.java 전체 코드

package com.example.calculator.step3;

import java.util.Scanner;

public class App {
    public static void main(String[] args) {

        Calculator calculator = new Calculator();
        Scanner sc = new Scanner(System.in);

        while (true) {
            System.out.print("첫 번째 숫자를 입력하세요:");
            int num1 = sc.nextInt();

            System.out.print("두 번째 숫자를 입력하세요:");
            int num2 = sc.nextInt();

            System.out.print("사칙연산 기호를 입력하세요: ");
            char operator = sc.next().charAt(0);

            try {
                OperatorType opType = OperatorType.fromSymbol(operator);
                double result = calculator.calculate(num1, num2, opType);
                System.out.println("결과: " + result);
            } catch (IllegalArgumentException e) {
                System.out.println("오류: " + e.getMessage());
                continue;
            }

            System.out.println("저장된 결과 목록: " + calculator.getResults());

            System.out.print("기준값을 입력하세요: ");
            double value = sc.nextDouble();

            System.out.println("기준값보다 큰 결과: " + calculator.getResultsGreaterThan(value));

            System.out.println("가장 먼저 저장된 결과를 삭제하시겠습니까? (remove 입력 시 삭제)");
            String cmd = sc.next();
            if (cmd.equalsIgnoreCase("remove")) {
                calculator.removeResult();
                System.out.println("삭제 후 결과 목록: " + calculator.getResults());
            }

            System.out.println("더 계산하시겠습니까? (exit 입력 시 종료)");
            String answer = sc.next();

            if (answer.equals("exit")) break;
        }

        sc.close();
    }
}

---

플로우차트

며칠 전에 플로우차트를 배우면서 간단한 실습을 진행했는데,
이번 계산기 과제를 정리하는 데도 플로우차트를 활용해보았다.

---

과제 총평 (회고)

Step1, Step2까지는 비교적 수월하게 진행했지만
Step3부터 난이도가 확 올라갔다고 느꼈다.

Enum, 제네릭, 스트림, 람다 모두
강의에서 분명히 들은 내용이었지만
막상 적용하려니 어디에, 어떤 방식으로 써야 할지 계속 고민하게 되었다.

특히 제네릭 적용 과정에서
int → double로 단순 변경하는 것이 아니라
<T extends Number>로 확장하는 부분이 가장 어려웠다.

처음에는 괄호 우선순위, 제곱, 제곱근 기능까지 확장해보려 했지만
수식 문자열을 토큰화하고 연산 우선순위를 처리하는 로직이
생각보다 난이도가 높아 이번 과제에서는 구현하지 못했다.

대신 Step3 완성에 집중했고,
다음에는 위 기능들을 구현하고
GUI 기반 계산기로도 확장해보고 싶다는 목표가 생겼다.

과제를 시작할 때는 AI를 사용하지 않고 해결해보려고 했지만
막히는 부분이 많아 결국 도움을 받게 되었다.

다만 코드를 그대로 요청하기보다는
개념이나 해결 방향에 대한 힌트를 얻는 용도로 사용했고,
그 이후에는 직접 코드를 작성하고 수정하며 이해하려고 노력했다.

이번 계산기 과제를 통해
자바 문법을 단순히 아는 것과
실제로 사용하는 것의 차이를 확실히 느낄 수 있었다.
아직 완전히 익숙하다고는 말할 수 없지만,
왜 이렇게 작성했는지는 설명할 수 있는 상태가 되었다는 점에서
의미 있는 과제였다고 생각한다.