[Kotlin] 코틀린 기초문법(변수, 함수, 흐름제어, 널 안정성, 예외처리, 클래스, 프로퍼티, 상속, 인터페이스, 열거형 클래스)

Kotlin Playground: Edit, Run, Share Kotlin Code Online

실시간으로 웹에서 코틀린의 문법을 학습할 수 있는 사이트

1. 변수

val a: Int = 1

//타입을 생략해도 컴파일 에러 X, 타입 추론이 가능하다.
val b = 1

//지연할당: 뒤늦게 값을 할당할 수 있다**(지연할당시에는 타입을 반드시 적어줘야함)**
val c: Int
c= 3

코틀린에서 변수 선언 시에 사용하는 키워드
- val : value의 약자, java의 final처럼 재할당이 불가능
- var : variable의 약자, 변수의 개념으로 재할당이 가능하다

    val e : String = "Hello"
    e = "World" //컴파일 에러, val은 재할당이 불가능하기 때문이다.

    var f = 123
    f = "hi" //컴파일 에러, 한번 타입이 고정되면 그 타입은 변경이 불가능하다.

변수를 top-level로
- 클래스 밖에서 변수를 선언할 수 있다.
```
  var x = 5
  fun main() {
  }
```
  코틀린은 클래스를 선언하지 않고도 변수를 사용할 수 있다. 이 변수(x)를 top-level 변수라고 한다.

2. 함수 선언 방법

기본적인 함수 선언 스타일
- fun키워드 + 함수명 + 인자, 타입+ 반환타입 + 결과로 구성

        fun funName(param:String, param2:String): String {
            return result
        }

표현식 스타일로 사용이 가능하다.
- 몸통 없이 로직만 사용할 수 있다.

        fun sum2(a: Int, b: Int) = a + b

  함수 또한 변수처럼 타입 추론이 가능하기 때문에 반환타입을 생략할 수 있다.

- 몸통이 있는 함수는 **반환 타입을 반드시** 필요하다.

        fun sum4(a: Int, b: Int): Int { //Int 생략시 컴파일 오류
            return a + b    
        }

- 반환타입이 없는 함수는 **Unit**을 반환한다(**생략 가능**하다), 자바의 void와 유사

        fun printSum(a: Int, b: Int) : Unit {
            println(1)    
        }

- 디폴트 파라미터 기능을 제공한다.

        fun greeting(message: String = "hi") {
            println(message)
        }

        fun main() {
            greeting() //hi
            greeting("HI!!") //HI!!
        }

  자바는 디폴트 파라미터가 딱히 없다.

- **named argument**

        fun log(level: Stirng = "INFO", message: String) {
            println("{$level]$message")
        }

        fun main() {
            log("info log")
            log(level="DEBUG", "debug log")
            log("WARN", "warning log")
            log(level="ERROR", message = "error log")
        }

  함수에 변수 값을 넣을 때, 이름과 값을 매핑하는 기법을 named argument라고 한다.

요약 : 코틀린의 함수는 간결하게 작성이 가능하고, named argument나 default parameter같은 경우에는 유용하게 사용된다.

3. 흐름 제어 문법

if…else 식

val job = "software"
if(job == "software") {
    println("개발자")
} else {
    println("개발자아님")
}

코틀린에서 말하는 if-else는 표현식으로, 표현식의 형태로 값을 리턴할 수 있다.

    val str = if(job == "software") {
        "개발자"
    } else {
        "개발자아님"
    }

코틀린은 if-else 자체가 표현식이기 때문에 삼항 연산자가 불필요하다.

    val a = 1
    val b = 2
    val c = if(b > a) b else a

when 식

kotlin의 when은 java의 switch랑 유사하다.

java에서는 특정 케이스에서 break문을 생략한 경우 다른 케이스가 실행될 수 있어 의도와 다르게 동작할 수 있다.

    val day = 2
    val result = when(day) {
        1 -> "월"
        2 -> "화"
        3 -> "수"
        4 -> "목"
        else -> "기타"
    }

when식을 사용하면 result값에 값을 바로 할당할 수 있다.

추가적으로 kotlin에서는 else를 생략할 수 있다.

    enum class Color {
        RED, GREEN, BLUE
    }
    fun getColor() = Color.RED

    fun main() {
        when (getColor()) {
            Color.RED -> println("red") 
            Color.GREEN -> println("green") 
            Color.BLUE -> println("blue")
        }

        when (getColor()) {
            Color.RED -> println("red")
            else -> println("not red")
            //GREEN, BLUE else
        } 
    }

Kotlin은 enum type인 red, green, blue를 모두 when절에서 명시해줬기 때문에 else를 별도로 작성하지 않아도 된다.

코틀린의 컴파일러는 이를 추론할 수 있다.

for loop

java의 for each와 매우 유사하다

    for(i in 0..3) { //(0~3)
        println(i) // 3을 포함한다.
    }

    for(i in 0 until 3) { //3을 포함하지 않는다.(0~2)
        println(i)
    }

범위 연산자 ..을 사용해 for loop를 돌릴 수 있다. (마지막 숫자까지 포함)

until을 이용하면 마지막 숫자는 미포함이다.

특정값만큼 증가하면서 반복하고 싶은 경우

    for(i in 0..6 step 2) {
        println(i)
    }

값이 2씩 증가하면서 0~6까지 반복한다.

값을 반복감소시키고 싶은 경우

    for(i in 3 downTo 1) {
        println(i)
    }

배열을 이용해 for-loop돌기

    val numbers = arrayOf(1,2,3) //배열 선언 

    for(i in numbers) {
        println(i)
    }

While

자바의 while문과 동일하다.

    var x = 5
    while(x>0) {
        println(x)
        x--
    }

4. 널(Null) 안정성

널 참조의 위험성

자바에서 가장 많이 발생하는 예외 유형, NPE(NullPointerException)

→ 자바에서는 NPE를 줄이기 위해 JDK8부터 Optional을 지원

Optional은 값을 매핑하기 때문에 객체 생성에 따른 오버헤드가 발생, 컴파일 단계에서 Null가능성을 검사하지 않는다.

→ 코틀린에서는 null가능성을 컴파일러가 미리 감지해서 NPE를 줄일 수 있다.
kotlin에서의 NPE

    fun main() {
        val a : String = null //컴파일 에러 발생
        var b : String = "aabbcc"
        b = null //컴파일 에러 발생
    }

코틀린은 기본적으로 null을 지원하지 않고, nullable한 타입을 따로 제공한다.

    var a : String? = null
    a.length //컴파일 에러 발생(a는 null일 수 있기 때문이다)
    a?.length //컴파일 에러 X

    print(a?.length) //null 참조에 대해서는 안전연산자를 통해 접근 시 npe없이 정상적으로 사용할 수 있게 해준다.

타입 뒤에 ?을 붙여 null이 될 수 있는 타입임을 선언한다. a가 nullable하다는 것을 코틀린 컴파일러에게 알려 컴파일 에러를 방지한다.

?. 는 안전연산자로 null 참조에 대해서 안전연산자를 통해 접근 시 NPE 없이 정상적으로 사용할 수 있게 한다.

    val b: Int = if(a != null) a.length else 0
    println(b) //a변수가 null이기 때문에 0이 출력된다.

    val c = a?.length ?: 0 //elvis연산자를 사용
    println(c)

?: 는 엘비스연산자이다. 이 연산자를 사용하면, 좌변이 null인 경우 우변의 결과를 리턴한다. 위의 b코드를 엘비스 연산자를 이용해 줄일 수 있다.

기존의 자바코드이다.

```java
import java.util.Optional;
public class Java_NullSafety {
    public static String getNullStr() {
        return null;
        }

    public static int getLengthIfNotNull(String str) {
        if (str == null || str.length() == 0) {
                    return 0; 
                }
        return str.length();
    }

    public static void main(String[] args) {
        String nullableStr = getNullStr();
        // Optional
        nullableStr = Optional.ofNullable(nullableStr)
                            .orElse("null");
                int nullableStrLength = nullableStr.length(); 
                System.out.println(nullableStrLength);
                int length = getLengthIfNotNull(null); 
                System.out.println(length);
        } 
}
```

NPE를 방지하기 위해 Optional로 받는 작업, str이 null인지 확인하는 작업, str의 길이가 0이 아닌지를 확인하는 작업을 거쳐야 한다.

이를 코틀린의 엘비스연산자와 안전연산자를 사용해서 고쳐보면 이렇게 줄일 수 있다.

    fun getNullStr(): String? = null
    fun getLengthIfNotNull(str: String?) = str?.length ?: 0

    fun main() {
        val nullableStr = getNullStr()

        val nullableStrLength = nullableStr?.length ?: "null".length
        println(nullableStrLength)

            println(getLengthIfNotNull(null))
    }

    val c: String? = null
    val d = c!!.length

!!. 는 단언 연산자이다. null이 발생하지 않는다고 개발자가 컴파일러에게 알려주는 역할이다. 그러나 null이 발생하던 안하던 개발자에게 책임을 맡기는 연산자이기 때문에 NPE가 발생할 수 있다.(잘 사용하지 않는다)

코틀린에서 자바 코드를 사용할 때는 반드시 nullable함을 고려해야 한다. 따라서 안전연산자와 엘비스 연산자를 사용해야 한다.

5. 예외처리

코틀린의 예외 클래스

모든 예외 클래스는 최상위 예외클래스인 Throwable을 상속한다.

- `Error` : 시스템에서 에러가 발생해서 복구가 어려운 상황(OOM, StackOverFlow Error)
- `Exception`
    - `CheckedException` : 시스템에서 포착 가능하여 복구 가능, 예외처리를 강제한다. (IOException, FileNotFoundException)
    - `RuntimeException` : 런타임시에 발생, 예외처리 강제하지 않음(NullPointerException, ArrayIndexOutOf`BoundsException, **Unchecked Exception)**

자바에서는 checked exception의 처리를 강제한다. 컴파일 에러가 발생하기 때문에 무조건 try-catch로 감싸거나 throws로 예외를 전파해야 한다.

    //try-catch문 작성하지 않으면 컴파일 에러 발생
    try {
        Thread.sleep(1);
    } catch(InterruptedException e) {
        //예외 처리
    }

코틀린은 checked exception 처리가 필수가 아니다.
```
  Thread.sleep(1) //컴파일에러X
```
물론, try-catch문을 사용해도 된다. 강제가 아닐 뿐이다!

코틀린은 표현식의 형태를 사용하기 때문에 try-catch문을 이용해 값을 전달할 수 있다. try-catch도 식이기 때문에 값을 리턴할 수 있다.

    val a = try {
        "1234".toInt()
    } catch (e: Exception) {
        println("예외 발생!")
    }

코틀린에서 exception 발생시키기

    throw Exception("예외 발생")

    fun failFast(message: String) { //리턴타입 Nothing이 생략
        throw IllegalArgumentException(message)
    }

throw 또한 식이기 때문에 값을 리턴할 수 있다.

Exception과 같은 경우에는 Nothing이라는 타입을 반환하게 된다. 이를 이용해 이 이후의 코드가 실행되지 않음을 보장한다.

또한 elvis연산자와 Nothing 타입을 이용해 null 안전 코드를 작성하지 않아도 된다.

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

    fun main() {
        val a: String? = null
        **val b: String = a ?: failFast("a is null ")**
        println(b.length)
    }

이렇게 될 경우 a가 null일 경우, IllegalArgumentException이 발생하기 때문에 NPE가 발생할 일이 없다.

6. 클래스와 프로퍼티

class

class키워드를 사용해 클래스를 선언한다.

    class Coffee constructor(val name: String) {

    }

    //같은 의미, 생략하는 것이 더 가독성이 좋음
    class Coffee(val name: String) {

    }

기본적으로 코틀린 클래스는 constructor 키워드를 생략할 수 있다.(주로 생략한다)

본문 내용이 없는 클래스도 만들 수 있다.

    class EmptyClass

후행쉼표를 허용한다.

    class Coffee (
        val name: String,
        val price: Int,
        ) {
    }

name이라는 property가 있고, price라는 properties를 하나 만들 때, 필드가 없음에도 불구하고 쉼표를 넣을 수 있다.

추후에 프로퍼티를 추가할 때 편하다.(코드리뷰, 가독성 등등…)

Properties

    class Coffee(
        var name: String = "",
        var price: Int = 0,
    )

    fun main() {
        val coffee = Coffee()
        coffee.name = "아이스 아메리카노"
        coffee.price = 2000

        println("${coffee.name} 가격은 ${coffee.price}")
    }

var 키워드를 사용하면 값을 재할당할 수 있다.
코틀린에서는 컴파일 시 getter, setter를 자동으로 생성해준다.
coffee name, price에 할당된 값은 기본적으로 setter를 이용해 할당이 된다.
값을 사용할 때는 getter를 사용한다.
custom setter 만들기


      class Coffee (
          var name: String = "",
          var price: Int = 0,
      ) {
          //custom setter
          var quantity: Int = 0
              set(value) {
                  if(valule > 0) { //수량이 0이상인 경우에만 할당
                      field = value
              }
      }

      fun main() {
          val coffee = Coffee()
          coffee.name = "아이스 아메리카노"
          coffee.price = 2000

          coffee.quantity = 1

          println("${coffee.quantity}")
      }

- var quantity를 선언했다. custom setter를 이용해 수량이 0 이상일 경우에 해당 값을 value로 할당한다.
- `backing field` : field는 식별자로 getter, setter에 대해서 field라는 식별자를 이용해 필드의 참조에 접근한다.

  이는 무한 재귀상태(StackOverFlowError)를 방지하기 위해 필드라는 식별자를 이용해 값을 할당해야 한다.

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

    fun main() {
        val coffee = Coffee()
        coffee.name = "아이스 아메리카노"
        coffee.price = 2000
        coffee.quantity = 1

        println("${coffee.brand}")
    }

예제 코드에서 coffee.brand 값을 가져오고자 하면 자동으로 custom getter가 불러와지고, “스타벅스”가 출력된다.
컴파일 시 val 객체에 대해서는 getter만 생성이 된다.(set이 불가능하기 때문에 만들지 않는다)

코틀린의 프로퍼티는 자바보다 객체지향적으로 코드를 작성할 수 있다.
- 자바는 상태를 메서드로 나타낸다.

      if(coffee.isIced()) {
          System.out.println("아이스 커피");
      }

코틀린은 프로퍼티로 상태를 나타낼 수 있다.

      if(coffee.iced) {
          println("아이스커피")
      }

요약

코틀린은 프로퍼티를 이용해 많은 양의 Boilerplate Code를 없앨 수 있다.

    //java
    public class Person {

        private String name;
        private int age;

        public Person(String name, int age){
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }

    // Kotlin
    // [var:getter, setter / val : getter]
    class Person(var name:String = "코틀린", var age:Int = 10)

이렇듯 자바에서 20줄이 넘는 코드를 코틀린으로는 프로퍼티를 이용해 한줄만에 표현할 수 있다.

클래스 선언방식	Getter 생성	Setter 생성	유형
class Person(name: String)	X	X	생성자 매개변수
class Person(var name: String)	O	O	property
class Person(val name: String)	O	X	property

7. 상속

자바의 상속

상속을 통해 기존 코드를 재사용하거나 확장할 수 있다.
자바는 기본적으로 모든 클래스가 상속가능하나 부작용을 방지하기 위해 final 키워드를 붙여서 상속을 막을 수 있다.

대표적인 클래스 : System class(final로 작성)
이펙티브 자바에서는 상속을 위한 설계와 문서를 작성하고 그렇지 않으면 상속을 금지하라는 주제가 있다.

→ 상속을 목적으로 만든 클래스가 아니라면 모두 final로 작성하는 것이 좋다.
자바의 모든 클래스의 조상은 Object다.

코틀린의 상속

코틀린의 모든 클래스의 조상은 Any다. (equals, hashCode, toString 함수들을 기본적으로 제공)
코틀린의 클래스는 기본적으로 final이다(상속을 막는다)

상속이 꼭 필요한 경우엔 open키워드를 사용한다.

    //final class
    class FinalDog 

    //상속가능한 클래스
    open class Dog

    class Bulldog : Dog() //상속코드

클래스명 콜론:상위클래스()의 꼴로 상속을 선언한다.

함수나 프로퍼티를 재정의할때도 open 키워드를 사용한다.

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

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

        override fun bark() {
            println("컹컹")
        }
    }

Bulldog 클래스는 오버라이드 키워드를 이용해 상위클래스에서 오픈한 메서드와 프로퍼티를 재정의한다.

코틀린에서는 기본생성자를 사용해 프로퍼티를 재정의 할 수 있다.

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

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

코틀린에서는 오버라이드가 되면 자동으로 함수나 프로퍼티가 open 상태가 된다.

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

    class ChildBulldog : Bulldog() {
        override var age: Int = 0
        override fun bark() {
            super.bark()
        }
    }

불독의 하위클래스인 ChildBulldog을 만들었다.

프로퍼티나 함수에서 별도의 open 키워드가 없음에도 childBulldog에서 재정의를 할 수 있는 것을 확인할 수 있다.

재정의를 하지 못하도록 막아야 하는 경우라면 final 키워드를 붙이면 된다.

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

    class ChildBulldog : 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()
        }
    }

상위클래스인 Dog에서의 bark 함수가 수행이 된다.

코틀린의 추상클래스

abstract 키워드를 사용한다

    abstract class Developer {
        abstract var age: Int

        abstract fun code(language: String)
    }

    class BackendDeveloper : Developer() {
        override var age: Int = 0

        override fun code(language: String) {
            println("$language")
        }    
    }

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

자바와 마찬가지로 상위클래스의 메서드와 프로퍼티에 abstract keyword가 붙으면 하위클래스가 반드시 구현을 해줘야 한다.

추상클래스를 구현할 때는 abstract class, abstract property, abstract method를 이용해 구현한다.

8. 인터페이스

코틀린에서 인터페이스 정의하기

interface 키워드 사용

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

    interface Cart {
        fun add(product: Product)
        fun rent() {

        }
    }

Cart라는 인터페이스를 정의했다. 앞에 interface라는 키워드만 사용하면 된다.

인터페이스 내부에는 상품을 인자로 받아서 추가하는 add함수, 아직은 구현이 없는 rent함수를 작성할 수 있다.

클래스에서 인터페이스를 구현할때는 콜론(:)을 붙이고 인터페이스 명만 적으면 된다.

    class MyCart: Cart {
        override fun add(product: Product) {

        }
    }

인터페이스는 생성자 호출 없이 인터페이스의 명만 적으면 된다.(추상클래스와의 다른점)

이 MyCart에서는 Cart인터페이스에서 구현해야하는 추상함수이기 때문에 override 키워드를 이용해 함수를 생성해야 한다.

rent()는 Cart 인터페이스 자체에서 내부 로직을 구현한 함수이기 때문에 MyCart에서는 별도 rent함수에 대해서는 오버라이드를 해주지 않아도 된다.

코틀린에서는 interface의 프로퍼티도 존재한다.

    interface Cart {
        var coin: Int

        val weight: String
            get() = "20KG"
    }

    class MyCart(override var coin: Int): Cart {

    }

coin이라는 프로퍼티는 MyCart 클래스에서 무조건 구현해야 하는 추상 프로퍼티가 된다.

또한, weight처럼 getter 접근자를 이용한 프로퍼티도 구현할 수 있다. 이 경우엔 프로퍼티에 대한 초기값이 따로 없기 때문에 인터페이스 자체에서 backing field에 접근할 수 없다. 즉, 특정값을 사용해서만 프로퍼티를 만들 수 있다.

  interface Cart {
      var coin: Int

      fun add(product: Product)

      val weight: String
          get() = "20KG"

      fun rent() {
          if(coin > 0) {
              println("카트를 대여합니다")
          }
      }
  }

  class MyCart(override var coin: Int): Cart {
      override fun add(product: Product) {
              if(coin <= 0)
                  println("코인을 넣어주세요")
              else println("${product.name}이(가) 카트에 추가됐습니다")
      }
  }

  fun main() {
      val cart = MyCart(coin = 100) 
      cart.rent() 
      cart.add(Product(name = "장난감", price = 1000))
  }

rent함수가 먼저 호출되었고, 코인이 100이기 때문에 카트를 대여한다는 문장이 출력되고, 1000원짜리 장난감을 카트에 넣었는데 코인이 0원 이상이기 때문에 카트에 추가됐다는 메세지가 뜰 것이다.

코틀린의 인터페이스는 상위 인터페이스를 가질 수 있다.

    interface Wheel {
        fun roll()
    }

    interface Cart: Wheel{
        var coin: Int

        fun add(product: Product)

        val weight: String
            get() = "20KG"

        fun rent() {
            if(coin > 0) {
                println("카트를 대여합니다")
            }
        }

        override fun roll() {
            println("카트가 굴러갑니다.")    
        }
    }

    class MyCart(override var coin: Int): Cart {
        override fun add(product: Product) {
                if(coin <= 0)
                    println("코인을 넣어주세요")
                else println("${product.name}이(가) 카트에 추가됐습니다")
        }
    }

    fun main() {
        val cart = MyCart(coin = 100) 
        cart.rent() 
        **cart.roll()**
        cart.add(Product(name = "장난감", price = 1000))
    }

Cart 인터페이스에서 Wheel에서의 roll()함수를 구현했다.

코틀린에서는 인터페이스도 상위 인터페이스를 가질 수 있으며 그 인터페이스에서 구현할 수 있는 함수를 하위 인터페이스에서도 재정의할 수 있다.

코틀린에서는 하나 이상의 인터페이스를 구현할 수 있다.

    interface Wheel {
        fun roll()
    }

    interface Cart: Wheel{
        var coin: Int

        fun add(product: Product)

        val weight: String
            get() = "20KG"

        fun rent() {
            if(coin > 0) {
                println("카트를 대여합니다")
            }
        }

        override fun roll() {
            println("카트가 굴러갑니다.")    
        }
    }

    **interface Order {
        fun add(product: Product) {
            println("상품 주문이 완료됐습니다.")
        }
    }**

    class MyCart(override var coin: Int): **Cart, Order** {
        override fun add(product: Product) {
                if(coin <= 0)
                    println("코인을 넣어주세요")
                else println("${product.name}이(가) 카트에 추가됐습니다")
        }
    }

    fun main() {
        val cart = MyCart(coin = 100) 
        cart.rent() 
        **cart.roll()**
        cart.add(Product(name = "장난감", price = 1000))
    }

MyCart는 현재 Cart랑 Order 인터페이스를 구현하는 클래스이다. 복수개의 인터페이스를 구현할때는 콤마(,)로 구분한다.

복수개의 인터페이스를 구현할때의 문제점은 동일한 시그니처를 가진 함수를 구현할때이다. 예를들어 Cart와 Order 모두 같은 add함수를 가진다고 했을 때 Order 인터페이스의 add는 호출되지 않는다.

복수개의 인터페이스에서 함수를 호출하라고 하면 상속과 마찬가지로 super키워드를 이용해 함수에 접근할 수 있다.

코틀린에서는 하나 이상의 인터페이스를 구현할 수 있다.

    interface Wheel {
        fun roll()
    }

    interface Cart: Wheel{
        var coin: Int

        fun add(product: Product)

        val weight: String
            get() = "20KG"

        fun rent() {
            if(coin > 0) {
                println("카트를 대여합니다")
            }
        }

        override fun roll() {
            println("카트가 굴러갑니다.")    
        }
    }

    **interface Order {
        fun add(product: Product) {
            println("상품 주문이 완료됐습니다.")
        }
    }**

    class MyCart(override var coin: Int): **Cart, Order** {
        override fun add(product: Product) {
                if(coin <= 0)
                    println("코인을 넣어주세요")
                else println("${product.name}이(가) 카트에 추가됐습니다")
        }
    }

    fun main() {
        val cart = MyCart(coin = 100) 
        cart.rent() 
        **cart.roll()**
        cart.add(Product(name = "장난감", price = 1000))
    }

MyCart는 현재 Cart랑 Order 인터페이스를 구현하는 클래스이다. 복수개의 인터페이스를 구현할때는 콤마(,)로 구분한다.

복수개의 인터페이스에서 함수를 호출하라고 하면 상속과 마찬가지로 super키워드를 이용해 함수에 접근할 수 있다.

    interface Wheel {
        fun roll()
    }

    interface Cart: Wheel{
        var coin: Int

        fun add(product: Product)

        val weight: String
            get() = "20KG"

        fun rent() {
            if(coin > 0) {
                println("카트를 대여합니다")
            }
        }

        override fun roll() {
            println("카트가 굴러갑니다.")    
        }
    }

    **interface Order {
        fun add(product: Product) {
            println("상품 주문이 완료됐습니다.")
        }
    }**

    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))
    }

Order의 add도 호출하고 싶다면 super<Order>.add(product) super와 꺽쇄를 이용해 상위 인터페이스에 대해 접근할 수 있다.

위의 코드에서 Cart 의 add는 추상함수이다. Order의 add는 구현이 된 디폴트함수이기 때문에 동일한 시그니처를 가진 디폴트함수를 만들어서 무엇이 실행되는지 테스트해보자.

    interface Wheel {
        fun roll()
    }

    interface Cart: Wheel{
        var coin: Int

        fun add(product: Product)

        val weight: String
            get() = "20KG"

        fun rent() {
            if(coin > 0) {
                println("카트를 대여합니다")
            }
        }

        override fun roll() {
            println("카트가 굴러갑니다.")    
        }

        **fun printId() = println("1234")**
    }

    **interface Order {
        fun add(product: Product) {
            println("상품 주문이 완료됐습니다.")
        }**

        fun printId() = println("1234")
    **}**

    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)**
        }

        override fun printId() {
            **super<Cart>.printId()
            super<Order>.printId()**
        }
    }

    fun main() {
        val cart = MyCart(coin = 100) 
        cart.rent() 
        cart.roll()
        cart.add(Product(name = "장난감", price = 1000))
        **cart.printId()**
    }

Cart와 Order 인터페이스 모두 동일한 이름의 디폴트 함수, printId를 가지게 된다. 이럴 경우에는 컴파일 오류가 발생한다.

이럴 경우에 문제가 발생하지 않게 하기 위해 하위 클래스에서는 디폴트함수에 대해서 override를 해줘야 한다.

이렇게 하위클래스에서 재정의를 해주어서 사용하게 되면 컴파일 오류가 사라지게 된다. 상위 인터페이스에 있는 디폴트함수를 사용하기 위해서 위와 같이 super와 꺽쇄를 이용해 호출했다.

10. 열거형 클래스(Enum)

Enum 클래스의 선언

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

fun main() {

}

4가지 상태를 paymentstatus enum class에 선언했다.
선언할 때는 enum class 클래스명을 사용한다. (자바는 class가 들어가지 않는다.)

enum class또한 생성자이기 때문에 property를 가질 수 있다.
property를 가지는 enum class
```
  enum class PaymentStatus(val label: String) {
      UNPAID("미지급"),
      PAID("지급완료"),
      FAILED("실패"), 
      REFUNDED("환불"),
  }

  fun main() {
          print(PaymentStatus.UNPAID.label)
  }
```
기본 생성자인 label을 선언했다. PaymentStatus클래스의 기본 생성자로 label이 생성되었기 때문에, enum 상수에도 선언을 해줘야 한다.

정의된 프로퍼티를 사용하는 방법은 PaymentStatus.UNPAID.label 이다.
enum class에 함수 정의하기

상수 뒤에 함수를 정의해야 하는 경우가 있다. 이럴 때는 세미콜론을 붙여야 한다.

결제 가능 여부를 조회하는 isPayable()함수를 만들자.

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

        abstract fun isPayable(): Boolean
    }

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

결제 가능한 상태인지를 확인하고, 가능하다면 출력하는 코드이다. UNPAID라는 상수 뒤에 isPayable 함수를 구현했다.

그런데 이렇게 짜여진 코드는 추상화된 시그니처를 가지기 때문에, enum class에 독자적으로 구현되는 방식은 좋지 않다.

재사용성을 위해 인터페이스로 분리해보자.

인터페이스로 열거형 클래스 확장하기

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

    fun main() {
        **val paymentStatus = PaymentStatus.valueOf("PAID")
        println(paymentStatus.label)

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

        for(status in PaymentStatus.values()) {
            println("$status : ${status.label}")
        }**
    }

enum class도 클래스이기 때문에 interface를 구현할 수 있다.

Payable이라는 인터페이스를 만들고 isPayable()이라는 추상함수를 정의한다.

동등성 비교 또한 제대로 된 것을 확인할 수 있다.

추가로 코틀린에서는 values 함수를 제공하는데, 이 함수를 이용해 상수값과 property값을 가져올 수 있다.

name : 상수의 이름 string 형태로 변환
label: property값
ordinal: int 타입으로, 상수의 선언 순서를 출력한다(0부터 시작)

참고

패스트캠퍼스 - Kotlin & Spring : 리팩토링부터 서비스 구현까지

정확한 정보를 전달하고자 최선을 다하지만, 틀린 부분이 있을 수 있습니다! 
틀린 부분이 있을 시 지적해주시면 감사히 반영하겠습니다😀

'🐤 study > Kotlin' 카테고리의 다른 글

[Kotlin] 코틀린 이해하기 \| 코틀린을 배워야 하는 이유 \| 자바와 코틀린의 차이점 \| 코틀린의 기능✏️[1] (0)	2022.12.20
[당근테크 밋업 요약] 코프링 \| 코틀린의 철학 \| 코틀린의 장점 \| 코틀린 특징(#살아있다 #자프링외길12년차 #코프링2개월생존기) -1편 (0)	2022.11.17