GoF23种设计模式之行为型模式之观察者模式

一、概述
        定义对象之间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
二、适用性
1.当一个抽象模型有两个方面，其中一个方面依赖于另一方面的时候。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
2.当对一个对象的改变需要同时改变其它对象，而且不知道具体有多少对象需要改变的时候。
3.当一个对象必须通知其它对象，而它又不能假定其它对象是谁的时候。
三、参与者
1.Subject（目标）：目标知道它的观察者。可以有任意多个观察者观察同一个目标。提供注册和删除观察者对象的接口。
2.Observer（观察者）：为那些在目标发生改变时需要获得通知的对象定义一个更新接口。
3.ConcreteSubject（具体目标）：将有关状态存入各ConcreteObserver对象。当它的状态发生改变时,向它的各个观察者发出通知。
4.ConcreteObserver（具体观察者）：维护一个指向ConcreteSubject对象的引用。存储有关状态，这些状态应与目标的状态保持一致。实现Observer的更新接口以使自身状态与目标的状态保持一致。

四、类图

五、示例

Subject

1. package cn.lynn.observer;
2. import java.util.ArrayList;
3. import java.util.List;
4. public abstract class Citizen {
5. protected List<Policeman> polices;
6. private String action = "normal";
7. public String getAction() {
8. return action;
9. }
10. public void setAction(String action) {
11. this.action = action;
12. }
13. public void setPolices() {
14. polices = new ArrayList<Policeman>();
15. }
16. public void register(Policeman police) {
17. polices.add(police);
18. }
19. public void unregister(Policeman police) {
20. polices.remove(police);
21. }
22. public abstract void notify(String action);
23. }

Observer

1. package cn.lynn.observer;
2. public interface Policeman {
3. public void setOut(Citizen citizen);
4. }

ConcreteSubject

1. package cn.lynn.observer;
2. public class DongHuCitizen extends Citizen {
3. public DongHuCitizen(Policeman police) {
4. setPolices();
5. register(police);
6. }
7. @Override
8. public void notify(String action) {
9. setAction(action);
10. for (int i = 0; i < polices.size(); i++) {
11. Policeman police = polices.get(i);
12. police.setOut(this);
13. }
14. }
15. }

1. package cn.lynn.observer;
2. public class NanHuCitizen extends Citizen {
3. public NanHuCitizen(Policeman police) {
4. setPolices();
5. register(police);
6. }
7. @Override
8. public void notify(String action) {
9. setAction(action);
10. for (int i = 0; i < polices.size(); i++) {
11. Policeman police = polices.get(i);
12. police.setOut(this);
13. }
14. }
15. }

ConcreteObserver

1. package cn.lynn.observer;
2. public class DongHuPoliceman implements Policeman {
3. @Override
4. public void setOut(Citizen citizen) {
5. String action = citizen.getAction();
6. if(action.equals("normal")) {
7. System.out.println("行为一切正常");
8. } else if(action.equals("unnormal")) {
9. System.out.println("有偷窃行为，东湖警察出动！");
10. }
11. }
12. }

1. package cn.lynn.observer;
2. public class NanHuPoliceman implements Policeman {
3. @Override
4. public void setOut(Citizen citizen) {
5. String action = citizen.getAction();
6. if(action.equals("normal")) {
7. System.out.println("行为一切正常");
8. } else if(action.equals("unnormal")) {
9. System.out.println("有抢劫行为，南湖警察出动！");
10. }
11. }
12. }

Client

1. package cn.lynn.observer;
2. public class Client {
3. public static void main(String[] args) {
4. Policeman dhPolice = new DongHuPoliceman();
5. Policeman nhPolice = new NanHuPoliceman();
6. Citizen citizen = new DongHuCitizen(dhPolice);
7. citizen.notify("normal");
8. citizen.notify("unnormal");
9. citizen = new NanHuCitizen(nhPolice);
10. citizen.notify("normal");
11. citizen.notify("unnormal");
12. }
13. }

Result

1. 行为一切正常
2. 有偷窃行为，东湖警察出动！
3. 行为一切正常
4. 有抢劫行为，南湖警察出动！