观察者模式-监听变量变化

需求：Java在一个A类中监听另一个B类里面一个整形变量N的变化，B类中N值一变化，A就得到这个变化的值

实现：这里用观察者模式来实现，话不多说，直接上代码。

1.首先定义更新监听器 UpdateListener

public interface UpdateListener {
    /**
     * 监听更新操作
     * @param n
     */
    void update(int n);
}

2.定义监听器管理接口 Subject

public interface Subject {
    /**
     * 添加更新监听器
     * @param updateListener
     */
    public void addUpdateListener(UpdateListener updateListener);

    /**
     * 移除更新监听器
     * @param updateListener
     */
    public void delUpdateListener(UpdateListener updateListener);

    /**
     * 通知所有的更新监听器
     * @param n
     */
    public void notifyAllUpdateListener(int n);

    /**
     * 自身的操作
     */
    public void operation();
}

3.监听器管理接口的实现类 AbstractSubject

public abstract class AbstractSubject implements Subject {
    private Vector<UpdateListener> vector = new Vector<UpdateListener>();

    /**
     * 添加更新监听器
     *
     * @param updateListener
     */
    @Override
    public void addUpdateListener(UpdateListener updateListener) {
        vector.add(updateListener);
    }

    /**
     * 移除更新监听器
     *
     * @param updateListener
     */
    @Override
    public void delUpdateListener(UpdateListener updateListener) {
        vector.remove(updateListener);
    }

    /**
     * 通知所有的更新监听器
     *
     * @param n
     */
    @Override
    public void notifyAllUpdateListener(int n) {
        Iterator<UpdateListener> iterator = vector.iterator();
        while (iterator.hasNext()) {
            UpdateListener listener = iterator.next();
            listener.update(n);
        }
    }

}

 4.要被监听的B类，继承 AbstractSubject

public class B extends AbstractSubject {
    private int n;

    public int getN() {
        return n;
    }

    public void setN(int n) {
        this.n = n;
    }

    /**
     * 更新变量n的值
     */
    @Override
    public void operation() {
        for (int i = 0; i < 10; i++) {
            //更新变量的值
            ++n;
            System.out.println("B中的变量n的值为：" + n);
            notifyAllUpdateListener(n);
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 5.最后在我们的主类A中给B类添加更新监听器。这样就实现了我们文章开头的需求啦。

public class A {

    public static void main(String[] args) {
        B b = new B();
        b.addUpdateListener(new UpdateListener() {
            @Override
            public void update(int n) {
                System.out.println("监听到B类中变量n的值更新为：" + n);
            }
        });

        b.operation();
    }
}

很简单和常见的一个需求，代码虽少，但是一开始自己总是忘记，所以按照整体思路，自己敲一遍，理解起来更容易。