设计模式(三) 观察者模式

一:定义观察者接口,定义更新的方法

public interface Observer {
    void update();
}

二:定义操作者接口

public interface Operator {
    public void addObserver(Observer obserber);
    public void deleteObserver(Observer obserber);
    public void notifyAllObservers();
    public void operate();

}

三:实现操作者接口抽象类

这里使用vector作为观察者合集,因为Vector是线程安全的,如果使用Arraylist建议使用同步锁.

notifyAllObservers()中使用了三种遍历Vector的方法,三选一即可.

public abstract class  AbstractOperator implements Operator {

    Vector<Observer> vector = new Vector<>();
    //ArrayList  list = new ArrayList(); 也可以用List 线程不安全,与synchronized结合使用


    @Override
    public void addObserver(Observer obserber) {
        vector.add(obserber);
    }

    @Override
    public void deleteObserver(Observer obserber) {
        vector.remove(obserber);
    }

    @Override
    public void notifyAllObservers() {
        int size = vector.size();
        //1.遍历1
        for (int i = 0; i < size; i++) {
            Observer observer = vector.get(i);
            observer.update();
        }

        //2.遍历2
        Enumeration<Observer> elements = vector.elements();
        while (elements.hasMoreElements()) {
            Observer observer = elements.nextElement();
            observer.update();
        }


        //3.遍历3
        Iterator<Observer> iterator = vector.iterator();
        while(iterator.hasNext()) {
            Observer observer = iterator.next();
            observer.update();
        }


    }

}

四:定义操作者实体类

public class MyOpertor extends AbstractOperator {
    @Override
    public void operate() {
        System.out.println("操作数据");
        notifyAllObservers();
    }
}

五:不同观察者实现类

public class ObserVerA implements Observer{
    @Override
    public void update() {
        System.out.print("这是A的操作");
    }
}

public class ObserverB implements Observer {
    @Override
    public void update() {
        System.out.print("这是B的操作");
    }
}

六:调用

       MyOpertor myOpertor = new MyOpertor();
        ObserVerA obserVerA = new ObserVerA();
        ObserverB observerB = new ObserverB();

        myOpertor.addObserver(obserVerA);
        myOpertor.addObserver(observerB);

        myOpertor.notifyAllObservers();

优化版:

Observer

public interface ObserVer {
    void onchange();
}

Optionor:
 

public abstract class Optionor<T> {

    Vector<T> vector;

    public void registor() {
        if (vector == null) {
            vector = new Vector<T>();
        }
    }

    public void add(T verctor) {
        vector.add(verctor);
    }

    public void remove(T verctor) {
        vector.remove(verctor);
    }

    public void removeRegistor() {
        if (vector != null) {
            vector.clear();
        }
    }

}

AbStracOptionor:

public abstract class AbStracOptionor extends Optionor<Observer> {

    public void notifyAllDataChange() {
        Enumeration<Observer> elements = vector.elements();
        if(elements.hasMoreElements()) {
            elements.nextElement().update();
        }
    }

}

一般观察者遵循,随用随取原则,不用就立即销毁的原则.如果AbstractOperator 中增加register 和 unregister 方法就更加完美了,当我们不需要观察者观察操作者数据操作时,我们就移除观察者,便于优化我们的系统,及时的释放内存.安卓中的ListView 中的适配器BaseAdapter 数据绑定就采用了这种模式,具体见博客 https://blog.csdn.net/startCrazyActivity/article/details/81260581

欢迎大家留言评论相互学习.