Implementar interfaz en Kotlin

Las interfaces en Kotlin pueden contener declaraciones de métodos abstractos, así como implementaciones de métodos. Lo que las diferencia de las clases abstractas es que las interfaces no pueden almacenar un estado. Pueden tener propiedades, pero estas deben ser abstractas o proporcionar implementaciones de acceso.

Interfaz básica

Una interfaz de Kotlin contiene declaraciones de métodos abstractos e implementaciones de métodos predeterminados, aunque no pueden almacenar el estado.

interface MyInterface {
    fun bar()
}

Esta interfaz ahora puede ser implementada por una clase de la siguiente manera:

class Child : MyInterface {
    override fun bar() {
        print("bar() was called")
    }
}

Interfaz con implementaciones predeterminadas 

Una interfaz en Kotlin puede tener implementaciones predeterminadas para funciones:

interface MyInterface {
    fun withImplementation() {
        print("withImplementation() was called")
    }
}

Las clases que implementen tales interfaces podrán usar esas funciones sin volver a implementar

class MyClass: MyInterface {
    // No need to reimplement here
}
    val instance = MyClass()
    instance.withImplementation()

Propiedades

Las implementaciones predeterminadas también funcionan para captadores y definidores de propiedades:

interface MyInterface2 {
 val helloWorld
 get() = "Hello World!"
}

Las implementaciones de accesores de interfaz no pueden usar campos de respaldo

interface MyInterface3 {
    // this property won't compile!
    var helloWorld: Int
    get() = field
    set(value) { field = value }
}

Múltiples implementaciones

Cuando varias interfaces implementan la misma función, o todas ellas se definen con una o más implementaciones, la clase derivada debe resolver manualmente la llamada adecuada

interface A {
   fun notImplemented()
   fun implementedOnlyInA() { print("only A") }
   fun implementedInBoth() { print("both, A") }
   fun implementedInOne() { print("implemented in A") }
}
  
interface B {
   fun implementedInBoth() { print("both, B") }
   // only defined
   fun implementedInOne() 
}
  
class MyClass: A, B {
   override fun notImplemented() { print("Normal implementation") }
   // implementedOnlyInA() can by normally used in instances
   // class needs to define how to use interface functions
   override fun implementedInBoth() {
   super<B>.implementedInBoth()
   super<A>.implementedInBoth()
 }
     
// even if there's only one implementation,
// there multiple definitions
override fun implementedInOne() {
   super<A>.implementedInOne()
   print("implementedInOne class implementation")
 }
}

Propiedades en interfaces

Puede declarar propiedades en las interfaces. Dado que una interfaz no puede haber declarado, solo puede declarar una propiedad como abstracta o proporcionando una implementación predeterminada para los accesores.

interface MyInterface {
  // abstract
  val property: Int 
  val propertyWithImplementation: String
      get() = "foo"
  fun foo() {
    print(property)
  }
}
  
class Child : MyInterface {
  override val property: Int = 29
}

Conflictos al implementar múltiples interfaces con implementaciones predeterminadas

Cuando se implementa más de una interfaz que tiene métodos del mismo nombre que incluyen implementaciones predeterminadas, el compilador no sabe qué implementación se debe usar. En caso de conflicto, el desarrollador debe anular el método en conflicto y proporcionar una implementación personalizada. Esa implementación puede optar por delegar a las implementaciones predeterminadas o no.

interface FirstTrait {
 fun foo() { print("first") }
 fun bar()
}
  
interface SecondTrait {
 fun foo() { print("second") }
 fun bar() { print("bar") }
}
  
class ClassWithConflict : FirstTrait, SecondTrait {
 override fun foo() {
     // delegate to the default
     // implementation of FirstTrait
     super<FirstTrait>.foo() 
     // delegate to the default 
     // implementation of SecondTrait
     super<SecondTrait>.foo() 
 }
 // function bar() only has a default implementation
 // in one interface and therefore is ok.
}

súper palabra clave

interface MyInterface {
 fun funcOne() {
     // optional body
     print("Function with default implementation")
 }
}

Nota:

Si el método en la interfaz tiene su propia implementación predeterminada, podemos usar la palabra clave super para acceder a él.

super.funcOne()