观察者模式

例如时间一到，同时可以预定可以选择班期

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
优点： 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。
缺点： 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而且仅仅只是知道观察目标发生了变化。

//被观察者
public class Subject {
    //观察者
    private List<Observer> observerList = new ArrayList<>();
    public void addObserver(Observer observer){
        observerList.add(observer);
    }
    public void updateAllObserver(){
        observerList.stream().forEach(observer -> {
            observer.update();
        });
    }

    //观察的属性
    @Getter
    private int state;
    public void setState(int state) {
        this.state = state;
        //修改值时修改所有Observer
        updateAllObserver();
    }
}

//观察的父类
public abstract class Observer {
    int i;
    protected Subject subject;
    public abstract void update();
}

//子类 这里写了两个
public class HexaObserver extends Observer{
   int i = 1;
   public HexaObserver(Subject subject){
      this.subject = subject;
      this.subject.addObserver(this);
   }
   @Override
   public void update() {
      i = i+subject.getState();
      System.out.println(i);
   }
}

public class OctalObserver extends Observer{
   int i = 0;
   public OctalObserver(Subject subject){
      this.subject = subject;
      this.subject.addObserver(this);
   }
   @Override
   public void update() {
     i = 1+subject.getState() + 2;
     System.out.println(i);
   }
}

//使用
public class ObserverPatternDemo {
   public static void main(String[] args) {
      Subject subject = new Subject();
 
      new HexaObserver(subject);
      new OctalObserver(subject);
 
      System.out.println("First state change: 15");   
      subject.setState(15);
   }
}