[Kotlin 공부 9일차] 인터페이스

1. 인터페이스란?

인터페이스는 클래스가 무엇을 하는지 기술하지만 그 일을 어떻게 하는지는 기술하지 않는 일종의 프로토타입의 역할을 합니다.

• 클래스의 형태를 제시하지만 일반적으로 구현은 포함하지 않는다.
• 객체의 동작을 지정하지만 어떻게 수행하는지에 대한 세부 사항은 제시하지 않는다.
• 인터페이스를 구현하는 클래스는 해당 인터페이스가 정의한 모든 메서드를 구현해야 합니다.

코틀린에서 인터페이스를 선언하고 사용하는 기본 문법은 다음과 같습니다.

interface Animal {
    fun sound(): String
    fun move(): String
}

class Dog : Animal {
    override fun sound() = "왈왈!"
    override fun move() = "사족보행";
}

인터페이스를 구현하는 클래스를 정의하려면 클래스 이름 뒤에 콜론(:) 과 인터페이스 이름을 넣으면 됩니다.

이 때 Animal은 sound(), move()라는 함수를 선언하지만 아무 구현도 제공하지 않고

이 인터페이스를 구현하는 클래스는 인터페이스가 선언한 모든 멤버를 구현하는 본문을 제공해야 합니다.

• interface 키워드를 사용해 인터페이스를 선언한다.
• sound(), move()는 구현이 없는 추상메서드입니다.
• Dog는 Animal 인터페이스를 구현하고 , 추상메서드를 override해 구현합니다.

 

1-1 인터페이스에서 프로퍼티 선언

인터페이스에서 프로퍼티 또한 선언할 수 있습니다. 

interface Vehicle {
    val speed: Int // 추상 프로퍼티
    val type: String
        get() = "Vehicle" // 기본 구현 제공
}

class Car : Vehicle { 
    override val speed: Int = 120 // 추상 프로퍼티를 오버라이드
}

이 때 인터페이스를 구현하는 클래스는 프로퍼티 또한 오버라이드해야합니다.

• Vehicle 인터페이스는 spped라는 추상 프로퍼티를 정의한다.
• Car 클래스는 spped를 오버라이드해 구체적인 값을 제공한다.

 

1-2 Enum에서의 인터페이스 구현

Enum 또한 인터페이스 구현이 가능합니다.

interface State {
    fun action(): String
}

enum class OrderState : State {
    PROCESSING {
        override fun action(): String = "주문 진행중입니다."
    },
    COMPLETED {
        override fun action(): String = "주문이 완료되었습니다."
    },
    CANCELLED {
        override fun action(): String = "주문이 취소되었습니다."
    }
}

• OrderState는 Enum 클래스로 State 인터페이스를 구현한다.
• 각 enum의 상수는 action() 메서드를 오버라이드해 고유한 동작을 제공한다.

 

1-3 여러 개의 인터페이스 구현

코틀린은 여러 개의 인터페이스 구현이 가능합니다.

interface A {
    fun methodA() 
}

interface B {
    fun methodB() 
}

class C : A, B {
    override fun methodA() {
        println("메서드 A")
    } 
    override fun methodB(){
        println("메서드 B")
    }
}

이 때도 마찬가지로 두 인터페이스에 정의된 메서드를 모두 오버라이드 해야합니다.

 

주의할 점은 두 개의 인터페이스에 동일한 시그니처가 존재할 경우 super<인터페이스명> 형식으로 어느 인터페이스의 메서드를 호출할지 지정해주어야 합니다.

interface A {
    fun show() {
        println("나는 인터페이스 A")
    }
}

interface B {
    fun show() {
        println("나는 인터페이스 B")
    }
}

class C : A, B {
    override fun show() {
        // 명시적으로 어느 인터페이스의 구현을 호출할지 정해야 함
        super<A>.show()
        super<B>.show()
    }
}

 

 

 

1-4 단일 추상 메서드 변환

단일 추상 메서드는 인터페이스가 단 하나의 추상메서드를 가지고 있는 경우를 의미하는데

코틀린에서는 SAM(Single Abstract Method) 인터페이스를 정의하는 fun interface라는 문법이 존재합니다.

fun interface Delivery {
    fun deliver()
}

SAM 인터페이스는 일반적으로 클래스 방식을 통해 구현하는 방식과

람다를 사용하는(SAM 변환) 방식으로 구현이 가능합니다.

 

클래스 방식

class FoodDelivery() : Delivery {
    override fun deliver() {
        println("음식이 고객님께 배달되고 있습니다!")
    }
}

fun startDelivery(delivery: Delivery) {
    delivery.deliver()
}

fun main() {
    val foodDelivery = FoodDelivery()
    startDelivery(foodDelivery)
}

 

람다 방식

fun startDelivery(delivery: Delivery) {
    delivery.deliver()
}

fun main() {
    val quickDelivery = Delivery {
        println("빠른 배달을 시작합니다..")
    }
     startDelivery(quickDelivery)
}

• 클래스 방식 : 클래스를 통해 Delivery 인터페이스를 구현
• 람다 방식 : 단일 추상 메서드만을 가질 때 람다 표현식으로 구현 가능

 

 

2. 총정리

• 인터페이스는 추상메서드, 프로퍼티를 선언할 수 있으며, 이를 구현하는 클래스에서 구현해야함
• Enum 클래스도 인터페이스 구현이 가능
• 여러 인터페이스를 동시에 구현할 수 있으며 충돌 시 명시적 해결이 필요
• 단일 추상 메서드 변환을 통해 람다 표현식으로 간단히 인터페이스 구현이 가능