Java 监听器

定义事件对象，必须继承EventObject 

 

1. import java.util.EventObject;  
2. public class DoorEvent extends EventObject {  
3.     private String doorState = "";//表示门的状态，有“开”和“关”两种  
4.   
5.     public DoorEvent(Object source, String doorState) {  
6.         super(source);  
7.         this.doorState = doorState;  
8.     }  
9.   
10.     public void setDoorState(String doorState) {  
11.         this.doorState = doorState;  
12.     }  
13.   
14.     public String getDoorState() {  
15.         return this.doorState;  
16.     }  
17. }

 

定义监听接口，负责监听DoorEvent事件 

 

1. import java.util.EventListener;  
2. public interface DoorListener extends EventListener {  
3.     public void doorEvent(DoorEvent event);  
4. }

该类为 门1监听接口的实现，做具体的开门，关门动作 

 

1. public class DoorListener1 implements DoorListener {  
2.     public void doorEvent(DoorEvent event) {  
3.         if(event.getDoorState()!=null&&event.getDoorState().equals("open"))  
4.         {  
5.              System.out.println("门1打开");  
6.         }  
7.         else  
8.         {  
9.               System.out.println("门1关闭");  
10.         }  
11.     }  
12. }  
13.   
14. /** 
15. * 该类为 门2监听接口的实现，做具体的开门，关门，以及开灯，关灯动作 
16. */  
17. package test;  
18. public class DoorListener2 implements DoorListener {  
19.     public void doorEvent(DoorEvent event) {  
20.         if(event.getDoorState()!=null&&event.getDoorState().equals("open"))  
21.         {  
22.              System.out.println("门2打开，同时打开走廊的灯");  
23.         }  
24.         else  
25.         {  
26.               System.out.println("门2关闭，同时关闭走廊的灯");  
27.         }  
28.     }  
29. }

事件源对象，在这里你可以把它想象成一个控制开门关门的遥控器， 

 

1. import java.util.*;  
2. public class DoorManager {  
3.     private Collection listeners;  
4.     /** 
5.      * 添加事件 
6.      * @param listener DoorListener 
7.      */  
8.     public void addDoorListener(DoorListener listener) {  
9.         if (listeners == null) {  
10.             listeners = new HashSet();  
11.         }  
12.         listeners.add(listener);  
13.     }  
14.   
15.     /** 
16.      * 移除事件 
17.      * @param listener DoorListener 
18.      */  
19.     public void removeDoorListener(DoorListener listener) {  
20.         if (listeners == null)  
21.             return;  
22.         listeners.remove(listener);  
23.     }  
24.   
25.     /** 
26.      * 触发开门事件 
27.      */  
28.     protected void fireWorkspaceOpened() {  
29.         if (listeners == null)  
30.             return;  
31.         DoorEvent event = new DoorEvent(this, "open");  
32.         notifyListeners(event);  
33.     }  
34.   
35.     /** 
36.      * 触发关门事件 
37.      */  
38.     protected void fireWorkspaceClosed() {  
39.         if (listeners == null)  
40.             return;  
41.         DoorEvent event = new DoorEvent(this, "close");  
42.         notifyListeners(event);  
43.     }  
44.   
45.     /** 
46.      * 通知所有的DoorListener 
47.      */  
48.     private void notifyListeners(DoorEvent event) {  
49.         Iterator iter = listeners.iterator();  
50.         while (iter.hasNext()) {  
51.             DoorListener listener = (DoorListener) iter.next();  
52.             listener.doorEvent(event);  
53.         }  
54.     }  
55.   
56. }