Design pattern---观察者模式

观察者模式：发布/订阅模式，当某对象（被观察者）状态发生改变时所有订阅该对象的观察者对象（观察者）都将更新自己

成员（4种）：

1.抽象被观察者：将所有的观察者对象的引用存入一个集合，并且定义了添加 / 删除 / 更新观察者的接口，每一个被观察者都可以有若干个观察者。

2.具体被观察者：实现了抽象被观察者的各种方法，将观察者的具体状态存入具体观察者对象；当被观察者对象的状态发生改变时，通过更新观察者的方法调用观察者的更新方法更新具体观察者的状态

3.抽象观察者：定义了抽象的更新状态的方法

4.具体观察者：实现了抽象观察者的更新方法

最后在需要更新观察者状态的地方调用被观察者的更新状态的方法即可实现对所有观察者状态的更新

//抽象被观察者
public interface MyObservable  {

    void add(MyObserver observer);
    void remove(MyObserver observer);
    void notifyMyObserver(String str);
}

//具体被观察者
public class MyConcreateObservable implements MyObservable {
    private List<MyObserver> observers=new ArrayList<>();

    @Override
    public void add(MyObserver observer) {
        observers.add(observer);
    }

    @Override
    public void remove(MyObserver observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyMyObserver(String str) {
        for (MyObserver observer:observers){
            observer.update(str);
        }
    }
}

//抽象观察者
public interface MyObserver {

    void update(String str);
}

//具体观察者
public class MyConcreateObserver implements MyObserver{

    @Override
    public void update(String str) {
        Log.e("update",str);
    }
}

 点击btn_observers 同时更新所有订阅了的观察者的状态

       //定义观察者
        MyObserver myObserver1 = new MyConcreateObserver();
        MyObserver myObserver2 = new MyConcreateObserver();
        MyObserver myObserver3 = new MyConcreateObserver();

        final MyObservable myObservable = new MyConcreateObservable();
        //添加观察者
        myObservable.add(myObserver1) ;
        myObservable.add(myObserver2);
        myObservable.add(myObserver3);

        findViewById(R.id.btn_observers).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //更新观察者
                myObservable.notifyMyObserver("BABANANA");
            }
        });

 优点：将具体观察者与具体被观察者之间进行了解耦，使具体的观察者或被观察者分别依赖于他们的抽象类

 缺点：但是抽象被观察者仍然依赖于抽象观察者

使用对象：1.一个对象的改变需要改变其他对象的状态时，而且被改变的对象数量未知

                  2.一个对象分为两个方面，一方面依赖于另一个方面时，可以将这两个方面各自封装在独立的对象中