[Kotlin] 코틀린 문법 기초 2

 

예외처리

모든 예외 클래스는 최상위 예외 클래스인 Throwable을 상속함

• 자바에서 checked exception은 컴파일 에러가 발생하기 때문에 무조건 try-catch로 감싸거나 throws 예외를 전파해야하나, 코틀린은 checked exception을 강제 X
• 코틀린에서 try-catch는 표현식

val a = try { 
    "1234".toInt() 
} catch (e: NumberFormatException) { 
    println("catch 동작") 
}
println(a) // 1234

• 코틀린에서 exception을 발생시키려면 throw 사용

fun failFast(message: String): {
	throw IllegalArgumentException(message)
}

• Nothing 타입을 사용하면 컴파일러는 해당 코드 이후에는 실행되지 않는다는 경고 보여줌

fun failFast(message: String): Nothing {
	throw IllegalArgumentException(message)
}

failFast("에러발생!")
// Unreachable code
println("이 메시지는 출력될까?")

• 엘비스 연산자와 Nothing 타입을 사용하면 null 안전 코드를 작성하지 않아도 됨 👉 null이 나올 수 없다고 인식하기 때문

fun main() {
    val a: String? = null
    val b: String = a ?: failFast("a is null ")
    println(b.length) // b?.length로 작성하지 않아도 됨
}

 

 

 

클래스와 프로퍼티

🔷 Class

• class 키워드 사용하여 선언
• 생성자는 기본생성자와 하나 이상의 보조 생성자 존재 가능 

class Coffee constructor(val name: String)
class Coffee(val name: String) // 기본 생성자는 constructor 생략 가능

 

• 클래스에 프로퍼티 선언할 때 trailing comma (후행쉼표) 사용 👉 이전의 마지막 줄을 수정하지 않고 프로퍼티 쉽게 추가 가능하므로 git에서 diff 등으로 코드를 비교했을 때 변경사항 명확히 알 수 있음 

class Coffee(
    val name: String,
    val price: Int, // trailing comma
)

 

🔷 프로퍼티

• val, var 키워드 모두 사용 가능

class Coffee(
    var name: String = "", // 기본 값 추가
    var price: Int = 0,
)

• 프로퍼티 수정하거나 사용하려면 참조 사용

fun main() {
    val coffee = Coffee()
    coffee.name = "아이스 아메리카노"
    coffee.price = 2000
    println("${coffee.name} 가격은 ${coffee.price}")
}

 

 

🔷 getter, setter

• var로 선언된 프로퍼티는 getter, setter를 자동으로 생성
• val로 선언된 프로퍼티는 getter만 존재 
• 커스텀 getter 만들 수 있음 

class Coffee(
    var name: String = "",
    var price: Int = 0, // trailing comma
) {
    val brand: String
    	get() = "스타벅스" // 커스텀 getter
}

fun main() {
    val coffee = Coffee()
    coffee.name = "아이스 아메리카노"
    coffee.price = 2000
    
    // brand를 포함해 출력
    println("${coffee.brand} ${coffee.name} 가격은 ${coffee.price}")
}

• var로 선언된 프로퍼티에 한하여 커스텀 setter 생성 가능

class Coffee(
    var name: String = "",
    var price: Int = 0, // trailing comma
) {
    val brand: String
        get() {
        	return "스타벅스"
    }
    
    var quantity: Int = 0
        set(value) { // 커스텀 setter
            if (value > 0) { // 수량이 0 이상인 경우에만 값을 할당
            	field = value
        }
    }
}

fun main() {
    val coffee = Coffee()
    coffee.name = "아이스 아메리카노"
    coffee.price = 2000
    coffee.quantity = 1 // 주문 수량 추가
    
    // 수량을 포함해 출력
    println("${coffee.brand} ${coffee.name} 가격은 ${coffee.price} 수량은 ${coffee.quantity}")
}

field 식별자 사용해 필드의 참조에 접근 = Backing Field
👉 field 대신 quantity로 직접 할당한다면 무한재귀 발생 (StackOverflow)

 

• 프로퍼티는 객체지향적 👉 행위는 메서드로 표현, 상태는 프로퍼티로 표현

class Coffee(
	var name: String = "",
    var price: Int = 0, // trailing comma
    var iced: Boolean = false,
){
	val brand: String
    	get(){
        	return "스타벅스"
        }
    
    var quantity: Int = 0
    	set(value) {
        	if(value > 0){
            	field = value
            }
        }
}

fun main(){
	val coffee = Coffee()
    coffee.name = "아이스 아메리카노"
    coffee.price = 2000
    coffee.quantity = 1
    coffee.iced = true
    
    if(coffee.iced){ // 프로퍼티
    	println("아이스 커피")
    }
    println("${coffee.brand} ${coffee.name} 가격은 ${coffee.price} 수량은 ${coffee.quantity}")
}

 

 

 

상속

🔷 상속

상속을 목적으로 만든 클래스가 아니라면 모두 final로 작성하는 것이 좋음 

• 자바의 모든 클래스 조상 = Object
• 코틀린에서 모든 클래스 조상 = Any
  • Any에는 equals, hashCode, toString이 존재하고 모든 클래스로 자동 상속됨
• open 키워드로 상속 허용

open class Dog

• 하위클래스에서 상위 클래스를 확장하려면 클래스 뒤에 : 추가하고 상위 클래스 작성

class Bulldog : Dog()

 

•  함수나 프로퍼티를 재정의할 때도 open 키워드로 오버라이드에 대해 허용

open class Dog{
	open var age: Int = 0
    
    open fun bark() {
    	println("멍멍")
    }
}

// 재정의 -> Dog 클래스 상속받음
class Bulldog : Dog() {
	override var age: Int = 0
    
    override fun bark(){
    	println("컹컹")
    }
}

// 기본생성자를 사용해 오버라이드
class Bulldog(override var age: Int = 0) : Dog() {
	override fun bark(){
    	println("컹컹")
    }
}

fun main(){
	val dog = Bulldog(age = 2)
    println(dog.age)
    dog.bark()
}

 

• override된 함수나 프로퍼티는 기본적으로 open되어 있으므로 하위클래스에서 오버라이드를 막기 위해 final을 앞에 붙임

open class Bulldog(final override var age: Int = 0) : Dog() {
	
    final override fun bark() {
    	println("컹컹")
    }
}

class childrenBulldog : Bulldog(){
	
    override var age: Int = 0 // 컴파일 오류
    override fun bark() {} // 컴파일 오류
}

• 하위 클래스에서 상위 클래스의 함수나 프로퍼티를 접근할 땐 super 키워드 사용

open class Bulldog(final override var age: Int = 0) : Dog(){

	final override fun bark(){
    	super.bark()
    }
}

 

 

🔷 추상클래스

• abstract 키워드 사용 👉 하위클래스에서 구현해야하는 프로퍼티나 함수 또한 abstract 키워드 사용

abstract class Developer {
	abstract var age: Int
    abstract fun code(language: String) // abstract 키워드 붙은 것 반드시 구현
}

class BackendDeveloper(override var age: Int) : Developer(){
	override fun code(language: String){
    	println("I code with $language")
    }
}

fun main(){
	val backendDeveloper = BackendDeveloper(age=20)
    println(backendDeveloper.age)
	backendDeveloper.code("Kotlin")
}
// I code with Kotlin

 

 

 

인터페이스

• interface 키워드 사용
• 인터페이스 내부에 추상함수와 구현을 가진 함수 (디폴트 메서드) 모두 정의 가능 

class Product(val name: String, val price: Int)

interface Wheel{ // 상위 인터페이스 
	fun roll()
}

interface Cart : Wheel {

	var coin: Int // 반드시 구현해야하는 추상 프로퍼티
    
    val weight: String
    	get() = "20KG" // backing field 사용 X
    
	fun add(product: Product) // 추상 함수
    
    fun rent(){
    	if(coin > 0){
        	println("카트를 대여합니다")
        }
    }
    
    override fun roll(){
    	println("카트가 굴러갑니다")
    }
}

interface Order{
	fun add(product: Product){
    	println("${product.name} 주문이 완료되었습니다")
    }
}
class MyCart(override var coin: Int): Cart, Order{
	override fun add(product: Product) {
    	if(coin <= 0) println("코인을 넣어주세요")
        else println("$(product.name)이(가) 카트에 추가됐습니다")
        
        // 주문하기
        super<Order>.add(product)
    }
}

fun main(){
	val cart = MyCart(coin = 100)
    cart.rent()
    cart.roll()
	cart.add(Product(name = "장난감", price = 1000))
    // 카트를 대여합니다
    // 카트가 굴러갑니다
    // 장난감이(가) 카트에 추가됐습니다
    // 장난감 주문이 완료되었습니다
    
    val cart2 = MyCart(coin = 0)
    cart2.rent()
    cart2.add(Product(name = "장난감", price = 1000))
    // 코인을 넣어주세요
}

• 인터페이스 구현 시 :을 붙이고 인터페이스의 이름 적음
• 인터페이스 자체에서 backing field 접근 불가
• 상속과 다른 점 👉 () 생성자 호출이 없음 
• 클래스는 하나 이상의 인터페이스 구현 가능 
  • Order에는 add가 구현이 있는 디폴트 함수이고, Cart는 abstract 함수임
  • 동일한 이름을 가진 함수가 있는 경우 super<인터페이스>를 사용해 호출 가능  👉 재정의 충돌 해결
  • 두 인터페이스에 구현을 가진 동일한 디폴트 함수를 사용할 경우 컴파일 오류 발생 

interface Cart : Wheel {
	fun printId() = println("1234")
}

interface Order {
	fun printId() = println("5678")
}

// 컴파일 오류 발생
class MyCart(override var coin: Int) : Cart, Order

 

class MyCart(override var coin: Int) : Cart, Order {
    override fun printId() {
        super<Cart>.printId()
        super<Order>.printId()
    }
}

• 하위 클래스에서 직접 구현해서 인터페이스의 디폴트 함수 사용하면 됨

 

 

열거형

🔷 enum class 사용

enum class PaymentStatus {
	UNPAID, PAID, FAILED, REFUNDED
}

• 클래스이므로 생성자와 프로퍼티 정의 가능

enum class PaymentStatus(val label: String) {
    UNPAID("미지급"),
    PAID("지급완료"),
    FAILED("지급실패"),
    REFUNDED("환불")
}

println(PaymentStatus.PAID.label)
// 지급완료

 

• 정의된 상수 목록 뒤에 함수 정의할 경우 ; (세미콜론) 사용

enum class PaymentStatus(val label: String) {
    UNPAID("미지급"),
    PAID("지급완료"),
    FAILED("지급실패"),
    REFUNDED("환불");
    
    fun isPayable(): Boolean = false
}

• 결제 상태에 따라 isPayable 상태 다르게 구현 👉 abstract 함수를 가질 수 있고 각각의 상수는 익명 클래스 형태로 abstract 함수 구현 가능 

enum class PaymentStatus(val label: String) {
    UNPAID("미지급") {
    	override fun isPayable() = true
    },
    PAID("지급완료") {
    	override fun isPayable() = false
    },
    FAILED("지급실패") {
    	override fun isPayable() = false
    },
    REFUNDED("환불") {
    	override fun isPayable() = false
    };
    
    abstract fun isPayable(): Boolean
}

fun main() {
	if(PaymentStatus.UNPAID.isPayable()){
    	println("결제 가능 상태")
    }
    // 결제 가능 상태 
}

 

• enum 클래스에서 인터페이스 구현 가능 

enum class PaymentStatus(val label: String) : Payable {
    UNPAID("미지급") {
    	override fun isPayable() = true
    },
    PAID("지급완료") {
    	override fun isPayable() = false
    },
    FAILED("지급실패") {
   	 override fun isPayable() = false
    },
    REFUNDED("환불") {
    	override fun isPayable() = false
    };
}

interface Payable {
	fun isPayable(): Boolean
}

 

• valueOf(value:String) : String 을 사용해서 enum 클래스 생성 가능 

val paymentStatus = PaymentStatus.valueOf("PAID")
println(paymentStatus.label)
// 지급완료

• 동등성 비교 👉 == 사용

if (paymentStatus == PaymentStatus.PAID) {
	println("결제 완료 상태")
}
// 결제 완료 상태

 

• enum 클래스의 상수 나열 👉 values() : Array<EnumClass> 사용

for (status in PaymentStatus.values()) {
	println("[$status](${status.label})")
}
// [UNPAID](미지급)
// [PAID](지급완료)
// [FAILED](지급실패)
// [REFUNDED](환불)

• 상수는 제공하는 2개의 프로퍼티 사용해 이름을 얻거나 순서 얻을 수 있음

val name: String
val ordinal: Int

for (status in PaymentStatus.values()) {
	println("[${status.name}](${status.label}) : ${status.ordinal}")
}
// [UNPAID](미지급) : 0
// [PAID](지급완료) : 1
// [FAILED](지급실패) : 2
// [REFUNDED](환불) : 3