谈爱情故事,谈观察者模式

     听听这首歌，真的好浪漫啊。看看身边的朋友都已经Find到了自己的对象了，而我自己还孤身一人。真的好羡慕他们的浪漫。在这里我就发发牢骚，给大家讲一个浪漫而又凄惨的爱情故事吧！
    
     我有个同学叫张三，自打他找了他所谓的“宝贝”后，他俩那股暧昧和亲热劲啊真让人受不了。到那都是宝贝啊，亲爱的啊叫个不停。让人听了全身啊都麻了，真是有的像癞蛤蟆爬花椒树：肉麻麻的。
     这个世界上的人啊太多了，帅哥也特别的多，正好我同学也算是一个帅哥吧，不过他和别的人可不一样，脾气好，对人好，从不发牢骚，也从不和别人计较。还乐意助人，心胸广阔............这如果从面向对象的思想来看，好象可以进行抽象吧，提取共性（他和别的帅哥都有的特征，如女孩高兴和不高兴的时候，他们该是什么反映？）：

 1 package  DesignPattern.Observer;
 2
 3 import  java.util.EventListener;
 4
 5 /** */ /**
 6 * 事件监听者接口--继承于EventListener
 7 * 所有的监听对象都继承于此接口
 8 */
 9 public   interface  EmotionListener  extends  EventListener   {
10    /** *//**
11     * 当女朋友高兴的时候我将会做什么？
12     * @param e--情感事件（事件对象）
13     */
14    void whatCanIdoWhenGirlHappy(EmotionEvent e);
15    
16    /** *//**
17     * 当女朋友不高兴的时候我将会做什么？
18     * @param e--情感事件（事件对象）
19     */
20    void whatCanIdoWhenGirlSad(EmotionEvent e);
21}

     仔细观察发现，上面的帅哥抽象出得接口里方法带有EmotionEvent类型的参数，这是什么东西？不好意思，上面忘说了，我在这里补充，EmotionEvent就是我这同学在认识了他女朋友后两个人发生了感情，然后产生的情感事件（EmotionEvent），这东西可强大了，一下子就把两个人关联到一块了，我们看看他的定义：

 1 package  DesignPattern.Observer;
 2
 3 import  java.util.EventObject;
 4
 5 /** */ /**
 6 * 情感事件--继承于事件对象（EventObject）
 7 * 事件对象
 8 */
 9 public   class  EmotionEvent  extends  EventObject  {
10    public EmotionEvent(Object source) {
11        super(source);
12    }
13    private static final long serialVersionUID = 1L;
14}
15

      正如前面所说，我这天下啊也算是帅哥的一种，那是不是他就应该实现于上面抽象出的帅哥（事件监听）接口呢？答案是肯定的。好，那我们下面就来看看这位从不和别人闹矛盾的善良帅哥"张三"同志，当女孩子不高兴或是高兴的时候他是怎么做的呢？

 1 package  DesignPattern.Observer;
 2
 3 /** */ /**
 4 * 事件监听者--监听对象
 5 * 响应事件源（Girl）发起的事件对象(情感事件-EmotionEvent)
 6 */
 7 public   class  HandSome  implements  EmotionListener  {
 8    
 9    private String name;
10    public String getName() {
11        return name;
12    }
13    
14    public void setName(String name) {
15        this.name = name;
16    }
17    
18    public HandSome(String name) {
19        super();
20        this.name = name;
21    }
22
23    /** *//**
24     * 当女朋友高兴的时候我将会做什么？
25     * @param e--情感事件（事件对象）
26     */
27    public void whatCanIdoWhenGirlHappy(EmotionEvent e) {
28        Object o = e.getSource();
29        Girl girl = (Girl)o;
30        System.out.print(name + "说:" + girl.getName());
31        System.out.println(",你高兴, 我也很高兴!!!");
32    }
33
34    /** *//**
35     * 当女朋友不高兴的时候我将会做什么？
36     * @param e--情感事件（事件对象）
37     */
38    public void whatCanIdoWhenGirlSad(EmotionEvent e) {
39        Object o = e.getSource();
40        Girl girl = (Girl)o;
41        //
42        System.out.print(name + "说:" + girl.getName());
43        System.out.print(",你不高兴, 我也会不高兴的。");
44        System.out.println("宝贝，甭怕，你不高兴的时候我会逗你开心的。");
45    }
46}

      哦，原来他是这样的啊。女孩子高兴的时候一起高兴，不高兴的时候，想尽一切办法逗女孩子开心。哎呀，惭愧啊，怪说不得我找不到女朋友的，因为我不会逗女孩子开心。一个人孤单的生活，这问题严重的呢，看来得找个时间找这老同学学习学习，向其请教怎么逗女孩子开心。
      
      在上面一直提到的还有个美女怎么没看到（张三的“宝贝”），那我们来看看这个大美女到底长什么样，把我们张三都给迷倒了。

 1 package  DesignPattern.Observer;
 2
 3 import  java.util.ArrayList;
 4 import  java.util.List;
 5
 6 /** */ /**
 7 *事件发起者--事件源
 8 */
 9 public   class  Girl  {
10    
11    public Girl(String name) {
12        super();
13        this.name = name;
14    }
15    private String name;
16    public String getName() {
17        return name;
18    }
19    
20    List<EmotionListener> boyFriends=new ArrayList<EmotionListener>();
21}

      好象这位大美女很小气，只是告诉了我们她的名字，以及她的男朋友（在boyFriends集合里？不是吧，还用集合，不会她想实现一妻多夫吧！！恐怖.......）.其实他也不是很小气的，她悄悄的告诉了我，他说人们谈恋爱吧，个谁在一起都有可能的，或许某个时候两个人说88就88了。呵呵，看来这个美女很现实哈。于此，那她是不是还具备找到男朋友和分手的方法呢（这是我猜的）？

 1 /** */ /**
 2* 女孩找到男朋友了---是谁？张三吗？还是李四？
 3* @param listener--事件监听对象
 4*/
 5 public   void  addEmotionListener(EmotionListener listener) {
 6    this.boyFriends.add(listener);
 7    HandSome hs=(HandSome)listener;
 8    System.out.println(name+"说:好高兴，我找到男朋友了,他叫：" + hs.getName() + ".");
 9}
10
11 /** */ /**
12* 女孩失恋了.
13* @param listener
14*/
15 public   void  removeEmotionListener(EmotionListener listener) {
16    this.boyFriends.remove(listener);
17    HandSome hs=(HandSome)listener;
18    System.out.println(name+" 说:亲爱的" + hs.getName() + ",我不能没有你,请不要离开我！！");
19}

      其实找到男朋友或是分手，这从事件模型上来看，也就是给事件源添加或注销事件监听对象。在JAVA的AWT事件模型里，事件源发起事件，事件监听者接收到发出的事件对象，并做相应的处理。而本文中呢，则是事件源女孩（Girl）向她的男朋友事件监听对象（HandSome）发起情感事件（EmotionEvent）,她男朋友（HandSome）作为事件监听对象（EmotionListener），应该响应事件源（Girl）发起的事件对象(情感事件-EmotionEvent)。Gril是如何向她的男朋友发起事件的呢？

1 public   void  fire()  {
2//女孩自己就是事件发起者，也就是事件源
3    EmotionEvent e = new  EmotionEvent(this);
4    for ( EmotionListener lis : boyFriends) {
5            lis.whatCanIdoWhenGirlHappy( e );
6            lis.whatCanIdoWhenGirlSad( e );
7  }
8}

 

Girl类的完整代码
 1package DesignPattern.Observer;
 2
 3import java.util.ArrayList;
 4import java.util.List;
 5
 6/** *//**
 7 *事件发起者--事件源
 8 */
 9public class Girl {
10    
11    public Girl(String name) {
12        super();
13        this.name = name;
14    }
15    private String name;
16    public String getName() {
17        return name;
18    }
19    
20    List<EmotionListener> boyFriends=new ArrayList<EmotionListener>();
21
22    /** *//**
23     * 女孩找到男朋友了---是谁？张三吗？还是李四？
24     * @param listener--事件监听对象
25     */
26    public void addEmotionListener(EmotionListener listener){
27        this.boyFriends.add(listener);
28        HandSome hs=(HandSome)listener;
29        System.out.println(name+"说:好高兴，我找到男朋友了,他叫：" + hs.getName() + ".");
30    }
31    
32    /** *//**
33     * 女孩失恋了.
34     * @param listener
35     */
36    public void removeEmotionListener(EmotionListener listener){
37        this.boyFriends.remove(listener);
38        HandSome hs=(HandSome)listener;
39        System.out.println(name+" 说:亲爱的" + hs.getName() + ",我不能没有你,请不要离开我！！");
40    }
41    
42    public void fire() {
43        //女孩自己就是事件发起者，也就是事件源
44        EmotionEvent e = new  EmotionEvent(this);
45        for ( EmotionListener lis : boyFriends) {
46            lis.whatCanIdoWhenGirlHappy( e );
47            lis.whatCanIdoWhenGirlSad( e );
48        }
49    }
50}
51

      女孩自己就是事件发起者，也就是事件源，通过调用监听对象的方法把自己的信息（情感事件EmotionEvent）传递到心爱的男朋友处，接下来我们就来看看他们两的浪漫爱情故事吧！

 1 public   class  TestObserver  {
 2    public static void main(String[] args) {
 3        
 4        //创建事件源对象--“宝贝”
 5        Girl g = new Girl("宝贝");
 6        //创建事件监听对象
 7        EmotionListener listener = new HandSome("张三");
 8        //将响应者注册到事件源
 9        //（将上面创建的帅哥（“张三”）设定为叫“宝贝”的这个美女的男朋友）
10        g.addEmotionListener(listener);
11        g.fire();    
12    }
13}

     

浪漫的事

宝贝说:好高兴，我找到男朋友了,他叫：张三.
张三说:宝贝,你高兴, 我也很高兴!!!
张三说:宝贝,你不高兴, 我也会不高兴的。宝贝，甭怕，你不高兴的时候我会逗你开心的。

    几个月后，他们的感情发生了问题，所谓的日久生情，日久也生疏。张三为了爱情的延续，以后的家庭生活，每天早出晚归的工作。两个人的感情淡了，正在这个时候，暗恋"宝贝"许久的 “周末”行动了，他假如了宝贝和张三的生活，成为了第三者，在宝贝的生活里就有了两个男人，而对她都是一样的好。

 1 public   class  TestObserver  {
 2    public static void main(String[] args) {
 3        
 4        //创建事件源对象--“宝贝”
 5        Girl g = new Girl("宝贝");
 6        //创建事件监听对象
 7        EmotionListener listener = new HandSome("张三");
 8        //将响应者注册到事件源
 9        //（将上面创建的帅哥（“张三”）设定为叫“宝贝”的这个美女的男朋友）
10        g.addEmotionListener(listener);
11        //第三者加入
12        EmotionListener lis = new HandSome("周末");
13        g.addEmotionListener(lis);
14        g.fire();    
15    }
16}

      

浪漫的事

宝贝说:好高兴，我找到男朋友了,他叫：张三.
宝贝说:好高兴，我找到男朋友了,他叫：周末.
张三说:宝贝,你高兴, 我也很高兴!!!
张三说:宝贝,你不高兴, 我也会不高兴的。宝贝，甭怕，你不高兴的时候我会逗你开心的。
周末说:宝贝,你高兴, 我也很高兴!!!
周末说:宝贝,你不高兴, 我也会不高兴的。宝贝，甭怕，你不高兴的时候我会逗你开心的。

     我真的很佩服，帅哥就是帅哥，说话都是一样，完全是从一个模型里套出来的。哎，看来我要学的还真多啊。说到这里，想想我的老同学张三啊，命苦啊，为了爱情整天忙碌的工作得到的确是冷落了心爱的“宝贝”，造成了第三者的加入，这时已是后悔...."这一切都是我错了，冷落了人家，或许也不是我的错，是她花心吧。不管怎样，她都接受别人了我还能？？？" 张三说：最后做出决定，离开他的“宝贝”：

1 // 这个善良的张三见女孩子多了好象开始花心了
2 // 或许是应该张三冷落了他才会引起第三者的加入
3 // 张三很后悔，决定离开了他的"宝贝"
4 g.removeEmotionListener(listener);

    当张三离开后，宝贝好象也后悔了，不想张三离开他：

   

哎，爱情总是这样，拥有的时候不好好珍惜，直到失去后才后悔莫及，人世间的......

宝贝 说:亲爱的张三,我不能没有你,请不要离开我！！

   总上所述，其实我们已经演绎了一个面向对象的设计模式--观察者模式，事件模型就是观察者模式的一种体现。本文只是趣味性的简单解说了一下事件模型的实现过程，要深入学习面向对象设计模式请查看相关书籍或资料。

    哎，原本浪漫的爱情故事最终却......，惭愧啊！我们帅气的张三现在会做什么？会不会因为"宝贝"的请求又回到她身边呢？还是彻底忘去旧爱，开始新的生活？要知详细请关注下回分解。

书籍推荐：
《软件设计精要与模式》，《JAVA与模式》以及WEBCAST等。