Kotlin 인터페이스(Interface)

이 기사에서는 예제를 통해 인터페이스 및 Kotlin에서 인터페이스 구현에 대한 지식을 배울 것입니다.

Kotlin 인터페이스는 Java와 유사합니다 8의 인터페이스. 그들은 추상 메서드 정의와 비추상 메서드 구현을 포함할 수 있습니다. 그러나, 그들은 어떤 상태도 포함할 수 없습니다.

따라서, 인터페이스는 속성이 있을 수 있지만, 반드시 추상이거나 접근자 구현을 제공해야 합니다.

추천 읽기: Kotlin 추상 클래스

Kotlin의 추상 클래스는 인터페이스와 유사하지만 중요한 차이점이 있습니다. 추상 클래스의 속성은 추상이거나 접근자 구현을 제공하지 않아도 됩니다.

인터페이스를 어떻게 정의합니까?

interface 키워드는 Kotlin에서 인터페이스를 정의하는 데 사용됩니다. 예를 들어,

interface MyInterface {
　　　　var test: String　　　//추상 속성
　　　　fun foo()　　　　　　　　　　//추상 메서드
　　　　fun hello() = "Hello there"　//기본 구현을 가진 메서드
}

여기서,

• MyInterface 인터페이스를 생성합니다.
  

• 이 인터페이스는 추상 속성 test와 추상 메서드 foo()를 가집니다.
  

• 이 인터페이스는 또한 non-abstract 메서드 hello()를 가집니다.

인터페이스를 어떻게 구현합니까?

이 클래스나 객체는 어떻게 인터페이스를 구현합니까?

interface MyInterface {
　　　　val test: Int　　　//추상 속성
　　　　fun foo(): String　　　//추상 메서드(문자열 반환)
　　　　fun hello() {　　　//기본 구현을 가진 메서드
　　　　　　　　//　body (선택 사항)
　　　　}
}
class InterfaceImp: MyInterface {
　　　　override val test: Int =　25
　　　　override fun foo() = "롤"
　　　　//기타 코드
}

여기서, InterfaceImp 클래스는 MyInterface 인터페이스를 구현합니다.

이 클래스는 인터페이스의 추상 멤버(test 속성과 foo() 메서드)를 재정의합니다.

예제: 인터페이스는 어떻게 작동합니까?

interface MyInterface {
　　　　val test: Int
　　　　fun foo(): String
　　　　fun hello() {
　　　　　　　　println("안녕하세요, 친구!")
　　　　}
}
class InterfaceImp: MyInterface {
　　　　override val test: Int =　25
　　　　override fun foo() = "롤"
}
fun main(args: Array<String>) {
　　　　val obj = InterfaceImp()
　　　　println("테스트 = ${obj.test}")
　　　　print("hello(): 호출 ")
　　　　obj.hello()
　　　　print("foo(): 호출하고 출력 ")
　　　　println(obj.foo())
}

프로그램을 실행할 때, 출력은 다음과 같습니다:

test =　25
hello(): 你好，伙计! 호출
foo(): Lol 호출하고 출력

지금까지 설명한 것처럼, 인터페이스는 접근자 구현을 제공하는 속성을 가질 수 있습니다. 예를 들어,

interface MyInterface {
　　　　//구현된 속성
　　　　val prop: Int
　　　　　　　　get() =　23
}
class InterfaceImp: MyInterface {
　　　　//클래스 본체
}
fun main(args: Array<String>) {
　　　　val obj = InterfaceImp()
　　　　println(obj.prop)
}

프로그램을 실행할 때, 출력은 다음과 같습니다:

23

여기서 prop은 추출되지 않지만, 인터페이스 내에서는 유효합니다. 이는 접근자 구현을 제공하기 때문입니다.

하지만, 인터페이스 내에서 val prop: Int과 같은 값을 실행할 수는 없습니다. 23 작업을 수행할 수 있습니다.

하나의 클래스에서 두 개나 더 많은 인터페이스를 구현하는

Kotlin은 실제로의 다중 상속을 허용하지 않습니다. 하지만, 하나의 클래스에서 두 개나 더 많은 인터페이스를 구현할 수 있습니다. 예를 들어,

interface A {
　　　　fun callMe() {
　　　　　　　　println("인터페이스 A에서")
　　　　}
}
interface B {
　　　　fun callMeToo() {
　　　　　　　　println("인터페이스 B에서")
　　　　}
}
//인터페이스 A와 B를 구현
class Child: A, B
fun main(args: Array<String>) {
　　　　val obj = Child()
　　　　obj.callMe()
　　　　obj.callMeToo()
}

프로그램을 실행할 때, 출력은 다음과 같습니다:

인터페이스 A에서
인터페이스 B에서

다중 상속 충돌 해결(다중 인터페이스)

두 개의 인터페이스(A와 B)가 같은 이름의 비 추출 메서드(예를 들어 callMe() 메서드)를 가지고 있다고 가정해 보겠습니다. 이 두 개의 인터페이스를 하나의 클래스에서 구현했습니다(예를 들어 C). 이제, C 클래스의 객체를 사용하여 callMe() 메서드를 호출하면 컴파일러가 오류를 발생시킵니다. 예를 들어,

interface A {
　　　　fun callMe() {
　　　　　　　　println("인터페이스 A")
　　　　}
}
interface B {
　　　　fun callMe() {
　　　　　　　　println("인터페이스 B")
　　　　}
}
class Child: A, B　
fun main(args: Array<String>) {
　　　　val obj = Child()
　　　　obj.callMe()
}

이렇게 발생하는 오류는 다음과 같습니다:

Error:(14,　1) Kotlin: Class 'C' must override public open fun callMe(): Unit defined in A because it inherits multiple interface methods of it

이 문제를 해결하려면, 자신의 구현을 제공해야 합니다. 이렇게 하면 됩니다:

interface A {
　　　　fun callMe() {
　　　　　　　　println("인터페이스 A")
　　　　}
}
interface B {
　　　　fun callMe() {
　　　　　　　　println("인터페이스 B")
　　　　}
}
class　C:　A,　B　{
　　　　override　fun　callMe()　{
　　　　　　　　super<A>.callMe()
　　　　　　　　super<B>.callMe()
　　　　}
}
fun main(args: Array<String>) {
　　　　val　obj　=　C()
　　　　obj.callMe()
}

이제, 프로그램을 실행하면 출력은 다음과 같습니다:

인터페이스　　A
인터페이스　　B

여기서, C 클래스에서 callMe() 메서드의 명시적인 구현을 제공합니다.

class　C:　A,　B　{
　　　　override　fun　callMe()　{
　　　　　　　　super<A>.callMe()
　　　　　　　　super<B>.callMe()
　　　　}
}

문장 super<A>.callMe()는 클래스 A의 callMe() 메서드를 호출합니다. 유사하게, super<B>.callMe()는 클래스 B의 callMe() 메서드를 호출합니다.