[kotlin] 코틀린에서 인터페이스를 통한 다형성의 장점 설명

07 Dec 2023

kotlin

코틀린은 자바와 마찬가지로 인터페이스를 사용하여 다형성을 구현할 수 있습니다. 다형성은 객체 지향 프로그래밍의 핵심 개념 중 하나로, 동일한 인터페이스를 구현하는 다양한 클래스들을 사용할 수 있는 유연성을 제공합니다. 이번 포스트에서는 코틀린에서 인터페이스를 통한 다형성의 장점에 대해 알아보겠습니다.

1. 유연한 코드 작성

인터페이스를 사용하면 클래스의 타입이 아닌 인터페이스의 타입으로 변수를 선언할 수 있습니다. 이로써 어떤 클래스의 인스턴스라도 해당 변수에 할당할 수 있습니다. 이는 코드 작성 시 유연성을 제공하며, 추후에 새로운 클래스를 추가할 때 기존 코드를 수정하지 않고도 해당 클래스를 사용할 수 있습니다.

interface Drawable {
    fun draw()
}

class Circle : Drawable {
    override fun draw() {
        println("Drawing a circle")
    }
}

class Rectangle : Drawable {
    override fun draw() {
        println("Drawing a rectangle")
    }
}

fun main() {
    val shape1: Drawable = Circle()
    val shape2: Drawable = Rectangle()

    shape1.draw()
    shape2.draw()
}

위의 예시에서는 Drawable 인터페이스를 구현한 Circle과 Rectangle 클래스를 사용하여 다각형을 그리는 코드를 작성했습니다. shape1과 shape2 변수는 Drawable 인터페이스 타입으로 선언되었기 때문에, 각각 Circle과 Rectangle 클래스의 인스턴스를 할당할 수 있습니다. 이를 통해 새로운 도형 클래스가 추가되더라도 기존 코드를 수정하지 않고도 사용할 수 있습니다.

2. 코드의 재사용성

인터페이스를 통해 다형성을 구현하면 코드의 재사용성이 높아집니다. 하나의 인터페이스를 구현하는 다양한 클래스들을 사용하여 원하는 기능을 구현할 수 있습니다. 이는 객체 지향 프로그래밍의 핵심 원칙인 “단일 책임 원칙”과 “개방-폐쇄 원칙”을 준수하며, 코드의 유지보수성을 향상시킵니다.

interface Vehicle {
    fun start()
    fun stop()
}

class Car : Vehicle {
    override fun start() {
        println("Starting the car")
    }

    override fun stop() {
        println("Stopping the car")
    }
}

class Motorcycle : Vehicle {
    override fun start() {
        println("Starting the motorcycle")
    }

    override fun stop() {
        println("Stopping the motorcycle")
    }
}

fun main() {
    val vehicle1: Vehicle = Car()
    val vehicle2: Vehicle = Motorcycle()

    vehicle1.start()
    vehicle1.stop()

    vehicle2.start()
    vehicle2.stop()
}

위의 예시에서는 Vehicle 인터페이스를 구현한 Car과 Motorcycle 클래스를 사용하여 차량의 동작을 제어하는 코드를 작성했습니다. Vehicle 인터페이스는 start와 stop 메서드를 정의하고 있으며, 각각 Car과 Motorcycle 클래스에서 구현합니다. 이렇게 인터페이스를 통해 다양한 차량 클래스를 작성하면 필요에 따라 해당 기능을 선택하여 재사용할 수 있습니다.

3. 테스트 용이성

인터페이스를 통한 다형성은 테스트 용이성을 제공합니다. 인터페이스를 사용하여 코드를 작성하면 해당 인터페이스를 구현한 다양한 클래스들을 모의 객체로 대체하여 테스트할 수 있습니다. 이를 통해 Mock 객체를 사용하여 의존성을 분리하고, 테스트에 필요한 동작을 가상으로 구현할 수 있습니다.

interface Database {
    fun save(data: String)
}

class MySQLDatabase : Database {
    override fun save(data: String) {
        // MySQL에 데이터 저장
    }
}

class TestDatabase : Database {
    override fun save(data: String) {
        // 테스트용 데이터 저장
    }
}

class DataManager(private val database: Database) {
    fun processData(data: String) {
        database.save(data)
    }
}

fun main() {
    val realDatabase = MySQLDatabase()
    val testData = TestDatabase()

    val dataManager1 = DataManager(realDatabase)
    dataManager1.processData("Real data")

    val dataManager2 = DataManager(testData)
    dataManager2.processData("Test data")
}

위의 예시에서는 Database 인터페이스를 구현한 MySQLDatabase 클래스와 TestDatabase 클래스를 사용하여 데이터를 저장하는 코드를 작성했습니다. DataManager 클래스는 Database 인터페이스에 의존하고 있습니다. 이를 통해 실제 데이터베이스와는 별개로 테스트용 데이터베이스를 사용하여 코드를 테스트할 수 있습니다.

결론

코틀린에서 인터페이스를 통한 다형성은 유연한 코드 작성, 코드의 재사용성, 테스트 용이성 등 다양한 장점을 제공합니다. 이를 통해 객체 지향 프로그래밍의 핵심 원칙을 지키고, 코드의 유지보수성을 높일 수 있습니다. 코틀린의 강력한 타입 시스템과 함께 인터페이스를 활용하여 다형성을 구현해보세요.