转 java事件机制（自定义事件）实例详解

Java事件处理机制

java中的事件机制的参与者有3种角色：

1.event object（事件类，事件触发/发布）：事件状态对象，用于listener的相应的方法之中，作为参数，一般存在于listerner的方法之中

2.event source（事件源类）：具体的事件源，比如说，你点击一个button，那么button就是event source，要想使button对某些事件进行响应，你就需要注册特定的listener。

3.event listener（监听类）：对每个明确的事件的发生，都相应地定义一个明确的Java方法。这些方法都集中定义在事件监听者（EventListener）接口中，这个接口要继承 java.util.EventListener。 实现了事件监听者接口中一些或全部方法的类就是事件监听者。

　　伴随着事件的发生，相应的状态通常都封装在事件状态对象中，该对象必须继承自java.util.EventObject。事件状态对象作为单参传递给应响应该事件的监听者方法中。发出某种特定事件的事件源的标识是：遵从规定的设计格式为事件监听者定义注册方法，并接受对指定事件监听者接口实例的引用。

具体的对监听的事件类，当它监听到event object产生的时候，它就调用相应的方法，进行处理。

先看看jdk提供的event包：

public interface EventListener：所有事件侦听器接口必须扩展的标记接口。

public class EventObject extends Object implements Serializable

所有事件状态对象都将从其派生的根类。 所有 Event 在构造时都引用了对象 "source"，在逻辑上认为该对象是最初发生有关 Event 的对象。

（1）通过DoorEvent.java文件创建DoorEvent类，这个类继承EventObject。

 

1. /**

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

3. */

4. public class DoorEvent extends EventObject {

5.  

6. private static final long serialVersionUID = 6496098798146410884L;

7.  

8. private String doorState = "";// 表示门的状态，有“开”和“关”两种

9.  

10. public DoorEvent(Object source, String doorState) {

11. super(source);

12. this.doorState = doorState;

13. }

14.  

15. public void setDoorState(String doorState) {

16. this.doorState = doorState;

17. }

18.  

19. public String getDoorState() {

20. return this.doorState;

21. }

22.  

23. }

（2）定义新的事件监听接口，该接口继承自EventListener；该接口包含对doorEvent事件的处理程序：

 

 

1. /**

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

3. */

4.  

5. public interface DoorListener extends EventListener {

6. public void doorEvent(DoorEvent event);

7. }

通过上面的接口我们再定义事件监听类，这些类具体实现了监听功能和事件处理功能。

 

 

1. /**

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

3. */

4.  
5.  

6. public class DoorListener1 implements DoorListener {

7. @Override

8. public void doorEvent(DoorEvent event) {

9. // TODO Auto-generated method stub

10. if (event.getDoorState() != null && event.getDoorState().equals("open")) {

11. System.out.println("门1打开");

12. } else {

13. System.out.println("门1关闭");

14. }

15. }

16.  

17. }

18.  

19. /**

20.  

21. * 该类为 门2监听接口的实现，做具体的开门，关门，以及开灯，关灯动作

22. */

23.  
24.  

25. public class DoorListener2 implements DoorListener {

26.  

27. @Override

28. public void doorEvent(DoorEvent event) {

29. // TODO Auto-generated method stub

30. if (event.getDoorState() != null && event.getDoorState().equals("open")) {

31. System.out.println("门2打开，同时打开走廊的灯");

32. } else {

33. System.out.println("门2关闭，同时关闭走廊的灯");

34. }

35. }

36.  

37. }

（3）通过DoorManager.java创造一个事件源类，它用一个Collection listeners对象来存储所有的事件监听器对象，存储方式是通过addDoorListener(..)这样的方法。notifyListeners(..)是触发事件的方法，用来通知系统：事件发生了，你调用相应的处理函数吧。

1. /**

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

3. * (如果是在swing中，就类似一个button)

4. */

5.  
6.  

7. public class DoorManager {

8. private Collection listeners;

9.  

10. /**

11. * 添加事件

12. *

13. * @param listener

14. * DoorListener

15. */

16. public void addDoorListener(DoorListener listener) {

17. if (listeners == null) {

18. listeners = new HashSet();

19. }

20. listeners.add(listener);

21. }

22.  

23. /**

24. * 移除事件

25. *

26. * @param listener

27. * DoorListener

28. */

29. public void removeDoorListener(DoorListener listener) {

30. if (listeners == null)

31. return;

32. listeners.remove(listener);

33. }

34.  

35. /**

36. * 触发开门事件

37. */

38. protected void fireWorkspaceOpened() {

39. if (listeners == null)

40. return;

41. DoorEvent event = new DoorEvent(this, "open");

42. notifyListeners(event);

43. }

44.  

45. /**

46. * 触发关门事件

47. */

48. protected void fireWorkspaceClosed() {

49. if (listeners == null)

50. return;

51. DoorEvent event = new DoorEvent(this, "close");

52. notifyListeners(event);

53. }

54.  

55. /**

56. * 通知所有的DoorListener

57. */

58. private void notifyListeners(DoorEvent event) {

59. Iterator iter = listeners.iterator();

60. while (iter.hasNext()) {

61. DoorListener listener = (DoorListener) iter.next();

62. listener.doorEvent(event);

63. }

64. }

65. }

（4）好了，最后写一个测试程序测试一下我们自定义的事件吧

1. /**

2. * 主程序，就想象成要开门的哪个人

3. */

4.  
5.  

6. public class DoorMain {

7. public static void main(String[] args) {

8. DoorManager manager = new DoorManager();

9. manager.addDoorListener(new DoorListener1());// 给门1增加监听器

10. manager.addDoorListener(new DoorListener2());// 给门2增加监听器

11. // 开门

12. manager.fireWorkspaceOpened();

13. System.out.println("我已经进来了");

14. // 关门

15. manager.fireWorkspaceClosed();

16. }

17. }

 

 

运行DoorMain

门1打开 
门2打开，同时打开走廊的灯

我已经进来了

门1关闭
门2关闭，同时关闭走廊的灯