Merge pull request biforest#4 from oereo/feature/java-calculator-comment

feat: add comment and refactor

Author: oereo

src/main/java/calculator/Application.java

@@ -3,6 +3,8 @@
 
 public class Application {
     public static void main(String[] args) {
+
+        // Declare calculator object and start calculation
         Calculator calculator = new Calculator();
         calculator.calculation();
     }

src/main/java/calculator/ArithmeticExpressionStack.java

@@ -21,7 +21,7 @@ public ArithmeticExpressionStack(String[] equation, int stackSize){
 
     public String pop(){
         if(isEmpty()){
-            return "없는데?";
+            return "스택이 존재하지 않습니다.";
         }
         else{
             return stack[flag++];

src/main/java/calculator/Calculator.java

@@ -5,56 +5,104 @@
 
 public class Calculator {
     Message message = new Message();
+
+    /**
+     * calculation method
+     * 1. getEquation - Receives numeric expression in string format entered by user
+     * 2. Put numeric expressions on the stack
+     * 3. Passing the stack to the operatorSetting method
+     *
+     * return type : void
+     */
     public void calculation(){
         String[] equation_list = getEquation();
         ArithmeticExpressionStack arithmeticExpressionStack = new ArithmeticExpressionStack(equation_list, equation_list.length);
         OperatorSetting(arithmeticExpressionStack);
 
     }
 
+    /**
+     * OperatorSetting method
+     * 1. Pop each operator and number onto the stack.
+     * 2. Perform error exception check and calculate
+     * 3. After the calculation process is complete, call init() to determine whether to return the calculator
+     *
+     * return type : void
+     */
     public void OperatorSetting(ArithmeticExpressionStack arithmeticExpressionStack) {
         ErrorException exceptionCheck = new ErrorException();
         String firstString = arithmeticExpressionStack.pop();
+
+        // Error checking when converting string to int
         int cumulativeResult = exceptionCheck.NumericalError(firstString);
 
         for(int i = 0; i<(arithmeticExpressionStack.getStackSize())/2;i++){
             String operator = arithmeticExpressionStack.pop();
             String secondString = arithmeticExpressionStack.pop();
             int secondNumber = exceptionCheck.NumericalError(secondString);
+
+            // calculated value are continuously accumulated
             cumulativeResult = chooseOperatorAndCalculate(cumulativeResult, operator, secondNumber);
         }
 
         if(cumulativeResult != 0){
             message.calculationResult(cumulativeResult);
         }
+
+        // Whether to re-execute after calculation
         init();
     }
 
+    /**
+     * chooseOperatorAndCalculate method
+     * 1. Pop each operator and number onto the stack.
+     * 2. Perform error exception check and calculate
+     * 3. After the calculation process is complete, call init() to determine whether to return the calculator
+     *
+     * return type : int
+     */
     public int chooseOperatorAndCalculate(int firstNumber, String operator, int SecondNumber){
         AddOperation addOperation = new AddOperation();
         SubOperation subOperation = new SubOperation();
         MultiplyOperation multiplyOperation = new MultiplyOperation();
         DivideOperation divideOperation = new DivideOperation();
         int result = 0;
+
+        // When the operator is equal to "+"
         if (operator.equals(addOperation.operationName())){
             result = addOperation.calculation(firstNumber, SecondNumber);
         }
+
+        // When the operator is equal to "-"
         else if (operator.equals(subOperation.operationName())){
             result = subOperation.calculation(firstNumber, SecondNumber);
         }
+
+        // When the operator is equal to "*"
         else if (operator.equals(multiplyOperation.operationName())){
             result = multiplyOperation.calculation(firstNumber, SecondNumber);
         }
+
+        // When the operator is equal to "/"
         else if (operator.equals(divideOperation.operationName())){
             result = divideOperation.calculation(firstNumber, SecondNumber);
         }
+
+        // Raise error when a symbol that does not correspond to the arithmetic operations(+, -, *, /) comes
         else{
             message.exceptionResult("NOT_OPERATOR");
         }
 
         return result;
     }
 
+    /**
+     * init method
+     * - Input "1" to redo calculator.
+     * - Input another key to exit
+     *
+     * return type : void
+     */
     public void init(){
         Scanner scanner = new Scanner(System.in);
         System.out.println("계산을 계속 진행하시려면 1, 멈추시려면 임의의 다른키를 눌러주세요");
@@ -68,6 +116,12 @@ public void init(){
         }
     }
 
+    /**
+     * getEquation method
+     * - Method to receive user input data
+     *
+     * return type : void
+     */
     public String[] getEquation(){
         Scanner scanner = new Scanner(System.in);
         System.out.print("수식을 입력해주세요 : ");

src/main/java/calculator/DivideOperation.java

@@ -13,12 +13,13 @@ public String operationName() {
 
     @Override
     public int calculation(int beforeNumber, int afterNumber) {
+        Message message = new Message();
         try{
             int Result = beforeNumber / afterNumber;
             return Result;
         }
         catch (ArithmeticException e){
-            System.out.println("0으로 나눌수가 없습니다.");
+            message.exceptionResult("INVALID_DIVIDE");
         }
         return 0;
     }

src/main/java/calculator/ErrorException.java

@@ -4,6 +4,13 @@
 
 public class ErrorException {
     Message message = new Message();
+
+    /**
+     * NumericalError method
+     * - Raise error when string is not converted to int
+     *
+     * return type : void
+     */
     public int NumericalError(String number) {
         int numberConverted = 0;
         try {

src/main/java/calculator/Message.java

@@ -1,19 +1,30 @@
 package calculator;
 
-import java.lang.reflect.Field;
 import java.util.HashMap;
 
+/**
+ * Message class
+ * - message output class
+ *
+ * return type : void
+ */
 public class Message {
     HashMap<String, String> exceptionMessageList = new HashMap<String, String>();
+
+    // Result output method when operation is normally performed
     public void calculationResult(int result){
         System.out.print("결과 : ");
         System.out.println(result);
     }
+
+    // Error message list management method
     private void exceptionMessageList(){
         exceptionMessageList.put("NOT_OPERATOR", "사칙연산 기호에 해당하지 않는 기호가 존재합니다.");
         exceptionMessageList.put("INVALID_EQUATION", "잘못된 연산식입니다.");
+        exceptionMessageList.put("INVALID_DIVIDE", "0으로 나눌수가 없습니다.");
     }
 
+    // Error message output method
     public void exceptionResult(String exceptionKeyword){
         exceptionMessageList();
         System.out.println(exceptionMessageList.get(exceptionKeyword));