监听器模式有三个要素:
事件源:顾名思义，事件发生的源头，比如点击的按钮，可以工作可以运作的机器人，属于被监听的对象
事件对象:这个经常和事件源混淆，它经常被用来包装事件源，或者说执行某个方法，比如点击事件,机器人程序执行
监听器:这个是监听器模式的核心，定义事件发生后的动作，通常事件对象作为监听器中定义的函数入参
当事件源对象上发生操作时，将会调用时间监听的一个方法，并在调用方法的时候把事件对象传递过去
执行顺序：
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<EventListener> 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是一个回调函数接口