코틀린(kotlin) 클래스(Class) : 인터페이스 (Interfaces)

코틀린의 인터페이스(interface) 에 대해 알아보자.

원문 https://kotlinlang.org/docs/reference/interfaces.html 을 보며 정리.

 

interface 키워드를 사용하는 인터페이스는 추상화 메소드와 그 구현 코드를 가지고 있고 state 는 저장할 수 없다.

interface MyInterface {
    fun bar()
    fun foo() {
      // optional body
    }
}

Implementing Interfaces

한개의 클래스나 오브젝트는 한개 이상의 인터페이스를 가질 수 있다.

class Child : MyInterface {
    override fun bar() {
        // body
    }
}

Properties in Interfaces

인터페이스는 property 를 가질 수 있으나 추상화(abstract) 하거나 접근자(accessor)를 구현해야 한다.

state 를 저장할 수 없는 속성때문에 property 는 backing fields 를 가질 수 없게되므로 interface 내의 접근자들 또한 property 를 참조할 수 없다.

interface MyInterface {
    val prop: Int // abstract

    val propertyWithImplementation: String
        get() = "foo"

    fun foo() {
        print(prop)
    }
}

class Child : MyInterface {
    override val prop: Int = 29
}

Interfaces Inheritance

인터페이스는 다른 인터페이스로부터 상속될 수 있고 따라서 상속관계에 있는 두 인터페이스들은 각 멤버의 구현을 서로 제공하게 되며 새로운 멤버 함수나 property 를 선언할 수 있다.

상속관계에 있는 인터페이스들을 구현하는 클래스의 경우엔 최종적으로 구현이 안된 멤버들만 구현하면 된다.

interface Named {
    val name: String
}

interface Person : Named {
    val firstName: String
    val lastName: String

    override val name: String get() = "$firstName $lastName"
}

data class Employee(
    // implementing 'name' is not required
    override val firstName: String,
    override val lastName: String,
    val position: Position
) : Person

인터페이스 Named 의 name: String 이 Person 에서 구현이 안되있다면 Employee 에서 구현되어야 한다.

Resolving overriding conflicts

같은 메소드에 여러 타입의 구현이 상속되는 경우가 있다.

interface A {
    fun foo() { print("A") }
    fun bar() // abstract
}

interface B {
    fun foo() { print("B") }
    fun bar() { print("bar") }
}

class C : A {
    override fun bar() { print("bar") }
}

class D : A, B {
    override fun foo() {
        super<A>.foo()
        super<B>.foo()
    }

    override fun bar() {
        super<B>.bar()
    }
}

클래스 C 의 경우 인터페이스 A 를 상속하므로 구현이 안된 bar() 의 구현만 제공하면 된다.

클래스 D 의 경우 인터페이스 A, B 를 상속하므로 두 인터페이스의 메소드를 모두 구현해야 하는데 foo() 가 중복되므로 명확한 처리가 필요하다.

이때 둘다 구현이 없는 foo() 와 한쪽만 구현이 되있는 bar() 모두 동일하게 적용되어야 한다.