基本要点

1、定义
它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新

2、使用场景
当一个对象与多个对象存在一对多的依赖关系，并且此对象发生变化时，它需要通知到其他对象，这时，我们就要使用观察者模式
例如，很多客户订阅了”LOL赛事”，当有比赛进行时，我们就会给这些客户推送消息

3、角色
观察者（Observer）：将自己注册到被观察对象中，被观察对象将观察者存放在一个容器里，就如例子中的客户

被观察者（Subject）：被观察对象发生了某种变化，从容器中得到所有注册过的观察者，将变化通知观察者，此处就是LOL赛事

4、通知观察者的方式分为被观察者主动推送、观察者主动获取两种

代码样例

首先我们定义观察者

/**
 * 观察者接口
 */
public interface Observe {
    void update(Subject subject);
}

/**
 * 具体观察者
 */
class ObserveA implements Observe {
    // 观察者自身的属性
    private int myState;

    @Override
    public void update(Subject subject) {
        myState = ((ConcreteSubject) subject).getState();
    }

    public int getMyState() {
        return myState;
    }

    public void setMyState(int myState) {
        this.myState = myState;
    }
}

然后我们再订阅被观察者

import java.util.ArrayList;
import java.util.List;

/**
 * 被观察者
 */
public class Subject {
    // 定义一个容器，来存放观察者
    protected List<Observe> list = new ArrayList<>();

    // 提供新增观察者和移除观察者的方法
    public void registerObserve(Observe observe) {
        list.add(observe);
    }

    public void removeObserve(Observe observe) {
        list.remove(observe);
    }

    // 通知所有观察者更新状态
    public void notifyAllObserve() {
        for (Observe obs: list) {
            obs.update(this);
        }
    }
}

public class ConcreteSubject extends Subject{
    // 定义一个状态属性
    private int state;

    public int getState() {
        return state;
    }

    // 一旦状态属性发生变化，那么就通知所有的观察者
    public void setState(int state) {
        this.state = state;
        this.notifyAllObserve();
    }
}

最后我们写一个测试类进行测试吧

public class Client {
    public static void main(String[] args) {
        // 创建被观察者
        ConcreteSubject subject = new ConcreteSubject();

        // 创建观察者
        ObserveA observe1 = new ObserveA();
        ObserveA observe2 = new ObserveA();
        ObserveA observe3 = new ObserveA();

        // 将这三个观察者加入被观察者的订阅队伍中
        subject.registerObserve(observe1);
        subject.registerObserve(observe2);
        subject.registerObserve(observe3);

        // 改变被观察者subject对象的属性，然后查看被观察者是否接收到通知
        subject.setState(100);
        System.out.println(observe1.getMyState());
        System.out.println(observe2.getMyState());
        System.out.println(observe3.getMyState());
    }
}

运行结果如下

Observable类和Observe接口

Java中实际上是提供了java.util.Observable和java.util.Observe给我们实现观察者模式
以下是我们的代码demo

import java.util.Observable;

/**
 * 被观察对象
 */
public class ConcreteSubject extends Observable {
    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;

        // 表示目标对象已经做了更改
        setChanged();
        // 当被观察者对象的属性发生变化后，我们调用方法类封装好的方法通知所有观察者
        notifyObservers();
    }
}

import java.util.Observable;
import java.util.Observer;

/**
 * 观察者
 */
public class ObserveA 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;
    }
}

public class Client {
    public static void main(String[] args) {
        // 创建被观察者
        ConcreteSubject subject = new ConcreteSubject();

        // 创建观察者
        ObserveA observe1 = new ObserveA();
        ObserveA observe2 = new ObserveA();
        ObserveA observe3 = new ObserveA();

        // 将这三个观察者加入被观察者的订阅队伍中
        subject.addObserver(observe1);
        subject.addObserver(observe2);
        subject.addObserver(observe3);

        // 改变被观察者subject对象的属性，然后查看被观察者是否接收到通知
        subject.setState(100);
        System.out.println(observe1.getMyState());
        System.out.println(observe2.getMyState());
        System.out.println(observe3.getMyState());
    }
}