Implementación de interfaces complicadas con múltiples métodos anulados en Kotlin

Kotlin es un lenguaje de programación de propósito general tipificado estáticamente desarrollado por JetBrains, que ha creado IDE de clase mundial como IntelliJ IDEA, PhpStorm, Appcode, etc. Fue presentado por primera vez por JetBrains en 2011 y es un nuevo lenguaje para JVM. Kotlin es un lenguaje orientado a objetos y un «lenguaje mejor» que Java, pero aún así es totalmente interoperable con el código Java. En este artículo, vamos a discutir cómo implementar interfaces complicadas con múltiples métodos anulados en Kotlin, pero antes de eso, debería saber algo mejor.

Principios SOLIDOS

SOLID es un acrónimo mnemotécnico que se utiliza para definir los cinco principios básicos del diseño orientado a objetos:

• Principio de responsabilidad única
• Principio abierto-cerrado
• Principio de sustitución de Liskov
• Principio de segregación de interfaz
• Principio de inversión de dependencia

El Principio de Segregación de Interfaz (ISP) establece que si una interfaz se vuelve demasiado larga, es mejor dividirla en partes más pequeñas (interfaces) para que el cliente no necesite implementar las que no le interesan. En este artículo, entenderemos qué y por qué esto es importante.

Ejemplo

Veamos un ejemplo donde el ISP nos puede ayudar:

Este es un ejemplo simple de una interfaz «gorda»:

button.setOnClickListener(object : View.OnClickListener {
  fun onClick (View v) {
    // TODO: do some stuff. . .
  }
  fun onLongClick (View v) {
    // we don't need it
  }
  fun onTouch (View v, MotionEvent event) {
    // we don't need it
  }
});

Como puede ver, el problema con una interfaz grande es que nos vemos obligados a implementar los métodos incluso si no tenemos nada para hacerlo allí. Una solución simple es dividir esa interfaz en interfaces más pequeñas, como el siguiente código:

interface OnClickListener {
  fun onClick ( v:View )
}
public interface OnLongClickListener {
  fun onLongClick ( v: View)
}
interface OnTouchListener {
  fun onTouch ( v: View , event : MotionEvent)

Tenga en cuenta que ahora hemos dividido la gran interfaz en otras más pequeñas, que se pueden implementar de forma independiente. Kotlin también tiene una función poderosa que le permite escribir la implementación completa de los métodos en las propias interfaces. Echemos un vistazo al siguiente código para entenderlo:

fun main (args: Array<String>) {
  Simple ().callMethod ()
}
  class Simple: A{
    fun callMethod () {
      bar ()
    }
  }
  interface A{
    fun bar () {
      println ("Printing from interface")
    }
  }

Como puede ver, implementamos todo el método en la interfaz y pudimos llamarlo desde la clase que implementó esa interfaz. Esta función también se puede utilizar para seguir el principio ISP, ya que podemos poner un método de uso común en las propias interfaces; como resultado, no necesitaremos implementarlo cada vez que implementemos esa interfaz.