diff --git a/.gitignore b/.gitignore
new file mode 100644
index 000000000..c0e01feb8
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,53 @@
+HELP.md
+.gradle
+build/
+!gradle/wrapper/gradle-wrapper.jar
+!src/main/**
+!src/test/**
+
+### macOS ###
+.DS_Store
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+out/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+# Ignore Gradle build output directory
+build
+
+# Ignore Gradle GUI config
+gradle-app.setting
+
+# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
+!gradle-wrapper.jar
+
+# Avoid ignore Gradle wrappper properties
+!gradle-wrapper.properties
+
+# Cache of project
+.gradletasknamecache
+
+### Gradle Patch ###
+# Java heap dump
+*.hprof
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
new file mode 100644
index 000000000..2d6c6dc89
--- /dev/null
+++ b/build.gradle
@@ -0,0 +1,20 @@
+plugins {
+    id 'java'
+}
+
+group = 'com.programmers.calculator'
+version = '1.0-SNAPSHOT'
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation platform('org.junit:junit-bom:5.9.1')
+    testImplementation 'org.junit.jupiter:junit-jupiter'
+    testImplementation 'org.assertj:assertj-core:3.22.0'
+}
+
+test {
+    useJUnitPlatform()
+}
\ No newline at end of file
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 000000000..9835fef44
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,97 @@
+## 📌 과제 설명
+
+- [x] 콘솔로 구현
+- [x] OOP 계산기 구현
+    - [x] 더하기
+    - [x] 빼기
+    - [x] 곱하기
+    - [x] 나누기
+    - [x] 우선순위 (사칙연산)
+- [x] 테스트 코드 구현
+- [x] 계산 이력을 맵으로 데이터 저장 기능
+    - 애플리케이션이 동작하는 동안 DB 외에 데이터를 저장할 수 있는 방법 고민
+- [x] 정규식 사용
+
+<br>
+
+## 👩‍💻 요구 사항과 구현 내용
+
+1. 입력과 출력이 현재는 콘솔이지만, 각기 다른 형태로 바뀔 수 있어서 인터페이스로 추상화하고 이를 구현한 InputConsole과 OutputConsole이 생겼습니다.
+2. Calculator 클래스에서 입력을 받게 했다가 계산이라는 책임에서 멀어지는 것 같아서 Controller를 추가하여 연결시켰습니다.
+3. Enum 클래스를 활용하여 선택 가능한 메뉴를 정의하였고 예외처리를 진행했습니다.
+4. Calculator 클래스에서는 계산이라는 동작만 수행하고 Expression이라는 표현식 클래스에서 표현식과 관련된 모든 책임을 갖습니다.
+    - 연산자에 대한 책임은 Enum 클래스를 활용한 Operator에서 가지고 있습니다.
+5. 저장소를 구현할 때, HistoryRepository로 추상화하였고 이를 구현했습니다. 추가로, CalculationHistory 객체를 이용하여 저장시키도록 구현했습니다.
+6. 기존에 정규식을 다루던 곳은 Expression 이었으나, 수식 계산마다 Pattern을 생성하는 비용이 크다고 생각하여, 따로 util로 뺐습니다.
+    - Pattern 생성 비용에 관한 근거는, 클래스를 살펴보면 `new Pattern()` 하는 부분입니다.
+
+<br>
+
+## 😭 1차 자기주도적 리뷰 피드백
+
+**영수님 피드백**
+1. 값의 검증에는 예외처리를 하지 않는 것이 좋습니다. (`Expression` 클래스의 `isNumber()` 메서드)
+2. `Calculator` 클래스에서 필드로 `expression`을 가지는 것에 의문이 듭니다.
+3. `Expression` 클래스가 너무 비대하고 특히 `converToPostfix()` 메서드를 최대한 쪼개봅시다.
+4. `if-else` 보단 `switch`를 이용하여 리팩토링 해봅시다.
+5. 최대한 3 depth를 넘지 않게 메서드를 리팩토링 해봅시다.
+6. 여러 객체가 참조하는 형태가 아니라면, static 사용에 관하여 고민해봅시다.
+    - OutOfMemory에 관해서도 고려해봅시다.
+    - 가능한 static을 사용하지 않고 코드를 짜봅시다.
+7. Regex는 상수를 모아놓기 위한 장소같아보이는데, 어떤 고민을 해봐야할까요? 생각해봅시다.
+
+<br>
+
+**흑구님 피드백**
+1. 현재 모두 구현인 것 같고, 확장에 너무 닫혀 있습니다.
+2. 궁금한 것을 설명하고 싶은 의도는 알겠으나, 코드리뷰 요청하는 입장에서 코드를 주석처리한 것은 반드시 없애봅시다.
+3. 인스턴스를 생성하지 못하게 하고 싶을 때, 방어적으로 코드 작성하는 것을 생각합시다.
+4. 1개의 콘솔로 입출력 하는 상황인데, `InputConsole`과 `OutputConsole`이 마치 2개의 콘솔처럼 보입니다.
+5. 객체지향적 설계가 어렵다면, 저만의 방식인데, logic → behavior → data 를 생각해봅시다.
+    - logic : data를 이용한 behavior의 전체적인 흐름
+    - behavior : data를 이용하는 어떠한 행위
+    - data : 말 그대로 데이터, 객체
+    - logic은 behavior에, behavior은 data에 의존(사용)
+    - 각각 interaction(상호작용)에 관해서도 생각해볼 것
+6. 무조건 메서드로 표현할 필요는 없습니다. 객체간 상호작용이 부족한 지 생각해봅시다.
+7. 무조건 적인 set 지양은 하지말고, 어떤 문제가 있는지, 어떤 이유 때문인지 알고 set을 지양해봅시다. 너무 무서워하지 마세요.
+
+<br>
+
+## 😤 피드백 기반 리팩토링
+
+- [x] Console 단일화 및 구현체가 아닌 추상체에 의존하도록
+- [x] Controller 클래스 리팩토링
+  - [x] logic → behavior → data 고려했는가?
+  - [x] 객체간 상호작용을 고려했는가?
+- [x] Expression 클래스 리팩토링
+  - [x] 3 depth를 넘지 않는가?
+  - [x] 추상화를 고려하였는가?
+- [x] Regex에 방어 코딩을 적용했는가?
+
+
+## ✅ PR 포인트 & 궁금한 점
+
+**PR 포인트**
+
+- Expression 클래스의 기능이 비대한 것 같아서 나눴습니다.
+  - Converter, Evaluator 추상체를 만들고 그를 구현한 구현체를 활용했습니다.
+  - Calculator 추상체를 구현한 구현체에서 조립하여 사용했습니다.
+  - Parser도 추가했었는데, 맡는 책임이 Regex에서 역할과 비슷하여 없애고 이관했습니다.
+- 계산 결과는 수식을 감싸기 위하여 CalculationResult와 Expression vo를 만들었습니다.
+- Regex의 역할이 상수만 저장하는 것이라서 util과 맞지 않아서 enum으로 따로 뺐습니다.
+
+<br>
+
+**궁금한 점**
+
+1. logic behavior data를 최대한 고려해봤는데, 사실 아직도 감이 잘 잡히지 않습니다. 최대한 추상화해보려고 했는데, 역할이 너무 작나? 과한 추상화인가? 라는 고민이 계속 생겼습니다.
+2. 테스트 코드가 미흡하여, 영수님 강의를 듣고 감이 조금 잡혀서 작성해봤는데, 방식이 맞는지 모르겠습니다.
+3. 홍섭님 피드백을 봤을 때, 공학용 계산기와 사칙연산만 가능한 계산기를 고려해보려 했습니다.
+    - 현재, Operator enum에 사칙연산이 모두 몰아두고  enum의 values()를 반복돌리는 메서드를 정의해놔서 enum에 정의되어 있다면 반환해주고 없으면 예외를 던지는 상태입니다.
+    - enum에 기능만 추가하면 되기 때문에 공학용 계산기가 추가되는건 문제가 없습니다.
+    - enum에 다른 기능을 추가하면 사칙연산만 가능한 계산기가 다른 기능도 사용할 수 있는 상황이 되어버립니다.
+    - 이에 대하여 생각한 해결 방법은 아래와 같습니다.
+      - 공학용 계산기 enum을 하나 더 만들 때, 인터페이스를 이용해 확장 가능한 Enum Type이 되도록 리팩토링 하는 것 입니다. [아이템38 - 인터페이스 활용 Enum Type 확장](https://medium.com/lucky-sonnie/item-38-%ED%99%95%EC%9E%A5%ED%95%A0-%EC%88%98-%EC%9E%88%EB%8A%94-enum-type%EC%9D%B4-%ED%95%84%EC%9A%94%ED%95%98%EB%A9%B4-%EC%9D%B8%ED%84%B0%ED%8E%98%EC%9D%B4%EC%8A%A4%EB%A5%BC-%EC%82%AC%EC%9A%A9%ED%95%98%EB%9D%BC-9c9f78334a5e)를 참고하였습니다.
+      - enum을 없애고 FourArithmeticStrategy 라는 인터페이스를 구현하는 각각 사칙연산이 있고, 공학용 전략 인터페이스를 하나 만들어서 거기에 심화적인 기능을 추가하고, 기본 계산기에는 사칙연산 전략만 적용, 공학용 계산기에는 사칙연산전략 + 심화전략 적용 이렇게 가보려고 합니다.
+      - 어떠한 방법이 더 괜찮을지 궁금합니다.
\ No newline at end of file
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 000000000..249e5832f
Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 000000000..2d4d62871
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,6 @@
+#Thu Jun 08 01:00:05 KST 2023
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
new file mode 100755
index 000000000..1b6c78733
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,234 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+APP_NAME="Gradle"
+APP_BASE_NAME=${0##*/}
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
new file mode 100644
index 000000000..107acd32c
--- /dev/null
+++ b/gradlew.bat
@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/settings.gradle b/settings.gradle
new file mode 100644
index 000000000..bcf30bf6c
--- /dev/null
+++ b/settings.gradle
@@ -0,0 +1,2 @@
+rootProject.name = 'java-calculator'
+
diff --git a/src/main/java/com/programmers/Application.java b/src/main/java/com/programmers/Application.java
new file mode 100644
index 000000000..ef743155c
--- /dev/null
+++ b/src/main/java/com/programmers/Application.java
@@ -0,0 +1,39 @@
+package com.programmers;
+
+import com.programmers.calculator.controller.CalculatorController;
+import com.programmers.calculator.domain.component.Evaluator;
+import com.programmers.calculator.domain.component.NotationConverter;
+import com.programmers.calculator.domain.component.PostfixConverter;
+import com.programmers.calculator.domain.component.PostfixEvaluator;
+import com.programmers.calculator.domain.core.Calculator;
+import com.programmers.calculator.domain.core.FourArithmeticCalculator;
+import com.programmers.calculator.repository.HistoryMapRepository;
+import com.programmers.calculator.repository.HistoryRepository;
+import com.programmers.calculator.view.Console;
+import com.programmers.calculator.view.Input;
+import com.programmers.calculator.view.InputReader;
+import com.programmers.calculator.view.Output;
+import com.programmers.calculator.view.OutputWriter;
+
+public class Application {
+    public static void main(String[] args) {
+
+        // view
+        Input input = new InputReader();
+        Output output = new OutputWriter();
+        Console console = new Console(input, output);
+
+        // domain
+        NotationConverter converter = new PostfixConverter();
+        Evaluator evaluator = new PostfixEvaluator();
+        Calculator calculator = new FourArithmeticCalculator(converter, evaluator);
+
+        // repository
+        HistoryRepository repository = new HistoryMapRepository();
+
+        // controller
+        CalculatorController calculatorController = new CalculatorController(console, calculator, repository);
+        calculatorController.run();
+
+    }
+}
diff --git a/src/main/java/com/programmers/calculator/constant/OptionType.java b/src/main/java/com/programmers/calculator/constant/OptionType.java
new file mode 100644
index 000000000..99fe7dbc7
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/constant/OptionType.java
@@ -0,0 +1,30 @@
+package com.programmers.calculator.constant;
+
+import java.util.Arrays;
+
+public enum OptionType {
+    EXIT("0"),
+    HISTORY("1"),
+    CALCULATION("2");
+
+    private static final OptionType[] OPTION_TYPES = OptionType.values();
+
+    private final String inputOption;
+
+    OptionType(String inputOption) {
+        this.inputOption = inputOption;
+    }
+
+    public String getInputOption() {
+        return inputOption;
+    }
+
+    public static OptionType of(String inputOption) {
+        return Arrays.stream(OPTION_TYPES)
+                .filter(optionType -> optionType.inputOption.equals(inputOption))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("유효하지 않은 메뉴입니다."));
+    }
+
+}
+
diff --git a/src/main/java/com/programmers/calculator/constant/RegexEnum.java b/src/main/java/com/programmers/calculator/constant/RegexEnum.java
new file mode 100644
index 000000000..6d1dd913e
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/constant/RegexEnum.java
@@ -0,0 +1,46 @@
+package com.programmers.calculator.constant;
+
+import com.programmers.calculator.domain.vo.Expression;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public enum RegexEnum {
+
+    FOUR_ARITHMETIC("\\d+|[-+*/]"),
+    NUMERIC("\\d+");
+
+    private final String regex;
+    private final Pattern pattern;
+
+    RegexEnum(String regex) {
+        this.regex = regex;
+        this.pattern = Pattern.compile(regex);
+    }
+
+    public String getRegex() {
+        return regex;
+    }
+
+    public Pattern getPattern() {
+        return pattern;
+    }
+
+    public static boolean isNumeric(String token) {
+        return token.matches(RegexEnum.NUMERIC.getRegex());
+    }
+
+    public static List<String> parseToTokens(Expression expression) {
+        List<String> tokens = new ArrayList<>();
+        Matcher matcher = RegexEnum.FOUR_ARITHMETIC.getPattern().matcher(expression.toString());
+
+        while (matcher.find()) {
+            tokens.add(matcher.group());
+        }
+
+        return tokens;
+    }
+}
+
diff --git a/src/main/java/com/programmers/calculator/controller/CalculatorController.java b/src/main/java/com/programmers/calculator/controller/CalculatorController.java
new file mode 100644
index 000000000..ac3fbb292
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/controller/CalculatorController.java
@@ -0,0 +1,84 @@
+package com.programmers.calculator.controller;
+
+import com.programmers.calculator.constant.OptionType;
+import com.programmers.calculator.domain.core.Calculator;
+import com.programmers.calculator.domain.vo.CalculationResult;
+import com.programmers.calculator.domain.vo.Expression;
+import com.programmers.calculator.repository.CalculationHistory;
+import com.programmers.calculator.repository.HistoryRepository;
+import com.programmers.calculator.view.Console;
+
+import java.util.List;
+
+public class CalculatorController {
+
+    private final Console console;
+    private final Calculator calculator;
+    private final HistoryRepository repository;
+
+    public CalculatorController(Console console, Calculator calculator, HistoryRepository repository) {
+        this.console = console;
+        this.calculator = calculator;
+        this.repository = repository;
+    }
+
+    public void run() {
+
+        while (true) {
+
+            try {
+                console.outputOption();
+                OptionType inputValue = OptionType.of(console.inputOption());
+
+                switch (inputValue) {
+                    case EXIT:
+                        exitCalculator();
+                        break;
+                    case HISTORY:
+                        loadCalculationHistory();
+                        break;
+                    case CALCULATION:
+                        processCalculation();
+                        break;
+                    default:
+                        errorDetection();
+                }
+            } catch (IllegalArgumentException | ArithmeticException e) {
+                e.printStackTrace();
+            }
+
+        }
+    }
+
+    private void exitCalculator() {
+        console.outputExit();
+        System.exit(0);
+    }
+
+    private void loadCalculationHistory() {
+        List<CalculationHistory> calculationHistoryList = repository.findAll();
+        console.outputHistory(calculationHistoryList);
+    }
+
+    private void processCalculation() {
+        Expression expression = new Expression(console.inputExpression());
+        CalculationResult calculationResult = calculator.calculate(expression);
+
+        printCalculationResult(calculationResult);
+        saveCalculationResult(expression, calculationResult);
+    }
+
+    private void printCalculationResult(CalculationResult calculationResult) {
+        console.outputCalculation(calculationResult);
+    }
+
+    private void saveCalculationResult(Expression expression, CalculationResult calculationResult) {
+        CalculationHistory calculationHistory = new CalculationHistory(expression, calculationResult);
+        repository.save(calculationHistory);
+    }
+
+    private void errorDetection() {
+        System.exit(0);
+    }
+
+}
diff --git a/src/main/java/com/programmers/calculator/domain/component/Evaluator.java b/src/main/java/com/programmers/calculator/domain/component/Evaluator.java
new file mode 100644
index 000000000..b20e5eb7e
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/domain/component/Evaluator.java
@@ -0,0 +1,9 @@
+package com.programmers.calculator.domain.component;
+
+import com.programmers.calculator.domain.vo.CalculationResult;
+
+import java.util.List;
+
+public interface Evaluator {
+    CalculationResult evaluate(List<String> convertedExpression);
+}
diff --git a/src/main/java/com/programmers/calculator/domain/component/NotationConverter.java b/src/main/java/com/programmers/calculator/domain/component/NotationConverter.java
new file mode 100644
index 000000000..bd7389011
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/domain/component/NotationConverter.java
@@ -0,0 +1,7 @@
+package com.programmers.calculator.domain.component;
+
+import java.util.List;
+
+public interface NotationConverter {
+    List<String> convert(List<String> tokens);
+}
diff --git a/src/main/java/com/programmers/calculator/domain/component/PostfixConverter.java b/src/main/java/com/programmers/calculator/domain/component/PostfixConverter.java
new file mode 100644
index 000000000..82c24a8fa
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/domain/component/PostfixConverter.java
@@ -0,0 +1,45 @@
+package com.programmers.calculator.domain.component;
+
+import com.programmers.calculator.constant.RegexEnum;
+import com.programmers.calculator.domain.core.Operator;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+public class PostfixConverter implements NotationConverter {
+
+    @Override
+    public List<String> convert(List<String> tokens) {
+        List<String> postfix = new ArrayList<>();
+        Stack<Character> operatorStack = new Stack<>();
+
+        for (String token : tokens) {
+            if (RegexEnum.isNumeric(token)) {
+                postfix.add(token);
+                continue;
+            }
+
+            compareOperatorPriority(postfix, operatorStack, token.charAt(0));
+            operatorStack.push(token.charAt(0));
+        }
+
+        pushUntilEmptyStack(postfix, operatorStack);
+
+        return postfix;
+    }
+
+    private void compareOperatorPriority(List<String> postfix, Stack<Character> operatorStack, char tokenChar) {
+        while (!operatorStack.isEmpty() && (Operator.of(tokenChar).getPriority() <= Operator.of(operatorStack.peek()).getPriority())) {
+            char popOperator = operatorStack.pop();
+            postfix.add(String.valueOf(popOperator));
+        }
+    }
+
+    private void pushUntilEmptyStack(List<String> postfix, Stack<Character> operatorStack) {
+        while (!operatorStack.isEmpty()) {
+            postfix.add(operatorStack.pop().toString());
+        }
+    }
+
+}
diff --git a/src/main/java/com/programmers/calculator/domain/component/PostfixEvaluator.java b/src/main/java/com/programmers/calculator/domain/component/PostfixEvaluator.java
new file mode 100644
index 000000000..b491e11bb
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/domain/component/PostfixEvaluator.java
@@ -0,0 +1,39 @@
+package com.programmers.calculator.domain.component;
+
+import com.programmers.calculator.constant.RegexEnum;
+import com.programmers.calculator.domain.core.Operator;
+import com.programmers.calculator.domain.vo.CalculationResult;
+
+import java.math.BigDecimal;
+import java.util.List;
+import java.util.Stack;
+
+public class PostfixEvaluator implements Evaluator {
+
+    @Override
+    public CalculationResult evaluate(List<String> convertedExpression) {
+        Stack<CalculationResult> operandStack = new Stack<>();
+
+        for (String token : convertedExpression) {
+            if (RegexEnum.isNumeric(token)) {
+                operandStack.push(new CalculationResult(new BigDecimal(token)));
+                continue;
+            }
+
+            if (operandStack.size() < 2) {
+                throw new IllegalArgumentException("잘못된 수식입니다.");
+            }
+
+            CalculationResult operand2 = operandStack.pop();
+            CalculationResult operand1 = operandStack.pop();
+            CalculationResult result = Operator.of(token.charAt(0)).getFunction().apply(operand1, operand2);
+            operandStack.push(result);
+        }
+
+        if (operandStack.size() != 1) {
+            throw new IllegalArgumentException("잘못된 수식입니다.");
+        }
+
+        return operandStack.pop();
+    }
+}
diff --git a/src/main/java/com/programmers/calculator/domain/core/Calculator.java b/src/main/java/com/programmers/calculator/domain/core/Calculator.java
new file mode 100644
index 000000000..0ce5c0daa
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/domain/core/Calculator.java
@@ -0,0 +1,8 @@
+package com.programmers.calculator.domain.core;
+
+import com.programmers.calculator.domain.vo.CalculationResult;
+import com.programmers.calculator.domain.vo.Expression;
+
+public interface Calculator {
+    CalculationResult calculate(Expression expression);
+}
diff --git a/src/main/java/com/programmers/calculator/domain/core/FourArithmeticCalculator.java b/src/main/java/com/programmers/calculator/domain/core/FourArithmeticCalculator.java
new file mode 100644
index 000000000..b6e6b15b5
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/domain/core/FourArithmeticCalculator.java
@@ -0,0 +1,28 @@
+package com.programmers.calculator.domain.core;
+
+import com.programmers.calculator.constant.RegexEnum;
+import com.programmers.calculator.domain.component.Evaluator;
+import com.programmers.calculator.domain.component.NotationConverter;
+import com.programmers.calculator.domain.vo.CalculationResult;
+import com.programmers.calculator.domain.vo.Expression;
+
+import java.util.List;
+
+public class FourArithmeticCalculator implements Calculator {
+
+    private final NotationConverter converter;
+    private final Evaluator evaluator;
+
+    public FourArithmeticCalculator(NotationConverter converter, Evaluator evaluator) {
+        this.converter = converter;
+        this.evaluator = evaluator;
+    }
+
+    @Override
+    public CalculationResult calculate(Expression expression) {
+        List<String> tokens = RegexEnum.parseToTokens(expression);
+        List<String> postfix = converter.convert(tokens);
+        return evaluator.evaluate(postfix);
+    }
+
+}
diff --git a/src/main/java/com/programmers/calculator/domain/core/Operator.java b/src/main/java/com/programmers/calculator/domain/core/Operator.java
new file mode 100644
index 000000000..764be377b
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/domain/core/Operator.java
@@ -0,0 +1,52 @@
+package com.programmers.calculator.domain.core;
+
+import com.programmers.calculator.domain.vo.CalculationResult;
+
+import java.math.BigDecimal;
+import java.util.Objects;
+import java.util.function.BiFunction;
+
+public enum Operator {
+    ADDITION('+', 10, CalculationResult::add),
+    SUBTRACTION('-', 10, CalculationResult::subtract),
+    MULTIPLICATION('*', 100, CalculationResult::multiply),
+    DIVISION('/', 100, (o1, o2) -> {
+        if (Objects.equals(o2.getValue(), BigDecimal.ZERO)) {
+            throw new ArithmeticException("0으로 나눌 수 없습니다.");
+        }
+        return o1.divide(o2);
+    });
+
+    private static final Operator[] OPERATORS = Operator.values();
+
+    private final char symbol;
+    private final int priority;
+    private final BiFunction<CalculationResult, CalculationResult, CalculationResult> function;
+
+    Operator(char symbol, int priority, BiFunction<CalculationResult, CalculationResult, CalculationResult> function) {
+        this.symbol = symbol;
+        this.priority = priority;
+        this.function = function;
+    }
+
+    public char getSymbol() {
+        return symbol;
+    }
+
+    public int getPriority() {
+        return priority;
+    }
+
+    public BiFunction<CalculationResult, CalculationResult, CalculationResult> getFunction() {
+        return function;
+    }
+
+    public static Operator of(char inputOperator) {
+        for (Operator operator : OPERATORS) {
+            if (operator.symbol == inputOperator) {
+                return operator;
+            }
+        }
+        throw new IllegalArgumentException("유효하지 않은 연산자입니다.");
+    }
+}
diff --git a/src/main/java/com/programmers/calculator/domain/vo/CalculationResult.java b/src/main/java/com/programmers/calculator/domain/vo/CalculationResult.java
new file mode 100644
index 000000000..3acbc3200
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/domain/vo/CalculationResult.java
@@ -0,0 +1,37 @@
+package com.programmers.calculator.domain.vo;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+public class CalculationResult {
+    private final BigDecimal value;
+
+    public CalculationResult(BigDecimal value) {
+        this.value = value;
+    }
+
+    public BigDecimal getValue() {
+        return value;
+    }
+
+    public CalculationResult add(CalculationResult otherValue) {
+        return new CalculationResult(value.add(otherValue.getValue()));
+    }
+
+    public CalculationResult subtract(CalculationResult otherValue) {
+        return new CalculationResult(value.subtract(otherValue.getValue()));
+    }
+
+    public CalculationResult multiply(CalculationResult otherValue) {
+        return new CalculationResult(value.multiply(otherValue.getValue()));
+    }
+
+    public CalculationResult divide(CalculationResult otherValue) {
+        return new CalculationResult(value.divide(otherValue.getValue(), 5, RoundingMode.HALF_UP));
+    }
+
+    @Override
+    public String toString() {
+        return value.toString();
+    }
+}
diff --git a/src/main/java/com/programmers/calculator/domain/vo/Expression.java b/src/main/java/com/programmers/calculator/domain/vo/Expression.java
new file mode 100644
index 000000000..56eeea513
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/domain/vo/Expression.java
@@ -0,0 +1,18 @@
+package com.programmers.calculator.domain.vo;
+
+public class Expression {
+    private final String expression;
+
+    public Expression(String expression) {
+        this.expression = expression;
+    }
+
+    public String getExpression() {
+        return expression;
+    }
+
+    @Override
+    public String toString() {
+        return expression;
+    }
+}
diff --git a/src/main/java/com/programmers/calculator/repository/CalculationHistory.java b/src/main/java/com/programmers/calculator/repository/CalculationHistory.java
new file mode 100644
index 000000000..8cba608e1
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/repository/CalculationHistory.java
@@ -0,0 +1,28 @@
+package com.programmers.calculator.repository;
+
+import com.programmers.calculator.domain.vo.CalculationResult;
+import com.programmers.calculator.domain.vo.Expression;
+
+public class CalculationHistory {
+
+    private Long id = 0L;
+    private Expression expression;
+    private CalculationResult result;
+
+    public CalculationHistory(Expression expression, CalculationResult result) {
+        this.expression = expression;
+        this.result = result;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public CalculationHistory saveHistory() {
+        return this;
+    }
+}
diff --git a/src/main/java/com/programmers/calculator/repository/HistoryMapRepository.java b/src/main/java/com/programmers/calculator/repository/HistoryMapRepository.java
new file mode 100644
index 000000000..47b05e231
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/repository/HistoryMapRepository.java
@@ -0,0 +1,23 @@
+package com.programmers.calculator.repository;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class HistoryMapRepository implements HistoryRepository {
+
+    private final Map<Long, CalculationHistory> store = new HashMap<>();
+    private long sequence = 0L;
+
+    @Override
+    public void save(CalculationHistory calculationHistory) {
+        calculationHistory.setId(++sequence);
+        store.put(calculationHistory.getId(), calculationHistory.saveHistory());
+    }
+
+    @Override
+    public List<CalculationHistory> findAll() {
+        return new ArrayList<>(store.values());
+    }
+}
diff --git a/src/main/java/com/programmers/calculator/repository/HistoryRepository.java b/src/main/java/com/programmers/calculator/repository/HistoryRepository.java
new file mode 100644
index 000000000..2af208ab8
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/repository/HistoryRepository.java
@@ -0,0 +1,8 @@
+package com.programmers.calculator.repository;
+
+import java.util.List;
+
+public interface HistoryRepository {
+    void save(CalculationHistory calculationHistory);
+    List<CalculationHistory> findAll();
+}
diff --git a/src/main/java/com/programmers/calculator/view/Console.java b/src/main/java/com/programmers/calculator/view/Console.java
new file mode 100644
index 000000000..c9a53a5e4
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/view/Console.java
@@ -0,0 +1,45 @@
+package com.programmers.calculator.view;
+
+import com.programmers.calculator.domain.vo.CalculationResult;
+import com.programmers.calculator.repository.CalculationHistory;
+
+import java.util.List;
+
+public class Console {
+
+    private final Input input;
+    private final Output output;
+    private final String newLine = System.getProperty("line.separator");
+
+    public Console(Input input, Output output) {
+        this.input = input;
+        this.output = output;
+    }
+
+    public String inputOption() {
+        output.write(newLine + newLine + "선택 : ");
+        return input.read();
+    }
+
+    public String inputExpression() {
+        return input.read();
+    }
+
+    public void outputOption() {
+        output.write(newLine + "0. 종료");
+        output.write(newLine + "1. 조회");
+        output.write(newLine + "2. 계산");
+    }
+
+    public void outputExit() {
+        output.write("프로그램이 종료됩니다.");
+    }
+
+    public void outputHistory(List<CalculationHistory> calculationHistories) {
+        output.write(calculationHistories);
+    }
+
+    public void outputCalculation(CalculationResult result) {
+        output.write(result);
+    }
+}
diff --git a/src/main/java/com/programmers/calculator/view/Input.java b/src/main/java/com/programmers/calculator/view/Input.java
new file mode 100644
index 000000000..03abada4e
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/view/Input.java
@@ -0,0 +1,5 @@
+package com.programmers.calculator.view;
+
+public interface Input {
+    String read();
+}
diff --git a/src/main/java/com/programmers/calculator/view/InputReader.java b/src/main/java/com/programmers/calculator/view/InputReader.java
new file mode 100644
index 000000000..a209d84ed
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/view/InputReader.java
@@ -0,0 +1,17 @@
+package com.programmers.calculator.view;
+
+import java.util.Scanner;
+
+public class InputReader implements Input {
+
+    private final Scanner scanner;
+
+    public InputReader() {
+        this.scanner = new Scanner(System.in);
+    }
+
+    @Override
+    public String read() {
+        return scanner.nextLine();
+    }
+}
diff --git a/src/main/java/com/programmers/calculator/view/Output.java b/src/main/java/com/programmers/calculator/view/Output.java
new file mode 100644
index 000000000..73dc10759
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/view/Output.java
@@ -0,0 +1,12 @@
+package com.programmers.calculator.view;
+
+import com.programmers.calculator.domain.vo.CalculationResult;
+import com.programmers.calculator.repository.CalculationHistory;
+
+import java.util.List;
+
+public interface Output {
+    void write(String message);
+    void write(List<CalculationHistory> calculationHistories);
+    void write(CalculationResult result);
+}
\ No newline at end of file
diff --git a/src/main/java/com/programmers/calculator/view/OutputWriter.java b/src/main/java/com/programmers/calculator/view/OutputWriter.java
new file mode 100644
index 000000000..8950422d3
--- /dev/null
+++ b/src/main/java/com/programmers/calculator/view/OutputWriter.java
@@ -0,0 +1,25 @@
+package com.programmers.calculator.view;
+
+import com.programmers.calculator.domain.vo.CalculationResult;
+import com.programmers.calculator.repository.CalculationHistory;
+
+import java.util.List;
+
+public class OutputWriter implements Output {
+
+    @Override
+    public void write(String message) {
+        System.out.print(message);
+    }
+
+    @Override
+    public void write(List<CalculationHistory> calculationHistories) {
+        calculationHistories.forEach(System.out::println);
+    }
+
+    @Override
+    public void write(CalculationResult result) {
+        System.out.println(result);
+    }
+
+}
diff --git a/src/test/java/com/programmers/calculator/constant/OptionTypeTest.java b/src/test/java/com/programmers/calculator/constant/OptionTypeTest.java
new file mode 100644
index 000000000..1cb7f4f00
--- /dev/null
+++ b/src/test/java/com/programmers/calculator/constant/OptionTypeTest.java
@@ -0,0 +1,36 @@
+package com.programmers.calculator.constant;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
+
+class OptionTypeTest {
+
+    @DisplayName("메뉴 번호를 파라미터로 넘겨주면, 올바른 Option 반환된다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"0", "1", "2"})
+    void right_option_menu(String inputOption) {
+
+        // given
+        OptionType optionType = OptionType.of(inputOption);
+
+        // then
+        assertThat(optionType.getInputOption()).isEqualTo(inputOption);
+
+    }
+
+    @DisplayName("잘못된 메뉴 번호를 파라미터로 넘겨주면, 예외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"3", "a", "+"})
+    void wrong_option_menu(String notInputOption) {
+
+        // then
+        assertThatThrownBy(() -> OptionType.of(notInputOption))
+                        .isInstanceOf(IllegalArgumentException.class)
+                                .hasMessage("유효하지 않은 메뉴입니다.");
+
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/programmers/calculator/constant/RegexEnumTest.java b/src/test/java/com/programmers/calculator/constant/RegexEnumTest.java
new file mode 100644
index 000000000..6209ad6c6
--- /dev/null
+++ b/src/test/java/com/programmers/calculator/constant/RegexEnumTest.java
@@ -0,0 +1,46 @@
+package com.programmers.calculator.constant;
+
+import com.programmers.calculator.domain.vo.Expression;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class RegexEnumTest {
+
+    @DisplayName("정규식에 맞게 토큰이 잘 쪼개지는지 확인")
+    @ParameterizedTest
+    @CsvSource({
+            "1 + 2 * 4 / 6",
+            "1+2*4/6"
+    })
+    void expression_regex_parsing (String inputExpression) {
+
+        // given
+        Expression expression = new Expression(inputExpression);
+
+        // when
+        List<String> result = RegexEnum.parseToTokens(expression);
+        List<String> expectedTokens = List.of("1", "+", "2", "*", "4", "/", "6");
+
+        // then
+        assertThat(result).isEqualTo(expectedTokens);
+    }
+
+    @DisplayName("숫자가 숫자 정규식에 체크 되는지 확인")
+    @Test
+    void numeric_regex() {
+        assertThat(RegexEnum.isNumeric("1")).isTrue();
+    }
+
+    @DisplayName("숫자 아닌 것이 숫자 정규식에 체크가 안되는지 확인")
+    @Test
+    void not_numeric_regex() {
+        assertThat(RegexEnum.isNumeric("a")).isFalse();
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/com/programmers/calculator/domain/component/PostfixConverterTest.java b/src/test/java/com/programmers/calculator/domain/component/PostfixConverterTest.java
new file mode 100644
index 000000000..f11b6fc0c
--- /dev/null
+++ b/src/test/java/com/programmers/calculator/domain/component/PostfixConverterTest.java
@@ -0,0 +1,28 @@
+package com.programmers.calculator.domain.component;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class PostfixConverterTest {
+
+    PostfixConverter postfixConverter = new PostfixConverter();
+
+    @DisplayName("후위표기식으로 변환 잘 되는지 확인")
+    @Test
+    void right_convert_postfix () {
+        // given
+        List<String> tokens = List.of("1", "+", "2", "*", "4", "/", "6");
+        List<String> expected = List.of("1", "2", "4", "*", "6", "/", "+");
+
+        // when
+        List<String> result = postfixConverter.convert(tokens);
+
+        // then
+        assertThat(result).isEqualTo(expected);
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/com/programmers/calculator/domain/component/PostfixEvaluatorTest.java b/src/test/java/com/programmers/calculator/domain/component/PostfixEvaluatorTest.java
new file mode 100644
index 000000000..b887f3756
--- /dev/null
+++ b/src/test/java/com/programmers/calculator/domain/component/PostfixEvaluatorTest.java
@@ -0,0 +1,45 @@
+package com.programmers.calculator.domain.component;
+
+import com.programmers.calculator.domain.vo.CalculationResult;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
+
+class PostfixEvaluatorTest {
+
+    PostfixEvaluator postfixEvaluator = new PostfixEvaluator();
+
+    @DisplayName("후위표기식의 계산이 잘 되는지 확인")
+    @Test
+    void right_convert_postfix () {
+
+        // given
+        List<String> postfix = List.of("1", "2", "4", "*", "6", "*", "+");
+
+        // when
+        CalculationResult result = postfixEvaluator.evaluate(postfix);
+
+        // then
+        assertThat(result.getValue()).isEqualTo(new BigDecimal(49));
+    }
+
+    @DisplayName("잘못된 후위표기식이 예외를 던지는지 확인")
+    @Test
+    void throw_wrong_evaluate_postfix () {
+
+        // given
+        List<String> postfix = List.of("1", "+", "+");
+
+        // then
+        assertThatThrownBy(() -> postfixEvaluator.evaluate(postfix))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("잘못된 수식입니다.");
+
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/com/programmers/calculator/domain/core/FourArithmeticCalculatorTest.java b/src/test/java/com/programmers/calculator/domain/core/FourArithmeticCalculatorTest.java
new file mode 100644
index 000000000..fb4e382c5
--- /dev/null
+++ b/src/test/java/com/programmers/calculator/domain/core/FourArithmeticCalculatorTest.java
@@ -0,0 +1,42 @@
+package com.programmers.calculator.domain.core;
+
+import com.programmers.calculator.domain.component.Evaluator;
+import com.programmers.calculator.domain.component.NotationConverter;
+import com.programmers.calculator.domain.component.PostfixConverter;
+import com.programmers.calculator.domain.component.PostfixEvaluator;
+import com.programmers.calculator.domain.vo.CalculationResult;
+import com.programmers.calculator.domain.vo.Expression;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import java.math.BigDecimal;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class FourArithmeticCalculatorTest {
+
+    NotationConverter converter = new PostfixConverter();
+    Evaluator evaluator = new PostfixEvaluator();
+    FourArithmeticCalculator calculator = new FourArithmeticCalculator(converter, evaluator);
+
+    @DisplayName("사칙연산 계산기의 계산이 잘 되는지 확인")
+    @ParameterizedTest
+    @CsvSource({
+            "1 + 5 * 3 - 8, 8",
+            "1 + 2 * 9 - 6, 13"
+    })
+    void right_calculate(String inputExpression, BigDecimal expectedResult) {
+
+        // given
+        Expression expression = new Expression(inputExpression);
+
+        // when
+        CalculationResult result = calculator.calculate(expression);
+
+        // then
+        assertThat(result.getValue()).isEqualTo(expectedResult);
+
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/com/programmers/calculator/domain/core/OperatorTest.java b/src/test/java/com/programmers/calculator/domain/core/OperatorTest.java
new file mode 100644
index 000000000..2fd895160
--- /dev/null
+++ b/src/test/java/com/programmers/calculator/domain/core/OperatorTest.java
@@ -0,0 +1,57 @@
+package com.programmers.calculator.domain.core;
+
+import com.programmers.calculator.domain.vo.CalculationResult;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.math.BigDecimal;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
+
+class OperatorTest {
+
+    @DisplayName("0으로 나눴을 때 예외를 던지는지 확인")
+    @ParameterizedTest
+    @CsvSource({"5, 0", "13, 0"})
+    void division_by_zero_throw_exception(BigDecimal testOperand1, BigDecimal testOperand2) {
+
+        // given
+        Operator division = Operator.DIVISION;
+
+        CalculationResult operand1 = new CalculationResult(testOperand1);
+        CalculationResult operand2 = new CalculationResult(testOperand2);
+
+        // when
+        assertThatThrownBy(() -> division.getFunction()
+                .apply(operand1, operand2))
+                .isInstanceOf(ArithmeticException.class)
+                .hasMessage("0으로 나눌 수 없습니다.");
+
+    }
+
+    @DisplayName("연산자를 파라미터로 넘겨주면, 그에 맞는 Operator가 반환")
+    @ParameterizedTest
+    @ValueSource(chars = {'+', '-', '*', '/'})
+    void operator_of_success(char operatorChar) {
+
+        // given
+        Operator operator = Operator.of(operatorChar);
+
+        // then
+        assertThat(operator.getSymbol()).isEqualTo(operatorChar);
+    }
+
+    @DisplayName("연산자가 아닌 값들을 파라미터로 넘겨주면, 예외가 발생")
+    @ParameterizedTest
+    @ValueSource(chars = {'|', '`', 'z', '1', '3'})
+    void of_throws_exception(char notOperatorChar) {
+
+        // then
+        assertThatThrownBy(() -> Operator.of(notOperatorChar))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("유효하지 않은 연산자입니다.");
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/programmers/calculator/repository/HistoryMapRepositoryTest.java b/src/test/java/com/programmers/calculator/repository/HistoryMapRepositoryTest.java
new file mode 100644
index 000000000..f96974d58
--- /dev/null
+++ b/src/test/java/com/programmers/calculator/repository/HistoryMapRepositoryTest.java
@@ -0,0 +1,43 @@
+package com.programmers.calculator.repository;
+
+import com.programmers.calculator.domain.vo.CalculationResult;
+import com.programmers.calculator.domain.vo.Expression;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class HistoryMapRepositoryTest {
+
+    HistoryRepository repository = new HistoryMapRepository();
+
+    @DisplayName("repository 정상적으로 저장되는지 확인")
+    @ParameterizedTest
+    @CsvSource({
+            "1 + 2 * 3, 7",
+            "3 + 2 * 3 / 3, 5"
+    })
+    void repository_right_work(String inputExpression, BigDecimal expectedResult) {
+
+        // given
+        Expression expression = new Expression(inputExpression);
+        CalculationResult calculationResult = new CalculationResult(expectedResult);
+        CalculationHistory result = new CalculationHistory(expression, calculationResult);
+
+        // when
+        repository.save(result);
+
+        // then
+        List<CalculationHistory> all = repository.findAll();
+
+        assertThat(all.size()).isEqualTo(1);
+        assertThat(all).contains(result);
+        assertThat(all.get(0)).isEqualTo(result);
+
+    }
+
+}
\ No newline at end of file