观察者模式

模式定义

定义对象间的一种一对多（变化）的依赖关系，以便当一个 对象(Subject)的状态发生改变时，所有依赖于它的对象都得到通知并自动更新

结构

代码

//subject
public interface Subject {
    public void addObserver(Observer o);

    public void removeObserver(Observer observer);

    public void notifyAllObserver();
}

//observer
public interface Observer {
    public void updateAction();
}
//显示通知
public interface display {
    public void displayAction();
}

//observer 实现类
public class show1 implements Observer,display {
    @Override
    public void updateAction() {
        System.out.println("show1收到通知");
        displayAction();
    }

    @Override
    public void displayAction() {
        System.out.println("show1显示通知");
    }
}

public class show2 implements Observer,display {
    @Override
    public void updateAction() {
        System.out.println("show2收到通知");
        displayAction();
    }

    @Override
    public void displayAction() {
        System.out.println("show2显示通知");
    }
}

public class show3 implements Observer,display {
    @Override
    public void updateAction() {
        System.out.println("show3收到通知");
        displayAction();
    }

    @Override
    public void displayAction() {
        System.out.println("show3显示通知");
    }
}

//subject 实现类
public class WeatherData implements Subject {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        show1 s1 = new show1();
        show2 s2 = new show2();
        show3 s3 = new show3();

        weatherData.addObserver(s1);
        weatherData.addObserver(s2);
        weatherData.addObserver(s3);

        weatherData.doWhenMessageChange();

    }
    ArrayList<Observer> list = new ArrayList<Observer>();

    @Override
    public void addObserver(Observer o) {
        list.add(o);
    }

    @Override
    public void removeObserver(Observer observer) {
        list.remove(observer);
    }

    @Override
    public void notifyAllObserver() {
        System.out.println("通知observers");
        for(Observer o:list)
            o.updateAction();
    }

    public void doWhenMessageChange(){
        System.out.println("消息改变了");
        notifyAllObserver();
    }
}

结果

总结

模式中变化和不变的地方

subject 的状态会改变: 信息变更
observer 的具体类型和数量会变化,行为的内容会变化.
subject 和 observer 一对多的依赖关系不变,具体行为也不变,但是行为的内容会变,所以可以用接口实现.

针对接口编程原则

subject 和 observer 都设计成了接口.