Interfaces Kotlin

Las interfaces son tipos personalizados proporcionados por Kotlin que no se pueden instanciar directamente. En cambio, estos definen una forma de comportamiento que los tipos de implementación deben seguir. Con la interfaz, puede definir un conjunto de propiedades y métodos que los tipos concretos deben seguir e implementar.

Creación de interfaces –

La definición de interfaz en Kotlin comienza con la palabra clave de interfaz seguida del nombre de la interfaz, seguido de las llaves dentro de las cuales residen los miembros de la interfaz. La diferencia es que los miembros no tendrán una definición propia. Estas definiciones serán proporcionadas por los tipos conformes.

Ejemplo:

interface Vehicle()
{
  fun start()
  fun stop()
}

Implementando Interfaces –

Una interfaz puede ser implementada por una clase o un objeto. Al implementar una interfaz, el tipo conforme debe proporcionar la definición para todos sus miembros. Para implementar una interfaz, el nombre del tipo personalizado va seguido de dos puntos y el nombre de la interfaz que se implementará.

class Car: Vehicle

Ejemplo para demostrar una interfaz en Kotlin –

interface Vehicle {
    fun start()
    fun stop()
}
  
class Car : Vehicle {
    override fun start()
    {
        println("Car started")
    }
  
    override fun stop()
    {
        println("Car stopped")
    }
}
  
fun main()
{
    val obj = Car()
    obj.start()
    obj.stop()
}

Producción:

Car started
Car stopped

Explicación:
En este programa, la interfaz Vehicle declara dos métodos start()y stop(), que deben anularse. La clase Car implementa la interfaz usando la sintaxis de clase literal y anula los dos métodos usando la palabra clave override. Finalmente, la función principal crea un objeto de clase Car y llama a los dos métodos.

Valores predeterminados y métodos predeterminados:

Los métodos en una interfaz pueden tener valores predeterminados para sus parámetros. Si el valor de un parámetro no se proporciona en el momento de la llamada a la función, se utiliza el valor predeterminado. Además, los métodos pueden tener implementaciones predeterminadas. Estos se utilizan en el caso de que el método no se invalide.

Ejemplo para demostrar el valor predeterminado y los métodos predeterminados:

interface FirstInterface {
    fun add(a: Int, b: Int = 5)
    fun print()
    {
        println("This is a default method defined in the interface")
    }
}
class InterfaceDemo : FirstInterface {
    override fun add(a: Int, b: Int)
    {
        val x = a + b
        println("Sum is $x")
    }
  
    override fun print()
    {
        super.print()
        println("It has been overridden")
    }
}
  
fun main()
{
    val obj = InterfaceDemo()
    println(obj.add(5))
    obj.print()
}

Producción:

Sum is 10
This is a default method defined in the interface
It has been overridden

Explicación:
En el programa anterior, FirstInterface define dos métodos add() y print() . El método add() tiene dos parámetros, uno de los cuales tiene un valor predeterminado de 5. Además, el método print() tiene una implementación predeterminada. Entonces, cuando la clase InterfaceDemo implementa la interfaz, anula ambos métodos y llama a la implementación predeterminada de print() usando la palabra clave super . Además, en la función principal, solo se especifica un argumento cuando se llama al método add, ya que al segundo se le asigna un valor predeterminado.

Propiedades en la interfaz –

Al igual que los métodos, las interfaces también pueden contener propiedades. Sin embargo, dado que la interfaz no tiene un estado, no se pueden instanciar, por lo que no hay campos de respaldo para contener sus valores. Por lo tanto, los campos en la interfaz se dejan abstractos o se les proporciona una implementación.

Ejemplo para demostrar las propiedades de la interfaz –

interface InterfaceProperties {
    val a : Int
    val b : String
        get() = "Hello"
}
  
class PropertiesDemo : InterfaceProperties {
    override val a : Int = 5000
    override val b : String = "Property Overridden"
}
  
fun main()
{
    val x = PropertiesDemo()
    println(x.a)
    println(x.b)
}

Producción:

5000
Property Overridden

Explicación:
En el programa anterior, InterfaceProperties define dos propiedades, a, que es un número entero, y b, de tipo String, que se proporciona como captador . La clase PropertiesDemo implementa InterfaceProperties y anula las dos propiedades, proporcionándoles valor. La función main crea un objeto de la clase y accede a las propiedades utilizando la sintaxis de puntos.

Herencia en Interfaces –

Las interfaces en Kotlin también pueden heredar otras interfaces. Cuando una interfaz extiende otra interfaz, puede agregar sus propias propiedades y métodos, y el tipo de implementación debe proporcionar una definición para todas las propiedades y métodos en ambas interfaces. Una interfaz puede heredar más de una interfaz.

Ejemplo para demostrar la herencia de la interfaz –

interface Dimensions {
    val length : Double
    val breadth : Double
}
  
interface CalculateParameters : Dimensions {
    fun area()
    fun perimeter()
}
  
class XYZ : CalculateParameters {
    override val length : Double
        get() = 10.0
    override val breadth : Double
        get()= 15.0
  
    override fun area()
    {
        println("Area is ${length * breadth}")
    }
  
    override fun perimeter()
    {
        println("Perimeter is ${2*(length+breadth)}")
    }
}
  
fun main()
{
    val obj = XYZ()
    obj.area()
    obj.perimeter()
}

Producción:

Area is 150.0
Perimeter is 50.0

Explicación:
En el programa, las dimensiones de la interfaz definen dos propiedades, largo y ancho . La interfaz CalculatedParameters hereda Dimensiones y agrega dos métodos area()y perimeter(). La clase XYZ implementa CalculatedParameters y anula tanto las propiedades como los métodos, que luego se invocan en la función principal.

Implementación de múltiples interfaces –

Dado que las clases en Kotlin siguen el concepto de herencia única, es decir, cada clase puede heredar solo una clase; sin embargo, en el caso de las interfaces, una clase admite la herencia múltiple, también conocida como conformidad múltiple en Kotlin. Una clase puede implementar más de una interfaz, siempre que proporcione una definición para todos los miembros de la interfaz.

Ejemplo para demostrar la implementación de múltiples interfaces:

interface InterfaceProperties {
    val a : Int
    val b : String
        get() = "Hello"
}
  
interface InterfaceMethods {
    fun description()
}
  
class MultipleInterface : InterfaceProperties, InterfaceMethods {
    override val a : Int
        get() = 50
  
    override fun description()
    {
        println("Multiple Interfaces implemented")
    }
}
fun main()
{
    val obj = MultipleInterface()
    obj.description()
}

Producción:

Multiple Interfaces implemented

Explicación:
En el programa, se definen dos interfaces InterfaceProperties e InterfaceMethods . Estas interfaces son implementadas por la clase MultipleInterface y luego los métodos son invocados en la función principal.