Patrón de diseño Observer Kotlin

Vista previa del material en texto

Patrón de diseño Observer Kotlin
El patrón de diseño Observer es una técnica muy útil en el desarrollo de software, que
permite establecer una relación de dependencia entre objetos, de manera que cuando un
objeto cambia su estado, todos los objetos que dependen de él son notificados y
actualizados automáticamente. En Kotlin, este patrón se implementa de manera sencilla y
eficiente.
En el patrón Observer, existen dos tipos de objetos principales: el sujeto observable y los
observadores. El sujeto observable es aquel que tiene la capacidad de cambiar su estado y
notificar a los observadores cuando esto sucede. Por otro lado, los observadores son
aquellos objetos que están interesados en conocer los cambios de estado del sujeto
observable y reaccionar en consecuencia.
En Kotlin, podemos implementar el patrón Observer utilizando las características del
lenguaje, como las interfaces y las funciones lambda. Para ello, podemos definir una
interfaz llamada "Observable" que contenga los métodos necesarios para añadir y
eliminar observadores, así como para notificar los cambios de estado. Por ejemplo:
interface Observable {
 val observers: MutableList<Observer>
 fun addObserver(observer: Observer) {
 observers.add(observer)
 }
 fun removeObserver(observer: Observer) {
 observers.remove(observer)
 }
 fun notifyObservers() {
 observers.forEach { it.update() }
 }
}
En este ejemplo, la interfaz "Observable" define una lista mutable de observadores y los
métodos necesarios para añadir, eliminar y notificar a los observadores. Cada observador
debe implementar la interfaz "Observer", que contiene el método "update()" que será
llamado cuando el sujeto observable cambie su estado. Por ejemplo:
interface Observer {
 fun update()
}
Una vez definidas las interfaces, podemos crear clases concretas que las implementen.
Por ejemplo, supongamos que tenemos una clase llamada "WeatherStation" que
representa una estación meteorológica y que queremos que otros objetos puedan
suscribirse a ella para recibir actualizaciones sobre el clima. Podemos implementarla de
la siguiente manera:
class WeatherStation : Observable {
 override val observers: MutableList<Observer> = mutableListOf()
 var temperature: Float = 0.0f
 set(value) {
 field = value
 notifyObservers()
 }
}
En este ejemplo, la clase "WeatherStation" implementa la interfaz "Observable" y define
una propiedad "temperature" que representa la temperatura actual. Cuando esta propiedad
cambia, se notifica a todos los observadores llamando al método "notifyObservers()".
Finalmente, podemos crear objetos observadores que implementen la interfaz "Observer"
y reaccionen a los cambios de estado del sujeto observable. Por ejemplo:
class PhoneDisplay(private val weatherStation: WeatherStation) : Observer {
 override fun update() {
 val temperature = weatherStation.temperature
 // Actualizar la pantalla del teléfono con la nueva temperatura
 }
}
En este ejemplo, la clase "PhoneDisplay" implementa la interfaz "Observer" y recibe una
instancia de la clase "WeatherStation" en su constructor. Cuando se llama al método
"update()", el objeto "PhoneDisplay" puede acceder a la temperatura actual del sujeto
observable y actualizar la pantalla del teléfono en consecuencia.
En resumen, el patrón de diseño Observer en Kotlin nos permite establecer una relación
de dependencia entre objetos, de manera que los observadores son notificados
automáticamente cuando el sujeto observable cambia su estado. Esto nos permite crear
sistemas flexibles y desacoplados, donde los objetos pueden reaccionar a los cambios de
manera independiente. Kotlin proporciona las herramientas necesarias para implementar
este patrón de manera sencilla y eficiente, utilizando interfaces y funciones lambda.