精华内容
下载资源
问答
  • Java事件监听器模式

    2017-08-05 19:58:04
    事件监听器模式(一个简单的例子) 在GUI程序设计中,在设计时通常不会知道用户的动作什么时候会发生,如用户可能点击某一 个按钮,也可能不点击,而且点击按钮的时机在运行时才可能知道。如果用传统的程序控制 ...

    事件监听器模式(一个简单的例子)

    在GUI程序设计中,在设计时通常不会知道用户的动作什么时候会发生,如用户可能点击某一
    个按钮,也可能不点击,而且点击按钮的时机在运行时才可能知道。如果用传统的程序控制
    方式,则很难做到准确的响应。通常这种情况或者类似的情况下,我们可以使用事件/监听器模式。

    将一个监听器(listener)与特定的控件(如按钮等)绑定起来,当发生用户点击等事件(Event)时,
    调用监听器的处理方法,从而响应用户的动作。是为事件/监听器模式。

    事件有很多种,而且事件发生的时序是不确定的。可以简单的定义一个事件的接口,如下例:

    Java代码
    1. interface Event{   
    2.     static int event1 0;   
    3.     static int event2 1;   
    4.     static int event3 2;   
    5.     …   
    6.     int getEventType();   
    7.  

    一个监听器的接口的一种可能形式:

    Java代码
    1. interface listener{   
    2.     void handleEvent(Event event);   

    实现监听器接口的类可以根据事件的类型作出具体的响应方式如:

    Java代码
    1. class ListenerImpl implements Listener{   
    2. some other methods of this implementation;   
    3. …   
    4. void handleEvent(Event event){   
    5.     switch(event.getEventType()){   
    6.         case Event.event1:   
    7.             doSomething();   
    8.             break;   
    9.         case Event.event2:   
    10.             doSomethingElse();   
    11.             break;   
    12.         default:   
    13.             break;   
    14.     }   
    15. }   
    16.   
    17. GUIThread thread new GUIThread();   
    18. thread.setListener(this);//注册监听器   
    19. …   
    20.  


    在GUI的主流程中,需要有一个Event的实现者,和一个发起事件的组件,如:

    Java代码
    1. class EventImpl implements Event{   
    2.     private int type;   
    3.     public EnentImpl(int type){   
    4.         this.type type;   
    5.     }   
    6. }   
    7.   
    8. class GUIThread{   
    9.     private Listener listener;   
    10.     public void setListener(Listener listener){   
    11.         this.listener listener;   
    12.     }   
    13.       
    14.     public void execute(){   
    15.         if(this.listener != null){   
    16.             Event event new EventImpl(type);//触发了某事件   
    17.             listener.handleEvent(event);   
    18.         }   
    19.     }   
    20.  

    当然,这个实现只是一个原理性的描述,应该可以很容易根据这个描述作出自己的实现。关于事件的处理以及事件类型的定义等可以完全根据自己的需求定制。

    原文地址:Java事件监听器模式

    展开全文
  • Java简单几个类实现万能事件总线,采用享元模式和监听器模式。 使用方法很简单,直接EventCenter.get().addListener(key,()->{...你的代码快...});就行, 无论在哪,只要执行EventCenter.get().sendMessage(key,...
  • java事件监听器原理

    千次阅读 2017-10-06 12:51:25
    java事件监听器分为三部分:事件事件源,监听器事件事件状态对象,也就是发生了什么事件。用于listener的相应的方法之中,作为参数,一般存在与listerner的方法之中。(伴随着事件的发生,相应的状态通常都封装...

    java事件监听器分为三部分:事件,事件源,监听器。

    事件—事件状态对象,也就是发生了什么事件。用于listener的相应的方法之中,作为参数,一般存在与listerner的方法之中。(伴随着事件的发生,相应的状态通常都封装在事件状态对象中,该对象必须继承自java.util.EventObject。事件状态对象作为单参传递给应响应该事件的监听者方法中。发出某种特定事件的事件源的标识是:遵从规定的设计格式为事件监听者定义注册方法,并接受对指定事件监听者接口实例的引用。)

    事件源—具体的事件源,比如说,你点击一个button,那么button就是event source,要想使button对某些事件进行响应,你就需要注册特定的listener(事件就是事件源中的一个状态)。这些方法都集中定义在事件监听者(EventListener)接口中,这个接口要继承 java.util.EventListener

    监听器—对每个明确的事件的发生,都相应地定义一个明确的Java方法

    —— 实例:

    如果博客可以作为一个事件源,那么修改,新增,删除都是事件,可以这么写。

    事件类

    接口:

    package event.events;
    
    import java.util.EventObject;
    
    public interface EventInfo{
        public String getDoType() ;
    }
    

    实现类:

    package event.events;
    
    import java.util.EventObject;
    
    public class AddEvent extends EventObject implements EventInfo{
        private final String doType = "add";
    
        /**
         * Constructs a prototypical Event.
         *
         * @param source The object on which the Event initially occurred.
         * @throws IllegalArgumentException if source is null.
         */
        public AddEvent(Object source) {
            super(source);
        }
    
        @Override
        public String toString(){
            return doType;
        }
    
        @Override
        public String getDoType(){
            return doType;
        }
    }
    
    package event.events;
    
    import java.util.EventObject;
    
    public class DelEvent extends EventObject implements EventInfo {
    
        //事件类型
        public final String doType= "delete";
    
        /**
         * Constructs a prototypical Event.
         *
         * @param source The object on which the Event initially occurred.
         * @throws IllegalArgumentException if source is null.
         */
        public DelEvent(Object source) {
            super(source);
        }
    
        @Override
        public String toString(){
            return doType;
        }
    
        @Override
        public String getDoType() {
            return doType;
        }
    }
    
    package event.events;
    
    import java.util.EventObject;
    
    public class ModifyEvent extends EventObject implements EventInfo{
        private final String doType = "modify";
    
        /**
         * Constructs a prototypical Event.
         *
         * @param source The object on which the Event initially occurred.
         * @throws IllegalArgumentException if source is null.
         */
        public ModifyEvent(Object source) {
            super(source);
        }
    
        @Override
        public String toString(){
            return doType;
        }
    
        @Override
        public String getDoType() {
            return doType;
        }
    }
    

    监听器

    接口

    package event.eventListener;
    
    import event.events.EventInfo;
    
    import java.util.EventListener;
    
    public interface EventListenerInfo extends EventListener {
    
        public default void handler(EventInfo eventInfo){
            System.out.println(eventInfo.toString());
        }
    
    }
    

    实现类

    package event.eventListener;
    
    import event.events.EventInfo;
    
    public class AddEventListener implements EventListenerInfo{
    
        @Override
        public void handler(EventInfo object) {
            if(object.getDoType().equals("add"))
                System.out.println("新增文章。。。。");
            //进行后续操作
        }
    }
    
    package event.eventListener;
    
    import event.events.EventInfo;
    
    public class DelEventListener implements EventListenerInfo{
    
        @Override
        public void handler(EventInfo object) {
            if(object.getDoType().equals("delete"))
                System.out.println("删除文章。。。。");
            //进行后续操作
        }
    }
    
    package event.eventListener;
    
    import event.events.EventInfo;
    
    public class ModifyEventListener implements EventListenerInfo{
    
        @Override
        public void handler(EventInfo object) {
            if(object.getDoType().equals("modify"))
                System.out.println("修改文章。。。。");
            //进行后续操作
        }
    }
    

    事件源

    package event;
    
    import com.sun.org.apache.xpath.internal.SourceTree;
    import event.eventListener.EventListenerInfo;
    import event.events.AddEvent;
    import event.events.DelEvent;
    import event.events.EventInfo;
    import event.events.ModifyEvent;
    
    import java.util.Collection;
    import java.util.EventObject;
    import java.util.HashSet;
    import java.util.Iterator;
    
    /**
     * 1.事件源--事件发生的地方。如一个map集合,它上面发生的增删查改,就是事件;这个map
     *   就是事件源。
     * 2.这个事件源是一篇博客。
     * 3.我们可以创建多个事件源
     */
    public class EventSource
    {
        private Collection listeners;
    
        //给事件源注册监听器
        public void addDoListener(EventListenerInfo eventListener){
            if(listeners==null){
                listeners = new HashSet();
            }
            listeners.add(eventListener);
        }
    
        //给事件源注销监听器
        public void remvoeDolistener(EventListenerInfo eventListener){
            if(listeners == null){
                return;
            }
            listeners.remove(eventListener);
        }
    
        //触发删除事件
        public void fireDelEvent(){
            if(listeners==null)
                return;
            EventInfo ei = new DelEvent(this);
            notifies(ei);
        }
    
        //触发新建事件
        public void fireAddEvent(){
            if(listeners==null)
                return;
            EventInfo ei = new AddEvent(this);
            notifies(ei);
        }
    
        //触发修改事件
        public void fireModifyEvent(){
            if(listeners==null)
                return;
            EventInfo ei = new ModifyEvent(this);
            notifies(ei);
        }
    
    
        //当该事件源上有事件发生时,通知该事件源上的所有的监听器做出相应的反应
        public void notifies(EventInfo eventInfo){
            Iterator it = listeners.iterator();
            while (it.hasNext()){
                ((EventListenerInfo)it.next()).handler( eventInfo);
            }
        }
    }
    

    测试

    package event;
    
    import event.eventListener.AddEventListener;
    import event.eventListener.DelEventListener;
    import event.eventListener.ModifyEventListener;
    import event.events.AddEvent;
    
    public class Test {
    
        public static void main(String[] args) {
            EventSource es = new EventSource();      //一个博客事件源
            EventSource es2 = new EventSource();     //另一个博客的事件源
    
            //给每个事件源增加监听器
            es.addDoListener(new AddEventListener());
            es.addDoListener(new DelEventListener());
            es.addDoListener(new ModifyEventListener());
    
            es2.addDoListener(new AddEventListener());
            es2.addDoListener(new DelEventListener());
            es2.addDoListener(new ModifyEventListener());
    
            //事件发生
            es.fireAddEvent();
            es.fireModifyEvent();
            es.fireDelEvent();
    
            es2.fireAddEvent();
            es2.fireModifyEvent();
            es2.fireDelEvent();
        }
    }
    

    后记:其实可以把三个事件类放到一个类里面,用一个变量分别代表三种状态(新增,修改,删除),在EventListener中也可以放在同一个类中,可以根据事件的状态,进行不同的处理。这样做的可以随时根据当前状态判断发生的是什么事件。

    展开全文
  • 事件监听包括必不可少的三个元素:事件事件源和监听器事件:容易理解,点击一下鼠标是一个事件,更改某个类属性也可以抽象为一个事件事件源:发布事件的地方,也就是事件产生的地方。 监听器:定义事件...

    事件监听包括必不可少的三个元素:事件、事件源和监听器。

    事件:容易理解,点击一下鼠标是一个事件,更改某个类属性也可以抽象为一个事件。

    事件源:发布事件的地方,也就是事件产生的地方。

    监听器:定义事件发生后要采取的操作。

    1,接下来举例说明Java如何实现监听模式

    事件:

    package com.wxy.popcorn.eventlistener.model;
    
    import java.util.EventObject;
    
    public class MyEvent extends EventObject {
        private String name;
    
        /**
         * Constructs a prototypical Event.
         *
         * @param source The object on which the Event initially occurred.
         * @throws IllegalArgumentException if source is null.
         */
        public MyEvent(Object source, String name) {
            super(source);
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    }

    事件源:

    package com.wxy.popcorn.eventlistener.model;
    
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    
    import com.wxy.popcorn.eventlistener.listener.MyListener;
    
    public class EventSource {
        private String name;
        private Set<MyListener> listeners = new HashSet<MyListener>();
    
        public void addListener(MyListener myListener) {
            listeners.add(myListener);
        }
    
        public void removeListener(MyListener myListener) {
            listeners.remove(myListener);
        }
    
        public void notifyEvent(MyEvent myEvent) {
            Iterator<MyListener> iterator = listeners.iterator();
            while(iterator.hasNext()) {
                MyListener listener = iterator.next();
                listener.handleEvent(myEvent);
            }
        }
    
        //当name属性发生了改变时发布一个事件。当然,完全可以在其他的逻辑下发布事件
        public void updateName(String name) {
            if(name==null && this.name==null) {
                return;
            }
            if (name==null || this.name==null || !name.equals(this.name)) {
                this.name = name;
                notifyEvent(new MyEvent(this, name));
            }
        }
    }
    


    监听器接口:

    package com.wxy.popcorn.eventlistener.listener;
    
    import java.util.EventListener;
    
    import com.wxy.popcorn.eventlistener.model.MyEvent;
    
    public interface MyListener extends EventListener{
        void handleEvent(MyEvent myEvent);
    }
    


    监听器实现:

    package com.wxy.popcorn.eventlistener.listener;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import com.wxy.popcorn.eventlistener.model.MyEvent;
    
    public class MyListenerImpl implements MyListener{
        private Logger logger = LoggerFactory.getLogger(this.getClass());
        public void handleEvent(MyEvent myEvent) {
            logger.info("the name was set to {}", myEvent.getName());
        }
    }
    


    测试类:

    package com.wxy.popcorn;
    
    import org.junit.Test;
    
    import com.wxy.popcorn.eventlistener.listener.MyListenerImpl;
    import com.wxy.popcorn.eventlistener.model.EventSource;
    
    public class EventlistenerTest {
    
        @Test
        public void test() {
            EventSource eventSource = new EventSource();
            eventSource.addListener(new MyListenerImpl());
            eventSource.updateName("popcorn");
        }
    }
    

    运行结果:

    2018-01-07 19:01:36.886 [main] INFO  [MyListenerImpl.java:11] the name was set to popcorn

    2,Spring事件监听

    事件:继承于SpringEvent,当然也可以不从SpringEvent继承,任意Object都可以作为事件发布。

    事件源:事件源必须实现 ApplicationEventPublisherAware 接口,调用ApplicationEventPublisher.publishEvent()发布事件。

    监听:使用@EventListener注解来标注事件处理方法,方法参数是事件对象。如果需要异步监听,则增加@Async注解。

    事件类:

    package com.wxy.popcorn.eventlistener.model;
    
    import org.springframework.context.ApplicationEvent;
    
    public class SpringEvent extends ApplicationEvent {
    
        private String name;
    
        public SpringEvent(Object source, String name) {
            super(source);
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    }
    

    事件源:

    package com.wxy.popcorn.eventlistener.model;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.ApplicationEventPublisher;
    import org.springframework.context.ApplicationEventPublisherAware;
    import org.springframework.stereotype.Service;
    
    @Service
    public class SpringEventSource implements ApplicationEventPublisherAware {
        private String name;
    
        @Autowired
        private ApplicationEventPublisher applicationEventPublisher;
    
        public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
            this.applicationEventPublisher = applicationEventPublisher;
        }
    
        public void updateName(String name) {
            if(name==null && this.name==null) {
                return;
            }
            if (name==null || this.name==null || !name.equals(this.name)) {
                this.name = name;
                applicationEventPublisher.publishEvent(new SpringEvent(this, name));
            }
        }
    }
    

    监听器:

    package com.wxy.popcorn.eventlistener.listener;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.context.event.EventListener;
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.stereotype.Service;
    
    import com.wxy.popcorn.eventlistener.model.SpringEvent;
    
    @Service
    public class SpringListener {
        Logger logger = LoggerFactory.getLogger(this.getClass());
    
        @EventListener
        @Async //异步监听
        public void handleEvent(SpringEvent springEvent) {
            logger.info("the name was set to {}", springEvent.getName());
        }
    }
    

    测试类:

    package com.wxy.popcorn;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import com.wxy.popcorn.eventlistener.App;
    import com.wxy.popcorn.eventlistener.model.SpringEventSource;
    @RunWith(SpringRunner.class)
    @SpringBootTest(classes = App.class)
    public class SpringEventlistenerTest {
    
        @Autowired
        SpringEventSource springEventSource;
    
        @Test
        public void test() {
            springEventSource.updateName("popcorn");
        }
    }
    


    测试结果:

    2018-01-07 19:11:37.479 [main] INFO  [SpringListener.java:18] the name was set to popcorn



    展开全文
  • 监听器模式事件源经过事件的封装传给监听器,当事件源触发事件后,监听器接收到事件对象可以回调事件的方法 观察者模式:观察者(Observer)相当于事件监听者,被观察者(Observable)相当于事件源和事件,执行逻辑...

    监听器模式:事件源经过事件的封装传给监听器,当事件源触发事件后,监听器接收到事件对象可以回调事件的方法

    观察者模式:观察者(Observer)相当于事件监听者,被观察者(Observable)相当于事件源和事件,执行逻辑时通知observer即可触发oberver的update,同时可传被观察者和参数

    监听器模式demo

    1、首要定义事件源对象(事件源相当于单击按钮事件当中的按钮对象、属于被监听者):

    [java] view plain copy
    1. publicclass DemoSource {     
    2. private Vector repository = new Vector();//监听自己的监听器队列   
    3. public DemoSource(){}     
    4. publicvoid addDemoListener(DemoListener dl) {     
    5.            repository.addElement(dl);     
    6.     }     
    7. publicvoid notifyDemoEvent() {//通知所有的监听器   
    8.            Enumeration enum = repository.elements();     
    9. while(enum.hasMoreElements()) {     
    10.                    DemoListener dl = (DemoListener)enum.nextElement();     
    11.                  dl.handleEvent(new DemoEvent(this));     
    12.            }     
    13.     }     
    14. }    


    2、其次定义事件(状态)对象(该事件对象包装了事件源对象、作为参数传递给监听器、很薄的一层包装类):

    [java] view plain copy
    1. publicclass DemoEvent extends java.util.EventObject {     
    2. public DemoEvent(Object source) {     
    3. super(source);//source—事件源对象—如在界面上发生的点击按钮事件中的按钮   
    4. //所有 Event 在构造时都引用了对象 "source",在逻辑上认为该对象是最初发生有关 Event 的对象   
    5.     }     
    6. publicvoid say() {     
    7.            System.out.println("This is say method...");     
    8.     }     
    9. }    

    3、最后定义我们的事件侦听器接口如下

    [java] view plain copy
    1. publicinterface DemoListener extends java.util.EventListener {     
    2. //EventListener是所有事件侦听器接口必须扩展的标记接口、因为它是无内容的标记接口、   
    3. //所以事件处理方法由我们自己声明如下:   
    4. publicvoid handleEvent(DemoEvent dm);     
    5. }  

    监听器实现类

    [java] view plain copy
    1. publicclass DemoListener1 implements DemoListener {     
    2. publicvoid handleEvent(DemoEvent de) {     
    3.               System.out.println("Inside listener1...");     
    4.               de.say();//回调   
    5.        }     
    6. }   

    4、测试代码

    [java] view plain copy
    1. publicclass TestDemo {     
    2.    DemoSource ds;     
    3. public TestDemo(){     
    4. try{     
    5.          ds = new DemoSource();     
    6. //将监听器在事件源对象中登记:   
    7.          DemoListener1 listener1 = new DemoListener1();     
    8.          ds.addDemoListener(listener1);     
    9.          ds.addDemoListener(new DemoListener() {     
    10. publicvoid handleEvent(DemoEvent event) {     
    11.             System.out.println("Method come from 匿名类...");     
    12.           }     
    13.         });     
    14.        ds.notifyDemoEvent();//触发事件、通知监听器   
    15.      }catch(Exception ex){  
    16.        ex.printStackTrace();  
    17.        }     
    18.     }     
    19. publicstaticvoid main(String args[]) {     
    20. new TestDemo();     
    21.     }     
    22. }    

    观察者模式demo

    观察者

    [java] view plain copy
    1. class Watcher implements java.util.Observer {     
    2. publicvoid update(java.util.Observable obj, Object arg) {     
    3.     System.out.println("Update() called, count is "
    4.                                 + ((Integer) arg).intValue());     
    5. }     
    6. }    


    被观察者

    [java] view plain copy
    1. class BeingWatched extends java.util.Observable {     
    2. void counter(int period) {     
    3. for(; period<=0; period-- ) {     
    4.                 setChanged();     
    5.                 notifyObservers(new Integer(period));     
    6. try {     
    7.                         Thread.sleep(100);     
    8.                 } catch( InterruptedException e) {     
    9.                   System.out.println("Sleep interrupeted" );     
    10.                 }     
    11.         }     
    12. }     
    13. };     


    测试

    [java] view plain copy
    1. publicclass ObserverDemo {     
    2. publicstaticvoid main(String[] args) {     
    3.         BeingWatched beingWatched = new BeingWatched();//受查者   
    4.         Watcher watcher = new Watcher();//观察者   
    5.         beingWatched.addObserver(watcher);     
    6.         beingWatched.counter(10);     
    7.     }     
    8. }    
    查阅了一些相关的东东 
    原来这两种api可以说都是基于:订阅-发布模式的事件/消息通知模式,二者应该都算是“推”方式吧,就是被监控者将消息通知给所有监控者。 
    1、订阅:Observable.addObserver;
    事件源.addDemoListener(这个方法是自己定义的)。 

    2、发布:Observable需要两步 :setChanged()、notifyObservers(newValue); 
    事件源.notifyDemoEvent()(这个方法也是自己定义的)。
    展开全文
  • 事情监听设计模式(通俗易懂) 这样一个场景:小狗要吃饭,爸爸妈妈收到他吃饭的消息 有哪些类呢 Dog:小狗,要被人监听了(事件源) PeopleEventLister:监听者的抽象接口,到时具体哪个类要监听小狗吃饭就要实现...
  • 最近在开发监控系统,涉及事件监听,所以又把之前的观察者设计模式和事件监听器模式拿了出来重新学习一下,总结内容如下: 观察者模式 1.名词解释 观察者对象:观察者对象是监听被观察者的一个对象,当被观察者状态...
  • 监听器将监听感兴趣的事件,一旦事件发生,便做出响应(属于设计模式中的观察者模式) 一:事件监听器组成部分 1.事件源(Event Source) 2.事件监听器(Event Listener) 作用于事件源 3.事件对象(Event Object)...
  • java事件监听器

    2011-06-01 21:30:42
    事件监听器机制是观察者模式的一种,通过把事件源和事件处理流程以监听器的方法隔离开来,减小了主流程与被触发事件的执行流程间的耦合,便于代码的维护和对事件处理流程的扩展。 在事件监听机制中,涉及到三个...
  • JAVA事件监听器

    千次阅读 2012-07-20 16:20:25
    java事由事件类和监听接口组成,算定义一个事件前,必须提供一个事件监听接口以及一个事件类。java监听接口是继承自java.util.EventListener的,事件类继承自java.util.EventObject。很多基本的事件系统已经为...
  • Java事件监听到Spring事件监听 java 事件监听 1. 发布订阅模式 java.util.Observable发布者 public class Observable { private boolean changed = false; private Vector&lt;Observer&gt; obs; /** ...
  • java事件监听

    千次阅读 2014-10-20 11:29:12
    java事件机制包括三个部分:事件事件监听器事件源。   1、事件。一般继承自java.util.EventObject类,封装了事件源对象及跟事件相关的信息。 com.javaedu.event.CusEvent类 Java代码  ...
  • 这两个模式实质上很简单,在实际项目中...监听器模式事件源经过事件的封装传给监听器,当事件源触发事件后,监听器接收到事件对象可以执行监听器要实现的业务功能,也可以回调事件源的方法。 观察者模式:观察者(...
  • 这只是几个小技巧,如果是主业务,那么不能用异步事件监听器.最好都在主方法里实现. 关于spring 事件的使用和示例代码;可参考我以前写的博客,站内链接: https://my.oschina.net/u/1590027/blog/1511379 ...
  • 监听器模式事件源经过事件的封装传给监听器,当事件源触发事件后,监听器接收到事件对象可以回调事件的方法 观察者模式:观察者(Observer)相当于事件监听者,被观察者(Observable)相当于事件源和事件,执行逻辑时...
  • 什么是事件监听? 例如,点击按钮,弹出一个文本框,点击一个文本,文本被删除; 按钮、文本等组件就是事件事件就是从开始触发事件源到出现效果的一个过程 以下是一个案例,点击按钮,记录点击的次数和获取...
  • 主要介绍了Java设计模式之监听器模式,结合实例形式较为详细的分析了java设计模式中监听器模式的概念、原理及相关实现与使用技巧,需要的朋友可以参考下
  • 监听器模式事件源经过事件的封装传给监听器,当事件源触发事件后,监听器接收到事件对象可以回调事件的方法 观察者模式:观察者(Observer)相当于事件监听者,被观察者(Observable)相当于事件源和事件,执行逻辑时...
  • 事件监听模型 对于事件监听模型,主要分为三部分: 事件源:就是事件发生的地方,比如一个按钮被点击了,那么事件源就是按钮 事件:发生了什么事,比如按钮被点击了,那么点击就是一个事件 监听者:监听发生了什么...
  • java 监听器和监听器模式

    千次阅读 2017-01-09 14:25:37
    监听器是观察者模式的一种实现,监听器模式也就是观察者模式的一种。  监听器模式是对某种共有操作的监控。当此操作执行时对此操作作相应处理。 包含的元素:  1. 要监控的事件定义Event  2. 监控该...
  • Java监听模式

    千次阅读 2018-02-07 22:12:46
    Java监听模式右三个部分组成:事件源、事件对象、事件监听器事件源触发某种行为,会自动执行事件监听器里面相应的方法 事件监听器方法参数是事件对象,事件对象包含事件源的引用,在方法中可以获取事件源的引用 ...
  • package .../**java事件监听机制和观察者设计模式 * Created by Dev_yang on 2016/3/1. */ public class Demo { public static void main(String[] args) { EventSource eventSource = new Eve

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 183,763
精华内容 73,505
关键字:

java事件监听模式

java 订阅