观察者模式

                                                                           观察者模式

1. 概述

　　　　观察者模式定义了一种一对多的关系，让多个观察者同时监听某个主题，当某个主题发生变化的时候会通知所有的观察者，然他们自动更新。

     2.  解决问题

　　　　将一个系统分割成一系列相互协作的类有一个很不好的副作用，当系统需要维护的时候就要维护系统的一致性，我们不希望为了维护系统的一致性而使各类紧密耦合，这样　　　　      会给系统的维护，扩展等带来不便。

     3. 角色

　　　　抽象主题(subject):它是一个抽象的类或者借口，它把所有观察者的引用保存到一个集合中，同时提供增加和移除观察者的方法，最重要的是通知所用观察者的方法。

　　　　具体主题(ConcreteSubject):继承或者实现抽象主题的类，主要保存当前状态，当状态发生变化的时候，通知所有已经登记过的观察者。

　　　　抽象观察者(Observer):一个抽象的接口，为所有就具体的观察者提供一个更新自己的方法。

　　　　具体观察者(ConcreteObserver):一个具体的实现类，主要实现抽象观察者的更新自己的方法，以便与主题的状态相协调。

　　4. 结构图

                       

　　5. 结构图中的代码

　　

　　　　抽象主题类

import java.util.ArrayList;


public class Subject {
    
    private ArrayList<Observer> mObservers = new ArrayList<>();
    
    //添加观察者
    public void add(Observer observer){
        mObservers.add(observer);
    }
    
    //移除观察者
    public void delete(Observer observer){
        mObservers.remove(observer);
    }
    
    //通知观察者更新
    public void notifyall(){
        for(Observer observer:mObservers){
            observer.update();
        }
    }
}

 

　　　　

　　　　抽象观察者

public interface Observer {
    
    public void update();

}

 

　　　　具体主题

public class ConcreteSubject extends Subject {
    
    private int mSubjectState = 0;
    public static int STATE_NOMAL = 0;
    public static int STATE_CHANGE = 1;
    
    public int getSubjectState() {
        return mSubjectState;
    }
    public void setSubjectState(int state) {
        mSubjectState = state;
    }

}

 

　　　　具体观察者

public class ConcreteObserver1 implements Observer{
    
    public int state = 0;
    
    public int getState() {
        return state;
    }

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

    @Override
    public void update() {
        System.out.println("状态改变");
    }

}

 

public class ConcreteObserver2 implements Observer {
    
    public int state = 0;

    public int getState() {
        return state;
    }

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

    @Override
    public void update() {
        System.out.println("状态改变");
    }

}

客户端

public class Client {

    public static void main(String[] args) {
        Observer observer1 = new ConcreteObserver1();
        Observer observer2 = new ConcreteObserver2();
        Subject subject = new ConcreteSubject();
        subject.add(observer1);
        subject.add(observer2);
        subject.notifyall();
    }
}

 

1. 总结
   1. 优点:降低系统中各类的耦合度，方便系统的扩展和维护
   2. 缺点:抽象的主题还是依赖于抽象的观察者,当然，在C#中可以通过委托事件，实现真正的解耦。