Java设计模式之观察者模式

观察者模式

行为型模式

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

• 在抽象类里有一个 ArrayList 存放观察者们
• 观察者和被观察者是抽象耦合的

主题（Subject）：主题是一个接口，规定了具体主题需要实现的方法

观察者（Observer）：观察者是一个接口，规定了具体观察者用来更新数据的方法。
具体主题（ConcreteSubject）：具体主题需使用一个集合，比如ArrayList，存放观察者的引用

具体观察者（ConcreteObserver）：包含有可以存放具体主题引用的主题接口变量

abstract interface Observer {
    void getMsg(String msg);
}

abstract interface Subject{
    void add(Observer o);
    void remove(Observer o);
    void notifyObserver();
}
class ObserverImpl implements Observer{
    int id;
    Subject subject;
    public ObserverImpl(Subject subject,int id){
        this.subject = subject;
        this.id = id;
        subject.add(this);
    }
    public void getMsg(String msg){
        //subject.notifyObserver(); //此处代表循环调用
        System.out.println("ob " + id  + ": subject say :" +  msg);
    }
}
class SubjectImpl implements Subject{
    ArrayList <Observer> list;
    public SubjectImpl(){
        list = new ArrayList <Observer>();
    }
    public void add(Observer o) {
        if(!list.contains(o))
            list.add(o);
    }
    public void remove(Observer o) {
        if(list.contains(o))
            list.remove(o);
    }
    public void notifyObserver() {
        for(Observer o : list){
            o.getMsg("Hello I am subject");
        }
    }

}

测试:

Subject subject = new SubjectImpl();
        Observer ob1 = new ObserverImpl(subject,1);
        Observer ob2 = new ObserverImpl(subject,2);
        Observer ob3 = new ObserverImpl(subject,3);
        subject.notifyObserver();
        subject.remove(ob2);
        subject.notifyObserver();

观察者和观察目标之间有循环依赖的话，
观察目标会触发它们之间进行循环调用

---

状态模式

类的行为是基于它的状态改变的。
行为型模式

在状态模式中，我们创建

• 表示各种状态的对象
• 一个行为随着状态对象改变而改变的 context 对象

Context类内部维护一个具体状态类的实例

//状态模式
class Context {
    public State state;
    public String str;
    public Context(){
        state = null;
    }
    public void setState(State state){
        this.state = state;
    }
    public State getState(){
        return state;
    }
    public void Action(){
        System.out.println(str);
    }
}
interface State{
    public void ChangeState(Context ctx);
}
class StartState implements State{
    public void ChangeState(Context ctx){
        ctx.setState(this);
        ctx.str = "start";
    }
}
class RunningState implements State{
    public void ChangeState(Context ctx){
        ctx.setState(this);
        ctx.str = "running";
    }
}
class StopState implements State{
    public void ChangeState(Context ctx){
        ctx.setState(this);
        ctx.str = "stop";
    }
}

测试：

Context ctx = new Context();
        StartState start = new StartState();
        StopState stop = new StopState();
        RunningState running = new RunningState();
        ctx.Action();
        start.ChangeState(ctx);
        ctx.Action();
        running.ChangeState(ctx);
        ctx.Action();
        stop.ChangeState(ctx);
        ctx.Action();