🔥TIL🔥스파르타 | 과제 : 계산기 앱

계산기

사칙 연산을 계산하는 계산기 코드를 작성했다.

처음에 내가 작성한 코드 구성

Calculator.kt
Main.kt

Calculator.kt

interface Calculator {
    fun calculate(a: Int, b: Int): Int
}

class AddOperation : Calculator {
    override fun calculate(a: Int, b: Int): Int {
        return a + b
    }
}

class SubtractOperation : Calculator {
    override fun calculate(a: Int, b: Int): Int {
        return a - b
    }
}

class MultiplyOperation : Calculator {
    override fun calculate(a: Int, b: Int): Int {
        return a * b
    }
}

class DivideOperation : Calculator {
    override fun calculate(a: Int, b: Int): Int {
        return a / b
    }
}

class ModOperation : Calculator {
    override fun calculate(a: Int, b: Int): Int {
        return a % b
    }
}

Main.kt

fun main() {
    println("연산식을 입력해주세요")

    val operators = listOf("+", "-", "*", "/", "%")

    while (true) {
        val inputOperation = readLine()?.replace(" ", "")

        var operator: String? = null
        for (op in operators) {
            if (inputOperation?.contains(op) == true) {
                operator = op
                break
            }
        }

        println("operator: $operator")

        if (operator != null) {
            val operationList = inputOperation!!.split(operator)
            try {
                val firstOperand = operationList[0].toInt()
                val secondOperand = operationList[1].toInt()

                val calc: Calculator = when (operator) {
                    "+" -> AddOperation()
                    "-" -> SubtractOperation()
                    "*" -> MultiplyOperation()
                    "/" -> DivideOperation()
                    "%" -> ModOperation()
                    else -> throw IllegalArgumentException("Unsupported operator")
                }

                println("calc: $calc")

                val result = calc.calculate(firstOperand, secondOperand)
                println("$firstOperand $operator $secondOperand 결과는 : $result 입니다")
            } catch (e: NumberFormatException) {
                println("숫자 형식이 올바르지 않습니다.")
            }
        } else {
            println("올바른 연산자를 입력해주세요.")
        }
    }
}

아직 인터페이스하고 추상 클래스의 차이를 잘 모르겠다.

계산기 과제 해설 보고 수정한 코드

설계

Calculator 클래스 안에 덧셈, 뺄셈, 곱셈, 나눗셈 함수를 정의할 수도 있다. 하지만 이렇게 하면 Calculator 클래스가 하는 일이 너무 많아진다.
그래서 이 사칙연산들을 하나로 묶으려고 한다.
덧셈, 뺄셈, 곱셈, 나눗셈이 아닌 <연산>으로 묶는다.

operate함수를 만들고 인자로 연산자, 피연산자를 받아서 연산하는 작업을 해줘도 되지만 이것도 관리할 포인트들이 늘어난다.

Calculator 생성자에다 객체를 넘겨준다

보완한 코드 구성

- kotlinApplication.kt

📂abs
 ㄴ AbstractOperation

📂calc
 ㄴ AddOperation
 ㄴ DivideOperation
 ㄴ ModOperation
 ㄴ MultiplyOperation
 ㄴ SubstractOperation

🖋️AbstractOperation.kt

연산을 하는 클래스라고 알려주기만 하는 것

operate : 추상 메서드, 연산을 하는 기능이 정의되어 있음

abstract class AbstractOperation {
    abstract fun operate(a: Int, b: Int): Double
}

🖋️AddOperation.kt (Divide/Mod/Multiply/Substract/Operation도 같음)

AbstractOperation의 메서드를 overriding해 operate의 동작을 재정의함

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

🖋️Calculator.kt

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

어떤 연산을 할 것인지는 아래처럼 쓸 수 있다

Calculator(AddOperation())

🖋️kotlinApplication.kt

fun main(){
    println("연산식을 입력해주세요")

    val operators = listOf("+", "-", "*", "/", "%")

    while (true) {
        val inputOperation = readLine()?.replace(" ", "")
        println(inputOperation)
        var operator: String? = null
        for (op in operators) {
            if (inputOperation?.contains(op) == true) {
                operator = op
                break
            }
        }

        if (operator != null) {
            val operationList = inputOperation!!.split(operator)
            try {
                val firstOperand = operationList[0].toInt()
                val secondOperand = operationList[1].toInt()

                val calc: Calculator = when (operator) {
                    "+" -> Calculator(AddOperation())
                    "-" -> Calculator(SubstractOperation())
                    "*" -> Calculator(MultiplyOperation())
                    "/" -> Calculator(DivideOperation())
                    "%" -> Calculator(ModOperation())
                    else -> throw IllegalArgumentException("Unsupported operator")
                }

                val result = calc.operator(firstOperand, secondOperand)
                println("$firstOperand $operator $secondOperand 결과는 : $result 입니다")

            } catch (e: NumberFormatException) {
                println("숫자 형식이 올바르지 않습니다.")
            }
        } else {
            println("올바른 연산자를 입력해주세요.")
        }
    }
}

😮 배운 것

단일 책임 원칙(SRP) : 객체는 단 하나의 책임만 가져야 한다는 원칙

한 클래스가 여러 동작을 수행하면 관리할 부분이 늘어난다.

AbstractOperation은 operate를 해주는 클래스라고 보장만 해주면 되고 자식들이 사칙연산을 해주면 된다.

튜터님이 해주신 과제 피드백 : operator는 kotlin에서 예약어로 쓰이기 때문에 변수명으로 적합하지 않다!