[java笔记]常用的设计模式

1.单例设计模式

　　单例设计模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

　　1）构造方法私有化

　　2）声明一个本类对象

　　3）给外部提供一个静态方法获取对象实例

　　例如：

　　　　class Singleton{

　　　　　　private static Singletho1 s = new Singletho1();

　　　　　　private Singletho1(){}

　　　　　　public static Singletho1 getInstance(){

　　　　　　　　return s;

　　　　　　}

2.模板方法模式（Templete Method）

　　模板方法模式：定义一个操作中的算法的骨架，而将一些可变部分的实现延迟到子类中。模板方法模式使得子类可以不改变

　　　　　　　　　一个算法的结构即可重新定义该算法的某些特定的步骤。

3.策略模式（Strategy Pattern）

　　策略模式：定义了一系列的算法，将每一种算法封装起来并可以互相替换使用，策略模式让算法独立于使用它的客户应用而独立变化

　　OO设计原则：

　　　　1）面向接口编程（面向抽象编程）

　　　　2）封装变化（把可变化的东西抽象出来，单独封装起来）

　　　　3）多用组合，少用继承

　　　　4）对修改关闭，对扩展开放

4.简单工厂模式

　　简单工厂模式：由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单使用的模式。

　　例如：

 1 public class FactoryDemo {
 2     
 3     public static void main(String[] args) {
 4         
 5         Doll clothDoll = DollFactory.getInstance("cloth");
 6         if(clothDoll != null){
 7             System.out.println(clothDoll.getInfo());
 8         }
 9         Doll barbieDoll = DollFactory.getInstance("barbie");
10         if(barbieDoll != null){
11             System.out.println(barbieDoll.getInfo());
12         }
13         
14     }
15     
16 }
17 
18 
19 /**
20  * @ClassName: DollFactory 
21  * @Description: 工厂类 
22  * @date 2015年1月16日 上午11:03:18 
23  */
24 class DollFactory{
25      //值负责产生对象
26     public static Doll getInstance (String name){
27         //根据条件不同的对象
28         if("cloth".equals(name)){
29             return new ClothDoll();
30         }else if ("barbie".equals(name)){
31             return new BarbieDoll();
32         }
33         return null;
34     }
35     
36 }
37 
38 /**
39  * @ClassName: Doll 
40  * @Description: 娃娃类 
41  * @date 2015年1月16日 上午11:03:13 
42  */
43 interface Doll{
44     
45     public String getInfo();
46 }
47 
48 /**
49  * @ClassName: ClothDoll 
50  * @Description:  布娃娃
51  * @date 2015年1月16日 上午11:03:09 
52  */
53 class ClothDoll implements Doll{
54     
55     public String getInfo(){
56         return "我是布娃娃。";
57     }
58 }
59 
60 
61 /**
62  * @ClassName: BarbieDoll 
63  * @Description: 芭比娃娃 
64  * @date 2015年1月16日 上午11:03:03 
65  */
66 class BarbieDoll implements Doll{
67     
68     public String getInfo(){
69         return "我是芭比娃娃.";
70     }
71 }

FactoryDemo Code

5.代理设计模式

　　代理模式（Proxy）：为其他对象提供一种代理以控制对这个对象的访问。代理模式说白了就是“真实对象”的代表，在

　　访问对象时引入一定程度的间接性，因为这种间接性可以附件多种用途。

　　静态代理：

 1 /**
 2  * @Title: ProxyDemo.java 
 3  * @Package proxydemo 
 4  * @Description: TODO 
 5  * @date 2015年1月16日 下午7:33:00 
 6  * @version V1.0  
 7  */
 8 package proxydemo;
 9 
10 /**
11  * @ClassName: ProxyDemo 
12  * @Description:  代理模式：为其他对象提供一种代理以控制对这个对象的访问。
13  * @date 2015年1月16日 下午7:33:00 
14  */
15 public class ProxyDemo {
16 
17     /**
18      * @Title: main 
19      * @Description: TODO 
20      * @param args     
21      * @return void     
22      */
23     public static void main(String[] args) {
24 
25         Person p = new Person("小白");
26         //创建代理对象，并把代理对象传进来
27         Matchmaker m = new Matchmaker(p);
28         
29         m.miai();//相亲
30     }
31 
32 }
33 
34 
35 /**
36  * @ClassName: Subject 
37  * @Description: 主题接口 
38  * @date 2015年1月16日 下午7:37:46 
39  */
40 interface Subject{
41     
42     public void miai();
43     
44 }
45 
46 
47 /**
48  * @ClassName: Person 
49  * @Description: 被代理类 
50  * @date 2015年1月16日 下午7:37:25 
51  */
52 class Person implements Subject{
53 
54     private String name;
55     
56     public Person(String name){
57         this.name = name;
58     }
59     
60     public void miai(){
61         System.out.println(name+"正在相亲中。。。");
62     }
63     
64 }
65 
66 
67 /**
68  * @ClassName: Matchamker 
69  * @Description: 代理类 
70  * @date 2015年1月16日 下午7:36:58 
71  */
72 class Matchmaker implements Subject{
73     
74     private Subject target;//要代理的目标对象
75     
76     public Matchmaker(Subject target){
77         this.target = target;
78     }
79     
80     //相亲之前要做的事情
81     private void before(){
82         System.out.println("为代理人匹配如意郎君。");
83     }
84     
85     //相亲之后要做的事情
86     private void after(){
87         System.out.println("本次相亲结束。");
88     }
89     
90     //相亲方法
91     public void miai(){
92         before();
93         //真正执行相亲方法
94         target.miai();
95         after();
96     }
97 }

ProxyDemo Code

　　动态代理：Proxy的代理，接口和实现类之间可以不直接发生联系，而可以再运行期（Runtime）实现动态关联。

  1 /**
  2  * @Title: Subject.java 
  3  * @Package dynaproxy 
  4  * @Description: TODO 
  5  * @date 2015年2月23日 下午8:37:49 
  6  * @version V1.0  
  7  */
  8 package dynaproxy;
  9 
 10 /**
 11  * @ClassName: Subject 
 12  * @Description: 要代理的主题接口 
 13  * @date 2015年2月23日 下午8:37:49 
 14  */
 15 public interface Subject {
 16 
 17     /**
 18      * @Title: miai 
 19      * @Description: 相亲      
 20      * @return void     
 21      */
 22     public void miai();
 23     
 24 }
 25 
 26 
 27 /**
 28  * @Title: Person.java 
 29  * @Package dynaproxy 
 30  * @Description: TODO 
 31  * @date 2015年2月23日 下午8:39:12 
 32  * @version V1.0  
 33  */
 34 package dynaproxy;
 35 
 36 /**
 37  * @ClassName: Person 
 38  * @Description: TODO 
 39  * @date 2015年2月23日 下午8:39:12 
 40  */
 41 public class Person implements Subject{
 42 
 43     private String name;
 44     
 45     public Person(String name){
 46         this.name = name;
 47     }
 48 
 49     /* (non-Javadoc)
 50      * <p>Title: miai</p> 
 51      * <p>Description: </p>  
 52      * @see dynaproxy.Subject#miai()
 53      */
 54     @Override
 55     public void miai() {
 56         
 57         System.out.println(name+"正在相亲中。。");
 58         
 59     }
 60     
 61 }
 62 
 63 /**
 64  * @Title: DynaProxy.java 
 65  * @Package dynaproxy 
 66  * @Description: TODO 
 67  * @date 2015年2月23日 下午8:40:47 
 68  * @version V1.0  
 69  */
 70 package dynaproxy;
 71 
 72 import java.lang.reflect.InvocationHandler;
 73 import java.lang.reflect.Method;
 74 
 75 /**
 76  * @ClassName: DynaProxy 
 77  * @Description: 动态代理类 
 78  * @date 2015年2月23日 下午8:40:47 
 79  */
 80 public class DynaProxy implements InvocationHandler{
 81 
 82     private Object target;
 83     public DynaProxy(Object target){
 84         this.target = target;
 85     }
 86     
 87     
 88     /* (non-Javadoc)
 89      * <p>Title: invoke</p> 
 90      * <p>Description: </p> 
 91      * @param proxy
 92      * @param method
 93      * @param args
 94      * @return
 95      * @throws Throwable 
 96      * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
 97      */
 98     @Override
 99     public Object invoke(Object proxy, Method method, Object[] args)
100             throws Throwable {
101         Object obj = null;
102         before();
103         //正真调用业务方法
104         obj = method.invoke(target, args);
105         after();
106         return obj;
107     }
108 
109 
110     /**
111      * @Title: after
112      * @Description: 相亲之后要做的事情
113      * @return void
114      */
115 
116     private void after() {
117         System.out.println("本次相亲结束。");
118     }
119 
120     /**
121      * @Title: before
122      * @Description: 相亲之前要做的事情
123      * @return void
124      */
125 
126     private void before() {
127         System.out.println("为代理人匹配如意郎君。");
128     }
129         
130 
131 }
132 
133 /**
134  * @Title: Test.java 
135  * @Package dynaproxy 
136  * @Description: TODO 
137  * @date 2015年2月23日 下午8:49:10 
138  * @version V1.0  
139  */
140 package dynaproxy;
141 
142 import java.lang.reflect.Proxy;
143 
144 /**
145  * @ClassName: Test 
146  * @Description: TODO 
147  * @date 2015年2月23日 下午8:49:10 
148  */
149 public class Test {
150 
151     public static void main(String[] args) {
152         
153         Person p = new Person("小白");
154         DynaProxy dp = new DynaProxy(p);
155         
156         /*
157          * Proxy提供用于创建动态代理类和实例的静态方法，
158          * 它还是这些方法创建的所有动态代理类的超类。
159          */
160         //动态生成代理对象（类加载器，被代理接口，InvocationHandler）
161         Subject s = (Subject) Proxy.newProxyInstance(p.getClass()
162                 .getClassLoader(), p.getClass().getInterfaces(), dp);
163         s.miai();
164     }
165     
166 }

View Code

6.适配器模式

　　适配器模式（Adapter）：将一个类的接口装换成客户希望的另一个接口。适配器模式使得原本由于接口不兼容而不能一

　　起工作的那些类可以一起工作。

　　例如：

  1 /**
  2  * @Title: AdapterDemo.java 
  3  * @Package adapterdemo 
  4  * @Description: TODO 
  5  * @date 2015年1月16日 下午8:03:11 
  6  * @version V1.0  
  7  */
  8 package adapterdemo;
  9 
 10 /**
 11  * @ClassName: AdapterDemo 
 12  * @Description: 适配器模式（Adapter）：将一个类的接口装换成客户希望的另一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 
 13  * @date 2015年1月16日 下午8:03:11 
 14  */
 15 public class AdapterDemo {
 16 
 17     /**
 18      * @Title: main 
 19      * @Description: TODO 
 20      * @param args     
 21      * @return void     
 22      */
 23     public static void main(String[] args) {
 24 
 25         PowerA powerA = new PowerAImpl();
 26         start(powerA);
 27         
 28         PowerB powerB = new PowerBImpl();
 29         //把powerB封装进适配器
 30         PowerAAdapter pa = new PowerAAdapter(powerB);
 31         start(pa);
 32     
 33     }
 34 
 35     //开始工作
 36     public static void start(PowerA powerA){
 37         powerA.insert();
 38     }
 39     
 40 }
 41 
 42 
 43 /**
 44  * @ClassName: PowerAAdapter 
 45  * @Description: 适配器类 
 46  * @date 2015年1月16日 下午8:31:59 
 47  */
 48 class PowerAAdapter implements PowerA{
 49     
 50     private PowerB powerB;//要进行适配的接口
 51     
 52     public PowerAAdapter(PowerB powerB){
 53         this.powerB = powerB;
 54     }
 55     
 56     public void insert(){
 57         powerB.connect();
 58     }
 59     
 60 }
 61 
 62 
 63 /**
 64  * @ClassName: PowerA 
 65  * @Description: 电源A接口 
 66  * @date 2015年1月16日 下午8:05:11 
 67  */
 68 interface PowerA{
 69     
 70     public void insert();
 71     
 72 }
 73 
 74 
 75 /**
 76  * @ClassName: PowerAImpl 
 77  * @Description: TODO 
 78  * @date 2015年1月16日 下午8:07:33 
 79  */
 80 class PowerAImpl implements PowerA{
 81     
 82     public void insert(){
 83         System.out.println("电源A接口插入，开始工作。");
 84     }
 85     
 86 }
 87 
 88 
 89 /**
 90  * @ClassName: PowerB 
 91  * @Description: 电源B接口 
 92  * @date 2015年1月16日 下午8:05:54 
 93  */
 94 interface PowerB{
 95     
 96     public void connect();
 97     
 98 }
 99 
100 /**
101  * @ClassName: PowerBImpl 
102  * @Description: TODO 
103  * @date 2015年1月16日 下午8:08:49 
104  */
105 class PowerBImpl implements PowerB{
106     
107     public void connect(){
108         System.out.println("电源B接口以连接，开始工作。");
109     }
110     
111 }

AdapterDemo Code

7.享元设计模式

　　享元设计模式（Flyweight Pattern）：它使用共享对象，用来尽可能减少内存使用量以及分享资讯给尽可能多的相似对象；

　　它适合用于当大量对象只是重复因而导致无法令人接受的使用大量内存。通常对象中的部分状态是可以分享的。常见做法是把

　　他们放在外部数据结构，当需要使用时再将他们传递给享元。

　　运用共享技术有效的支持大量细粒度的对象。

　　例如：Integrate在一个字节内的对象。

8.装饰者设计模式

　　装饰着设计模式（Decorator）：动态地给对象添加一些额外的职责。就添加功能来说，Decorator模式相比生成子类更为灵活。

　　改模式以对客户透明的方式扩展对象的功能。

　　涉及角色：

　　　　1）抽象构件角色：定义一个抽象接口，来规范准备附加功能的类。

　　　　2）具体构件角色：将要被附加功能的类，实现抽象构件角色接口。

　　　　3）抽象装饰者角色：将有对具体构件角色的引用并定义与抽象构件角色一致的接口。

　　　　4）具体装饰角色：实现抽象装饰者角色，负责为具体构件添加额外功能。

　　示例代码：

  1 package decoratorDemo;
  2 
  3 /**
  4  * @ClassName: Drink 
  5  * @Description: 被装饰者对象接口
  6  * @date 2015年2月5日 下午9:23:33 
  7  */
  8 public interface Drink {
  9 
 10     //饮料的描述
 11     public String description();
 12     
 13     //计算价格
 14     public float cost();
 15         
 16 }
 17 
 18 
 19 package decoratorDemo;
 20 
 21 /**
 22  * @ClassName: SoyaBeanMilk 
 23  * @Description: 具体的被装饰者对象： 豆浆
 24  * @date 2015年2月5日 下午9:26:13 
 25  */
 26 public class SoyaBeanMilk implements Drink{
 27 
 28     /* (non-Javadoc)
 29      * <p>Title: decription</p> 
 30      * <p>Description: </p> 
 31      * @return 
 32      * @see decoratorDemo.Drink#decription()
 33      */
 34     @Override
 35     public String description() {        
 36         return "纯豆浆";
 37     }
 38 
 39     /* (non-Javadoc)
 40      * <p>Title: cost</p> 
 41      * <p>Description: </p> 
 42      * @return 
 43      * @see decoratorDemo.Drink#cost()
 44      */
 45     @Override
 46     public float cost() {
 47         return 5f;
 48     }
 49 
 50 }
 51 
 52 
 53 package decoratorDemo;
 54 
 55 /**
 56  * @ClassName: Decorator 
 57  * @Description: 装饰者基类 
 58  * @date 2015年2月5日 下午9:29:37 
 59  */
 60 public abstract class Decorator implements Drink{
 61 
 62     private Drink drink;//要装饰的对象
 63     
 64     public Decorator(Drink drink){
 65         this.drink = drink;
 66     }
 67     
 68     /* (non-Javadoc)
 69      * <p>Title: decription</p> 
 70      * <p>Description: </p> 
 71      * @return 
 72      * @see decoratorDemo.Drink#decription()
 73      */
 74     @Override
 75     public String description() {        
 76         return drink.description();
 77     }
 78 
 79     /* (non-Javadoc)
 80      * <p>Title: cost</p> 
 81      * <p>Description: </p> 
 82      * @return 
 83      * @see decoratorDemo.Drink#cost()
 84      */
 85     @Override
 86     public float cost() {        
 87         return drink.cost();
 88     }
 89 
 90 }
 91 
 92 
 93 package decoratorDemo;
 94 
 95 /**
 96  * @ClassName: SugarDecorator 
 97  * @Description: 具体的装饰者对象：糖 
 98  * @date 2015年2月5日 下午9:35:35 
 99  */
100 public class SugarDecorator extends Decorator{
101 
102     /**
103      * @Title: SugarDecorator 
104      * @Description: TODO 
105      * @param drink    
106      */
107     public SugarDecorator(Drink drink) {
108         super(drink);        
109     }
110 
111     public String description(){
112         return super.description()+"+糖";
113     }
114     
115     public float cost(){
116         return super.cost()+0.5f;
117     }
118     
119 }
120 
121 
122 package decoratorDemo;
123 
124 
125 /**
126  * @ClassName: BlackBeanDecorator 
127  * @Description: 具体的装饰者对象：黑豆 
128  * @date 2015年2月5日 下午9:39:34 
129  */
130 public class BlackBeanDecorator extends Decorator{
131 
132     /**
133      * @Title: BlackBeanDecorator 
134      * @Description: TODO 
135      * @param drink    
136      */
137     public BlackBeanDecorator(Drink drink) {
138         super(drink);
139     }
140     
141     public String description(){
142         return super.description()+"+黑豆";
143     }
144     
145     public float cost(){
146         return super.cost()+3.0f;
147     }
148 
149 }
150 
151 
152 package decoratorDemo;
153 
154 /**
155  * @ClassName: EggDecorator 
156  * @Description: 具体装饰者对象：鸡蛋 
157  * @date 2015年2月5日 下午9:44:01 
158  */
159 public class EggDecorator extends Decorator{
160 
161     /**
162      * @Title: EggDecorator 
163      * @Description: TODO 
164      * @param drink    
165      */
166     public EggDecorator(Drink drink) {
167         super(drink);
168     }
169 
170     public String description(){
171         return super.description()+"+鸡蛋";
172     }
173     
174     public float cost(){
175         return super.cost()+2.0f;
176     }
177     
178     
179 }
180 
181 
182 package decoratorDemo;
183 
184 /**
185  * @ClassName: Test 
186  * @Description: 测试 
187  * @date 2015年2月5日 下午9:46:59 
188  */
189 public class Test {
190 
191     /**
192      * @Title: main 
193      * @Description: TODO 
194      * @param args     
195      * @return void     
196      */
197     public static void main(String[] args) {
198 
199         //生产一杯豆浆
200         Drink soya = new SoyaBeanMilk();
201         //在豆浆中加鸡蛋
202         EggDecorator eggSoya = new EggDecorator(soya);
203         //在加了鸡蛋的豆浆中加糖
204         SugarDecorator sugarEggSoya = new SugarDecorator(eggSoya);
205         //在加了糖的豆浆中加黑豆
206         BlackBeanDecorator blackBeanSugarEggSoya = new BlackBeanDecorator(sugarEggSoya);
207         
208         //结账
209         System.out.println("你点的是："+blackBeanSugarEggSoya.description());
210         System.out.println("一共："+blackBeanSugarEggSoya.cost()+"元");
211     }
212 
213 }

装饰者模式

9.观察者模式

　　观察者模式定义：简单地说，观察者模式定义了一个一对多的依赖关系，让一个或多个观察者对象观察一个主题对象。

　　这样一个主题对象在状态上的变化能够通过所有的依赖于此对象的那些观察者对象，使这些观察者对象能够自动更新。

　　Subject( 被观察的对象接口）

　　　　-规定ConcreteSubject的统一接口；

　　　　-每个Subject可以有多个Observer；

　　ConcreteSubject（具体被观察对象）

　　　　-维护对所有具体观察者的引用的列表；

　　　　-状态变化时会发送通知给所有注册的观察者。

　　Observer（观察者接口）

　　　　-规定ConcreteObserver的统一接口；

　　　　-定义了一个update（）方法；

　　ConcreteObserver（具体观察者）

　　　　-维护一个对ConcreteSubject的引用；

　　　　-特定状态与ConcreteSubject同步；

　　　　-实现Observer接口，通过update（）方法接收ConcreteSubject的通知。

　　示例代码：

  1 /**
  2  * @Title: Subject.java 
  3  * @Package observer 
  4  * @Description: TODO 
  5  * @date 2015年2月23日 上午10:09:19 
  6  * @version V1.0  
  7  */
  8 package observer;
  9 
 10 /**
 11  * @ClassName: Subject 
 12  * @Description: 被观察者接口 
 13  * @date 2015年2月23日 上午10:09:19 
 14  */
 15 public interface Subject {
 16 
 17     /**
 18      * @Title: registerObserver 
 19      * @Description: 注册为一个观察者 
 20      * @param o     
 21      * @return void     
 22      */
 23     public void registerObserver(Observer o);
 24     
 25     /**
 26      * @Title: removeObserver 
 27      * @Description: 取消观察者 
 28      * @param o     
 29      * @return void     
 30      */
 31     public void removeObserver(Observer o);
 32     
 33     /**
 34      * @Title: notifyObserver 
 35      * @Description: 通知所有观察者更新信息      
 36      * @return void     
 37      */
 38     public void notifyObservers();
 39     
 40 }
 41 
 42 /**
 43  * @Title: Observer.java 
 44  * @Package observer 
 45  * @Description: TODO 
 46  * @date 2015年2月23日 上午10:13:40 
 47  * @version V1.0  
 48  */
 49 package observer;
 50 
 51 /**
 52  * @ClassName: Observer 
 53  * @Description: TODO 
 54  * @date 2015年2月23日 上午10:13:40 
 55  */
 56 public interface Observer {
 57 
 58     /**
 59      * @Title: update 
 60      * @Description: 观察者更新信息方法 
 61      * @param price     
 62      * @return void     
 63      */
 64     public void update(float price);
 65     
 66 }
 67 
 68 /**
 69  * @Title: Doll.java 
 70  * @Package observer 
 71  * @Description: TODO 
 72  * @date 2015年2月23日 上午10:17:18 
 73  * @version V1.0  
 74  */
 75 package observer;
 76 
 77 import java.util.Vector;
 78 
 79 /**
 80  * @ClassName: Doll 
 81  * @Description: 具体的被观察者对象：娃娃 
 82  * @date 2015年2月23日 上午10:17:18 
 83  */
 84 public class Doll implements Subject {
 85 
 86     
 87     /**
 88      * @Fields v : 被观察者维护的一个观察者对象列表
 89      */
 90     private Vector<Observer> v = new Vector<Observer>();
 91     
 92     /**
 93      * @Fields price : 价格
 94      */
 95     private float price;
 96     
 97     public float getPrice(){
 98         return price;
 99     }
100     
101     /**
102      * @Title: setPrice 
103      * @Description: 修改价格时，通知所有观察者 
104      * @param price     
105      * @return void     
106      */
107     public void setPrice(float price){
108         this.price = price;
109         notifyObservers();
110     }
111     
112     /**
113      * @Title: Doll 
114      * @Description: TODO 
115      * @param price    
116      */
117     public Doll(float price) {
118         super();
119         this.price = price;
120     }
121 
122     /**
123      * @Title: Doll 
124      * @Description: TODO     
125      */
126     public Doll() {
127         super();
128     }
129 
130     /* (non-Javadoc)
131      * <p>Title: registerObserver</p> 
132      * <p>Description: </p> 
133      * @param o 
134      * @see observer.Subject#registerObserver(observer.Observer)
135      */
136     @Override
137     public void registerObserver(Observer o) {
138         //注册观察者
139         v.add(o);
140         
141     }
142 
143     /* (non-Javadoc)
144      * <p>Title: removeObserver</p> 
145      * <p>Description: </p> 
146      * @param o 
147      * @see observer.Subject#removeObserver(observer.Observer)
148      */
149     @Override
150     public void removeObserver(Observer o) {
151         //取消观察者
152         v.remove(o);
153         
154     }
155 
156     /* (non-Javadoc)
157      * <p>Title: notifyObserver</p> 
158      * <p>Description: </p>  
159      * @see observer.Subject#notifyObserver()
160      */
161     @Override
162     public void notifyObservers() {
163         //实现通知所有的观察者对象
164         for (Observer o:v){
165             o.update(price);
166         }
167         
168     }
169 
170 }
171 
172 /**
173  * @Title: Person.java 
174  * @Package observer 
175  * @Description: TODO 
176  * @date 2015年2月23日 上午10:29:39 
177  * @version V1.0  
178  */
179 package observer;
180 
181 /**
182  * @ClassName: Person 
183  * @Description: 具体的观察者对象 
184  * @author 欧其平
185  * @date 2015年2月23日 上午10:29:39 
186  */
187 public class Person implements Observer{
188 
189     private String name;
190     
191     public  Person(String name){
192         this.name = name;
193     }
194     
195     /* (non-Javadoc)
196      * <p>Title: update</p> 
197      * <p>Description: </p> 
198      * @param price 
199      * @see observer.Observer#update(float)
200      */
201     @Override
202     public void update(float price) {
203 
204         System.out.println(name+"关注的娃娃的价格已更新为："+price);
205         
206     }
207 
208 }
209 
210 /**
211  * @Title: Main.java 
212  * @Package observer 
213  * @Description: TODO 
214  * @date 2015年2月23日 上午10:35:19 
215  * @version V1.0  
216  */
217 package observer;
218 
219 /**
220  * @ClassName: Main 
221  * @Description: TODO 
222  * @date 2015年2月23日 上午10:35:19 
223  */
224 public class Main {
225 
226     /**
227      * @Title: main 
228      * @Description: TODO 
229      * @param args     
230      * @return void     
231      */
232     public static void main(String[] args) {
233         
234         //创建一个被观察者对象
235         Doll doll = new Doll(3000);        
236         Person p1 = new Person("小白");
237         Person p2 = new Person("小黑");        
238         //注册成为一个观察者
239         doll.registerObserver(p1);
240         doll.registerObserver(p2);
241         System.out.println("第一次降价：");
242         //价格变动
243         doll.setPrice(2698);
244         System.out.println("第二次降价：");
245         //价格变动
246         doll.setPrice(2299);
247         System.out.println("第三次降价：");
248         //价格变动
249         doll.setPrice(1998);
250         
251         doll.removeObserver(p2);
252         System.out.println("第四次降价：");
253         //价格变动
254         doll.setPrice(1098);
255     }
256 
257 }

View Code