Skip to content

Open 클래스와 특수 클래스 ​

이 장에서는 open 클래스, open 클래스가 인터페이스와 함께 동작하는 방식, 그리고 Kotlin에서 제공하는 그 밖의 특수한 클래스 타입에 대해 알아봅니다.

Open 클래스 ​

인터페이스나 추상 클래스를 사용할 수 없는 경우, 클래스를 open으로 선언하여 명시적으로 상속 가능하게 만들 수 있습니다. 이렇게 하려면 클래스 선언 앞에 open 키워드를 사용합니다.

kotlin
open class Vehicle(val make: String, val model: String)

다른 클래스를 상속하는 클래스를 만들려면 클래스 헤더 뒤에 콜론을 추가한 다음 상속하려는 부모 클래스의 생성자 호출을 작성합니다. 이 예제에서 Car 클래스는 Vehicle 클래스를 상속합니다.

kotlin
open class Vehicle(val make: String, val model: String)

class Car(make: String, model: String, val numberOfDoors: Int) : Vehicle(make, model)

fun main() {
    // Car 클래스의 인스턴스를 생성합니다
    val car = Car("Toyota", "Corolla", 4)

    // 자동차의 세부 정보를 출력합니다
    println("Car Info: Make - ${car.make}, Model - ${car.model}, Number of doors - ${car.numberOfDoors}")
    // Car Info: Make - Toyota, Model - Corolla, Number of doors - 4
}

일반 클래스 인스턴스를 생성할 때와 마찬가지로, 클래스가 부모 클래스를 상속하는 경우에는 부모 클래스 헤더에 선언된 모든 매개변수를 초기화해야 합니다. 따라서 이 예제에서는 Car 클래스의 car 인스턴스가 부모 클래스의 매개변수인 make와 model을 초기화합니다.

상속된 동작 오버라이드하기 ​

클래스를 상속하면서 일부 동작을 변경하고 싶다면, 상속된 동작을 오버라이드(재정의)할 수 있습니다.

기본적으로는 부모 클래스의 멤버 함수나 프로퍼티를 오버라이드할 수 없습니다. 추상 클래스와 마찬가지로 특수한 키워드를 추가해야 합니다.

멤버 함수 ​

부모 클래스의 함수가 오버라이드될 수 있도록 허용하려면 부모 클래스의 함수 선언 앞에 open 키워드를 사용합니다.

kotlin
open fun displayInfo() {}

상속된 멤버 함수를 오버라이드하려면 자식 클래스의 함수 선언 앞에 override 키워드를 사용합니다.

kotlin
override fun displayInfo() {}

예를 들면 다음과 같습니다.

kotlin
open class Vehicle(val make: String, val model: String) {
    open fun displayInfo() {
        println("Vehicle Info: Make - $make, Model - $model")
    }
}

class Car(make: String, model: String, val numberOfDoors: Int) : Vehicle(make, model) {
    override fun displayInfo() {
        println("Car Info: Make - $make, Model - $model, Number of Doors - $numberOfDoors")
    }
}

fun main() {
    val car1 = Car("Toyota", "Corolla", 4)
    val car2 = Car("Honda", "Civic", 2)

    // 오버라이드된 displayInfo() 함수를 사용합니다
    car1.displayInfo()
    // Car Info: Make - Toyota, Model - Corolla, Number of Doors - 4
    car2.displayInfo()
    // Car Info: Make - Honda, Model - Civic, Number of Doors - 2
}

이 예제는 다음과 같이 동작합니다.

  • Vehicle 클래스를 상속하는 Car 클래스의 두 인스턴스 car1과 car2를 생성합니다.
  • 문의 개수도 함께 출력하도록 Car 클래스에서 displayInfo() 함수를 오버라이드합니다.
  • car1과 car2 인스턴스에서 오버라이드된 displayInfo() 함수를 호출합니다.

프로퍼티 ​

Kotlin에서는 open 키워드를 사용하여 프로퍼티를 상속 가능하게 만든 뒤 나중에 오버라이드하는 방식은 흔히 사용되지 않습니다. 대부분의 경우 기본적으로 프로퍼티를 상속할 수 있는 추상 클래스나 인터페이스를 사용합니다.

open 클래스 내부의 프로퍼티는 자식 클래스에서 접근할 수 있습니다. 일반적으로는 새 프로퍼티로 오버라이드하기보다는 직접 접근하는 편이 좋습니다.

예를 들어 나중에 오버라이드하고 싶은 transmissionType이라는 프로퍼티가 있다고 가정해 보겠습니다. 프로퍼티를 오버라이드하는 구문은 멤버 함수를 오버라이드하는 구문과 완전히 동일합니다. 다음과 같이 작성할 수 있습니다.

kotlin
open class Vehicle(val make: String, val model: String) {
    open val transmissionType: String = "Manual"
}

class Car(make: String, model: String, val numberOfDoors: Int) : Vehicle(make, model) {
    override val transmissionType: String = "Automatic"
}

하지만 이는 좋은 관행이 아닙니다. 대신 상속 가능한 클래스의 생성자에 프로퍼티를 추가하고 Car 자식 클래스를 생성할 때 해당 값을 선언할 수 있습니다.

kotlin
open class Vehicle(val make: String, val model: String, val transmissionType: String = "Manual")

class Car(make: String, model: String, val numberOfDoors: Int) : Vehicle(make, model, "Automatic")

프로퍼티를 오버라이드하는 대신 직접 접근하면 코드가 더 단순해지고 가독성이 높아집니다. 부모 클래스에 프로퍼티를 한 번만 선언하고 생성자를 통해 값을 전달함으로써 자식 클래스에서 불필요하게 오버라이드할 필요를 없앨 수 있습니다.

클래스 상속 및 클래스 동작 오버라이드에 대한 자세한 내용은 상속(Inheritance)을 참조하세요.

Open 클래스와 인터페이스 ​

클래스를 상속하는 동시에 여러 인터페이스를 구현하는 클래스를 만들 수 있습니다. 이 경우 콜론 뒤에 인터페이스 목록을 나열하기 전에 부모 클래스를 먼저 선언해야 합니다.

kotlin
// 인터페이스 정의
interface EcoFriendly {
    val emissionLevel: String
}

interface ElectricVehicle {
    val batteryCapacity: Double
}

// 부모 클래스
open class Vehicle(val make: String, val model: String)

// 자식 클래스
open class Car(make: String, model: String, val numberOfDoors: Int) : Vehicle(make, model)

// Car를 상속하고 두 개의 인터페이스를 구현하는 새 클래스
class ElectricCar(
    make: String,
    model: String,
    numberOfDoors: Int,
    val capacity: Double,
    val emission: String
) : Car(make, model, numberOfDoors), EcoFriendly, ElectricVehicle {
    override val batteryCapacity: Double = capacity
    override val emissionLevel: String = emission
}

특수 클래스 ​

Kotlin에는 추상 클래스, open 클래스, 데이터 클래스 외에도 특정 동작을 제한하거나 작은 객체 생성 시 발생하는 성능 영향을 줄이기 위해 설계된 다양한 목적의 특수한 클래스 타입들이 있습니다.

Sealed 클래스 ​

상속을 제한하고 싶을 때가 있을 수 있습니다. sealed 클래스를 사용하면 이를 구현할 수 있습니다. sealed 클래스는 특수한 종류의 추상 클래스입니다. 클래스를 sealed로 선언하면 동일한 패키지 내에서만 해당 클래스의 자식 클래스를 생성할 수 있습니다. 이 범위를 벗어나서는 sealed 클래스를 상속할 수 없습니다.

패키지는 일반적으로 디렉터리 내에 있는 연관된 클래스와 함수들의 코드 모음입니다. Kotlin의 패키지에 대해 자세히 알아보려면 패키지와 임포트를 참조하세요.

sealed 클래스를 생성하려면 sealed 키워드를 사용합니다.

kotlin
sealed class Mammal

sealed 클래스는 when 표현식과 함께 사용할 때 특히 유용합니다. when 표현식을 사용하면 가능한 모든 자식 클래스에 대한 동작을 정의할 수 있습니다. 예를 들면 다음과 같습니다.

kotlin
sealed class Mammal(val name: String)

class Cat(val catName: String) : Mammal(catName)
class Human(val humanName: String, val job: String) : Mammal(humanName)

fun greetMammal(mammal: Mammal): String {
    when (mammal) {
        is Human -> return "Hello ${mammal.name}; You're working as a ${mammal.job}"
        is Cat -> return "Hello ${mammal.name}"   
    }
}

fun main() {
    println(greetMammal(Cat("Snowy")))
    // Hello Snowy
}

이 예제에서는 다음과 같은 작업이 이루어집니다.

  • 생성자에 name 매개변수를 갖는 Mammal이라는 sealed 클래스가 있습니다.
  • Cat 클래스는 Mammal sealed 클래스를 상속하며, 자체 생성자의 catName 매개변수를 Mammal 클래스의 name 매개변수로 사용합니다.
  • Human 클래스는 Mammal sealed 클래스를 상속하며, 자체 생성자의 humanName 매개변수를 Mammal 클래스의 name 매개변수로 사용합니다. 또한 생성자에 job 매개변수를 가지고 있습니다.
  • greetMammal() 함수는 Mammal 타입의 인자를 받아 문자열을 반환합니다.
  • greetMammal() 함수 본문 내부에는 is 연산자를 사용하여 mammal의 타입을 확인하고 어떤 동작을 수행할지 결정하는 when 표현식이 있습니다.
  • main() 함수는 Cat 클래스의 인스턴스와 Snowy라는 name 매개변수로 greetMammal() 함수를 호출합니다.

이 둘러보기에서는 Null 안전성 장에서 is 연산자에 대해 더 자세히 다룹니다.

sealed 클래스와 권장 사용 사례에 대한 자세한 내용은 Sealed 클래스 및 인터페이스를 참조하세요.

Enum 클래스 ​

Enum 클래스는 클래스에서 유한한 고유 값 집합을 표현하고자 할 때 유용합니다. enum 클래스는 enum 상수를 포함하며, 이 상수들 자체가 enum 클래스의 인스턴스입니다.

enum 클래스를 생성하려면 enum 키워드를 사용합니다.

kotlin
enum class State

프로세스의 다양한 상태를 포함하는 enum 클래스를 생성한다고 가정해 보겠습니다. 각 enum 상수는 쉼표(,)로 구분해야 합니다.

kotlin
enum class State {
    IDLE, RUNNING, FINISHED
}

State enum 클래스에는 IDLE, RUNNING, FINISHED라는 enum 상수가 있습니다. enum 상수에 접근하려면 클래스 이름 뒤에 .과 enum 상수 이름을 사용합니다.

kotlin
val state = State.RUNNING

이 enum 클래스를 when 표현식과 함께 사용하여 enum 상수의 값에 따라 수행할 동작을 정의할 수 있습니다.

kotlin
enum class State {
    IDLE, RUNNING, FINISHED
}

fun main() {
    val state = State.RUNNING
    val message = when (state) {
        State.IDLE -> "It's idle"
        State.RUNNING -> "It's running"
        State.FINISHED -> "It's finished"
    }
    println(message)
    // It's running
}

enum 클래스는 일반 클래스와 마찬가지로 프로퍼티와 멤버 함수를 가질 수 있습니다.

예를 들어 HTML을 다루고 있으며 몇 가지 색상을 포함하는 enum 클래스를 만들고 싶다고 가정해 보겠습니다. 각 색상이 16진수 RGB 값을 포함하는 rgb라는 이름의 프로퍼티를 갖도록 하려고 합니다. enum 상수를 생성할 때 이 프로퍼티로 초기화해야 합니다.

kotlin
enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF),
    YELLOW(0xFFFF00)
}

Kotlin은 16진수를 정수로 저장하므로 rgb 프로퍼티의 타입은 String이 아니라 Int입니다.

이 클래스에 멤버 함수를 추가하려면 세미콜론(;)으로 enum 상수와 구분합니다.

kotlin
enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF),
    YELLOW(0xFFFF00);

    fun containsRed() = (this.rgb and 0xFF0000 != 0)
}

fun main() {
    val red = Color.RED
    
    // enum 상수에 대해 containsRed() 함수를 호출합니다
    println(red.containsRed())
    // true

    // 클래스 이름을 통해 enum 상수의 containsRed() 함수를 호출합니다
    println(Color.BLUE.containsRed())
    // false
  
    println(Color.YELLOW.containsRed())
    // true
}

이 예제에서 containsRed() 멤버 함수는 this 키워드를 사용하여 enum 상수의 rgb 프로퍼티 값에 접근하고, 16진수 값의 첫 번째 비트에 FF가 포함되어 있는지 확인하여 불리언 값을 반환합니다.

자세한 내용은 Enum 클래스를 참조하세요.

인라인 값 클래스(Inline value classes) ​

코드 작성 시 클래스로부터 작은 크기의 객체를 생성하고 잠시만 사용하는 경우가 있습니다. 이러한 방식은 성능에 영향을 줄 수 있습니다. 인라인 값 클래스는 이러한 성능 저하를 방지하는 특수한 유형의 클래스입니다. 단, 값만 포함할 수 있습니다.

인라인 값 클래스를 생성하려면 value 키워드와 @JvmInline 애너테이션을 사용합니다.

kotlin
@JvmInline
value class Email

@JvmInline 애너테이션은 코드가 컴파일될 때 최적화하도록 Kotlin에 지시합니다. 자세한 내용은 애너테이션을 참조하세요.

인라인 값 클래스는 반드시 클래스 헤더에서 초기화된 단 하나의 프로퍼티만을 가져야 합니다.

이메일 주소를 수집하는 클래스를 생성한다고 가정해 보겠습니다.

kotlin
// address 프로퍼티는 클래스 헤더에서 초기화됩니다.
@JvmInline
value class Email(val address: String)

fun sendEmail(email: Email) {
    println("Sending email to ${email.address}")
}

fun main() {
    val myEmail = Email("example@example.com")
    sendEmail(myEmail)
    // Sending email to example@example.com
}

이 예제에서는 다음과 같은 작업이 이루어집니다.

  • Email은 클래스 헤더에 하나의 프로퍼티 address를 가지는 인라인 값 클래스입니다.
  • sendEmail() 함수는 Email 타입의 객체를 받아 표준 출력으로 문자열을 출력합니다.
  • main() 함수는 다음과 같습니다.
    • Email 클래스의 인스턴스인 myEmail을 생성합니다.
    • myEmail 객체를 전달하여 sendEmail() 함수를 호출합니다.

인라인 값 클래스를 사용하면 클래스가 인라인화(inline)되어 실제 객체를 생성하지 않고도 코드에서 직접 사용할 수 있습니다. 이를 통해 메모리 사용량을 크게 줄이고 런타임 성능을 향상시킬 수 있습니다.

인라인 값 클래스에 대한 자세한 내용은 인라인 값 클래스를 참조하세요.

연습 ​

Sealed 클래스로 배송 상태 모델링하기

배송 서비스를 관리하면서 소포의 상태를 추적하는 방법이 필요합니다. Pending, InTransit, Delivered, Canceled 상태를 표현하는 데이터 클래스들을 포함하는 DeliveryStatus라는 sealed 클래스를 생성하세요. main() 함수의 코드가 성공적으로 실행되도록 DeliveryStatus 클래스 선언을 완성하세요.

kotlin
sealed class // 여기에 코드를 작성하세요

fun printDeliveryStatus(status: DeliveryStatus) {
    when (status) {
        is DeliveryStatus.Pending -> {
            println("The package is pending pickup from ${status.sender}.")
        }
        is DeliveryStatus.InTransit -> {
            println("The package is in transit and expected to arrive by ${status.estimatedDeliveryDate}.")
        }
        is DeliveryStatus.Delivered -> {
            println("The package was delivered to ${status.recipient} on ${status.deliveryDate}.")
        }
        is DeliveryStatus.Canceled -> {
            println("The delivery was canceled due to: ${status.reason}.")
        }
    }
}

fun main() {
    val status1: DeliveryStatus = DeliveryStatus.Pending("Alice")
    val status2: DeliveryStatus = DeliveryStatus.InTransit("2024-11-20")
    val status3: DeliveryStatus = DeliveryStatus.Delivered("2024-11-18", "Bob")
    val status4: DeliveryStatus = DeliveryStatus.Canceled("Address not found")

    printDeliveryStatus(status1)
    // The package is pending pickup from Alice.
    printDeliveryStatus(status2)
    // The package is in transit and expected to arrive by 2024-11-20.
    printDeliveryStatus(status3)
    // The package was delivered to Bob on 2024-11-18.
    printDeliveryStatus(status4)
    // The delivery was canceled due to: Address not found.
}
해결 방법 예시 {...}
kotlin
sealed class DeliveryStatus {
    data class Pending(val sender: String) : DeliveryStatus()
    data class InTransit(val estimatedDeliveryDate: String) : DeliveryStatus()
    data class Delivered(val deliveryDate: String, val recipient: String) : DeliveryStatus()
    data class Canceled(val reason: String) : DeliveryStatus()
}

fun printDeliveryStatus(status: DeliveryStatus) {
    when (status) {
        is DeliveryStatus.Pending -> {
            println("The package is pending pickup from ${status.sender}.")
        }
        is DeliveryStatus.InTransit -> {
            println("The package is in transit and expected to arrive by ${status.estimatedDeliveryDate}.")
        }
        is DeliveryStatus.Delivered -> {
            println("The package was delivered to ${status.recipient} on ${status.deliveryDate}.")
        }
        is DeliveryStatus.Canceled -> {
            println("The delivery was canceled due to: ${status.reason}.")
        }
    }
}

fun main() {
    val status1: DeliveryStatus = DeliveryStatus.Pending("Alice")
    val status2: DeliveryStatus = DeliveryStatus.InTransit("2024-11-20")
    val status3: DeliveryStatus = DeliveryStatus.Delivered("2024-11-18", "Bob")
    val status4: DeliveryStatus = DeliveryStatus.Canceled("Address not found")

    printDeliveryStatus(status1)
    // The package is pending pickup from Alice.
    printDeliveryStatus(status2)
    // The package is in transit and expected to arrive by 2024-11-20.
    printDeliveryStatus(status3)
    // The package was delivered to Bob on 2024-11-18.
    printDeliveryStatus(status4)
    // The delivery was canceled due to: Address not found.
}
Enum 클래스로 문제 유형 정의하기

프로그램에서 다양한 상태와 오류 유형을 처리할 수 있기를 원합니다. 데이터 클래스나 객체로 선언된 여러 상태를 캡처하는 sealed 클래스가 있습니다. NETWORK, TIMEOUT, UNKNOWN이라는 서로 다른 문제 유형을 나타내는 Problem enum 클래스를 생성하여 아래 코드를 완성하세요.

kotlin
sealed class Status {
    data object Loading : Status()
    data class Error(val problem: Problem) : Status() {
        // 여기에 코드를 작성하세요
    }

    data class OK(val data: List<String>) : Status()
}

fun handleStatus(status: Status) {
    when (status) {
        is Status.Loading -> println("Loading...")
        is Status.OK -> println("Data received: ${status.data}")
        is Status.Error -> when (status.problem) {
            Status.Error.Problem.NETWORK -> println("Network issue")
            Status.Error.Problem.TIMEOUT -> println("Request timed out")
            Status.Error.Problem.UNKNOWN -> println("Unknown error occurred")
        }
    }
}

fun main() {
    val status1: Status = Status.Error(Status.Error.Problem.NETWORK)
    val status2: Status = Status.OK(listOf("Data1", "Data2"))

    handleStatus(status1)
    // Network issue
    handleStatus(status2)
    // Data received: [Data1, Data2]
}
해결 방법 예시 {...}
kotlin
sealed class Status {
    data object Loading : Status()
    data class Error(val problem: Problem) : Status() {
        enum class Problem {
            NETWORK,
            TIMEOUT,
            UNKNOWN
        }
    }

    data class OK(val data: List<String>) : Status()
}

fun handleStatus(status: Status) {
    when (status) {
        is Status.Loading -> println("Loading...")
        is Status.OK -> println("Data received: ${status.data}")
        is Status.Error -> when (status.problem) {
            Status.Error.Problem.NETWORK -> println("Network issue")
            Status.Error.Problem.TIMEOUT -> println("Request timed out")
            Status.Error.Problem.UNKNOWN -> println("Unknown error occurred")
        }
    }
}

fun main() {
    val status1: Status = Status.Error(Status.Error.Problem.NETWORK)
    val status2: Status = Status.OK(listOf("Data1", "Data2"))

    handleStatus(status1)
    // Network issue
    handleStatus(status2)
    // Data received: [Data1, Data2]
}