I want to fly higher
programming Explorer
posts - 114,comments - 263,trackbacks - 0
学习设计模式之观察者模式Demo

    所谓观察者模式是指当一个对象的状态发生变化时，能够自动通知其他关联对象，自动刷新对象状态。Observer模式提供给关联对象一种同步通信的手段，使某个对象与依赖它的其他对象之间保持状态同步。《设计模式》一书对Observer是这样描述的：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都将得到通知并自动更新。
    JDK提供了对observer设计模式的支持：
    通过java.util.Observable类扮演Subject（被观察者）角色，一个类只需通过继承java.util.Observable类便可担当ConcreteSubject角色；
    通过java.util.Observer接口扮演Observer（观察者）角色，一个类只需实现java.util.Observer接口便可担当ConcreteObserver角色。    
    java.util.Observable的实现类通过调用setChanged()方法以及notifyObservers(Object)方法便可简单地通知Observer。
    下面写了一个程序实现观察者模式：包括被观察者Children.java（孩子）继承Observable，观察者Father.java（父亲）和Mother.java（母亲）实现Observer接口，还有一个测试类ClientTest_Oberver.java。

Industry.java：

 1package com.landon.trainjava.oop;
 2/**
 3 * 一个普通的接口，行业
 4 * @author landon
 5 *
 6 */
 7public interface Industry {
 8 void getIndustry();
 9
10}
11
12


Person.java:

 1package com.landon.trainjava.oop;
 2/**
 3 * 一个普通的抽象类，人
 4 * @author landon
 5 *
 6 */
 7public abstract class Person {
 8 /**
 9  * 为了享元模式中的方便一些，没有加入private修饰符
10  * 另外为了另一个包下的使用，用protectd修饰
11  */
12  protected String personName;
13  protected int personAge;
14 
15 //右键Source->Generate Getters and Setters
16 public String getPersonName() {
17  return personName;
18 }
19
20 public void setPersonName(String personName) {
21  this.personName = personName;
22 }
23
24 public int getPersonAge() {
25  return personAge;
26 }
27
28 public void setPersonAge(int personAge) {
29  this.personAge = personAge;
30 }
31
32 /**
33  * 抽象方法
34  */
35 public abstract void sayHello();
36
37}
38
39


Children.java:

 1package com.landon.landon.trainjava.designpattern;
 2import java.util.Observable;
 3
 4import com.landon.landon.trainjava.oop.Industry;
 5/**
 6 * 观察者模式中的被观察者，孩子
 7 * @author landon
 8 *
 9 */
10
11class Children extends Observable implements Industry{
12 /**
13  * 孩子的状态，通过孩子的状态来提醒观察者父母
14  */
15 private String state;
16 
17 public void setState(String s)
18 {
19  this.state = s;
20 }
21 
22 public String getState()
23 {
24  return state;
25 }
26 
27 public void getIndustry()
28 {
29  System.out.println("My Industry is Observable children!");
30 }
31 
32 @Override
33 //通过该方法表明对象的状态已经发生变化
34 protected synchronized void setChanged() {
35  super.setChanged();
36 }
37 
38 @Override
39 //通知被观察者
40 public void notifyObservers() {
41  super.notifyObservers(state);
42 }
43 
44 public void noticeParents()
45 {
46  setChanged();
47  notifyObservers();
48 }
49
50}
51
52


Father.java:

 1package com.landon.trainjava.designpattern;
 2import java.util.Observable;
 3import java.util.Observer;
 4
 5import com.landon.trainjava.oop.Person;
 6
 7/**
 8 * 观察者模式中的观察者：父亲
 9 * @author landon
10 *
11 */
12class Father extends Person implements Observer{
13 public void sayHello()
14 {
15  System.out.println("Hello,I'm the Observer-Father!");
16 }
17
18 @Override
19 public void update(Observable o, Object arg) {
20  if(((Children)o).getState().equals("fight"))
21  {
22   System.out.println("Tell father,you fight with others!");
23  }
24  else if(((Children)o).getState().equals("scholarship"))
25  {
26   System.out.println("Tell father,you got scholarship!");
27  }
28 }
29
30}
31
32
33
34Mother.java:
35
36
37
38package com.landon.trainjava.designpattern;
39import java.util.Observable;
40import java.util.Observer;
41
42import com.landon.trainjava.oop.Person;
43
44/**
45 * 观察者模式中的观察者：母亲
46 * @author landon
47 *
48 */
49class Mother extends Person implements Observer{
50 public void sayHello()
51 {
52  System.out.println("Hello,I'm the Observer-Mother!");
53 }
54
55 @Override
56 public void update(Observable o, Object arg) {
57  if(((Children)o).getState().equals("fight"))
58  {
59   System.out.println("Tell mother,you fight with others!");
60  }
61  else if(((Children)o).getState().equals("scholarship"))
62  {
63   System.out.println("Tell mother,you got scholarship!");
64  }
65 }
66
67}
68
69


ClientTest_Oberver.java：

 1package com.landon.trainjava.designpattern;
 2/**
 3 *测试观察者模式 
 4 * @author landon
 5 *
 6 */
 7public class ClientTest_Observer {
 8 public static void main(String []args)
 9 {
10  Children children = new Children();
11  
12  //添加观察者对象
13  children.addObserver(new Father());
14  children.addObserver(new Mother());
15  
16  //打架状态
17  children.setState("fight");
18  //通知父母
19  children.noticeParents();
20  
21  //奖学金状态，通知父母
22  children.setState("scholarship");
23  //通知父母
24  children.noticeParents();
25 }
26
27}
28
29


    ps:此程序是参考网上的一个例子改写而成，我觉得作为观察者模式的例子非常好。使用观察者模式的好处是支持广播通信，被观察者会向所有的登记过的观察者发出通知。而且，观察者模式实现了表示层与数据逻辑层的分离，并定义了稳定的更新消息传递机制，类别清晰。

posted on 2010-07-07 23:26 landon 阅读(1452) 评论(0)  编辑  收藏 所属分类: Program

只有注册用户登录后才能发表评论。
网站导航:
 
Copyright ©2024 landon Powered By博客园 模板提供：沪江博客