当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。

    普通数据类

    1. /**
    2.  * @author meikb
    3.  * @desc 存储数据类 一个数据改变  通知其他数据
    4.  * @date 2020-05-26 10:48
    5.  */
    6. public class DataObj implements Observer{
    7.     public int getNum() {
    8.         return num;
    9.     }
    11.     public void setNum(int num) {
    12.         this.num = num;
    13.     }
    15.     private int num;
    17.     public DataObj(int num){
    18.         this.num = num;
    19.     }
    21.     @Override
    22.     public void change(DataCenter dataCenter) {
    23.         System.out.println("我想要减1，大家都一起减1");
    24.         dataCenter.notifyObserver();
    25.     }
    27.     @Override
    28.     public void updateSelf() {
    29.         num = this.num - 1;
    30.     }
    31. }

    观察者类

    1. /**
    2.  * @author meikb
    3.  * @desc
    4.  * @date 2020-05-26 10:45
    5.  */
    6. public interface Observer {
    7.     public abstract void change(DataCenter dataCenter); //负责发现数据变化
    9.     public abstract void updateSelf();  //更新数据
    10. }

    数据服务中心

    1. /**
    2.  * @author meikb
    3.  * @desc
    4.  * @date 2020-05-26 10:48
    5.  */
    6. public class DataCenter {
    7.     private List<Observer> observers = new ArrayList<>();
    9.     public void notifyObserver(){
    10.         observers.forEach(observer -> {
    11.             observer.updateSelf();
    12.         });
    13.     }
    15.     public void addData(Observer observer){
    16.         observers.add(observer);
    17.     }
    19.     @Override
    20.     public String toString() {
    21.         StringBuilder sb = new StringBuilder();
    22.         observers.forEach(observer -> {
    23.             DataObj dataObj =  (DataObj)observer;
    24.             sb.append(dataObj.getNum());
    25.         });
    26.         return sb.toString();
    27.     }
    28. }

    测试主函数

    1. /**
    2.  * @author meikb
    3.  * @desc
    4.  * @date 2020-05-26 11:02
    5.  */
    6. public class ObserverMain {
    7.     public static void main(String[] args) {
    8.         DataCenter center = new DataCenter();
    10.         DataObj dataObj1 = new DataObj(1);
    11.         center.addData(dataObj1);
    12.         DataObj dataObj2 = new DataObj(2);
    13.         center.addData(dataObj2);
    14.         DataObj dataObj3 = new DataObj(3);
    15.         center.addData(dataObj3);
    17.         dataObj1.change(center);
    20.         System.out.println(center);
    21.     }
    22. }