Java 观察者可观察的设计模式——让一个静态成员的类成为观察者？

我的类C1有所有静态成员（变量和方法）。它也有一个数组A1的对象类型C2是可观察的。我希望C1成为一个观察者，记录C2中的变化，然后使用A1中包含的引用将这些变化应用到对象。 我正在使用C1的一个实例，以便将其添加为C2对象的观察者

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

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

}


}

import java.util.*；
类FlightStatusChangeEvent{
智力状态；
飞行；
FlightStatusChangeEvent（内部状态代码，航班）{
this.status=状态代码；
这个飞行=飞行；
}
public int getStatus（）{返回this.status；}
公共航班getFlight（）{返回this.Flight；}
}
可观测的类飞行{
int status；//0=准时，-1=迟到，+1=在计划时间之前
公共无效更新状态（int状态代码）{
this.status=状态代码；
FlightStatusChangeEvent fsce=新的FlightStatusChangeEvent（状态，此）；
setChanged（）；
观察员（fsce）；
}
}
类FlightStatusMonitor实现了Observer{
公共静态ArrayList flights=新建ArrayList（）；
//保持每10秒调用此方法以获取最新的航班状态
公共无效显示状态关闭灯（）{
//打印阵列列表中的所有航班状态-航班
}
公共无效更新（可观察航班、对象航班状态事件）{
FlightStatusChangeEvent fsce=（FlightStatusChangeEvent）flightStatusEvent；
Flight fl=fsce.getFlight（）；
int status=fsce.getStatus（）；
//在阵列航班中查找航班，然后更新其状态
}
}

这就是在您的案例中如何实现观察者模式：

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);
    }

}

类FlightStatusEvent{
智力状态；
飞行；
FlightStatusEvent（int状态代码，航班）{
this.status=状态代码；
这个飞行=飞行；
}
public int getStatus（）{
返回此状态；
}
公共航班{
返回本航班；
}
}
可观测的类飞行{
int status；//0=准时，-1=迟到，+1=在计划时间之前
公共无效更新状态（int状态代码）{
this.status=状态代码；
FlightStatusEvent fsce=新的FlightStatusEvent（状态，此）；
setChanged（）；
观察员（fsce）；
}
}
类FlightStatusMonitor实现了Observer{
public ArrayList flights=new ArrayList（）；
公共无效显示状态关闭灯（）{
适用于（f航班：航班）{
系统输出打印项次（“航班”+f+”，状态=“+f.status”）；
}
}
公共无效更新（可观察航班、对象航班状态事件）{
displayStatusOfFlights（）；
}
公共静态void main（字符串[]args）{
FlightStatusMonitor fsm=新的FlightStatusMonitor（）；
航班f1=新航班（）；
f1.添加观察者（fsm）；
航班f2=新航班（）；
f2.附加观察者（fsm）；
ArrayList flights=新建ArrayList（）；
航班。添加（f1）；
航班。添加（f2）；
fsm.flights=航班；
fsm.displayStatusOfFlights（）；
//这将触发观察者模式事件。
f1.更新状态（1）；
}
}

你能分享一些代码吗？所有静态成员类都是一个很好的反模式。你能改变吗？@DiogoSantana-我添加了代码。为什么FlightStatusMonitor.flights需要是静态的？没有这些，你可以做你想做的。@DiogoSantana-对不起，我无法理解你的观点。回答你的问题：observer-desgin模式是合适的。你做这件事的方法是对的。但是请注意静态FlightStatusMonitor.flights成员。如果您有多个此类实例，则可能会出现问题。Param为什么将我的代码中的静态成员更改为类成员？静态类的O-O模式失败了吗？理论上，静态字段/方法属于类（而不是对象）。在您的例子中，flights对象属于FSM对象，而不是类本身。O-O模式可用于静态/非静态方法/字段。