Nivel inicial14 min de lectura · Publicado el

Interfaces en Kotlin: interface vs clase abstracta

Interfaces en Kotlin: la placa de un enchufe marca la forma de las clavijas, fun abstractMethod(); una lámpara y una radio con esa forma encajan. Interfaz: forma, no aparatorubentejera.com interfacefun abstractMethod()lámpararadio
La placa es la interfaz: marca la forma de las clavijas (fun abstractMethod()), pero no fabrica ningún aparato. La lámpara y la radio son las clases que la implementan: tienen esa forma exacta y encajan.

Una interface en Kotlin es un contrato: declara qué funciones y propiedades debe tener una clase, sin decir cómo se construye ni guardar datos. Es como la placa de un enchufe: marca la forma de las clavijas, pero no fabrica ningún aparato. Cualquier aparato que tenga esa forma encaja.

Cómo se declara y se implementa una interface en Kotlin

Se declara con la palabra interface. Dentro van las funciones y propiedades que forman el contrato:

interface Enchufable {
    val voltaje: Int                     // propiedad abstracta: sin valor
    val nombre: String                   // propiedad con get() por defecto
        get() = "aparato"

    fun encender()                       // método abstracto: sin cuerpo

    fun describir() {                    // método por defecto: con cuerpo
        println("$nombre a $voltaje V")
    }
}

class Lampara : Enchufable {
    override val voltaje = 230
    override val nombre = "lámpara"
    override fun encender() = println("La lámpara da luz")
}

class Radio : Enchufable {
    override val voltaje = 230
    override fun encender() = println("La radio suena")
}

fun enchufar(aparato: Enchufable) {
    aparato.describir()
    aparato.encender()
}

fun main() {
    enchufar(Lampara())
    enchufar(Radio())
}
lámpara a 230 V
La lámpara da luz
aparato a 230 V
La radio suena

Tres cosas que conviene ver en este ejemplo:

  • No hay implements en Kotlin. Se usan los dos puntos tanto para heredar de una clase como para implementar una interfaz: class Lampara : Enchufable.
  • override es obligatorio en todo lo que implementas o redefines. Si se te olvida implementar algo abstracto, el compilador te lo dice.
  • enchufar() no sabe qué aparato recibe. Solo conoce el contrato. Por eso funciona con la lámpara, con la radio y con cualquier clase que implemente Enchufable más adelante.

fun encender() equivale a abstract fun encender(): en una interfaz, lo que no tiene cuerpo es abstracto, y el abstract se puede escribir, pero sobra. Los miembros de una interfaz, además, son open por defecto: se pueden redefinir sin marcarlos.

Interfaz o clase abstracta en Kotlin

Es una duda frecuente. Las dos sirven para definir un contrato que otras clases completan y ninguna se puede instanciar directamente. La diferencia está en lo que cada una puede llevar dentro:

interface abstract class
¿Se puede instanciar? No No
¿Cuántas puede usar una clase? Todas las que quiera Una sola (Kotlin no tiene herencia múltiple de clases)
Constructor No tiene Sí, con parámetros
Estado (propiedades con valor guardado) No: solo propiedades abstractas o con get() Sí
Métodos abstractos Sin cuerpo, sin escribir abstract Hay que marcarlos con abstract
Métodos con implementación Sí (por defecto) Sí
Visibilidad de sus miembros public o private (este, con cuerpo) Cualquiera, también protected e internal

La tabla es una explicación nuestra a partir de las páginas Interfaces y Classes de la documentación oficial; las filas de visibilidad y de herencia se han comprobado con los errores del compilador que aparecen más abajo.

En código se ve mejor. Una clase abstracta puede guardar datos y pedirlos en el constructor; una clase hija la extiende y, a la vez, implementa las interfaces que necesite:

interface Enchufable {
    fun encender()
}

interface ConMando {
    fun subirVolumen() = println("Volumen +1")
}

abstract class Electrodomestico(val marca: String) {   // constructor con parámetros
    var horasDeUso = 0                                   // estado: un campo que guarda un valor
        private set

    abstract fun consumoWatios(): Int                    // aquí 'abstract' es obligatorio

    fun usar(horas: Int) {
        horasDeUso += horas
        println("$marca: $horasDeUso h de uso, ${consumoWatios() * horasDeUso} Wh")
    }
}

// Una sola clase padre, pero tantas interfaces como haga falta
class Television(marca: String) : Electrodomestico(marca), Enchufable, ConMando {
    override fun consumoWatios() = 100
    override fun encender() = println("$marca: tele encendida")
}

fun main() {
    val tele = Television("Acme")
    tele.encender()
    tele.subirVolumen()
    tele.usar(2)
    tele.usar(3)
}
Acme: tele encendida
Volumen +1
Acme: 2 h de uso, 200 Wh
Acme: 5 h de uso, 500 Wh

La clase padre lleva paréntesis (Electrodomestico(marca)) porque se llama a su constructor; las interfaces no, porque no tienen. Si intentas heredar de dos clases a la vez, no compila:

abstract class Electrodomestico
abstract class Mueble
class MuebleTv : Electrodomestico(), Mueble()
ErrDosClases.kt:3:38: error: only one class can appear in a supertype list.
class MuebleTv : Electrodomestico(), Mueble()
                                     ^^^^^^

Cuándo usar cada una

Esto es criterio nuestro, no una regla de la documentación:

  • Interfaz cuando describes una capacidad que pueden tener clases muy distintas («se puede enchufar», «se puede guardar», «envía notificaciones»), o cuando quieres poder cambiar una implementación por otra, por ejemplo una falsa en los tests.
  • Clase abstracta cuando varias clases comparten datos y un constructor, y tiene sentido decir que «son un» tipo común: una televisión es un electrodoméstico.
  • Ante la duda, interfaz. No consume la única herencia de clase que tienes y obliga a mantener el estado en las clases concretas, donde se ve.

Propiedades en una interface

Una interfaz puede declarar propiedades, pero no guardarlas. Hay dos opciones:

  • Abstracta: sin valor, como val voltaje: Int. Quien implemente la interfaz le da uno con override.
  • Con get(): como nombre en el primer ejemplo. Se calcula cada vez que se lee y la clase puede redefinirla.

Lo que no se puede es darle un valor inicial, porque eso necesitaría un sitio donde guardarlo:

interface Contador {
    var cuenta: Int = 0
}
ErrEstado.kt:2:23: error: property initializers in interfaces are prohibited.
    var cuenta: Int = 0
                      ^

Ese «sitio donde guardarlo» se llama backing field (campo de respaldo), y en un getter o setter se usa con la palabra field. Las interfaces no lo tienen:

interface Contador {
    var cuenta: Int
        get() = field
        set(value) { field = value }
}
ErrCampo.kt:2:5: error: property in interface cannot have a backing field.
    var cuenta: Int
    ^^^^^^^^^^^^^^^

Métodos por defecto y conflictos entre interfaces

Un método con cuerpo es un método por defecto: las clases lo heredan tal cual o lo redefinen con override.

¿Qué pasa si una clase implementa dos interfaces con un método por defecto del mismo nombre? Kotlin no elige por ti:

interface Luz { fun encender() = println("Luz") }
interface Sonido { fun encender() = println("Sonido") }
class Despertador : Luz, Sonido
ErrConflicto.kt:3:1: error: class 'Despertador' must override 'encender' because it inherits multiple interface methods for it.
class Despertador : Luz, Sonido
^^^^^^^^^^^^^^^^^

La solución es redefinirlo y decir qué versión quieres con super<Interfaz>:

interface Luz {
    fun encender() = println("Luz encendida")
}

interface Sonido {
    fun encender() = println("Sonido encendido")
}

class Despertador : Luz, Sonido {
    override fun encender() {      // obligatorio: hay dos versiones por defecto
        super<Luz>.encender()
        super<Sonido>.encender()
    }
}

fun main() {
    Despertador().encender()
}
Luz encendida
Sonido encendido

Funciones privadas dentro de una interface

Un método por defecto puede apoyarse en funciones private de la propia interfaz, que nadie ve desde fuera:

interface Saludo {
    val nombre: String

    fun saludar() = println(formatear("Hola"))
    fun despedir() = println(formatear("Adiós"))

    private fun formatear(palabra: String) = "$palabra, $nombre"   // ayuda interna, con cuerpo
}

class Persona(override val nombre: String) : Saludo

fun main() {
    val ana = Persona("Ana")
    ana.saludar()
    ana.despedir()
}
Hola, Ana
Adiós, Ana

Una función private de una interfaz necesita cuerpo, porque nadie podría implementarla. Y dentro de una interfaz no se admiten protected ni internal:

interface A {
    protected fun uno() = 1
    internal fun dos() = 2
    private fun tres(): Int
}
V.kt:2:5: error: modifier 'protected' is not applicable inside 'interface'.
V.kt:3:5: error: modifier 'internal' is not applicable inside 'interface'.
V.kt:4:5: error: function 'tres' without a body cannot be private.

Qué ve cada uno de estos modificadores lo tienes en Modificadores de acceso en Kotlin.

Una interface que hereda de otra

Una interfaz puede extender otra y completar parte del contrato. La clase final solo implementa lo que queda pendiente:

interface Nombrado {
    val nombre: String
}

interface Persona : Nombrado {
    val nombrePila: String
    val apellido: String
    override val nombre: String
        get() = "$nombrePila $apellido"
}

data class Empleada(
    override val nombrePila: String,
    override val apellido: String,
) : Persona

fun main() {
    println(Empleada("Ada", "Lovelace").nombre)
}
Ada Lovelace

fun interface: interfaces funcionales (SAM)

Una interfaz con un único método abstracto se llama interfaz funcional o SAM (Single Abstract Method, «un solo método abstracto»). Si la declaras con fun interface, puedes crear una implementación con una lambda, sin escribir una clase ni un object:

fun interface Filtro {
    fun acepta(precio: Int): Boolean           // un único método abstracto

    fun describir() = "filtro de precios"      // los demás pueden tener cuerpo
}

fun filtrar(precios: List<Int>, filtro: Filtro) = precios.filter { filtro.acepta(it) }

fun main() {
    val baratos = Filtro { it < 20 }           // una lambda en vez de un object : Filtro { … }
    println(baratos.describir())
    println(filtrar(listOf(5, 18, 40, 12), baratos))
    println(filtrar(listOf(5, 18, 40, 12)) { it % 2 == 0 })
}
filtro de precios
[5, 18, 12]
[18, 40, 12]

A esto se le llama conversión SAM: Kotlin convierte la lambda en un objeto que implementa la interfaz. En la última línea ni siquiera hace falta escribir Filtro, porque el parámetro ya dice qué tipo espera.

Sin la palabra fun, la interfaz es normal y la lambda no se acepta:

ErrSinFun.kt:4:15: error: interface 'interface Filtro : Any' does not have constructors.
val baratos = Filtro { it < 20 }
              ^^^^^^

Y con dos métodos abstractos ya no es funcional:

ErrFunInterface.kt:1:1: error: functional interface must have exactly one abstract function.
fun interface Filtro {
^^^

¿Cuándo una fun interface y cuándo un tipo función como (Int) -> Boolean? Resumido de la documentación: si tu función acepta cualquier función con esos parámetros, basta un tipo función (o un typealias para darle nombre); si representa algo con un contrato propio, con otros métodos o que implementa otras interfaces, declara una interfaz funcional. Las conversiones SAM también funcionan con interfaces de Java como Runnable; la diferencia entre los tipos función de Kotlin y las interfaces SAM de Java la tienes resumida en Kotlin vs Java.

Delegación con by

A veces quieres una clase que implemente una interfaz casi igual que otra que ya existe, cambiando solo un detalle. En vez de heredar, Kotlin te deja delegar: la clase implementa la interfaz reenviando cada llamada a otro objeto, y el compilador escribe esos reenvíos por ti.

interface Enchufable {
    fun encender()
    fun apagar()
}

class Lampara : Enchufable {
    override fun encender() = println("Lámpara encendida")
    override fun apagar() = println("Lámpara apagada")
}

// LamparaConTemporizador implementa Enchufable reenviando todo a 'lampara'...
class LamparaConTemporizador(private val lampara: Enchufable) : Enchufable by lampara {
    // ...salvo lo que redefine
    override fun encender() {
        println("Temporizador: 30 minutos")
        lampara.encender()
    }
}

fun main() {
    val aparato = LamparaConTemporizador(Lampara())
    aparato.encender()
    aparato.apagar()      // no está escrito en la clase: lo genera 'by'
}
Temporizador: 30 minutos
Lámpara encendida
Lámpara apagada

Funciona con cualquier Enchufable, no solo con Lampara, y no necesita que nadie esté marcado como open.

Un detalle que avisa la documentación: lo que redefines en la clase que delega no lo ve el objeto delegado. Si Lampara tuviera un reiniciar() que llama a su propio encender(), usaría su versión, no la del temporizador:

interface Enchufable {
    fun encender()
    fun reiniciar()
}

class Lampara : Enchufable {
    override fun encender() = println("Lámpara encendida")
    override fun reiniciar() {
        println("Reiniciando…")
        encender()                      // llama a SU encender()
    }
}

class LamparaConTemporizador(private val lampara: Enchufable) : Enchufable by lampara {
    override fun encender() {
        println("Temporizador: 30 minutos")
        lampara.encender()
    }
}

fun main() {
    LamparaConTemporizador(Lampara()).reiniciar()
}
Reiniciando…
Lámpara encendida

El temporizador no aparece. Si necesitas que el objeto interno llame a las versiones redefinidas, la delegación no sirve y tendrás que replantear el diseño.

Objetos anónimos que implementan una interface

No puedes crear una instancia de una interfaz:

ErrInstancia.kt:2:22: error: interface 'interface Enchufable : Any' does not have constructors.
fun main() { val e = Enchufable() }
                     ^^^^^^^^^^

Lo que sí puedes es crear un objeto anónimo (un objeto de una clase sin nombre) que la implemente en el momento. Es el ejemplo de la versión original del artículo, reducido a una interfaz:

interface Interface1 {
    fun abstractMethod()                       // sin cuerpo: abstracto

    fun methodWithImplementationByDefault() {  // con cuerpo: implementación por defecto
        println("Implementación por defecto de Interface1")
    }
}

fun main() {
    val obj1 = object : Interface1 {
        override fun abstractMethod() {
            println("Mi implementación de abstractMethod")
        }
    }
    obj1.methodWithImplementationByDefault()
    obj1.abstractMethod()
}
Implementación por defecto de Interface1
Mi implementación de abstractMethod

El tipo de la variable importa

El original guardaba el objeto en una variable declarada como Any? y luego tenía que convertirla (castear) cada vez:

private var anonymousObjectImplementingInterface: Any? = null
// ...
(anonymousObjectImplementingInterface as Interface1).abstractMethod()

Con Any, Kotlin solo sabe que es «algo» y no te deja llamar a los métodos de la interfaz sin el as. Basta con darle el tipo de la interfaz (private var obj: Interface1? = null) o dejar que Kotlin lo deduzca, como en val obj1 = object : Interface1 { … }.

Otra opción es private lateinit var obj: Interface1. Si la usas antes de asignarla, no recibes un NullPointerException, sino un error que dice qué propiedad olvidaste inicializar:

Exception in thread "main" kotlin.UninitializedPropertyAccessException: lateinit property obj has not been initialized

Errores típicos

  • Olvidar implementar un miembro abstracto. El mensaje dice cuál falta:

    ErrNoImplementa.kt:2:1: error: class 'Tostadora' is not abstract and does not implement abstract member:
    fun encender(): Unit
  • Buscar implements. No existe en Kotlin: son los dos puntos, class Tostadora : Enchufable.

  • Querer guardar estado en la interfaz. Ni valores iniciales ni field. El estado va en la clase.

  • Poner paréntesis a la interfaz (: Enchufable()). Las interfaces no tienen constructor; los paréntesis son solo para la clase padre.

  • Dos métodos por defecto con el mismo nombre. Hay que redefinirlo y elegir con super<Interfaz>.

  • Declarar una fun interface con dos métodos abstractos. Solo admite uno.

Siguiente paso

Las interfaces son la base para separar «qué hace» de «cómo lo hace». Esa idea está detrás de la segregación de interfaces y la inversión de dependencias de SOLID, de los puertos de la arquitectura hexagonal y de poder sustituir una dependencia por una falsa en los tests, como se hace al practicar TDD.

Para seguir con Kotlin:

Fuentes