🕮 [Kotlin] 코틀린으로 계산기 단계별 구현하기

2024. 3. 8. 17:47, 📱Android Study

1. 간단한 사칙연산 구현

package com.limheejin.calculator

class Calculator {

    fun main() {

        println("=============계산기=============")
        println("안녕하세요! 사칙연산 계산기입니다.")
        println("계산을 원하시는 정수 두 개를 입력해주세요. ")
        var num1 = Integer.parseInt(readLine())
        var num2 = Integer.parseInt(readLine())

        println("원하시는 연산자 기호를 입력해주세요 (+, -, *, / )")
        val operator = readLine()
        val result =
            when (operator) {
                "+" -> num1 + num2
                "-" -> num1 - num2
                "*" -> num1 * num2
                "/" -> num1 / num2
                else -> throw Exception("잘못된 연산자입니다. 계산기를 다시 켜주세요.")
            }

        println("${num1} ${operator} ${num2} = ${result} 입니다.")
        println("다시 진행하시겠습니까? 네: 1 / 아니오, 끝내겠습니다: -1 ")

        var isExit = readLine()!!.toInt()
        when (isExit){
            1 -> main()
            -1 -> println("계산을 종료하겠습니다. 이용해주셔서 감사합니다.")
            else -> throw Exception("잘못된 연산자입니다. 계산기를 다시 켜주세요.")
        }



    }
}

단일 클래스 내에서 main 메소드만을 이용해 구현한 간단한 코드다.
간단한 사칙연산, 1을 입력할 시 계산 반복, -1을 입력할 시 종료메시지 출력 정도의 기능이 있다.
잘못된 숫자를 입력했을 때의 예외처리도 없고, 정수가 아닌 실수 계산도 못한다.
throw Exception에서 Try catch Finally 처리도 없다.

실제 구현

Main.kt

fun main() {
		val calculator = Calculator()
		
		while(true) { //while의 파라미터를 true로 둬서 무한 루프
				val select = readLine()!!.toInt()
				println("[1]덧셈, [2]뺄셈, [3]곱셈, [4]나눗셈, [5]나머지, [-1]종료")
				
				val num1 = readLine()!!.toInt()
				println("첫 번째 숫자 입력")
				val num2 = readLine()!!.toInt()
				println("두 번째 숫자 입력")
				
				if(select == 1) {
						calculator.addOperation(num1, num2)
				} else if(select == 2) {
						calculator.minusOperation(num2, num1)
				} else if(select == 3) {
						calculator.multipleOperation(num1, num2)
				} else if(select == 4) {
						calculator.divideOperation(num2, num1)
				} else if(select == 5) {
						calculator.restOperation(num2, num1)
				} else {
						break
				}
		}
		println("종료")
}

Calculator.kt

class Calculator {
		fun addOperation(num1: Int, num2: Int) {
				val result = num1 + num2
				println("결과값은: ${result}입니다. ")
		}
		
		fun minusOperation(num1: Int, num2: Int) {
				val result = num2 - num1
				println("결과값은: ${result}입니다. ")
		}
		
		fun multipleOperation(num1: Int, num2: Int) {
				val result = num1 * num2
				println("결과값은: ${result}입니다. ")
		}
		
		fun divideOperation(num1: Int, num2: Int) {
				val result = num2 / num1
				println("결과값은: ${result}입니다. ")
		}
		
		fun restOperation(num1: Int, num2: Int) {
				val result = num2 % num1
				println("결과값은: ${result}입니다. ")
		}
}

2. 클래스의 분리와 단일 책임 원칙

Main.kt

fun main() {
		val addCalc = AddOperation()
		val minusCalc = SubstractOperation()
		val multipleCalc = MultiplyOperation()
		val divideCalc = DivideOperation()
		
		addCalc.addOperation(10, 20)
		minusCalc.minusOperation(20, 10)
		multipleCalc.multiplyOperation(10, 20)
		divideCalc.divideOperation(20, 10)
}

Calculator.kt

open class Calculator {
	 open fun operate(num1: Int, num2: Int)
}

AddOperation.kt

class AddOperation: Calculator() {

		override fun operate(num1: Int, num2: Int) {
				val result = num1 + num2
				println("결과값은: ${result}입니다. ")
		}
}

SubstractOperation.kt

class SubstractOperation: Calculator() {

		override fun operate(num1: Int, num2: Int) {
				val result = num2 - num2
				println("결과값은: ${result}입니다. ")
		}
}

MultiplyOperation.kt

class MultiplyOperation: Calculator() {

		override fun operate(num1: Int, num2: Int) {
				val result = num1 * num2
				println("결과값은: ${result}입니다. ")
		}
}

DivideOperation.kt

class DivideOperation: Calculator() {

		override fun operate(num1: Int, num2: Int) {
				val result = num2 / num1
				println("결과값은: ${result}입니다. ")
		}
}

각 기능에 맞게 클래스를 분리하고, Calculator 클래스도 넣어준다.
모든 클래스가 2개의 값을 입력 받는다는 것은 공통적이므로, Calculator 클래스에서는 두 개의 값을 받는 메소드를 만든다. 또한 상속을 할수 있게 클래스와 함수에 open 키워드를 넣어준다.
각각의 사칙연산 클래스에서 Calculator 클래스를 상속받고 operate 함수를 오버라이딩한다.
객체지향 5원칙(SOLID) 중 SRP는 하나의 객체는 반드시 하나의 동작만의 책임을 갖는다는 원칙이다.
객체가 담당하는 동작(책임)이 많아질수록 해당 객체의 변경에 따른 영향도의 양과 범위가 매우 커진다. 단일 책임 원칙은 특정 객체의 책임 의존성 과중을 최대한 지양하기 위한 원칙이다.

3. 추상화, 클래스 간의 결합도, 의존성(의존성 역전 원칙)

Main.kt

fun main() {
    val addCalc = Calculator(AddOperation())
    println("10더하기 20 결과는 : ${addCalc.operate(10, 20)} 입니다")

    val minusCalc = Calculator(SubstractOperation())
    println("20빼기 10 결과는 : ${minusCalc.operate(20, 10)} 입니다")

    val multipleCalc = Calculator(MultiplyOperation())
    println("10곱하기 20 결과는 : ${multipleCalc.operate(10, 20)} 입니다")

    val divideCalc = Calculator(DivideOperation())
    println("20나누기 10 결과는 : ${divideCalc.operate(20, 10)} 입니다")
}

Calculator.kt

class Calculator(private val operator: AbstractOperation) {
    fun operate(num1: Int, num2: Int): Double {
        return operator.operate(num1, num2)
    }
}

AbstractOperation.kt

abstract class AbstractOperation {
    abstract fun operate(num1: Int, num2: Int): Double
}

AddOperation.kt

class AddOperation: AbstractOperation() {
    override fun operate(num1: Int, num2: Int): Double = (num1 + num2).toDouble()
}

SubstractOperation.kt

class SubstractOperation: AbstractOperation() {
    override fun operate(num1: Int, num2: Int): Double = (num1 - num2).toDouble()
}

MultiplyOperation.kt

class MultiplyOperation: AbstractOperation() {
    override fun operate(num1: Int, num2: Int): Double = (num1 * num2).toDouble()
}

DivideOperation.kt

class DivideOperation: AbstractOperation() {
    override fun operate(num1: Int, num2: Int): Double {
        require(num2 != 0) {
            ArithmeticException("Divide by Zero")
        }
        return (num1 / num2).toDouble()
    }
}

open class: 일반적인 클래스, 단독으로 객체가 되어 사용할 수 있음
abstract class: 추상 클래스, 객체를 직접 생성할 수 없음. 구현 없이 선언만 되어 있어, 상속 및 재정의만 가능
객체지향 5원칙(SOLID) 중 DIP는 "추상화에 의존해야지, 구체화에 의존하면 안 된다" 는 원칙이다.
자신보다 변화하기 쉬운 것을 의존해서는 안 되고, 거의 변화가 없는 개념에 의존해야 한다
추상화를 위해 AbstractOperation이라는 추상클래스 생성 후 operate 추상메서드 생성
기능 클래스에서 추상클래스를 상속하고 오버라이딩
Divide에서 나누기 0이 불가능한 예외를 추가적으로 처리
(이해 안 됨) Calculator 클래스는 생성자를 통해 operator라는 이름의 AbstractOperation 타입 매개변수를 받는다.
이 매개변수는 Calculator의 인스턴스를 생성할 때 제공되는 연산자 종류를 나타낸다.
operate 함수는 두 개의 정수를 받아들이고, operator를 사용하여 해당 연산을 수행한 뒤 Double 결과를 반환한다.
여기서 operator 객체의 실제 동작은 AbstractOperation 클래스를 구현한 하위 클래스에 의해 결정된다.
결과적으로 덧셈계산기, 뺄셈계산기, 곱셈계산기를 일일히 불러오는 게 아니라 다 같이 계산기를 불러오게 된다.

4. 기능 추가 (3개 이상의 수 연산 시 부호 우선 순위, 괄호 사용 시 우선 순위 등)

Main.kt

fun main() {
    val addCalc = Calculator(AddOperation())
    println("10더하기 20 결과는 : ${addCalc.operate(10, 20)} 입니다")

    val minusCalc = Calculator(SubstractOperation())
    println("20빼기 10 결과는 : ${minusCalc.operate(20, 10)} 입니다")

    val multipleCalc = Calculator(MultiplyOperation())
    println("10곱하기 20 결과는 : ${multipleCalc.operate(10, 20)} 입니다")

    val divideCalc = Calculator(DivideOperation())
    println("20나누기 10 결과는 : ${divideCalc.operate(20, 10)} 입니다")

    val myStack = MyStack()
    val calResult = myStack.getPostFixExpressionOperation("(2 + 4) * 4 / 2 * 12")
    println("결과: ${calResult}입니다")
}

Calculator.kt, 기능Operation.kt 모두 위의 3번과 동일

MyStack.kt

class MyStack {
    fun getPostFixExpressionOperation(originalExpression: String): Int {
        val stack = Stack<String>()
        val arr = strToArr(originalExpression)
        var result = ""

        for(e in arr) {
            when(e) {
                "+", "-", "*", "/" -> {
                    while(!stack.isEmpty() && precedence(stack.peek()) >= precedence(e)) {
                        result += stack.pop() + " "
                    }
                    stack.push(e)
                }
                "(" -> {
                    stack.push(e)
                }
                ")" -> {
                    while(stack.peek() != "(") {
                        result += stack.pop() + " "
                    }
                    stack.pop() // "(" 제거
                }
                else -> {
                    result += "$e "
                }
            }
        }

        while(!stack.isEmpty()) {
            result += stack.pop() + " "
        }

        println("---최종---")
        println("후위표기법: $result")

        val realResult = finalCalc(result)
        println("결과: $realResult")
        return realResult
    }

    fun finalCalc(result: String): Int {
        val stack = Stack<String>()
        val calResult = result.split(" ")
        var result = 0

        for(e in calResult) {
            when(e) {
                "+" -> {
                    result = stack.pop().toInt() + stack.pop().toInt()
                    stack.push(result.toString())
                }
                "-" -> {
                    result = -stack.pop().toInt() + stack.pop().toInt()
                    stack.push(result.toString())
                }
                "*" -> {
                    result = stack.pop().toInt() * stack.pop().toInt()
                    stack.push(result.toString())
                }
                "/" -> {
                    val num2 = stack.pop().toInt()
                    val num1 = stack.pop().toInt()
                    result = num1 / num2
                    stack.push(result.toString())
                }
                else -> {
                    stack.push(e)
                }
            }
        }
        return result
    }

    fun strToArr(str: String): Array<String> {
        var tempStr = str.replace("(", "( ")
        tempStr = tempStr.replace(")", " )")
        return tempStr.split(" ").toTypedArray()
    }

    fun precedence(operator: String): Int {
        return when(operator) {
            "+", "-" -> 1
            "*", "/" -> 2
            else -> 0
        }
    }
}

우선 순위 처리를 위해 Stack과 후위 연산의 개념을 알아야 한다.
연산자 우선 순위
(1) ( )
(2) * / %
(4) + -
문법 공부를 다 한뒤 3월 15일에 다시 돌아오자

저작자표시 비영리 변경금지

💬 C O M M E N T

1. 간단한 사칙연산 구현

실제 구현

2. 클래스의 분리와 단일 책임 원칙

3. 추상화, 클래스 간의 결합도, 의존성(의존성 역전 원칙)

4. 기능 추가 (3개 이상의 수 연산 시 부호 우선 순위, 괄호 사용 시 우선 순위 등)

티스토리툴바