监听器模式有三个要素:

事件源:顾名思义，事件发生的源头，比如点击的按钮，可以工作可以运作的机器人，属于被监听的对象

事件对象:这个经常和事件源混淆，它经常被用来包装事件源，或者说执行某个方法，比如点击事件,机器人程序执行

监听器:这个是监听器模式的核心，定义事件发生后的动作，通常事件对象作为监听器中定义的函数入参

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

执行顺序：

1.给事件源注册监听器

2.组件接受外部作用，也就是事件触发

3.组件产生一个相应的事件对象，并把此对象传递给与之关联的事件处理器

4.事件处理器启动，并执行相关代码来处理事件

监听器模式:事件源注册监听器后，当事件源触发事件，监听器就可以回调事件对象的方法;

更加形象地说，监听者模式就是基于:注册-回调事件/消息通知处理模式，就是被监听者将消息通知给所有监控者

1.注册监听器:事件源.setListener

2.回调:事件源实现onListener

/**

* 事件源:机器人

*/

public class Robot{

private RobotListener listener;

/**

* 注册机器人监听器

* @param listener

*/

public void registerListener(RobotListener listener){

this.listener = listener;

}

/**

* 工作

*

*/

public void working() {

if (listener != null){

Even even = new Even(this);

this.listener.working(even);

}

System.out.println("robot 开始 工作.......");

}

/**

* 跳舞

*

*/

public void dancing() {

if (listener != null){

Even even = new Even(this);

this.listener.dancing(even);

}

System.out.println("robot 开始 跳舞.......");

}

}

/**

* 监听器接口

*/

public interface RobotListener {

/**

* 工作

* @param even

*/

void working(Even even);

/**

* 跳舞

* @param even

*/

void dancing(Even even);

}

public class MyRobotListener implements RobotListener {

/**

* 工作

*

* @param even

*/

@Override

public void working(Even even) {

Robot robot = even.getRobot();

System.out.println("机器人开始工作，防止偷窥.....");

}

/**

* 跳舞

*

* @param even

*/

@Override

public void dancing(Even even) {

Robot robot = even.getRobot();

System.out.println("机器人开始跳舞，防止走神.....");

}

}

/**

* 事件对象

*/

public class Even {

private Robot robot;

public Even() {

super();

}

public Even(Robot robot) {

super();

this.robot = robot;

}

public Robot getRobot(){

return robot;

}

public void setRobot(Robot robot) {

this.robot = robot;

}

}

public class TestListener {

public static void main(String[] args) {

Robot robot = new Robot();

robot.registerListener(new MyRobotListener());

robot.working();

robot.dancing();

}

}

or

/**

* 监听器接口

*/

public interface EventListener extends java.util.EventListener {

/**

* 事件处理

* @param eventObject

*/

void handleEvent(EventObject eventObject);

}

/**

* 事件对象

*/

public class EventObject extends java.util.EventObject {

public EventObject(Object source) {

super(source);

}

public void doEvent(){

System.out.println("通知一个事件源 source:"+this.getSource());

}

}

/**

* 事件源

*/

public class EventSource {

// 监听器列表，

private List listeners = new ArrayList();

public void addListener(EventListener listener){

listeners.add(listener);

}

public void removeListener(EventListener listener){

listeners.remove(listener);

}

public void notifyListenerEvent(EventObject eventObject){

listeners.forEach(x->{

x.handleEvent(eventObject);

});

}

}

测试执行

public class EventDome {

public static void main(String[] args) {

EventSource eventSource = new EventSource();//事件源

eventSource.addListener(eventObject -> {

eventObject.doEvent();

if (eventObject.getSource().equals("closeWindow")) {

System.out.println("doClose。。。。。"); //回调

}

});

EventObject eventObject = new EventObject("closeWindow"); // 事件对象

eventSource.notifyListenerEvent(eventObject); // 触发事件

}

}

通知一个事件源 source:closeWindow

doClose。。。。。

EventListener是一个回调接口类，handleEvent是一个回调函数接口