[4기 - 김재웅] 1~2주차 과제 : 계산기 구현 미션 제출합니다.

calculator/src/main/java/org/example/CalConfig.java

@@ -0,0 +1,27 @@
+package org.example;
+
+import org.example.Calculate.*;
+import org.example.Input.Input;
+import org.example.Input.UserInput;
+import org.example.Output.Show;
+import org.example.Output.ShowingText;
+import org.example.Repository.ExpressionRepository;
+import org.example.Repository.Repository;
+
+public class CalConfig {
+    public Calculate calculate(){
+        return new Calculator(new CalOrderImpl());
+    }
+    public Repository repository(){
+        return new ExpressionRepository();
+    }
+    public Input input(){
+        return new UserInput();
+    }
+    public Show show(){
+        return new ShowingText();
+    }
+    public PreProcess preProcess() {
+        return new PreProcessImpl();
+    }
+}

calculator/src/main/java/org/example/Calculate/CalOrder.java

@@ -0,0 +1,9 @@
+package org.example.Calculate;
+
+import java.util.Stack;
+
+public interface CalOrder {
+    void setStack(Stack<String> expressionStack);
+
+    int calculate();
+}

calculator/src/main/java/org/example/Calculate/CalOrderImpl.java

@@ -0,0 +1,59 @@
+package org.example.Calculate;
+
+import java.util.Stack;
+
+public class CalOrderImpl implements CalOrder {
+    private int result = 0;
+    Stack<String> expressionStack = new Stack<>();
+
+    public int calculate() {
+        calculateMultiplyDivide();
+        return calculatePlusMinus();
+    }
+
+    private void calculateMultiplyDivide() {
+        for (int i = 1; i < expressionStack.size(); i += 2) {
+            if (expressionStack.get(i).equals("*")) {
+                multiply(i);
+                i -= 2;
+            } else if (expressionStack.get(i).equals("/")) {
+                divide(i);
+                i -= 2;
+            }
+        }
+    }
+
+    private int calculatePlusMinus() {
+        result = Integer.parseInt(expressionStack.get(0));
+        for (int i = 1; i < expressionStack.size(); i += 2) {
+            if (expressionStack.get(i).equals("+")) {
+                result += Integer.parseInt(expressionStack.get(i + 1));
+            } else {
+                result -= Integer.parseInt(expressionStack.get(i + 1));
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public void setStack(Stack<String> expressionStack) {
+        this.expressionStack = expressionStack;
+    }
+
+    private void multiply(int idx) {
+        result = Integer.parseInt(expressionStack.get(idx - 1)) * Integer.parseInt(expressionStack.get(idx + 1));
+        replaceNumOperatorNumWithResult(idx);
+    }
+
+    private void divide(int idx) {
+        result = Integer.parseInt(expressionStack.get(idx - 1)) / Integer.parseInt(expressionStack.get(idx + 1));
+        replaceNumOperatorNumWithResult(idx);
+    }
+
+    private void replaceNumOperatorNumWithResult(int idx) {
+        expressionStack.add(idx - 1, String.valueOf(result));
+        expressionStack.remove(idx);
+        expressionStack.remove(idx);
+        expressionStack.remove(idx);
+    }
+}

calculator/src/main/java/org/example/Calculate/Calculate.java

@@ -0,0 +1,7 @@
+package org.example.Calculate;
+
+import java.util.Stack;
+
+public interface Calculate {
+    int calculate(Stack<String> expressionStack);
+}

calculator/src/main/java/org/example/Calculate/Calculator.java

@@ -0,0 +1,16 @@
+package org.example.Calculate;
+
+import java.util.Stack;
+
+public class Calculator implements Calculate {
+    CalOrder calOrder;
+
+    public Calculator(CalOrder calOrder) {
+        this.calOrder = calOrder;
+    }
+
+    public int calculate(Stack<String> expressionStack) {
+        calOrder.setStack(expressionStack);
+        return calOrder.calculate();
+    }
+}

calculator/src/main/java/org/example/Calculate/PreProcess.java

@@ -0,0 +1,7 @@
+package org.example.Calculate;
+
+import java.util.Stack;
+
+public interface PreProcess {
+    Stack<String> expressionToStack(String expression);
+}

calculator/src/main/java/org/example/Calculate/PreProcessImpl.java

@@ -0,0 +1,20 @@
+package org.example.Calculate;
+
+import java.util.Arrays;
+import java.util.Stack;
+
+public class PreProcessImpl implements PreProcess {
+    Stack<String> expressionStack = new Stack<>();
+
+    @Override
+    public Stack<String> expressionToStack(String expression) {
+        makeEmptyStack();
+        Arrays.stream(expression.split(" "))
+                .forEach(expressionStack::add);
+        return expressionStack;
+    }
+
+    private void makeEmptyStack() {
+        expressionStack.clear();
+    }
+}

calculator/src/main/java/org/example/Choice.java

@@ -0,0 +1,19 @@
+package org.example;
+
+public enum Choice {
+    HISTORY(1), CALCULATION(2), END(3),WRONGNUMBER(4);
+
+    private final int inputValue;
+    private static final Choice[] CHOICES = Choice.values();
+
+    Choice(int inputValue) {
+        this.inputValue = inputValue;
+    }
+
+    public static Choice of(int inputValue) {
+        if (inputValue < 1 || inputValue > 3) {
+            return CHOICES[3];
+        }
+        return CHOICES[inputValue - 1];
+    }
+}

calculator/src/main/java/org/example/Input/Input.java

@@ -0,0 +1,6 @@
+package org.example.Input;
+
+public interface Input {
+    int inputNumber();
+    String inputExpression();
+}

calculator/src/main/java/org/example/Input/UserInput.java

@@ -0,0 +1,17 @@
+package org.example.Input;
+
+import java.util.Scanner;
+
+public class UserInput implements Input {
+    Scanner scanner = new Scanner(System.in);
+    @Override
+    public int inputNumber() {
+        return scanner.nextInt();
+    }
+
+    @Override
+    public String inputExpression() {
+        scanner.nextLine();
+        return scanner.nextLine();
+    }
+}

calculator/src/main/java/org/example/Main.java

@@ -0,0 +1,49 @@
+package org.example;
+
+import org.example.Calculate.Calculate;
+import org.example.Calculate.PreProcess;
+import org.example.Input.Input;
+import org.example.Output.Show;
+import org.example.Repository.Repository;
+
+import java.util.List;
+import java.util.Stack;
+
+public class Main {
+    private static int choice;
+
+    public static void main(String[] args) {
+        CalConfig calConfig = new CalConfig();
+        Calculate calculator = calConfig.calculate();
+        Repository repository = calConfig.repository();
+        Input input = calConfig.input();
+        Show show = calConfig.show();
+        PreProcess preProcess = calConfig.preProcess();
+
+        while (true) {
+            show.showMenu();
+            choice = input.inputNumber();
+            Choice menuChoice = Choice.of(choice);
+            show.lineBreak();
+            switch (menuChoice) {
+                case HISTORY:
+                    List<String> records = repository.getRecords();
+                    show.showRecords(records);
+                    break;
+                case CALCULATION:
+                    String expression = input.inputExpression();
+                    Stack<String> expressionStack = preProcess.expressionToStack(expression);
+                    int result = calculator.calculate(expressionStack);
+                    repository.save(expression, result);
+                    show.showResult(result);
+                    break;
+                case WRONGNUMBER:
+                    show.showInvalidInput();
+                    break;
+                case END:
+                    return;
+            }
+            show.lineBreak();
+        }
+    }
+}

calculator/src/main/java/org/example/Output/Show.java

@@ -0,0 +1,15 @@
+package org.example.Output;
+
+import java.util.List;
+
+public interface Show {
+    void showMenu();
+
+    void showRecords(List<String> records);
+
+    void showResult(int result);
+
+    void lineBreak();
+
+    void showInvalidInput();
+}

calculator/src/main/java/org/example/Output/ShowingText.java

@@ -0,0 +1,31 @@
+package org.example.Output;
+
+import java.util.List;
+
+public class ShowingText implements Show {
+    @Override
+    public void showMenu() {
+        System.out.println("1. 조회\n2. 계산\n3. 종료\n");
+        System.out.print("선택 : ");
+    }
+
+    @Override
+    public void showRecords(List<String> records) {
+        records.forEach(System.out::println);
+    }
+
+    @Override
+    public void showResult(int result) {
+        System.out.println(result);
+    }
+
+    @Override
+    public void lineBreak() {
+        System.out.println();
+    }
+
+    @Override
+    public void showInvalidInput() {
+        System.out.println("잘못된 값을 입력하였습니다.");
+    }
+}

calculator/src/main/java/org/example/Repository/ExpressionRepository.java

@@ -0,0 +1,18 @@
+package org.example.Repository;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ExpressionRepository implements Repository {
+    private static List<String> store = new ArrayList<>();
+
+    @Override
+    public void save(String expression, int result) {
+        store.add(expression + " = " + result);
+    }
+
+    @Override
+    public List<String> getRecords() {
+        return store;
+    }
+}

calculator/src/main/java/org/example/Repository/Repository.java

@@ -0,0 +1,8 @@
+package org.example.Repository;
+
+import java.util.List;
+
+public interface Repository {
+    void save(String expression, int result);
+    List<String> getRecords();
+}

calculator/src/test/java/org/example/Calculate/CalculateImplTest.java

@@ -0,0 +1,36 @@
+package org.example.Calculate;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.Stack;
+
+class CalculateImplTest {
+
+    PreProcess preProcess = new PreProcessImpl();
+    Calculate calculator = new Calculator(new CalOrderImpl());
+
+    @Test
+    void calculateTest() {
+        String expression = "2 * 3 - 6 / 3";
+        Stack<String> expressionStack = preProcess.expressionToStack(expression);
+        int result = calculator.calculate(expressionStack);
+        Assertions.assertEquals(result, 4);
+    }
+
+    @Test
+    void calculateTest2() {
+        String expression = "3 * 6 * 2 / 2";
+        Stack<String> expressionStack = preProcess.expressionToStack(expression);
+        int result = calculator.calculate(expressionStack);
+        Assertions.assertEquals(result, 18);
+    }
+
+    @Test
+    void calculateTest3() {
+        String expression = "3 + 6 + 2 + 2";
+        Stack<String> expressionStack = preProcess.expressionToStack(expression);
+        int result = calculator.calculate(expressionStack);
+        Assertions.assertEquals(result, 13);
+    }
+}