Android - 设计模式-观察者

什么是观察者模式？

自我总结：被观察者状态改变时通知观察者

代码举例

版本1-初版：

1、定义被观察者（被观察者集合泛型为观察者）内置3个方法 增、删、通知
2、定义观察者
3、执行通知

//1、定义被观察者
public class MyObservable {
    //观察者用List存储，方便统一通知
    List<MyObserver> observerList = new ArrayList();

    //添加
    public void add(MyObserver observer) {
        observerList.add(observer);
    }

    //移除
    public void remove(MyObserver observer) {
        observerList.remove(observer);
    }

    public void notifyObservers() {
        //增强for,逐个通知
        for (MyObserver obs : observerList) {
            obs.update();
        }
    }
}

//2、定义观察者
public class MyObserver {
    public void update() {
        Log.i("Observer", "收到通知");
    }
}

//3、执行通知
public class NotifyActivity extends Activity{
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //创建被观察者
        MyObservable observable = new MyObservable();
        //创建观察者
        MyObserver observerA = new MyObserver();
        MyObserver observerB = new MyObserver();
        //添加
        observable.add(observerA);
        observable.add(observerB);
        //移除
        observable.remove(observerA);
        //通知
        observable.notifyObservers();
    }
}

版本2-通用版本：

1、定义被观察者接口
2、定义被观察者
3、定义观察者接口
4、定义观察者
5、执行通知

//1、定义被观察者接口
interface InterfaceMyObservable {
    //添加观察者
    void addMyObserver(InterfaceMyObserver interfaceMyObserver);

    //移除观察者
    void removeMyObserver(InterfaceMyObserver interfaceMyObserver);

    //通知观察者
    void notifyMyObservers();
}

//2、定义被观察者
public class MyObservable implements InterfaceMyObservable {
    //集合
    List<InterfaceMyObserver> list = new ArrayList<>();

    //添加观察者
    @Override
    public void addMyObserver(InterfaceMyObserver interfaceMyObserver) {
        list.add(interfaceMyObserver);
    }

    //移除观察者
    @Override
    public void removeMyObserver(InterfaceMyObserver interfaceMyObserver) {
        list.remove(interfaceMyObserver);
    }

    @Override
    public void notifyMyObservers() {
        //增强for，通知观察者
        for (InterfaceMyObserver obs : list) {
            obs.upDate();
        }
    }
}

/

/3、定义观察者接口
interface InterfaceMyObserver {
    void upDate();
}

//4、定义观察者
public class MyObserver implements InterfaceMyObserver {
    @Override
    public void upDate() {
        Log.i("tag", "收到通知");
    }
}

//5、通知观察者
public class Notify {
    public static void main(String[] args) {
        //创建被观察者
        MyObservable myObservable = new MyObservable();
        //创建观察者
        MyObserver myObserver = new MyObserver();
        MyObserver myObserverA = new MyObserver();
        //将观察者添入集合
        myObservable.addMyObserver(myObserver);
        myObservable.addMyObserver(myObserverA);
        //通知观察者
        myObservable.notifyMyObservers();
    }
}

版本3-JDK版：(jdk版本增加了多线程处理，实现了线程安全)

1、定义被观察者
2、定义观察者
3、执行通知

//1、定义被观察者
public class JdkObervable extends Observable {
    public void perfrom(String notify) {
        //当changed属性为true时才更行观察者
        this.setChanged();
        //this.clearChanged();
        this.notifyObservers(notify);
    }
}

//2、定义观察者
public class JdkObserver implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        String argu = (String) arg;
        Log.i("tag", argu);
    }
}

//3、执行通知
public class JdkNotify {
    public static void main(String[] args) {
        //创建被观察者
        JdkObervable jdkObervable = new JdkObervable();
        JdkObserver jdkObserverA = new JdkObserver();
        JdkObserver jdkObserverB = new JdkObserver();
        //添加
        jdkObervable.addObserver(jdkObserverA);
        jdkObervable.addObserver(jdkObserverB);
        //移除
        jdkObervable.deleteObserver(jdkObserverA);
        //通知观察者
        jdkObervable.perfrom("通知");
    }
}

文章由个人搜集资料总结，如有错误，欢迎指证！