Interfaces de Kotlin

Las interfaces de Kotlin son similares a las de Java 8, se definen con la palabra clave `interface` y permiten que los métodos tengan implementaciones predeterminadas:

interface MyInterface { fun bar() //Sin implementar fun foo() { //Implementado //Cuerpo de método opcional println("foo") } }

Implementar interfaces

Una clase u objeto puede implementar una o más interfaces.

class Child : MyInterface { override fun bar() { //Cuerpo del método } }

Ejemplo

interface MyInterface { fun bar() fun foo() { //Cuerpo de método opcional println("foo") } } class Child : MyInterface { override fun bar() { //Cuerpo del método println("bar") } } fun main(args: Array<String>) { val c = Child() c.foo(); c.bar(); }

La salida es:

foo
bar

Propiedades en interfaces

Las propiedades en las interfaces solo pueden ser abstractas, no se permite inicializar valores. La interfaz no guarda el valor de la propiedad; al implementar la interfaz, se debe sobrescribir la propiedad:

interface MyInterface{ var name:String //Propiedad `name`, abstracta } class MyImpl:MyInterface{ override var name: String = "ejemplo" //Sobrescribir propiedad }

Ejemplo

interface MyInterface { var name:String //Propiedad `name`, abstracta fun bar() fun foo() { //Cuerpo de método opcional println("foo") } } class Child : MyInterface { override var name: String = "ejemplo" //Sobrescribir propiedad override fun bar() { //Cuerpo del método println("bar") } } fun main(args: Array<String>) { val c = Child() c.foo(); c.bar(); println(c.name) }

La salida es:

foo
bar
ejemplo

Anulación de funciones

Al implementar múltiples interfaces, puede surgir el problema de heredar múltiples implementaciones del mismo método. Por ejemplo:

Ejemplo

interface A { fun foo() { print("A") } //Implementado fun bar() //Sin implementar, no tiene cuerpo de método, es abstracto } interface B { fun foo() { print("B") } //Implementado fun bar() { print("bar") } //Implementado } class C : A { override fun bar() { print("bar") } //Sobrescribir } class D : A, B { override fun foo() { super<A>.foo() super<B>.foo() } override fun bar() { super<B>.bar() } } fun main(args: Array<String>) { val d = D() d.foo(); d.bar(); }

La salida es:

ABbar

En el ejemplo, las interfaces A y B definen los métodos foo() y bar(). Ambas implementan foo(), y B implementa bar(). Como C es una clase concreta que implementa A, debe sobrescribir bar() e implementar este método abstracto.

Sin embargo, si derivamos D de A y B, necesitamos implementar todos los métodos heredados de las múltiples interfaces e indicar cómo debe implementarlos D. Esta regla se aplica tanto a los métodos que heredan una sola implementación (bar()) como a los que heredan múltiples implementaciones (foo()).

Otras extensiones