观察者模式：定义一种一对多的依赖关系，让多个观察者对象关联一个对象，当这个对象发生变化时，会通知所有观察者对象，让他们自动更新自己

    优点：自动更新状态，不需要额外执行

    实现：工作之余，同事之间会讨论股票，讨论NBA等，但是如果让老板看到，即使本职工作已经完成，老板依然会不爽。这时候，就有同事跟前台打好关系，当老板回来时，通知大家，让大家回归工作状态。

    1、抽象观察者、抽象通知者

    1. /**
    2.  * 抽象观察者
    3.  */
    4. public abstract class Observer {
    5.     /**
    6.      * 观察者名称
    7.      */
    8.     String name;
    10.     /**
    11.      * 通知类
    12.      */
    13.     Subject sub;
    15.     /**
    16.      * 修改方法
    17.      */
    18.     public abstract void update();
    19. }
    21. /**
    22.  * 抽象通知类
    23.  */
    24. public abstract class Subject {
    25.     /**
    26.      * 添加被通知观察者
    27.      */
    28.     public abstract void addObserver(Observer observer);
    30.     /**
    31.      * 移除被通知观察者
    32.      */
    33.     public abstract void deleteObserver(Observer observer);
    35.     /**
    36.      * 通知
    37.      */
    38.     public abstract void notifit();
    40.     /**
    41.      * 通知消息
    42.      */
    43.     String subjectStaff;
    45.     public String getSubjectStaff() {
    46.         return subjectStaff;
    47.     }
    49.     public void setSubjectStaff(String subjectStaff) {
    50.         this.subjectStaff = subjectStaff;
    51.     }
    52. }

    2、观察者实现

    1. /**
    2.  * 看NBA的员工
    3.  */
    4. public class ObserverStaffNba extends Observer{
    5.     public ObserverStaffNba(String name , Subject sub){
    6.         super.name = name;
    7.         super.sub = sub;
    8.     }
    10.     /**
    11.      * 修改方法
    12.      */
    13.     public void update(){
    14.         System.out.println(MessageFormat.format("{0}，{1}关闭NBA，开始工作", sub.getSubjectStaff() , this.name));
    15.     }
    16. }
    18. /**
    19.  * 看股票的员工
    20.  */
    21. public class ObserverStaffShares extends Observer{
    22.     public ObserverStaffShares(String name , Subject sub){
    23.         super.name = name;
    24.         super.sub = sub;
    25.     }
    27.     /**
    28.      * 修改方法
    29.      */
    30.     public void update(){
    31.         System.out.println(MessageFormat.format("{0}，{1}关闭股票，开始工作", sub.getSubjectStaff() , this.name));
    32.     }
    33. }

    3、通知者实现

    1. /**
    2.  * 前台
    3.  */
    4. public class SubjectReception extends Subject{
    5.     List<Observer> list = new ArrayList<>();
    6.     public void addObserver(Observer observer){
    7.         list.add(observer);
    8.     }
    10.     public void deleteObserver(Observer observer){
    11.         list.remove(observer);
    12.     }
    15.     public void notifit(){
    16.         list.forEach(observer -> {
    17.             observer.update();
    18.         });
    19.     }
    20. }

    4、测试

    1. /**
    2.  * 测试观察者模式
    3.  */
    4. public class TestObserver {
    6.     public static void main(String [] args){
    7.         Subject subject = new SubjectReception();
    8.         subject.addObserver(new ObserverStaffNba("张三", subject));
    9.         subject.addObserver(new ObserverStaffShares("李四", subject));
    11.         subject.setSubjectStaff("老板来了");
    12.         subject.notifit();
    13.     }
    14. }

    测试结果：
    image.png

    观察者模式又成为发布-订阅模式，Subject作为一个通知类，把对应观察者放在一个集合里面，当通知类发生一定变化时，统一执行观察者集合。观察者模式的优势在于，当系统被分割成相互协作的类时，需要维护对象之间的一致性，可以避免因为维护一致性造成的各类紧耦合。