[4기 - 한승원] 1~2주차 과제 : 계산기 구현 미션 제출합니다(사칙연산)

src/main/java/co/programmers/App.java

@@ -0,0 +1,20 @@
+package co.programmers;
+
+import co.programmers.domain.CalculatorApp;
+import co.programmers.repository.CalculatorRepository;
+import co.programmers.repository.Repository;
+import co.programmers.view.CalculatorInputView;
+import co.programmers.view.CalculatorOutputView;
+import co.programmers.view.InputView;
+import co.programmers.view.OutputView;
+
+public class App {
+
+	public static void main(String[] args) {
+		InputView inputView = new CalculatorInputView();
+		OutputView outputView = new CalculatorOutputView();
+		Repository repository = new CalculatorRepository();
+		CalculatorApp calculatorApp = new CalculatorApp(inputView, outputView, repository);
+		calculatorApp.run();
+	}
+}

src/main/java/co/programmers/domain/Calculation.java

@@ -0,0 +1,59 @@
+package co.programmers.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Calculation {
+
+	private List<String> parsedExpression;
+	private List<String> operators;
+	private Expression expression;
+
+	public Calculation(Expression expression) {
+		this.expression = expression;
+		parsedExpression = new ArrayList<>();
+		operators = new ArrayList<>();
+	}
+
+	public Double calculate() throws ArithmeticException {
+		parsedExpression = expression.split();
+		operators = extractOperators();
+		Operator.decideCalculationOrder(operators);
+		for (String operator : operators) {
+			int operatorPosition = parsedExpression.indexOf(operator);
+			Double[] operands = extractOperands(operator);
+			Double calculationRes = Operator.calculate(operator, operands[0], operands[1]);
+			storeIntermediateResult(operatorPosition, calculationRes);
+			removeCompletedExpression(operatorPosition, operands.length);
+		}
+		return calcFinalResult();
+	}
+
+	private void removeCompletedExpression(int operatorPosition, int count) {
+		for (int cnt = 0; cnt <= count; cnt++) {
+			parsedExpression.remove(operatorPosition);
+		}
+	}
+
+	private void storeIntermediateResult(int operatorPosition, Double calculationRes) {
+		parsedExpression.add(operatorPosition - 1, String.valueOf(calculationRes));
+	}
+
+	private Double[] extractOperands(String operator) {
+		int operatorIdx = parsedExpression.indexOf(operator);
+		Double operand1 = Double.parseDouble(parsedExpression.get(operatorIdx - 1));
+		Double operand2 = Double.parseDouble(parsedExpression.get(operatorIdx + 1));
+		return new Double[] {operand1, operand2};
+	}
+
+	private List<String> extractOperators() {
+		expression.eliminateWhiteSpace();
+		List<String> parsed = expression.split("\\d+");
+		parsed.removeIf(String::isEmpty);
+		return parsed;
+	}
+
+	private Double calcFinalResult() {
+		return Double.parseDouble(parsedExpression.get(0));
+	}
+}

src/main/java/co/programmers/domain/CalculatorApp.java

@@ -0,0 +1,62 @@
+package co.programmers.domain;
+
+import co.programmers.exception.ExceptionMessage;
+import co.programmers.repository.Repository;
+import co.programmers.view.CalculatorOutputView;
+import co.programmers.view.InputView;
+import co.programmers.view.OutputView;
+
+public class CalculatorApp {
+
+	private final InputView inputView;
+	private final OutputView outputView;
+	private final Repository repository;
+
+	public CalculatorApp(InputView inputView, OutputView outputView, Repository repository) {
+		this.inputView = inputView;
+		this.outputView = outputView;
+		this.repository = repository;
+	}
+
+	public void run() {
+		UserMenu userMenu;
+		do {
+			CalculatorOutputView.printMenuChoiceGuide();
+			userMenu = UserMenu.get(inputView.inputUserMenu());
+			executeSelectedMenu(userMenu);
+		} while (userMenu != UserMenu.TERMINATE);
+	}
+
+	private void executeSelectedMenu(UserMenu userMenu) {
+		switch (userMenu) {
+			case INQUIRY:
+				inquiry();
+				break;
+			case CALCULATE:
+				calculate();
+				break;
+			case TERMINATE:
+				break;
+			default:
+				outputView.printMessage(ExceptionMessage.INVALID_INPUT);
+				break;
+		}
+	}
+
+	public void inquiry() {
+		outputView.printCalculationHistory(repository.read());
+	}
+
+	public void calculate() {
+		try {
+			CalculatorOutputView.printCalculationGuide();
+			Expression expression = inputView.inputExpression();
+			Calculation calculator = new Calculation(expression);
+			Double output = calculator.calculate();
+			outputView.printCalculationResult(output);
+			repository.save(expression.getExpression(), output);
+		} catch (ArithmeticException arithmeticException) {
+			System.out.println(arithmeticException.getMessage());
+		}
+	}
+}

src/main/java/co/programmers/domain/Expression.java

@@ -0,0 +1,47 @@
+package co.programmers.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import co.programmers.exception.ExceptionMessage;
+
+public class Expression {
+
+	private static final Pattern EXPRESSION_FORMAT = Pattern.compile("(\\d+\\s[\\+\\-\\*\\/]\\s)+\\d+");
+	private static final String DELIMITER = " ";
+	private String expression;
+
+	public Expression(String expression) {
+		this.expression = expression;
+		if (expression == null || expression.isEmpty()) {
+			throw new IllegalArgumentException(ExceptionMessage.EMPTY_INPUT);
+		}
+		if (!validate()) {
+			throw new ArithmeticException(ExceptionMessage.INVALID_EXPRESSION);
+		}
+	}
+
+	private boolean validate() {
+
+		Matcher matcher = EXPRESSION_FORMAT.matcher(expression);
+		return matcher.matches();
+	}
+
+	public List<String> split() {
+		return new ArrayList<>(List.of(expression.split(DELIMITER)));
+	}
+
+	public List<String> split(String delimiter) {
+		return new ArrayList<>(List.of(expression.split(delimiter)));
+	}
+
+	public void eliminateWhiteSpace() {
+		expression = expression.replaceAll("\\s", "");
+	}
+
+	public String getExpression() {
+		return expression;
+	}
+}