[Kotlin 문법 심화] 팀과제 - 키오스크 Lv4.

🍥구현 기능

• 현재 잔액과 가격을 비교하여 결제 구현하기

🍥구현하기

• 🔗github link

PaymentManager 클래스

• 결제 관련 기능을 구현한 클래스
• 프로퍼티:
  • balance
    현재 잔고
• 메소드:
  • getBalance():Int
    현재 잔고 반환
  • deposit(money:Int):Int
    현재 잔고에 money 입금 후, 잔고 반환
  • withDraw(money:Int):Boolean
    현재 잔고에서 money 출금 후
    출금에 성공한 경우 true 반환, 잔고가 부족하여 출금에 실패한 경우 false 반환

class PaymentManager {
    private var balance = 0

    fun getBalance():Int = balance

    fun deposit(money:Int):Int{
        balance += money
        return balance
    }

    fun withDraw(money:Int):Boolean{
        if(balance < money) return false
        balance -= money
        return true
    }
}

➖

OrderScreen 클래스

• run():String이 input을 반환하도록 수정

override fun run():String{
    isShoppingCartEmpty = MyKiosk.shoppingCart.isEmpty()

    val input = getInput()
    return input
}

OrderPaymentScreen 클래스

• 주문하기 화면과 주문 완료 화면 사이에 주문 결제 화면 추가
• 주문하기 위해 필요한 금액 출력
• 현재 잔고가 부족하지 않은 경우, 바로 결제 진행 후 주문 완료 화면으로 이동
• 현재 잔고가 부족한 경우, 잔고가 부족하지 않을 때까지 추가 금액 입금 받기

[주문 결제 화면]
주문하기 위해 필요한 금액은 30000원 입니다.
현재 잔고는 32000원 입니다.
결제가 진행 중입니다...

[주문 결제 화면]
주문하기 위해 필요한 금액은 30000원 입니다.
현재 잔고는 15000원 입니다.
추가로 입금할 금액을 입력해주세요.(단위: 원)
-> 10000
현재 잔고는 25000원 입니다.
추가로 입금할 금액을 입력해주세요.(단위: 원)
-> 100000
현재 잔고는 35000원 입니다.
결제가 진행중입니다...

• Screen 클래스 상속
• 프로퍼티:
  • costSum
    장바구니 속 메뉴 아이템 가격의 총합
  • balance
    현재 잔고
• 메소드:
  • run():String
    주문 결제 화면 실행
    잔고가 주문하기 위해 필요한 금액보다 크거가 같을 때까지 입력받은 후, 결제 진행
  • getInput():String
    주문 결제 화면에 알맞는 입력값 받기
    (가능한 입력값: 금액을 입력받아야 하므로, Int로 형변환이 되는 입력값)
  • printScreen()
    주문 결제 화면 출력

class OrderPaymentScreen : Screen() {
    var costSum = 0
    var balance = 0

    override fun run(): String {
        costSum = MyKiosk.shoppingCart.getCostSum()
        balance = MyKiosk.paymentManager.getBalance()

        printScreen()
        while(balance < costSum) {
            val money = getInput()
            balance = MyKiosk.paymentManager.deposit(money.toInt())
            println("현재 잔고는 ${balance}원 입니다.")
        }
        println("결제가 진행중입니다...")
        if(MyKiosk.paymentManager.withDraw(costSum)) return "true"
        return "false"
    }

    override fun getInput(): String {
        var input = ""
        while(true){
            println("추가로 입금할 금액을 입력해주세요.(단위: 원)")
            print("->")
            input = readLine()?.toString() ?: ""
            try{
                //입력된 값을 Int로 바꿀 수 있다면, 입력 성공적으로 끝내기
                input.toInt()
                break
            }catch(e:Exception){
                println("잘못된 입력입니다.")
            }
        }
        return input

    }

    override fun printScreen() {
        println("[주문 결제 화면]")
        println("주문하기 위해 필요한 금액은 ${costSum}원 입니다.")
        println("현재 잔고는 ${balance}원 입니다.")
    }
}

OrderCompleteScreen 클래스

• 결제 후 잔고 출력하도록 수정

[주문 완료 화면]
주문이 완료되었습니다.
현재 잔고는 5000원 입니다.
잠시 후 첫 화면으로 이동합니다...

override fun printScreen(){
    println("[주문 완료 화면]")
    println("주문이 완료되었습니다.")
    println("현재 잔고는 ${MyKiosk.paymentManager.getBalance()}원 입니다.")
    println("잠시 후 첫 화면으로 이동합니다...")
}

➖

MyKiosk 클래스

• 프로퍼티에 orderPaymentScreen 추가
• companion object 프로퍼티에 paymentManager 추가
• orderScreen.run()의 반환값이 "p"일 때, orderPaymentScreen.run()이 호출되도록 수정
• orderPaymentScreen.run()의 반환값이 "true"일 때, orderCompleteScreen.run()이 호출되도록 수정

class MyKiosk private constructor(){

    //각 화면 구현
    private val firstScreen = FirstScreen()
    private val takeOutScreen = TakeOutScreen()
    private val mainScreen = MainScreen()
    private val selectMenuScreen = SelectMenuScreen()
    private val shoppingCartScreen = ShoppingCartScreen()
    private val orderScreen = OrderScreen()
    private val orderPaymentScreen = OrderPaymentScreen()
    private val orderCompleteScreen = OrderCompleteScreen()

    companion object{
        //싱글톤 패턴
        private var instance:MyKiosk? = null

        fun newInstance():MyKiosk{
            if(instance == null) instance = MyKiosk()
            return instance!!
        }

        //모든 메뉴 정보
        val myMenu = MyMenu()
        val shoppingCart = MenuItemCollection()
        val paymentManager = PaymentManager()
        var isTakeOut:Boolean = false
    }

    //키오스크 프로그램 실행 (무한 반복)
    fun run(){
        //0. 첫 화면
        firstLoop@ while(true){
            firstScreen.run()

            //1. 먹고 가기/포장하기 화면
            takeOutLoop@ while(true) {
                //장바구니 초기화
                shoppingCart.clearMenuItemList()

                val takeOutResult = takeOutScreen.run()
                when(takeOutResult) {
                    "1" -> isTakeOut = false
                    "2" -> isTakeOut = true
                    "q" -> continue@firstLoop //0. 첫 화면
                }

                //2. 메인 화면
                mainLoop@ while (true) {
                    val mainResult = mainScreen.run()
                    when (mainResult) {
                        "c" -> shoppingCartScreen.run() //4. 장바구니 화면
                        "o" -> {
                            //5. 주문하기 화면
                            val orderResult = orderScreen.run()
                            when(orderResult) {
                                "b" -> continue@mainLoop//2. 메인 화면
                                "p" ->{
                                    //주문 결제 화면
                                    val orderPaymentResult = orderPaymentScreen.run()
                                    if(orderPaymentResult == "true") break@mainLoop //6. 주문 완료 화면
                                    else continue@mainLoop //2. 메인 화면 (결제 실패, not reached)
                                }
                            }
                        }
                        "b" -> continue@takeOutLoop //1. 먹고가기/포장하기 화면
                        "q" -> continue@firstLoop //0. 첫 화면

                        else -> selectMenuScreen.run(mainResult) //3. 메뉴 선택 화면
                    }
                }
                //6. 주문 완료 화면
                orderCompleteScreen.run()
                continue@firstLoop
            }
        }

    }
}