详解设计模式——观察者模式

观察者模式(Observer)

对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

类图：

• 1.抽象主题(Subject)角色：把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。
• 2.抽象观察者(Observer)角色：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。
• 3.具体主题(ConcreteSubject)角色：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。
• 4.具体观察者(ConcreteObserver)角色：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。通常用一个子类实现。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。

继续学习 

控件按钮、报警器等都是观察者模式。

1.  publicinterfaceSubject{

2.      //添加观察者

3.      void attach(Observer o);

4.      //删除观察者

5.      void detach(Observer o);

6.      //通知观察者

7.      void notifyObservers();

8.      //发生某事

9.      void doSomeThings()

10. }

1.  //观察者

2.  publicinterfaceObserver{

3.   

4.      void update();

5.  }

1.  publicclassConcreteSubjectimplementsSubject{

2.   

3.      ArrayList<Observer> observers=newArrayList<>();

4.   

5.      @Override

6.      publicvoid attach(Observer o){

7.          observers.add(o);

8.      }

9.   

10.     @Override

11.     publicvoid detach(Observer o){

12.         observers.remove(o);

13.     }

14.  

15.     @Override

16.     publicvoid notifyObservers(){

17.         for(Observer o: observers){

18.             o.update();

19.         }

20.     }

21.  

22.     publicvoid doSomeThings(){

23.         //doSomeThings

24.         notifyObservers();//通知观察者

25.     }

26. }

1.  //具体观察者

2.  publicclassConcreteObserverimplementsObserver{

3.      @Override

4.      publicvoid update(){

5.          System.out.println("我观察到subject发生了某事");

6.      }

7.  }

1.  publicstaticvoid main(String[] args){

2.          Subject cs=newConcreteSubject();

3.          //添加观察者

4.          cs.attach(newConcreteObserver());

5.          //subject发生了某事，通知观察者

6.          cs.doSomeThings();

7.      }

输出结果：

观察者模式优点：

• 1.观察者和被观察者是抽象耦合的。
• 2.建立一套触发机制。

观察者模式缺点：

• 1.如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
• 2.如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
• 3.观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

适用场景：

• 1.当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
• 2.当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
• 3.当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。

为了生产的安全，你决定为你的汽车工厂安装火警报警器，硬件完成了，现在你需要为这个报警器写个控制软件。用观察者模式试试吧。

为了生产的安全，你决定为你的汽车工厂安装火警报警器，硬件完成了，现在你需要为这个报警器写个控制软件。用观察者模式试试吧。

 

import java.util.ArrayList;

 

//安装火灾报警器的工厂

interface Factory {

    //添加火灾报警器

    void attach(Alarm alarm);

 

    //移除火灾报警器

    void detach(Alarm alarm);

 

    //通知报警器

    void nofityObserver();

 

    //发生火灾

    void fire();

    //...

}

 

//安装了报警器的工厂

class PorscheFactory implements Factory {

 

    ArrayList<Alarm> alarms = new ArrayList<>();

 

    @Override

    public void attach(Alarm alarm) {

        alarms.add(alarm);

    }

 

    @Override

    public void detach(Alarm alarm) {

        alarms.remove(alarm);

    }

 

    @Override

    public void nofityObserver() {

        for (Alarm alarm : alarms) {

            alarm.rang();

        }

    }

 

    @Override

    public void fire() {

       //补全,工厂发生火灾,通知报警器

      nofityObserver();

    }

}

 

//报警器(抽象观察者)

interface Alarm {

    void rang();

}

 

//火灾报警器(具体观察者)

class FireAlarm implements Alarm {

    //火灾报警器观察到工厂发行火灾鸣笛

    @Override

    public void rang() {

        System.out.println("发生工厂火灾了,鸣笛");

    }

}

 

public class Main {

 

    public static void main(String[] args) {

        Factory f = new PorscheFactory();

        //火灾报警器

        Alarm alarm = new FireAlarm();

        //补全,工厂安装火灾报警器

             f.attach(alarm);

        //补全,发生火灾了

        f.fire();

    }

 

}