观察者模式 一读便会

说明

定义：定义了对象之前的一对多模式，当一个对象更新时，他的所有依赖对象都会收到通知，然后自动更新自己设定好的要更新的东西
接口：首先你需要定义好相应的接口

• 主题 Subject，包含方法有registerObserver（Observer o），removeObserver（Observer o），notifyServer（Observer o）
• 观察者 ObServer，包含方法（这里以更新方法为例），update（int a, int b, int c）
• 展示DisplayElement，这个接口可自定义需要操作的事儿 包含方法display()
  然后对应实现 主题类实现subject，观察者实现ObServer，DisplayElement

另外在java中有内置的观察者模式（不想看可以跳过这段），在《Head First》p65有提到，有兴趣的可以看下，大概就是：

• 调用Observable对象的add Observer()方法，对应移除就是deleteObserver();
• 通知观察者 先调用setChang()方法，标注状态已改变，然后调用notifyObservers()或notifyObservers(Object ob)
• 观察者实现update的方式不一样update(Observable o, Object ob) 具体可以看书p68页的例子

实现

开始实现，一读便会！
Subject接口

public interface Subject {

    public void registerObServer(ObServer o);
    public void removeObServer(ObServer o);
    public void notifyObServer();

}

ObServer接口

public interface ObServer {

    public void update(int el1,int el2,int el3);
}

DisplayElement接口

public interface DisplayElement {

    public void display();
}

SubjectData实现Subject接口

public class SubjectData implements Subject {

    /**
     * 用户注册观察者
     */
    public List<ObServer> obServers = new ArrayList<>();
    private int el1;
    private int el2;
    private int el3;

    @Override
    public void registerObServer(ObServer o) {
        obServers.add(o);
    }

    @Override
    public void removeObServer(ObServer o) {
        int i = obServers.indexOf(o);
        if(i >= 0 ){
            obServers.remove(i);
        }
    }

    @Override
    public void notifyObServer() {
        for (int i = 0; i < obServers.size(); i++){
            ObServer obServer = (ObServer) obServers.get(i);
            obServer.update(el1, el2, el3);
        }
    }

    public void notifyChange(){
        notifyObServer();
    }

    public void changeElements(int el1, int el2, int el3){
        this.el1 = el1;
        this.el2 = el2;
        this.el3 = el3;
        notifyChange();
    }
}

ObserverOne实现ObServer接口

public class ObserverOne implements ObServer, DisplayElement {
    private int el1;
    private int el2;
    private Subject subject;

    public ObserverOne(Subject subject){
        this.subject = subject;
        subject.registerObServer(this);
    }

    @Override
    public void update(int el1, int el2, int el3) {
        this.el1 = el1;
        this.el2 = el2;
        display();
    }

    @Override
    public void display() {
        System.out.println("ObserverOne Elements: el1:"+el1+",el2:"+el2);
    }
}

ObserverTwo实现ObServer接口

public class ObserverTwo implements ObServer, DisplayElement {
    private int el2;
    private int el3;
    private Subject subject;

    public ObserverTwo(Subject subject){
        this.subject = subject;
        subject.registerObServer(this);
    }

    @Override
    public void update(int el1, int el2, int el3) {
        this.el2 = el2;
        this.el3 = el3;
        display();
    }

    @Override
    public void display() {
        System.out.println("ObserverOne Elements: el2:"+el2+",el3:"+el3);
    }
}

最后就是测试了

public class TestSO {
    public static void main(String[] args) {
        SubjectData subjectData = new SubjectData();
        ObserverOne observerOne = new ObserverOne(subjectData);
        ObserverTwo observerTwo = new ObserverTwo(subjectData);

        subjectData.changeElements(1,2,3);
        subjectData.changeElements(3,4,5);
    }
}

参考《Head First》中的观察模式讲解