Declaración e implementación de interfaces en Kotlin¶

Las interfaces permiten definir un conjunto de métodos y propiedades que una o varias clases deben implementar.
En Kotlin, una interface puede contener:

Métodos abstractos
Métodos con implementación por defecto
Propiedades abstractas
Propiedades con getters/setters por defecto

Permiten suplir la falta de herencia múltiple, ya que una clase puede implementar varias interfaces a la vez.

¿Qué es una interface?

Una interface define un contrato que las clases implementadoras deben cumplir.

classDiagram
    IVolar <|.. Avion
    IVolar <|.. Helicoptero

    class IVolar{
        <<interface>>
        +volar(): void
    }

    class Avion{
        +volar(): void
    }

    class Helicoptero{
        +volar(): void
    }

Sintaxis de una interface en Kotlin¶

ImplementaciónInterfaces con métodos implementadosInterfaces con propiedades

interface IVolar {
    fun volar()
}

class Avion : IVolar {
    override fun volar() {
        println("El avión despega por la pista y asciende.")
    }
}

class Helicoptero : IVolar {
    override fun volar() {
        println("El helicóptero asciende verticalmente con sus hélices.")
    }
}

interface IVehiculo {
    fun arrancar() {
        println("Iniciando secuencia de arranque…")
    }
    fun descripcion(): String
}

class Coche : IVehiculo {
    override fun descripcion() = "Vehículo de cuatro ruedas"
}

interface Identificable {
    val id: String
    val tipo: String get() = "GENÉRICO"
}

Clases implementando varias interfaces¶

interface A { fun accionA() }
interface B { fun accionB() }

class Multi : A, B {
    override fun accionA() = println("Realizando A")
    override fun accionB() = println("Realizando B")
}

Pasar interfaces como parámetro¶

fun hacerVolar(v: IVolar) {
    v.volar()
}

fun main() {
    hacerVolar(Avion())
    hacerVolar(Helicoptero())
}

Ejemplo¶

DefinicionAdaptación a Jetpack Compose

interface Conectable {
    fun conectar(): Boolean
}

data class Sistema(val nombre: String)

class Drone(val id: String, val sistema: Sistema) : Conectable {
    override fun conectar(): Boolean {
        println("Conectando drone $id al sistema ${sistema.nombre}…")
        return true
    }
}

interface IVolar {
    fun volar(): String
}

class Avion : IVolar {
    override fun volar() = "El avión despega a gran velocidad"
}

class Helicoptero : IVolar {
    override fun volar() = "El helicóptero asciende verticalmente"
}

@Composable
fun FichaVuelo(vehiculo: IVolar) {
    Card(
        modifier = Modifier
            .fillMaxWidth()
            .padding(8.dp)
    ) {
        Text(
            vehiculo.volar(),
            modifier = Modifier.padding(16.dp),
            style = MaterialTheme.typography.bodyLarge
        )
    }
}

@Composable
fun ListaVuelos() {
    val objetos: List<IVolar> = listOf(Avion(), Helicoptero())

    LazyColumn {
        items(objetos) { obj ->
            FichaVuelo(obj)
        }
    }
}

Actividad¶

PR 420 (RA2 / CE2a / IC2 / 5p). Diseña un sistema que modelar distintos tipos de vehículos aéreos y mostrar su comportamiento polimórfico en una interfaz dinámica.
1. Crea la interface IVolar, con:
  - fun despegar(): String
  - fun aterrizar(): String
2. Crea la interface IIdentificable, con:
  - val id: String
  - Método con implementación por defecto:
```
fun infoId(): String = "ID del vehículo: $id"
```
3. Implementa las siguientes clases:
  
  Avion
  - Implementa IVolar e IIdentificable.
  - Propiedades:
    - override val id: String
    - modelo: String
  - Métodos propios:
    - despega desde pista.
    - aterriza con tren de aterrizaje.
  Helicoptero
  - Implementa IVolar e IIdentificable.
  - Propiedades:
    - override val id: String
    - tipoRotores: Int
  - Métodos propios:
    - despega verticalmente.
    - aterriza verticalmente.
  Dron
  - Implementa IVolar e IIdentificable.
4. Implementa un composable:
```
FichaVuelo(vehiculo: IVolar)
```
  Debe mostrar:
  - Tipo de vehículo (usa when)
  - Resultado de despegar()
  - Resultado de aterrizar()
  - Información del ID (infoId())
5. Implementa otro composable:
```
ListaVuelos(lista: List<IVolar>)
```
  - Usa LazyColumn
  - Cada elemento debe mostrarse dentro de una Card
6. La pantalla principal mostrará una lista polimórfica:
```
val lista = listOf(
    Avion("A320", "Airbus"),
    Helicoptero("H700", 4),
    Dron("DRN-01")
)
```
Se valorará
- Debes usar dos interfaces implementadas por varias clases.
- Debe verse el polimorfismo en acción al llamar a despegar() y aterrizar().
- Usa relación de colaboración en la clase Dron.
- La UI debe usar LazyColumn, Card y when() para distinguir tipos.
- Usa al menos una propiedad con implementación por defecto en la interface.