Patrón de observador | Conjunto 2 (Implementación)

Recomendamos encarecidamente consultar el Conjunto 1 a continuación antes de pasar a esta publicación.

En el Conjunto 1, discutimos el problema a continuación, una solución para el problema sin patrón de Observador y problemas con la solución.

Supongamos que estamos creando una aplicación de cricket que notifica a los espectadores sobre información como el puntaje actual, la velocidad de carrera, etc. Supongamos que hemos creado dos elementos de visualización CurrentScoreDisplay y AverageScoreDisplay. CricketData tiene todos los datos (carreras, bolos, etc.) y cada vez que los datos cambian, los elementos de la pantalla reciben una notificación con nuevos datos y muestran los datos más recientes en consecuencia.

Aplicando el patrón Observer al problema anterior:
Veamos cómo podemos mejorar el diseño de nuestra aplicación usando el patrón Observer. Si observamos el flujo de datos, podemos ver fácilmente que CricketData y los elementos de visualización siguen una relación sujeto-observador.

Diagrama de nueva clase:

Implementación Java:

// Java program to demonstrate working of
// onserver pattern
import java.util.ArrayList;
import java.util.Iterator;
  
// Implemented by Cricket data to communicate
// with observers
interface Subject
{
    public void registerObserver(Observer o);
    public void unregisterObserver(Observer o);
    public void notifyObservers();
}
  
class CricketData implements Subject
{
    int runs;
    int wickets;
    float overs;
    ArrayList<Observer> observerList;
  
    public CricketData() {
        observerList = new ArrayList<Observer>();
    }
  
    @Override
    public void registerObserver(Observer o) {
        observerList.add(o);
    }
  
    @Override
    public void unregisterObserver(Observer o) {
        observerList.remove(observerList.indexOf(o));
    }
  
    @Override
    public void notifyObservers()
    {
        for (Iterator<Observer> it =
              observerList.iterator(); it.hasNext();)
        {
            Observer o = it.next();
            o.update(runs,wickets,overs);
        }
    }
  
    // get latest runs from stadium
    private int getLatestRuns()
    {
        // return 90 for simplicity
        return 90;
    }
  
    // get latest wickets from stadium
    private int getLatestWickets()
    {
        // return 2 for simplicity
        return 2;
    }
  
    // get latest overs from stadium
    private float getLatestOvers()
    {
        // return 90 for simplicity
        return (float)10.2;
    }
  
    // This method is used update displays
    // when data changes
    public void dataChanged()
    {
        //get latest data
        runs = getLatestRuns();
        wickets = getLatestWickets();
        overs = getLatestOvers();
  
        notifyObservers();
    }
}
  
// This interface is implemented by all those
// classes that are to be updated whenever there
// is an update from CricketData
interface Observer
{
    public void update(int runs, int wickets,
                      float overs);
}
  
class AverageScoreDisplay implements Observer
{
    private float runRate;
    private int predictedScore;
  
    public void update(int runs, int wickets,
                       float overs)
    {
        this.runRate =(float)runs/overs;
        this.predictedScore = (int)(this.runRate * 50);
        display();
    }
  
    public void display()
    {
        System.out.println("\nAverage Score Display: \n"
                           + "Run Rate: " + runRate +
                           "\nPredictedScore: " +
                           predictedScore);
    }
}
  
class CurrentScoreDisplay implements Observer
{
    private int runs, wickets;
    private float overs;
  
    public void update(int runs, int wickets,
                       float overs)
    {
        this.runs = runs;
        this.wickets = wickets;
        this.overs = overs;
        display();
    }
  
    public void display()
    {
        System.out.println("\nCurrent Score Display:\n"
                           + "Runs: " + runs +
                           "\nWickets:" + wickets +
                           "\nOvers: " + overs );
    }
}
  
// Driver Class
class Main
{
    public static void main(String args[])
    {
        // create objects for testing
        AverageScoreDisplay averageScoreDisplay =
                          new AverageScoreDisplay();
        CurrentScoreDisplay currentScoreDisplay =
                          new CurrentScoreDisplay();
  
        // pass the displays to Cricket data
        CricketData cricketData = new CricketData();
  
        // register display elements
        cricketData.registerObserver(averageScoreDisplay);
        cricketData.registerObserver(currentScoreDisplay);
  
        // in real app you would have some logic to
        // call this function when data changes
        cricketData.dataChanged();
  
        //remove an observer
        cricketData.unregisterObserver(averageScoreDisplay);
  
        // now only currentScoreDisplay gets the
        // notification
        cricketData.dataChanged();
    }
}

Producción:

Average Score Display: 
Run Rate: 8.823529
PredictedScore: 441

Current Score Display:
Runs: 90
Wickets:2
Overs: 10.2

Current Score Display:
Runs: 90
Wickets:2
Overs: 10.2

Nota: Ahora podemos agregar/eliminar tantos observadores como sea posible sin cambiar el tema.

Referencias:

https://en.wikipedia.org/wiki/Observer_pattern
Libro Head First Design Patterns (muy recomendable)

Este artículo es una contribución de Sulabh Kumar . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo y enviarlo por correo electrónico a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta