【设计模式】19、观察者模式

 

 1 package com.shejimoshi.behavioral.Observer;
 2 
 3 
 4 /**
 5  * 功能：学生观察者
 6  * 时间：2016年3月7日上午10:28:00
 7  * 作者：cutter_point
 8  */
 9 public interface Student
10 {
11     //根据相应的事件作出反应
12     public abstract void reaction();
13 }

 

 1 package com.shejimoshi.behavioral.Observer;
 2 
 3 
 4 /**
 5  * 功能：学生类具体观察者
 6  * 时间：2016年3月7日上午10:30:57
 7  * 作者：cutter_point
 8  */
 9 public class SeniorHighSchoolStudents implements Student
10 {
11     //老师
12     private Teacher teacher;
13     private String name;    //名字
14     
15     public SeniorHighSchoolStudents()
16     {
17     }
18     
19     public SeniorHighSchoolStudents(Teacher t, String n)
20     {
21         this.teacher = t;
22         this.name = n;
23     }
24     
25     /**
26      * 学生做出相应的反应
27      */
28     @Override
29     public void reaction()
30     {
31         String action = teacher.getAction();
32         System.out.println("老师说：" + action + "\t" + name + "回到教室，准备学习");
33     }
34 
35 }

 

 1 package com.shejimoshi.behavioral.Observer;
 2 
 3 
 4 /**
 5  * 功能：老师类，作为通知者
 6  * 时间：2016年3月7日上午10:31:16
 7  * 作者：cutter_point
 8  */
 9 public interface Teacher
10 {
11     /**
12      * 添加学生
13      * @param student
14      */
15     public void addStrudnet(Student student);
16     
17     /**
18      * 开除一个同学
19      * @param student
20      */
21     public void removeStudent(Student student);
22     
23     /**
24      * 开始上课
25      */
26     public void classBegin();
27     
28     /**
29      * 取得通知事件
30      * @return
31      */
32     public String getAction();
33 }

 

 1 package com.shejimoshi.behavioral.Observer;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 
 7 /**
 8  * 功能：曹老师
 9  * 时间：2016年3月7日上午10:36:30
10  * 作者：cutter_point
11  */
12 public class TeacherChao implements Teacher
13 {
14     private List ls = new ArrayList();
15     private String action;    //事件
16 
17     @Override
18     public void addStrudnet(Student student)
19     {
20         ls.add(student);
21     }
22 
23     @Override
24     public void removeStudent(Student student)
25     {
26         ls.remove(student);
27     }
28 
29     @Override
30     public void classBegin()
31     {
32         
33         for(Student s : ls)
34         {
35             //通知上课开始
36             s.reaction();
37         }//for
38     }
39 
40     public String getAction()
41     {
42         return action;
43     }
44 
45     public void setAction(String action)
46     {
47         this.action = action;
48     }
49 
50 }

 

测试代码：

 1 package com.shejimoshi.behavioral.Observer;
 2 
 3 
 4 /**
 5  * 功能：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变的时候，所有依赖于它的对对象都得到通知并被自动更新
 6  * 适用：当一个抽象模式有两个方面的时候，其中一个方面依赖另外一个方面。将这两种封装在独立的对象中以使它们可以独立地改变和复用
 7  *         当对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象有待改变
 8  *         当一个对象必须通知其他对象，而它又不能假定其它对象是谁。换言之，你不希望这些对象时紧密耦合的
 9  * 时间：2016年3月7日上午8:32:18
10  * 作者：cutter_point
11  */
12 public class Test
13 {
14     public static void main(String[] args)
15     {
16         TeacherChao tc = new TeacherChao();
17         //学生
18         SeniorHighSchoolStudents xiaoming = new SeniorHighSchoolStudents(tc, "小明");
19         SeniorHighSchoolStudents xiaocheng = new SeniorHighSchoolStudents(tc, "小城");
20         SeniorHighSchoolStudents xiaohong = new SeniorHighSchoolStudents(tc, "小红");
21         SeniorHighSchoolStudents xiaozhi = new SeniorHighSchoolStudents(tc, "小智");
22         SeniorHighSchoolStudents xiaohua = new SeniorHighSchoolStudents(tc, "笑话");
23         
24         tc.addStrudnet(xiaoming); tc.addStrudnet(xiaocheng); tc.addStrudnet(xiaohong);
25         tc.addStrudnet(xiaozhi); tc.addStrudnet(xiaohua);
26         
27         tc.setAction("上课");
28         tc.classBegin(); //老师上课啦
29         
30     }
31 }

 

测试结果：

老师说：上课	小明回到教室，准备学习
老师说：上课	小城回到教室，准备学习
老师说：上课	小红回到教室，准备学习
老师说：上课	小智回到教室，准备学习
老师说：上课	笑话回到教室，准备学习

　

 

接受@ zhco的意见，这里做出修改，还有很多不足，观察者模式中的方法应该可以使用到策略模式根据不同的通知者做出不同的反应，由于本人最近事情比较多，并且这里是单独将观察者的所以我就

写的冗杂一些，多写了一个public abstract void reaction1();无伤大雅，大家理解观察者模式就好

 

 

 

 

 

 

 

 1 package com.shejimoshi.behavioral.Observer;
 2 
 3 
 4 /**
 5  * 功能：作为通知者
 6  * 时间：2016年3月7日上午10:31:16
 7  * 作者：cutter_point
 8  */
 9 public interface Notice
10 {
11     /**
12      * 添加观察者
13      * @param student
14      */
15     public void add(Object Observer);
16     
17     /**
18      * 去除观察者
19      * @param student
20      */
21     public void remove(Object Observer);
22     
23     /**
24      * 开始事件
25      */
26     public void EventBegin();
27     
28     /**
29      * 取得通知事件
30      * @return
31      */
32     public String getAction();
33 }

 

 1 package com.shejimoshi.behavioral.Observer;
 2 
 3 
 4 /**
 5  * 功能：学生观察者
 6  * 时间：2016年3月7日上午10:28:00
 7  * 作者：cutter_point
 8  */
 9 public interface Observer
10 {
11     //根据相应的事件作出反应
12     public abstract void reaction();
13     //根据相应的事件作出反应
14     public abstract void reaction1();
15 }

 

 1 package com.shejimoshi.behavioral.Observer;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 
 7 /**
 8  * 功能：上课铃声类
 9  * 时间：2016年3月10日上午8:21:23
10  * 作者：cutter_point
11  */
12 public class Bell implements Notice
13 {
14     private List ls = new ArrayList();
15     private String action;    //事件
16 
17     @Override
18     public void add(Object Observer)
19     {
20         ls.add((Observer) Observer);
21     }
22 
23     @Override
24     public void remove(Object Observer)
25     {
26         ls.remove(Observer);
27     }
28 
29     @Override
30     public void EventBegin()
31     {
32         //开始铃声事件的时候，观察者们得做出反应
33         for(Observer o : ls)
34         {
35             o.reaction1();
36         }
37     }
38 
39     public String getAction()
40     {
41         return action;
42     }
43 
44     public void setAction(String action)
45     {
46         this.action = action;
47     }
48     
49 }

 

 1 package com.shejimoshi.behavioral.Observer;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 
 7 /**
 8  * 功能：曹老师
 9  * 时间：2016年3月7日上午10:36:30
10  * 作者：cutter_point
11  */
12 public class TeacherChao implements Notice, Observer
13 {
14     private List ls = new ArrayList();
15     private String action;    //事件
16     //作为观察者
17     //老师
18     private Notice bell;
19     private String name;    //名字
20     
21     public TeacherChao(Notice t, String n)
22     {
23         this.bell = t;
24         this.name = n;
25     }
26 
27     public String getAction()
28     {
29         return action;
30     }
31 
32     public void setAction(String action)
33     {
34         this.action = action;
35     }
36 
37     @Override
38     public void add(Object Observer)
39     {
40         ls.add((Observer) Observer);
41     }
42 
43     @Override
44     public void remove(Object Observer)
45     {
46         ls.remove(Observer);
47     }
48 
49     @Override
50     public void EventBegin()
51     {
52         for(Object s : ls)
53         {
54             //通知上课开始
55             Observer oo = (Observer) s;
56             oo.reaction();
57         }//for
58     }
59 
60     @Override
61     public void reaction()
62     {
63         String action = bell.getAction();
64         System.out.println(action + "\t" + name + "回到教室");
65     }
66 
67     @Override
68     public void reaction1()
69     {
70         String action = bell.getAction();
71         System.out.println(action + "\t" + name + "回到教室");
72     }
73 
74 }

 

 1 package com.shejimoshi.behavioral.Observer;
 2 
 3 
 4 /**
 5  * 功能：学生类具体观察者
 6  * 时间：2016年3月7日上午10:30:57
 7  * 作者：cutter_point
 8  */
 9 public class SeniorHighSchoolStudents implements Observer
10 {
11     //老师
12     private Notice teacher;
13     private String name;    //名字
14     
15     public SeniorHighSchoolStudents()
16     {
17     }
18     
19     public SeniorHighSchoolStudents(Notice t, String n)
20     {
21         this.teacher = t;
22         this.name = n;
23     }
24     
25     /**
26      * 学生做出相应的反应
27      */
28     @Override
29     public void reaction()
30     {
31         String action = teacher.getAction();
32         System.out.println("老师说：" + action + "\t" + name + "老师好");
33     }
34     
35     //观察两个对象，不同对象不同的反应
36     public void reaction1()
37     {
38         String action = teacher.getAction();
39         System.out.println(action + "\t" + name + "回到教室");
40     }
41 
42 }

 

测试代码：

 1 package com.shejimoshi.behavioral.Observer;
 2 
 3 
 4 /**
 5  * 功能：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变的时候，所有依赖于它的对对象都得到通知并被自动更新
 6  * 适用：当一个抽象模式有两个方面的时候，其中一个方面依赖另外一个方面。将这两种封装在独立的对象中以使它们可以独立地改变和复用
 7  *         当对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象有待改变
 8  *         当一个对象必须通知其他对象，而它又不能假定其它对象是谁。换言之，你不希望这些对象时紧密耦合的
 9  * 时间：2016年3月7日上午8:32:18
10  * 作者：cutter_point
11  */
12 public class Test
13 {
14     public static void main(String[] args)
15     {
16         Bell b = new Bell();
17         TeacherChao tc = new TeacherChao(b, "曹老师");
18         //学生
19         SeniorHighSchoolStudents xiaoming = new SeniorHighSchoolStudents(tc, "小明");
20         SeniorHighSchoolStudents xiaocheng = new SeniorHighSchoolStudents(tc, "小城");
21         SeniorHighSchoolStudents xiaohong = new SeniorHighSchoolStudents(tc, "小红");
22         SeniorHighSchoolStudents xiaozhi = new SeniorHighSchoolStudents(tc, "小智");
23         SeniorHighSchoolStudents xiaohua = new SeniorHighSchoolStudents(tc, "笑话");
24         //所有人都是铃声的观察者
25         b.add(tc);b.add(xiaoming);b.add(xiaocheng);b.add(xiaohong);b.add(xiaozhi);b.add(xiaohua);
26         
27         tc.add(xiaoming); tc.add(xiaocheng); tc.add(xiaohong);
28         tc.add(xiaozhi); tc.add(xiaohua);
29         
30         b.setAction("打铃");
31         tc.setAction("上课");
32         b.EventBegin(); //打铃，观察者响应事件
33         tc.EventBegin(); //老师上课啦
34         
35     }
36 }

结果：

打铃	曹老师回到教室
上课	小明回到教室
上课	小城回到教室
上课	小红回到教室
上课	小智回到教室
上课	笑话回到教室
老师说：上课	小明老师好
老师说：上课	小城老师好
老师说：上课	小红老师好
老师说：上课	小智老师好
老师说：上课	笑话老师好

　　

 

转载于:https://www.cnblogs.com/cutter-point/p/5249780.html