观察者模式（Observer）

观察者模式

一. 观察者模式

1.1 定义

• 定义对象间一种一对多的依赖关系，使得当每一个对象改变状态，则所有依赖于他的对象都会得到通知，并自动更新.

1.2 角色

• 抽象观察者角色（IObserver）.
• 抽象被观察者角色（ISubject）.
• 具体观察者角色（Observer）.
• 具体被观察者角色（Subject）.

1.3 模式

• 拉模式：只通知是否变化而没有具体细节.
• 推模式：会通知具体细节.

二. 具体实现

2.1 创建观察者抽象接口

    public interface IObserver {
        void update();
    }

2.2 创建具体观察者

    public class ObserverA implements IObserver {
        @Override
        public void update() {
            System.out.println("ObserverA update ...");
        }
    }
    public class ObserverB implements IObserver {
        @Override
        public void update() {
            System.out.println("ObserverB update ...");
        }
    }

2.3 创建被观察者对象

    public class Subject {
        List<IObserver> observerList = new ArrayList<>();
        public void addObserver(IObserver observer){
            if(!observerList.contains(observer)){
                observerList.add(observer);
            }
        }
        public void change (){
            System.out.println("Subject change ...");
            notifyObservers();
        }
        public void notifyObservers(){
            for(IObserver observer : observerList){
                observer.update();
            }
        }
    }

2.4 调用

    public static void main(String[] args) {
        Subject subject = new Subject();
        IObserver observerA = new ObserverA();
        IObserver observerB = new ObserverB();
        subject.addObserver(observerA);
        subject.change();
        subject.addObserver(observerB);
        subject.change();
    }

2.5 输出

    Subject change ...
    ObserverA update ...
    Subject change ...
    ObserverA update ...
    ObserverB update ...

三. 优缺点

3.1 优点

• 观察者与被观察者抽象耦合，容易扩展.
• 建立了一套触发机制.

3.2 缺点

• 循环依赖会导致系统崩溃.
• 观察者太多会浪费时间.

四. 源码

    https://github.com/Seasons20/DisignPattern.git