发布-订阅模式：观察者就是一个监听者，类似监听器的存在，一旦被观察者/监听的目标发生的情况，就会被监听者发现，目标将情况发送到观察者
    观察者模式多用于实现订阅功能的场景

    1. /**
    2.  * 观察者
    3.  */
    4. public interface Observer {
    6.     void update(String message, String name);
    7. }
    1. /**
    2.  * 便衣人1
    3.  */
    4. public class Civies1 implements Observer {
    6.     @Override
    7.     public void update(String message, String name) {
    8.         System.out.println(name + "有情况" + message);
    9.     }
    10. }
    12. /**
    13.  * 便衣人2
    14.  */
    15. public class Civies2 implements Observer {
    17.     @Override
    18.     public void update(String message, String name) {
    19.         System.out.println(name + "有情况" + message);
    20.     }
    21. }
    1. /**
    2.  * 目标接口
    3.  */
    4. public interface Target {
    6.     void addObserver(Observer observer);
    8.     void rmOberver(Observer observer);
    10.     void notice(String message);
    11. }
    1. /**
    2.  * 嫌犯1
    3.  */
    4. public class Suspect1 implements Target {
    6.     private String name = "嫌犯1";
    8.     //观察者集合
    9.     private List<Observer> list = new ArrayList<>();
    11.     @Override
    12.     public void addObserver(Observer observer) {
    13.         if (!list.contains(observer)) {
    14.             list.add(observer);
    15.         }
    16.     }
    18.     @Override
    19.     public void rmOberver(Observer observer) {
    20.         if (list.contains(observer)) {
    21.             list.remove(observer);
    22.         }
    23.     }
    25.     @Override
    26.     public void notice(String message) {
    27.         list.forEach(observer -> observer.update(message, name));
    28.     }
    29. }
    1. /**
    2.  * 嫌犯2
    3.  */
    4. public class Suspect2 implements Target {
    6.     private String name = "嫌犯2";
    8.     private List<Observer> list = new ArrayList<>();
    10.     @Override
    11.     public void addObserver(Observer observer) {
    12.         if (!list.contains(observer)) {
    13.             list.add(observer);
    14.         }
    15.     }
    17.     @Override
    18.     public void rmOberver(Observer observer) {
    19.         if (list.contains(observer)) {
    20.             list.remove(observer);
    21.         }
    22.     }
    24.     @Override
    25.     public void notice(String message) {
    26.         list.forEach(item -> item.update(message, name));
    27.     }
    28. }
    1. public class Clienter {
    3.     public static void main(String[] args) {
    4.         //定义2个嫌犯
    5.         Suspect1 suspect1 = new Suspect1();
    6.         Suspect2 suspect2 = new Suspect2();
    7.         //定义2个便衣
    8.         Observer civies1 = new Civies1();
    9.         Observer civies2 = new Civies2();
    10.         //增加嫌犯便衣观察
    11.         suspect1.addObserver(civies1);
    12.         suspect1.addObserver(civies2);
    13.         suspect2.addObserver(civies1);
    14.         suspect2.addObserver(civies2);
    16.         //定义嫌犯的情况
    17.         String message1 = "又卖了一批货";
    18.         String message2 = "老大来视察了";
    19.         suspect1.notice(message1);
    20.         suspect2.notice(message2);
    22.     }
    23. }