观察者模式

　　观察者模式，又叫发布-订阅模式。

　　观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象在状态发生变化时，会通知所有的观察者对象，使他们能够自动更新自己。

　　

　　我们来看具体的代码实现，首先是抽象的通知者以及他的实现类：

　　

package observer;

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

public abstract class Subject {
    private List<Observer> observers = new ArrayList<Observer>();
    private String subject;

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

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

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

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }
}

public class ConcreteSubject extends Subject{

}

　　然后是抽象的观察者以及它的实现：

　　

package observer;

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

public class ConcreteObserver extends Observer{
    
    private String name;
    private String observerState;
    private Subject subject;
    
    public ConcreteObserver(Subject subject,String name){
        this.subject = subject;
        this.name = name;
    }
    
    @Override
    public void update() {
        observerState = subject.getSubject();
        System.out.println("观察者 "+name+" 的新状态是："+observerState);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getObserverState() {
        return observerState;
    }

    public void setObserverState(String observerState) {
        this.observerState = observerState;
    }

    public Subject getSubject() {
        return subject;
    }

    public void setSubject(Subject subject) {
        this.subject = subject;
    }
    
}

　　客户端调用类如下：

　　

public class MainClass {
    public static void main(String[] args) {
        Subject subject = new ConcreteSubject();
        
        subject.attachObserver(new ConcreteObserver(subject, "A"));
        subject.attachObserver(new ConcreteObserver(subject, "B"));
        subject.attachObserver(new ConcreteObserver(subject, "C"));
        
        subject.setSubject("哈哈");
        subject.notifyObserver();
        
    }
}

　　将一个系统分割成一些列相互协作的类有一个很不好的副作用，那就是需要维护相关对象间的一致性，我们不希望为了维持一致性而使各类精密耦合，这样会给维护、扩展和重用都带来不便。

　　一个subject可以有任意数量依赖它的Observer，一旦Subject的状态发生了改变，其他的观察者都会得到通知，subject发出通知时并不知道谁是它的Observer。

　　那么观察者模式在什么时候使用呢？当一个对象的改变需要同时改变其他对象的时候，而且它不知道具体有多少对象改变的时候，应该考虑使用观察者模式。

　　一个抽象模型有两个方面，其中一方面依赖于另一方面，这时使用观察者模式可以将这两者封装在独立的对象中使他们各自独立的改变和复用。

　　观察者模式所做的工作其实就是在解除耦合，让耦合的双方都依赖于抽象，而不是依赖于具体。从而使得各自的变化都不会影响到另一边的变化。