监听器模式(Listener)

　　　　监听器模式有三个要素:

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

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

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

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

 执行顺序：

　　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是一个回调函数接口

https://www.cnblogs.com/jackson-yqj/p/7784694.html