一，类的四大基本关系： 

a.关联关系：如A类调用B类。 

b.继承关系：如A类是B类的父类。 

c.聚合关系：如装橘子的箱子，箱子是否存在与里面装没装橘子没有任何关系，也就是说橘子不会影响箱子的存在。 

d.组合关系：如一个小组，小组是否存在与小组中是否有组员是息息相关的，如果没有组员，小组就不存在了。

监听器模式：事件源经过事件的封装传给监听器，当事件源触发事件后，监听器接收到事件对象可以回调事件的方法

观察者模式：观察者(Observer)相当于事件监听者，被观察者(Observable)相当于事件源和事件，执行逻辑时通知observer即可触发oberver的update,同时可传被观察者和参数

二，监听模式

   当事件源对象上发生操作时，将会调用事件监听器的一个方法，并在调用该方法时把事件对象传递过去。

 

三，监听模式的使用实例

四，观察者模式与监听模式的区别

       什么也不说了，图是最直观的

 

1. 事件-监听机制 
事件源经过事件的封装传给监听器，当事件源触发事件后，监听器接收到事件对象可以回调事件的方法。 

demo

事件源:

Context:

[java] view plain copy

1. package com.demo.event;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. public class Context {  
7.     private static List<Listener> list=new ArrayList<Listener>();  
8.     public static void addListener(Listener listener){  
9.         list.add(listener);  
10.     }  
11.     public static void removeListener(Listener listener){  
12.         list.remove(listener);  
13.     }  
14.     public static void sendNotification(Event event){  
15.         for(Listener listener:list){  
16.             listener.onChange(event);  
17.         }  
18.     }  
19. }  

监听者:

Listener

[java] view plain copy

1. package com.demo.event;  
2.   
3. public interface Listener {  
4.     public void onChange(Event event);  
5. }  

MyListener

[java] view plain copy

1. package com.demo.event;  
2.   
3. public class MyListener implements Listener {  
4.   
5.     @Override  
6.     public void onChange(Event event) {  
7.         switch(event.getType()){  
8.             case Event.INSTALLED:  
9.                 System.out.println("do install...");  
10.                 break;  
11.             case Event.STARTED :  
12.                 System.out.println("do started...");  
13.                 break;  
14.             case Event.RESOLVED :  
15.                 System.out.println("do resolved...");  
16.                 break;  
17.             case Event.STOPPED :  
18.                 System.out.println("do stopped...");  
19.                 break;  
20.             case Event.UNRESOLVED :  
21.                 System.out.println("do unresolved...");  
22.                 break;  
23.             case Event.UNINSTALLED :  
24.                 System.out.println("do uninstalled...");  
25.                 break;  
26.             default:  
27.                 throw new IllegalArgumentException();  
28.         }  
29.     }  
30.   
31. }  

事件:

[java] view plain copy

1. package com.demo.event;  
2.   
3. public class Event {  
4.     public static final int INSTALLED =1;   
5.     public static final int STARTED =2;   
6.     public static final int RESOLVED  =3;   
7.     public static final int STOPPED =4;   
8.     public static final int UNRESOLVED  =5;   
9.     public static final int UNINSTALLED   =6;  
10.     private int type ;  
11.     private Object source ;  
12.     public Event(int type, Object source) {  
13.         this.type = type;  
14.         this.source = source;  
15.     }  
16.     public int getType() {  
17.         return type;  
18.     }  
19.     public Object getSource() {  
20.         return source;  
21.     }  
22. }  

测试:

[java] view plain copy

1. package com.demo.event;  
2.   
3. public class EventTest {  
4.   
5.     /** 
6.      * @param args 
7.      */  
8.     public static void main(String[] args) {  
9.         Listener listener=new MyListener();  
10.         //添加监听者  
11.         Context.addListener(listener);  
12.         //模拟bundle安装完成事件触发  
13.         Context.sendNotification(new Event(Event.INSTALLED, new MyBundle()));  
14.     }  
15.   
16. }  

2. 观察者模式 
观察者(Observer)相当于事件监听者（监听器），被观察者(Observable)相当于事件源和事件，执行逻辑时通知observer即可触发oberver的update,同时可传被观察者和参数。简化了事件-监听模式的实现。 

3．对比 
（1） 从uml图上也可以看出，Observer的实现相对简单，event-listener需要实现三个角色，observer-observable需要实现两个角色。 

（2）Observable的api已经把对观察者的注册，删除等定义好了，而且是线程安全的。而event-listener需要使用者自己实现。 

（3）两者都需要自己定义并实现触发事件的通知。但Observable需要注意要在通知Observer之前调用jdk提供的setChanged()。 

（4）event-listener是传统的c/s界面事件模型，分事件源和事件（状态）角色，事件源要经过事件的包装、成为事件的属性之一再传递给事件监听/处理者，这个事件监听者就相当于观察者。Observer更简洁一些。两者在思想上是统一的，很多框架仍然使用了event-listener模式，比如spring框架的ApplicationEvent,ApplicationListener。