观察者模式

观察者模式

为什么需要观察者模式？

一个对象的改变需要同时改变其他对象的模式（不知道需要具体改变多少对象）。

一个系统被分割成一系列相互协助的类，我们需要维护对象的一致性，也就是改变某个对象的时候需要改变其他对象，我们不希望为了维护一致性而使各类紧密耦合。

什么是观察者模式？

观察者模式可以抽象成，自变量对象即通知者，因变量对象即观察者，两者之间不依赖于具体的对象，而是依赖于抽象，依赖于接口。自变量与因变量是一对多的关系。这个一对多的“多”不仅仅是同一类型，而是不同类型的观察者，这里只举同一类型的例子。

观察者模式的抽象实现

逻辑说明：抽象的通知类拥有抽象的观察者集合，具体的通知类可设置不同的状态，抽象的观察者有一个更新状态的方法，具体的观察者实现相应的方法。每次具体的通知类改变状态后，则遍历观察者集合根据通知者状态做出不同的改变。

uml图

抽象的通知类

public abstract class Subject {

    private List<Observer> observers = new ArrayList<Observer>();

    public void add(Observer observer){
        observers.add(observer);
    }

    public void delete(Observer observer){
        observers.remove(observer);
    }

    public void MyNotify(){
        for (Observer observer : observers) {
            observer.update();
        }
    }
    
}

具体的通知类

public class ConcreteSubject extends Subject{

    private String state;//状态

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

抽象的观察者接口

public interface Observer {
    public abstract void update();
}

具体的观察者接口

public class ConcreteObserver implements Observer{

    private String name;

    private String state;

    private ConcreteSubject subject;

    public ConcreteObserver(String name, ConcreteSubject subject) {
        this.name = name;
        this.subject = subject;
    }

    @Override
    public void update() {
        this.state = subject.getState();
        System.out.println("观察者"+name+"新状态是"+state);
    }
}

客户端类

public class App {
    public static void main(String[] args) {

        ConcreteSubject subject = new ConcreteSubject();

        subject.add(new ConcreteObserver("摸鱼man",subject));
        subject.add(new ConcreteObserver("工作man",subject));
        subject.add(new ConcreteObserver("睡觉man",subject));

        subject.setState("996");
        subject.MyNotify();
    }
}

不足之处

抽象的通知者还是依赖于抽象的通知者。

改进方法

在抽象的通知类添加一个委托方法A，在客户端类中进行将具体的观察者的不同方法委托到方法A中，因此抽象的通知者类中不再依赖抽象的观察者。委托通过反射实现。