Esta página se tradujo automáticamente con la API de traducción de Google Cloud.
Algunas páginas se pueden leer mejor en su totalidad.
El patrón de observador es un patrón de diseño de software en el que un objeto, llamado sujeto, mantiene una lista de sus dependientes, llamados observadores, y les notifica automáticamente cualquier cambio de estado, generalmente llamando a uno de sus métodos.
Es un patrón muy útil para implementar sistemas controlados por eventos y también es uno de los patrones de diseño de comportamiento.
El patrón de observador es un patrón de diseño de software en el que un objeto, llamado sujeto, mantiene una lista de sus dependientes, llamados observadores, y les notifica automáticamente cualquier cambio de estado, generalmente llamando a uno de sus métodos.
Es un patrón muy útil para implementar sistemas controlados por eventos y también es uno de los patrones de diseño de comportamiento.
El Patrón del Observador tiene los siguientes participantes:
El patrón de observador se utiliza en las siguientes situaciones:
Kotlin no tiene un patrón de observador incorporado, pero es fácil de implementar.
Primero, creemos la interfaz Asunto:
interface Subject {
fun addObserver(observer: Observer)
fun removeObserver(observer: Observer)
fun notifyObservers()
}
Como puede ver, la interfaz Asunto tiene tres métodos:
Ahora vamos a crear la interfaz de Observer:
interface Observer {
fun update(subject: Subject)
}
La interfaz de Observer tiene un solo método:
Ahora vamos a crear una clase ConcreteSubject que implemente la interfaz Subject:
class ConcreteSubject : Subject {
private val observers = mutableListOf<Observer>()
private var state: Int = 0
override fun addObserver(observer: Observer) {
observers.add(observer)
}
override fun removeObserver(observer: Observer) {
observers.remove(observer)
}
override fun notifyObservers() {
for (observer in observers) {
observer.update(this)
}
}
fun setState(state: Int) {
this.state = state
notifyObservers()
}
fun getState(): Int {
return state
}
}
Como puede ver, la clase ConcreteSubject mantiene una lista de observadores y les notifica cuando cambia el estado del sujeto.
Finalmente, creemos una clase ConcreteObserver que implemente la interfaz Observer:
class ConcreteObserver : Observer {
private var state: Int = 0
override fun update(subject: Subject) {
state = subject.getState()
}
fun getState(): Int {
return state
}
}
La clase ConcreteObserver simplemente almacena el estado del sujeto y proporciona un método getter para acceder a él.
Ahora escribamos una prueba para ver el patrón de observador en acción:
import org.junit.Test
import kotlin.test.assertEquals
class ObserverPatternTest {
@Test
fun testObserverPattern() {
val subject = ConcreteSubject()
val observer1 = ConcreteObserver()
val observer2 = ConcreteObserver()
subject.addObserver(observer1)
subject.addObserver(observer2)
subject.setState(1)
assertEquals(1, observer1.getState())
assertEquals(1, observer2.getState())
subject.setState(2)
assertEquals(2, observer1.getState())
assertEquals(2, observer2.getState())
subject.removeObserver(observer1)
subject.setState(3)
assertEquals(2, observer1.getState())
assertEquals(3, observer2.getState())
}
}
En esta prueba, primero creamos un ConcreteSubject y dos ConcreteObservers. Luego agregamos los observadores al sujeto y cambiamos el estado del sujeto. Afirmamos que los estados de los observadores han cambiado en consecuencia. Finalmente, eliminamos uno de los observadores y volvemos a cambiar el estado del sujeto. Afirmamos que solo ha cambiado el estado del observador restante.