Effect

• Defines a one to many dependency between objects. When the state of an object changes, all objects that depend on it are notified and automatically updated.

When to use

• When the state of an object (target object) changes, all dependent objects (observer object) will be notified and broadcast.

Advantage

1. The observer and the observed are abstractly coupled.
2. Set up a trigger mechanism.

Example

• Create yourself

  /**
   * @Author: create_By: chenxin
   * @Data:Created in 2018/9/25 17:15
   * @Version:
   * @Acton:
   */
  public interface Observer {
  
      void update(Subject subject);
  }

  /**
   * @Author: create_By: chenxin
   * @Data:Created in 2018/9/25 17:16
   * @Version:
   * @Acton:
   */
  public class Subject {
  
      protected List<Observer> list = new ArrayList<>();
  
      public void registerObserver(Observer observer){
          list.add(observer);
      }
  
      public void removeObserver(Observer observer){
          list.remove(observer);
      }
  
      //Notify all observers to update status
      public void notifyAllObserver(){
          for (Observer observer : list) {
              observer.update(this);
          }
      }
  }

  /**
   * @Author: create_By: chenxin
   * @Data:Created in 2018/9/25 17:22
   * @Version:
   * @Acton:
   */
  public class ConreteSubject extends Subject {
  
      private int state;
  
      public int getState() {
          return state;
      }
  
      public void setState(int state) {
          this.state = state;
          this.notifyAllObserver();
      }
  }

  /**
   * @Author: create_By: chenxin
   * @Data:Created in 2018/9/25 17:29
   * @Version:
   * @Acton:
   */
  public class ObserverA implements Observer {
  
      private int myState;        //myState needs to be consistent with the state value of the target object
      @Override
      public void update(Subject subject) {
          myState = ((ConreteSubject)subject).getState();
      }
  
      public int getMyState() {
          return myState;
      }
  
      public void setMyState(int myState) {
          this.myState = myState;
      }
  }

  /**
   * @Author: create_By: chenxin
   * @Data:Created in 2018/9/25 16:02
   * @Version:
   * @Acton:
   */
  public class TestObserverDemo {
      public static void main(String[] args){
          test1();
      }
  
      public static void test1(){
          //create themes
          ConreteSubject subject = new ConreteSubject();
  
          //Create multiple observers
          ObserverA ob1 = new ObserverA();
          ObserverA ob2 = new ObserverA();
          ObserverA ob3 = new ObserverA();
  
          //Register all observers
          subject.registerObserver(ob1);
          subject.registerObserver(ob2);
          subject.registerObserver(ob3);
  
          //Setup state
          subject.setState(3000);
  
          //
          System.out.println(ob1.getMyState());
          System.out.println(ob2.getMyState());
          System.out.println(ob3.getMyState());
  
          System.out.println("#====================?====================");
          //Setup state
          subject.setState(30);
  
          //
          System.out.println(ob1.getMyState());
          System.out.println(ob2.getMyState());
          System.out.println(ob3.getMyState());
      }
  }

   

• Create according to the API provided by the system

  import java.util.Observable;
  import java.util.Observer;
  
  /**
   * @Author: create_By: chenxin
   * @Data:Created in 2018/9/25 18:51
   * @Version:
   * @Acton:
   */
  public class ObserverA implements Observer {
  
      private int myState;
  
      @Override
      public void update(Observable o, Object arg) {
          myState = ((ConcreteSubject)o).getState();
      }
  
      public int getMyState() {
          return myState;
      }
  
      public void setMyState(int myState) {
          this.myState = myState;
      }
  }

  import java.util.Observable;
  
  /**
   * @Author: create_By: chenxin
   * @Data:Created in 2018/9/25 18:41
   * @Version:
   * @Acton:
   */
  public class ConcreteSubject extends Observable {
  
      private int state;
  
      public void set(int s){
          state = s;          //Object target changed
  
          setChanged();       //Indicates that the target object has changed
  
          notifyObservers(state); //Notify all observers
      }
  
      public int getState() {
          return state;
      }
  
      public void setState(int state) {
          this.state = state;
      }
  }

  /**
   * @Author: create_By: chenxin
   * @Data:Created in 2018/9/25 18:30
   * @Version:
   * @Acton:
   */
  public class TestObserverDemo{
  
      public static void main(String[] args){
          test1();
      }
  
      public static void test1(){
          //Create target object
          ConcreteSubject subject = new ConcreteSubject();
  
          //Create observer
          ObserverA ob1 = new ObserverA();
          ObserverA ob2 = new ObserverA();
          ObserverA ob3 = new ObserverA();
  
          //Add to container of target object
          subject.addObserver(ob1);
          subject.addObserver(ob2);
          subject.addObserver(ob3);
  
          //Change the state of the subject object
          subject.set(20000);
  
          //The state of the observer has changed
          System.out.println(subject.getState());
          System.out.println(subject.getState());
          System.out.println(subject.getState());
  
          //Change the state of the subject object
          subject.set(50000);
  
          //The state of the observer has changed
          System.out.println(subject.getState());
          System.out.println(subject.getState());
          System.out.println(subject.getState());
  
      }
  }
  

   

Diagram structure

• Self created
  
• Created by system API