模式笔记——观察者模式

    观察者模式，以前看过，今天想了一下，似乎有点模糊了，回顾一下，再加之以笔记，以备……

    行为模式，为实现此模式，应该具备这几个角色：被观察的主题，观察者。这是必须的！一般来说，为使构建的东西有一定的可用性，会进行进一步的分工。主题角色再分为抽象主题和具体主题，同样滴划分观察者角色为抽象观察者及具体观察者角色。这就是将在此文中提及的 Subject, ConcreteSubject, Observer, ConcreteObserver。
    按照《JAVA 与模式》书来的，实现了最简单的两个版本。
版本一：
    /** 抽象主题角色，属于被观察者 */
    public interface Subject {
        /**
         * 登记一个新的观察者对象
         */
        public void attach(Observer observer);
        /**
         * 删除一个观察者对象
         */
        public void detach(Observer observer);
        /**
         * 通知所有登记过的观察者对象
         */
        void notifyObservers();
    }

    /** 具体主题角色，属于被观察者 */
    public class ConcreteSubject implements Subject {        
        private Vector observersVector = new Vector();
        /** 这里省略了几个方法的实现，无非是往向量中添加 Observer, 没什么好写的 */  
        /**
         * 通知所有登记过的观察者对象
         * 这里和书有一点点的不一样，我用的是 Iterator 接口来实现
         * 书上的是 Enumeration ，但大同小异。
         */
        public void notifyObservers() {
            Iterator it = observersVector.iterator();
            while(it.hasNext()) {
                ((Observer)it.next()).update();
            }
        }
    }

    /** 抽象观察者角色 */
    public interface Observer {
        /**
         * 调用这个方法会更新自己
         */
        void update();
    }

    /** 具体观察者角色 */
    public class ConcreteObserver implements Observer {
        /**
         * 调用这个方法会更新自己
         */
        public void update() {
            System.out.println(this + "   I am notified");
        }
    }

    客户端的 main() 如下：
    public static void main(String[] args) {
        Subject subject = new ConcreteSubject();
        Observer observer1 = new ConcreteObserver();
        Observer observer2 = new ConcreteObserver();
        subject.attach(observer1);
        subject.attach(observer2);
        subject.notifyObservers();
    }

    版本一的实现基本上与书上的没有什么不同，而版本二则有一点点的不一样。版本二只改变了版本一中的两个被观察者的一些细节。在此贴上：

    /**
     * 这是一个重量级的抽象主题角色，将子类的一些方法移至此
     * 增加了抽象类的重量而减少了具体主题类的分量
     */
    public abstract class Subject {        
        /**
         * 保存所有对观察者对象的引用
         */
        private Vector observersVector = new Vector();
        
        /**
         * 更改主题的状态
         *   在书上没有该方法，为了在客户端能够用基类声明对象，将该方法的声明移至此
         */
        public abstract void change(String newState);

        /** 在这里也把往主题角色中添加/删除观察者对象的方法省略了 */  

        /**
         * 通知所有登记过的观察者对象
         */
        public void notifyObservers() {
            Iterator it = observersVector.iterator();
            while(it.hasNext()) {
                    ((Observer)it.next()).update();
            }
        }
    }

    /**
     * 轻量级的具体主题类角色
     */
     public class ConcreteSubject extends Subject {
        
        private String state;
        
        /**
         * 更改主题的状态
         */
        public void change(String newState) {
            state = newState;
            this.notifyObservers();        
        }
    }
    客户端的代码是完全一样的。


    其实这样一个模式是相对比较简单的，当然，简单并不意味着力量不大，呵呵。用另外一个形式来表示：

    public class 被观察者 {

        public void 通知观察者() {

            观察者对象.有情况发生();

        }

    }

    public class 观察者 {

        public void 有情况发生() {

            /* 在这里做你想做的事情 */

        }

    }

    当再把这两个类分解成抽象的和具体的后，一个相对完整的观察者模式的实现就出来了。呵呵！~！~！~