[코틀린기초] 31. 인터페이스

01 Dec 2020

kotlin

현실 세계의 계약서로, 어떤 작업자가 받아들였다면 계약서에 있는 활동의 구체적인 내용을 실행해야함

계약서 자체로는 실행될 수 없음

추상 클래스와 다른점?

인터페이스는 클래스가 아니므로 다중 상속 가능

추상 클래스와는 다르게 강한 연관을 가지지 않는다!

단일 인스턴스로 객체 생성

추상 클래스로부터 하위 클래스를 생성하지 않고 단일 인스턴스로 객체 생성 가능

object 키워드로 생성한다. 임시객체를 만든다고 생각하면 된다.

  abstract class Printer{
    abstract fun print()
  }
  
  val myPrinter = object: Printer(){
    override fun print(){
      println("출력합니다.")
    }
  }
  
  fun main(){
    myPrinter.print()
  }

코틀린의 인터페이스

다른 언어와는 다르게 기본적인 구현 내용이 포함될 수 있다. (자바8 에서는 defalut키워드를 사용해 구현 내용 포함 가능)

interface 키워드를 사용해 정의

상속한 하위 클래스에서는 override 를 사용해 해당 메서드를 구현

  interface Pet {
    var category: String  // abstract 가 없어도 기본은 추상 프로퍼티!
    fun feeding() // 추상 메서드
    fun patting(){  // 구현부를 포함하면 일반 메서드가 된다!
      println("Keep patting")
    }
  }
  
  //하위 클래스
  class Car(overrride var category: String) : Pet{
    override fun feeding(){
      //구현 내용
    }
  }
  
  fun main(){
    val obj = Cat("small")
    println("Pet Category: $(obj.category)")
    obj.feeding()
    obj.patting()
  }

### 게터를 통한 구현

인터페이스에서는 프로퍼티에 값을 저장할 수 없지만 val로 선언된 프로퍼티는 게터를 통해 내용을 구현할 수 있다.

  interface Pet{
    var category: String
    val msgTags: String
      get() = "I'm your lovely pet!"  // 게터를 이용해 내용을 구현함!
      
    fun feeding()
    fun patting(){
      println("Keep patting")
    }
  }

### 다중 상속에 대한 예

  interface Bird{
    val wings : Int
    fun fly()
    fun jump() = println("bird jump!")
  }
  
  interface House{
    val maxSpeed: Int
    fun run()
    fun jump() = println("jump!, max speed: $maxSpeed")
  }
  
  class Pegasus : Bird, Horse {  // 두개의 인터페이스를 상속
    override val wings: Int = 2
    override val maxSpeed: Int 100
    override fun fly() = println("Fly!")
    override fun run() = println("Run!")
    override fun jump(){
       super<Horse>.jump()  //Horse 인터페이스의 jump를 수행
       println("and Jump!")
    }
  }
  

인터페이스의 위임

위임을 사용하면 메서드를 쉽게 사용할 수 있다.

  interface A{
    fun functionA(){}
  }
  interface B{
    fun functionB(){}
  }

  class C(val a: A, val b : B){
    fun functionC(){
      a.functionA()
      b.functionB()
    }
  }

  class DelegatedC(a: A,b: B): A by a, B by b{
    fun functionC(){
      functionA() //  A의 위임
      functionB() //  B의 위임
     }
  }