观察者可观察的设计模式 - 与静态成员进行类观察者？ [英] Observer observable design pattern - Making a class with static members an Observer?

问题描述

我的类C1有所有静态成员（变量和方法）。它还具有可观察的类型C2的对象的阵列A1。我想要C1是观察者，注意到C2的变化，然后通过使用A1中包含的引用将这些更改应用于对象。
我正在使用C1的实例，以便可以作为C2对象的观察者添加。

观察者可观察的设计模式是否适合此情况？如果是，那么我正确地应用它？

  import java.util。*; 
 
 class FlightStatusChangeEvent {
 
 int status; 
飞行航班
 
 FlightStatusChangeEvent（int statusCode，Flight flight）{
 
 this.status = statusCode; 
 this.flight = flight; 
 
} 
 
 public int getStatus（）{return this.status;} 
 
 public Flight getFlight（）{return this.flight;} 
 
 
} 
 
 class Flight extends Observable {
 
 int status; // 0 = on time，-1 = late，+1 =在预定时间之前
 
 public void updateStatus（int statusCode）{
 
 
 this.status = statusCode; 
 FlightStatusChangeEvent fsce = new FlightStatusChangeEvent（status，this）; 
 setChanged（）; 
 notifyObservers（fsce）; 
 
} 
 
 
} 
 
 class FlightStatusMonitor implements Observer {
 
 public static ArrayList< Flight> flights = new ArrayList< Flight>（）; 
 
 //持续每10秒钟调用此方法以获取最新的航班状态
 public void displayStatusOfFlights（）{
 
 //打印数组列表中的所有航班状态 - 航班
} 
 
 public void update（可见航班，对象flightStatusEvent）{
 
 FlightStatusChangeEvent fsce =（FlightStatusChangeEvent）flightStatusEvent; 
 Flight fl = fsce.getFlight（）; 
 int status = fsce.getStatus（）; 
 
 //在阵列航班中找到航班，然后更新其状态
 
} 
 
 
} 
  

解决方案

这就是您的情况下可以实现Observer模式：

  class FlightStatusEvent {
 
 int status; 
飞行航班
 
 FlightStatusEvent（int statusCode，Flight flight）{
 this.status = statusCode; 
 this.flight = flight; 
} 
 
 public int getStatus（）{
 return this.status; 
} 
 
 public Flight getFlight（）{
 return this.flight; 
} 
 
} 
 
 class Flight extends Observable {
 
 int status; // 0 = on time，-1 = late， +1 =在预定时间之前
 
 public void updateStatus（int statusCode）{
 
 this.status = statusCode; 
 FlightStatusEvent fsce = new FlightStatusEvent（status，this）; 
 setChanged（）; 
 notifyObservers（fsce）; 
 
} 
 
} 
 
 class FlightStatusMonitor implements Observer {
 
 public ArrayList< Flight> flights = new ArrayList< Flight>（）; 
 
 public void displayStatusOfFlights（）{
 for（Flight f：flights）{
 System.out.println（Flight+ f +，status =+ f。状态）; 
} 
} 
 
 public void update（可观察的航班，对象flightStatusEvent）{
 displayStatusOfFlights（）; 
} 
 
 public static void main（String [] args）{
 FlightStatusMonitor fsm = new FlightStatusMonitor（）; 
 
航班f1 =新航班（）; 
 f1.addObserver（fsm）; 
航班f2 =新航班（）; 
 f2.addObserver（fsm）; 
 
 ArrayList< Flight> flights = new ArrayList< Flight>（）; 
 flights.add（f1）; 
 flights.add（f2）; 
 
 fsm.flights =航班; 
 fsm.displayStatusOfFlights（）; 
 
 //这将触发观察者模式事件。 
 f1.updateStatus（1）; 
} 
 
} 
  

My class C1 has all static members (variables and methods). It also has an array A1 of Objects of type C2 which are observable. I want C1 to be an observer that notes changes in C2's and then applies those changes to the objects by using the references contained in A1. I am using an instance of C1 just so that it can be added as an observer of C2 objects.

Is the Observer-observable design pattern appropriate for this situation ? If yes, then am I applying it correctly ?

import java.util.*;

class FlightStatusChangeEvent{

int status;
Flight flight;

FlightStatusChangeEvent(int statusCode, Flight flight){

    this.status = statusCode;
    this.flight = flight;

}

public int getStatus(){return this.status;}

public Flight getFlight(){return this.flight;}


}

class Flight extends Observable{

int status;// 0 = on time, -1 = late, +1 = before scheduled time

public void updateStatus(int statusCode){


    this.status = statusCode;
    FlightStatusChangeEvent fsce = new FlightStatusChangeEvent(status, this);
    setChanged();
    notifyObservers(fsce);

}


}

class FlightStatusMonitor implements Observer{

public static ArrayList<Flight> flights = new ArrayList<Flight>();

//keep calling this method every 10 sec to get latest flight status
public void displayStatusOfFlights(){

    //print all flight statuses in array list - flights
}

public void update(Observable flight, Object flightStatusEvent){

    FlightStatusChangeEvent fsce = (FlightStatusChangeEvent) flightStatusEvent;     
    Flight fl = fsce.getFlight();
    int status = fsce.getStatus();

    //find the flight in array flights and then update its status

}


}

解决方案

This is how Observer pattern can be implemented in your case:

class FlightStatusEvent {

    int status;
    Flight flight;

    FlightStatusEvent(int statusCode, Flight flight) {
        this.status = statusCode;
        this.flight = flight;
    }

    public int getStatus() {
        return this.status;
    }

    public Flight getFlight() {
        return this.flight;
    }

}

class Flight extends Observable {

    int status;// 0 = on time, -1 = late, +1 = before scheduled time

    public void updateStatus(int statusCode) {

        this.status = statusCode;
        FlightStatusEvent fsce = new FlightStatusEvent(status, this);
        setChanged();
        notifyObservers(fsce);

    }

}

class FlightStatusMonitor implements Observer {

    public ArrayList<Flight> flights = new ArrayList<Flight>();

    public void displayStatusOfFlights() {
        for(Flight f : flights) {
            System.out.println("Flight " + f + ", status = " + f.status);
        }
    }

    public void update(Observable flight, Object flightStatusEvent) {
        displayStatusOfFlights();
    }

    public static void main(String[] args) {
        FlightStatusMonitor fsm = new FlightStatusMonitor();

        Flight f1 = new Flight();
        f1.addObserver(fsm);
        Flight f2 = new Flight();
        f2.addObserver(fsm);

        ArrayList<Flight> flights = new ArrayList<Flight>();
        flights.add(f1);
        flights.add(f2);

        fsm.flights = flights;
        fsm.displayStatusOfFlights();

        // this will trigger observer pattern event.
        f1.updateStatus(1);
    }

}

这篇关于观察者可观察的设计模式 - 与静态成员进行类观察者？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！