Una interface declara una serie de métodos y propiedades que deben ser implementados luego por una o más clases, también una interface en Kotlin puede tener implementado métodos.
Las interfaces vienen a suplir la imposibilidad de herencia múltiple en Kotlin.
Se utiliza la misma sintaxis que la herencia para indicar que una clase implementa una interface.
Por ejemplo podemos tener dos clases que representen un avión y un helicóptero. Luego plantear una interface con un método llamado volar. Las dos clases pueden implementar dicha interface y codificar el método volar (los algoritmos seguramente sean distintos pero el comportamiento de volar es común tanto a un avión como un helicóptero)
La sintaxis en Kotlin para declarar una interface es:
interface [nombre de la interface] {
[declaración de propiedades]
[declaración de métodos]
[implementación de métodos]
}
Definir una interface llamada Punto que declare un método llamado imprimir. Luego declarar dos clases que la implementen.
interface Punto {
fun imprimir()
}
class PuntoPlano(val x: Int, val y: Int): Punto {
override fun imprimir() {
println("Punto en el plano: ($x,$y)")
}
}
class PuntoEspacio(val x: Int, val y: Int, val z: Int): Punto {
override fun imprimir() {
println("Punto en el espacio: ($x,$y,$z)")
}
}
fun main(parametro: Array<String>) {
val puntoPlano1 = PuntoPlano(10, 4)
puntoPlano1.imprimir()
val puntoEspacio1 = PuntoEspacio(20, 50, 60)
puntoEspacio1.imprimir()
}
Para declarar una interface en Kotlin utilizamos la palabra clave interface y seguidamente su nombre. Luego entre llaves indicamos todas las cabeceras de métodos, propiedades y métodos ya implementados. En nuestro ejemplo declaramos la interface Punto e indicamos que quien la implemente debe definir un método llamado imprimir sin parámetros y que no retorna nada:
interface Punto {
fun imprimir()
}
Por otro lado declaramos dos clases llamados PuntoPlano con dos propiedades y PuntoEspacio con tres propiedades, además indicamos que dichas clases implementarán la interface Punto:
class PuntoPlano(val x: Int, val y: Int): Punto {
override fun imprimir() {
println("Punto en el plano: ($x,$y)")
}
}
class PuntoEspacio(val x: Int, val y: Int, val z: Int): Punto {
override fun imprimir() {
println("Punto en el espacio: ($x,$y,$z)")
}
}
La sintaxis para indicar que una clase implementa una interface es igual a la herencia. Si una clase hereda de otra también puede implementar una o más interfaces separando por coma cada una de las interfaces.
El método imprimir en cada clase se implementa en forma distinta, en uno se imprimen 3 propiedades y en la otra se imprimen 2 propiedades.
Luego definimos en la función main un objeto de la clase PuntoPlano y otro de tipo PuntoEspacio:
fun main(parametro: Array<String>) {
val puntoPlano1 = PuntoPlano(10, 4)
puntoPlano1.imprimir()
val puntoEspacio1 = PuntoEspacio(20, 50, 60)
puntoEspacio1.imprimir()
}
Se tiene la siguiente interface:
interface Figura {
fun calcularSuperficie(): Int
fun calcularPerimetro(): Int
fun tituloResultado() {
println("Datos de la figura")
}
}
Definir dos clases que representen un Cuadrado y un Rectángulo. Implementar la interface Figura en ambas clases.
interface Figura {
fun calcularSuperficie(): Int
fun calcularperimetro(): Int
fun tituloResultado() {
println("Datos de la figura")
}
}
class Cuadrado(val lado: Int): Figura {
override fun calcularSuperficie(): Int {
return lado * lado
}
override fun calcularPerimetro(): Int{
return lado * 4
}
}
class Rectangulo(val ladoMayor:Int, val ladoMenor: Int): Figura {
override fun calcularSuperficie(): Int {
return ladoMayor * ladoMenor
}
override fun calcularPerimetro(): Int {
return (ladoMayor * 2) + (ladoMenor * 2)
}
}
fun main(parametro: Array<String>) {
val cuadrado1 = Cuadrado(10)
cuadrado1.tituloResultado()
println("Perimetro del cuadrado : ${cuadrado1.calcularPerimetro()}")
println("Superficie del cuadrado : ${cuadrado1.calcularSuperficie()}")
val rectangulo1 = Rectangulo(10, 5)
rectangulo1.tituloResultado()
println("Perimetro del rectangulo : ${rectangulo1.calcularPerimetro()}")
println("Superficie del cuadrado : ${rectangulo1.calcularSuperficie()}")
}
En este problema la interface Figura tiene dos métodos abstractos que deben ser implementados por las clases y un método concreto, es decir ya implementado:
interface Figura {
fun calcularSuperficie(): Int
fun calcularPerimetro(): Int
fun tituloResultado() {
println("Datos de la figura")
}
}
La clase Cuadrado indica que implementa la interface Figura, esto hace necesario que se implementen los métodos calcularSuperficie y calcularPerimetro:
class Cuadrado(val lado: Int): Figura {
override fun calcularSuperficie(): Int {
return lado * lado
}
override fun calcularPerimetro(): Int{
return lado * 4
}
}
De forma similar la clase Rectangulo implementa la interface Figura:
class Rectangulo(val ladoMayor:Int, val ladoMenor: Int): Figura {
override fun calcularSuperficie(): Int {
return ladoMayor * ladoMenor
}
override fun calcularPerimetro(): Int {
return (ladoMayor * 2) + (ladoMenor * 2)
}
}
En la función main definimos un objeto de la clase Cuadrado y otro de la clase Rectangulo, luego llamamos a los métodos tituloResultado, calcularPerimetro y calcularSuperficie para cada objeto:
fun main(parametro: Array<String>) {
val cuadrado1 = Cuadrado(10)
cuadrado1.tituloResultado()
println("Perimetro del cuadrado : ${cuadrado1.calcularPerimetro()}")
println("Superficie del cuadrado : ${cuadrado1.calcularSuperficie()}")
val rectangulo1 = Rectangulo(10, 5)
rectangulo1.tituloResultado()
println("Perimetro del rectangulo : ${rectangulo1.calcularPerimetro()}")
println("Superficie del cuadrado : ${rectangulo1.calcularSuperficie()}")
}
Un método o función puede recibir como parámetro una interface. Luego le podemos pasar objetos de distintas clases que implementan dicha interface:
interface Figura {
fun calcularSuperficie(): Int
fun calcularPerimetro(): Int
fun tituloResultado() {
println("Datos de la figura")
}
}
class Cuadrado(val lado: Int): Figura {
override fun calcularSuperficie(): Int {
return lado * lado
}
override fun calcularPerimetro(): Int{
return lado * 4
}
}
class Rectangulo(val ladoMayor:Int, val ladoMenor: Int): Figura {
override fun calcularSuperficie(): Int {
return ladoMayor * ladoMenor
}
override fun calcularPerimetro(): Int {
return (ladoMayor * 2) + (ladoMenor * 2)
}
}
fun imprimir(fig: Figura) {
println("Perimetro: ${fig.calcularPerimetro()}")
println("Superficie: ${fig.calcularSuperficie()}")
}
fun main(parametro: Array<String>) {
val cuadrado1 = Cuadrado(10)
cuadrado1.tituloResultado()
println("Perimetro del cuadrado : ${cuadrado1.calcularPerimetro()}")
println("Superficie del cuadrado : ${cuadrado1.calcularSuperficie()}")
val rectangulo1 = Rectangulo(10, 5)
rectangulo1.tituloResultado()
println("Perimetro del rectangulo : ${rectangulo1.calcularPerimetro()}")
println("Superficie del cuadrado : ${rectangulo1.calcularSuperficie()}")
imprimir(cuadrado1)
imprimir(rectangulo1)
}
La función imprimir recibe como parámetro fig que es de tipo Figura:
fun imprimir(fig: Figura) {
println("Perimetro: ${fig.calcularPerimetro()}")
println("Superficie: ${fig.calcularSuperficie()}")
}
En la main podemos llamar a la función imprimir pasando tanto el objeto cuadrado1 como rectangulo1:
imprimir(cuadrado1)
imprimir(rectangulo1)
Esto es posible ya que ambos objetos sus clases implementan la interface Figura.