Interfaces en Kotlin: interface vs clase abstracta
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
implementsen Kotlin. Se usan los dos puntos tanto para heredar de una clase como para implementar una interfaz:class Lampara : Enchufable. overridees 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 implementeEnchufablemá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 conoverride. - Con
get(): comonombreen 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 interfacecon 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:
- Companion object en Kotlin: los miembros «de la clase», que también pueden implementar interfaces.
- Modificadores de acceso en Kotlin: qué ve cada uno de
public,internal,protectedyprivate. - ¿Qué es Kotlin?, si estás empezando, y Kotlin vs Java, si vienes de Java.
Fuentes
- Documentación oficial de Kotlin, consultada el 9 de noviembre de 2026: Interfaces, Classes: abstract classes, Inheritance, Functional (SAM) interfaces, Delegation, Object expressions y Late-initialized properties.
- Todo el código y los errores de compilación se han ejecutado con
kotlinc-jvm2.4.21 (zip oficial de las releases de GitHub) sobre OpenJDK 25.0.5, en la imagen Dockereclipse-temurin:25. Los mensajes de error se copian tal como los da el compilador; en los más largos solo se muestran las líneas que importan. En el original se usabaLog.wde Android; aquí,println, para poder ejecutarlo fuera de Android.