[Kotlin] 클래스(Class) 실습 계산기 만들기

안녕하세요.

 

이번 포스팅은 코틀린 클래스를 이용하여 계산기를 만드는 실습을 해보겠습니다.

 

(1) 기본형

 

단순히 계산값을 리턴하는 클래스 입니다.

class Calculate {
    fun plus(num1: Int, num2: Int) : Int {
        return num1 + num2
    }

    fun minus(num1: Int, num2: Int) : Int {
        return num1 - num2
    }

    fun multiple(num1: Int, num2: Int) : Int {
        return num1 * num2
    }

    fun divide(num1: Int, num2: Int) : Int {
        return num1 / num2
    }
}

 

(2) 다중 파라미터형

 

여러 파라미터를 받아 계산하여 결과 값을 리턴하는 클래스입니다

class Calculate2 {
    fun plus(vararg numbers : Int) : Int {
        var result : Int = 0
        numbers.forEach {
            result += it
        }
        return result
    }

    fun minus(vararg numbers : Int) : Int {
        var result : Int = 0
        for(i in 0 until numbers.size) {
            result -= numbers[i]
        }

        return result
    }

    fun multiply(vararg numbers: Int) : Int {
        var result : Int = 1
        numbers.forEach {
            if(it != 0) result *= it
        }

        return result
    }

    fun divide(vararg numbers : Int) : Int {
        var result : Int = numbers[0]
        numbers.forEachIndexed{ index, value ->
            if(index != 0 && value != 0) result /= value
        }
        return result
    }
}

 

(3) 객체리턴형

 

계산한 결과를 다시 재귀적으로 리턴하는 객체 리턴형입니다.

class Calculator3(val initialValue : Int) {
    fun plus(number : Int) : Calculator3 {
        val result = this.initialValue + number
        return Calculator3(result)
    }

    fun minus(number : Int) : Calculator3 {
        val result = this.initialValue - number
        return Calculator3(result)
    }

    fun multiply(number : Int) : Calculator3 {
        val result = this.initialValue * number
        return Calculator3(result)
    }

    fun divide(number : Int) : Calculator3 {
        val result = this.initialValue / number
        return Calculator3(result)
    }
}

 

fun main(args: Array<String>)

fun main(args: Array<String>) {

    var cal : Calculate = Calculate()
    println(cal.plus(4,2))
    println(cal.minus(4,2))
    println(cal.multiple(4,2))
    println(cal.divide(4,2))
    println()

    var cal2 : Calculate2 = Calculate2()
    println(cal2.plus(1,2,3,4,5))
    println(cal2.minus(10,1,2,3))
    println(cal2.multiply(1,2,3))
    println(cal2.divide(10,2,3))
    println()

    val calculator3 = Calculator3(3)
    calculator3.plus(5).minus(5)
    // -------> Calculator3(3)
    // ---------------> Calculator3(8)
    // -----------------------------> Calculator3(8).minus(5)
    // -> Chaining(체이닝)
}

 

calculator3은 객체를 리턴 받아서 바로 함수를 이어서 쓸 수 있습니다.

이 형태를 바로 체이닝이라고 합니다.