1.定义

观察者模式：定义对象之间的一对多依赖，当一个对象改变，它所有依赖者都会收到通知。让主题和观察者之间以松耦合的方式结合

2.简介

Subject：目标。他把所有对观察者对戏的引用保存在一个聚集里，每一个主题都可以有多个观察者。
Observer：观察者。为所有的具体观察者定义一个接口，在得到主题的通知时能够及时的更新自己。
ConcreteSubject：具体主题。将有关状态存入具体观察者对象。在具体主题发生改变时，给所有的观察者发出通知。
ConcreteObserver：具体观察者。实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题状态相协调。

3.类图

image.png

4.实例

package designMode;

import java.io.IOException;
import java.util.ArrayList;

/**
 * 观察者模式：定义对象之间的一对多依赖，当一个对象改变，它所有依赖者都会收到通知
 */
public class ObserverPattern {
    public static void main(String[] args) throws IOException {
        DuiaAppNoteCenter duiaAppNoteCenter = new DuiaAppNoteCenter();
        ObserverA observerA = new ObserverA();
        duiaAppNoteCenter.registerObserver(observerA);
        duiaAppNoteCenter.registerObserver(new ObserverB());
        duiaAppNoteCenter.registerObserver(new ObserverC());
        duiaAppNoteCenter.setNote(2);
        duiaAppNoteCenter.removeObserver(observerA);
        duiaAppNoteCenter.setNote(3);
    }
    //主题接口
    interface Subject{
       void registerObserver(Observer o);
       void removeObserver(Observer o);
       void notifyObservers();
    }
    //观察者接口
    interface Observer {
        void update(Integer note);
    }
    //APP设备（显示器）
    interface APP {
        void display(Integer note);
    }
    //消息中心（具体主题）
    public static class  DuiaAppNoteCenter implements Subject{
        private ArrayList<Observer> observers;
        Integer note=1;
        public DuiaAppNoteCenter() {
            this.observers = new ArrayList();
        }

        @Override
       public void registerObserver(Observer o) {
            observers.add(o);
       }

       @Override
       public void removeObserver(Observer o) {
           observers.remove(o);
       }

       @Override
       public void notifyObservers() {
           for (Observer o:observers) {
               o.update(this.note);
           }
       }
       public void setNote(Integer note){
            this.note=note;
             changed();
       }
        public void changed(){
            notifyObservers();
        }
   }
    //观察者A（具体观察者）
    public static class ObserverA implements Observer,APP{
        @Override
        public void update(Integer note) {
            display(note);
        }
        @Override
        public void display(Integer note) {
            System.out.println("观察者A:"+note);
        }
    }
    //观察者B
    public static class ObserverB implements Observer,APP{
        @Override
        public void update(Integer note) {
            display(note);
        }
        @Override
        public void display(Integer note) {
            System.out.println("观察者B:"+note);
        }
    }
    //观察者C
    public static class ObserverC implements Observer,APP{
        @Override
        public void update(Integer note) {
            display(note);
        }
        @Override
        public void display(Integer note) {
            System.out.println("观察者C:"+note);
        }
    }
}