精华内容
下载资源
问答
  • vue 第五天 (事件监听基础)

    万次阅读 2021-03-03 08:37:12
    vue 第五天 (事件监听基础) 一般事件监听写的是 v-on:简化@ 1、单击事件 v-on:click 简化 @click <!--单击+1事件--> <div id="vue_one"> <h2>{{result}}</h2> <button @click=...

    vue 第五天 (事件监听基础)

    一般事件监听写的是 v-on:简化@

    1、单击事件 v-on:click 简化 @click

    <!--单击+1事件-->
    <div id="vue_one">
        <h2>{{result}}</h2>
        <button @click="increment">+1</button>
    </div>
    <script type="text/javascript">
        const vm = new Vue({
            el: '#vue_one',
            data: {
                result : 0
            },
            methods: {
                increment(){
                    this.result++
                }
            }
        })
    </script>
    

    2、v-on 传参问题

    如果传了多个参数的话没有event 我们需要将event加上个美元符号 $event

    <!--单击+1-->
    <div id="vue_one">
        <h2>{{result}}</h2>
        <button @click="increment('qwe',$event)">+2</button>
    </div>
    <script type="text/javascript">
        const vm = new Vue({
            el: '#vue_one',
            data: {
                result : 0
            },
            methods: {
                increment(ev,event){
                    console.log(ev+"/"+event)
                    this.result++
                }
            }
        })
    </script>
    

    3、常用修饰符问题

    3.1、阻止冒泡 (.stop)

    当嵌套多个div 里面有很多个点击事件的话点击一个div会调用多个数据

    正常出现冒泡代码

    <!--单击按钮会出现两个点击事件-->
    <div id="vue_one">
        <div @click="div1">
            <button @click="button1">点我</button>
    
        </div>
    </div>
    <script type="text/javascript">
        const vm = new Vue({
            el: '#vue_one',
            data: {
                result: 0
            },
            methods: {
                div1(){
                    console.log("div1");
                },
                button1(){
                    console.log("button1");
                }
            }
        })
    </script>
    

    添加 .stop防止出现冒泡

    <body>
    <!--添加冒泡.stop 已经不会出现其他点击事件-->
    <div id="vue_one">
        <div @click="div1">
            <button @click.stop="button1">点我</button>
        </div>
    </div>
    <script type="text/javascript">
        const vm = new Vue({
            el: '#vue_one',
            data: {
                result: 0
            },
            methods: {
                div1(){
                    console.log("div1");
                },
                button1(){
                    console.log("button1");
                }
            }
        })
    </script>
    

    3.2、阻止默认方法的执行(.prevent)

    比如form表单,默认的就是会自动的进行跳转

    <!--显示跳转到form表单-->
    <div id="vue_one">
        <form>
            <input type="submit" value="提交" @click="button1">
        </form>
    </div>
    <script type="text/javascript">
        const vm = new Vue({
            el: '#vue_one',
            data: {
                result: 0
            },
            methods: {
                button1(){
                    console.log("button1");
                }
            }
        })
    </script>
    

    添加属性 .prevent防止默认的方法

    <!--.prevent阻止跳转了-->
    <div id="vue_one">
        <form>
            <input type="submit" value="提交" @click.prevent="button1">
        </form>
    </div>
    <script type="text/javascript">
        const vm = new Vue({
            el: '#vue_one',
            methods: {
                button1(){
                    console.log("button1");
                }
            }
        })
    </script>
    

    3.3、只执行一次(.once)

    <!--只点击一次有效果,多次就无效果-->
    <div id="vue_one">
        <button @click.once="button1">点我</button>
    </div>
    <script type="text/javascript">
        const vm = new Vue({
            el: '#vue_one',
            methods: {
                button1(){
                    console.log("button1");
                }
            }
        })
    </script>
    

    3.4、某个键盘敲击事件的监听修饰符(@keyup.键盘按钮名称) 松开按键进行监听

    <!--监听某一个键盘的按键,松手监听-->
    <div id="vue_one">
        <input type="text" @keyup.esc="keyUp">
    </div>
    <script type="text/javascript">
        const vm = new Vue({
            el: '#vue_one',
            methods: {
                keyUp(){
                    console.log("button1");
                }
            }
        })
    </script>
    

    3.5、修饰符可以串联

    <!--修饰符可以串联-->
    <div id="vue_one">
        <div @click="div1">
        <a href="www.baidu.com" @click.stop.prevent="doThat">12345</a>
        </div>
    </div>
    <script type="text/javascript">
        const vm = new Vue({
            el: '#vue_one',
            methods: {
                div1(){
                    console.log("div1");
                },
                doThat(){
                    console.log("a");
                }
            }
        })
    </script>
    

    3.6、只能通过鼠标左右键调用函数 .left .right

    <body>
    <!--.left只能点击鼠标左键调用函数,.right只能点击鼠标右键调用函数-->
    <div id="vue_one">
        <button @click.right="right">点我</button>
        <button @click.left="left">点我</button>
    </div>
    <script type="text/javascript">
        const vm = new Vue({
            el: '#vue_one',
            methods: {
                right(){
                    console.log("right");
                },
                left(){
                    console.log("left");
                }
            }
        })
    </script>
    






    花开一千年,花落一千年,花叶永不见

    展开全文
  • 事件监听机制(一)Java事件监听

    千次阅读 2019-02-25 09:56:27
    事件监听机制(一)Java事件监听 事件监听实现流程 事件对象: 继承自java.util.EventObject对象,由开发者自行定义实现。 事件源: 就是触发事件的源头,不同的事件源会触发不同的事件类型。 ...

    事件监听机制(一)Java事件监听

    事件监听实现流程

    1. 事件对象:
      继承自java.util.EventObject对象,由开发者自行定义实现。

    2. 事件源:
      就是触发事件的源头,不同的事件源会触发不同的事件类型。

    3. 事件监听器:
      事件监听器负责监听事件源发出的事件,事件监听器可以通过实现java.util.EventListener这个标识接口.,实现事件监听。

    流程总结

    事件源可以注册事件监听器对象,并可以向事件监听器对象发送事件对象,事件发生后,事件源将事件对象发给已经注册的所有事件监听器,监听器对象随后会根据事件对象内的相应方法响应这个事件。

    自定义实现事件监听

    自定义事件监听对象

    /**
     * @ClassName: Event
     * @Description: 事件监听源
     * @Author: 尚先生
     * @CreateDate: 2019/2/25 9:31
     * @Version: 1.0
     */
    public class Event {
        private String name;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "Event{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
    

    自定义事件源

    /**
     * @ClassName: EventSourceDemo
     * @Description: 自定义事件源
     * @Author: 尚先生
     * @CreateDate: 2019/2/25 9:11
     * @Version: 1.0
     */
    public class EventSourceDemo {
    
        private LinkedBlockingQueue<EventListenerDemo> queue = new LinkedBlockingQueue<>();
    
        public EventSourceDemo() {
            super();
        }
    
        public void addMyEventListener(EventListenerDemo eventListener) {
            queue.offer(eventListener);
        }
    
        public void deleteMyEventListener(EventListenerDemo eventListener) {
            queue.remove(eventListener);
        }
    
        public void notifyMyEvent(EventObjectDemo eventObject) {
            Iterator<EventListenerDemo> iterator = queue.iterator();
            while (iterator.hasNext()) {
                //在类中实例化自定义的监听器对象,并调用监听器方法
                iterator.next().execute(eventObject);
            }
        }
    }
    

    自定义事件

    /**
     * @ClassName: EventObjectDemo
     * @Description: 自定义事件
     * @Author: 尚先生
     * @CreateDate: 2019/2/25 8:53
     * @Version: 1.0
     */
    public class EventObjectDemo extends EventObject {
        /**
         * Constructs a prototypical Event.
         *
         * @param source The object on which the Event initially occurred.
         * @throws IllegalArgumentException if source is null.
         */
        public EventObjectDemo(Object source) {
            super(source);
        }
    }
    

    自定义监听器

    /**
     * @ClassName: EventListenerDemo
     * @Description: 自定义监听器
     * @Author: 尚先生
     * @CreateDate: 2019/2/25 8:53
     * @Version: 1.0
     */
    public class EventListenerDemo implements EventListener {
    
    
        /**
         * 执行监听器
         * @param eventObject
         */
        public void execute(EventObjectDemo eventObject){
            System.err.println(eventObject.getSource());
        }
    }
    

    测试类

    public class EventTest {
        public static void main(String args[]) {
            // 创建 eventListener
            EventListenerDemo eventListener = new EventListenerDemo();
            // 创建 eventSource
            EventSourceDemo eventSource = new EventSourceDemo();
            // 添加 eventListener
            eventSource.addMyEventListener(eventListener);
            // 创建事件源
            Event event = new Event();
            event.setName("event");
            EventObjectDemo eventObjectDemo = new EventObjectDemo(event);
            // 事件通知
            eventSource.notifyMyEvent(eventObjectDemo);
        }
    }
    

    测试结果

    Event{name='event'}
    

    往期文章

    博客地址:https://blog.csdn.net/shang_xs
    微信公众号地址:http://mp.weixin.qq.com/mp/homepage?__biz=MzUxMzk4MDc1OQ==&hid=2&sn=c6c58c06f6f8403af27b6743648b3055&scene=18#wechat_redirect
    

    完整代码及详情

    具体依赖及相关源码参照

    https://github.com/dwyanewede/project-learn/tree/master/src/main/java/com/learn/demo/java/base/event
    

    更多文章

    事件监听机制(一)Java事件监听
    https://blog.csdn.net/shang_xs/article/details/87911756
    事件监听机制(二)Spring事件监听
    https://blog.csdn.net/shang_xs/article/details/88048545
    事件监听机制(三)Spring Cloud Bus流程分析
    https://blog.csdn.net/shang_xs/article/details/88050196
    事件监听机制(四)从Java事件监听到Spring事件监听
    https://blog.csdn.net/shang_xs/article/details/86560994
    事件监听机制(五)再话Jdk事件监听到Spring框架事件监听
    https://blog.csdn.net/shang_xs/article/details/119794917

    展开全文
  • 事件监听机制(二)Spring事件监听

    千次阅读 2019-03-01 08:51:14
    事件监听机制(二)Spring事件监听 事件监听实现流程 事件对象: 继承自java.util.EventObject对象,由开发者自行定义实现。 事件源: 就是触发事件的源头,不同的事件源会触发不同的事件类型。 ...

    事件监听机制(二)Spring事件监听

    事件监听实现流程

    1. 事件对象:
      继承自java.util.EventObject对象,由开发者自行定义实现。

    2. 事件源:
      就是触发事件的源头,不同的事件源会触发不同的事件类型。

    3. 事件监听器:
      事件监听器负责监听事件源发出的事件,事件监听器可以通过实现java.util.EventListener这个标识接口.,实现事件监听。

    流程总结

    事件源可以注册事件监听器对象,并可以向事件监听器对象发送事件对象,事件发生后,事件源将事件对象发给已经注册的所有事件监听器,监听器对象随后会根据事件对象内的相应方法响应这个事件。

    自定义实现Spring事件监听

    自定义事件

    /**
     * @ClassName: MyApplicationEvent 
     * @Description: 自定义事件
     * @Author: 尚先生
     * @CreateDate: 2019/3/1 8:11
     * @Version: 1.0
     */
      public class MyApplicationEvent extends ApplicationEvent {
    
            public MyApplicationEvent(String message) {
                super(message);
            }
        }
    
    

    自定义监听器

    /**
     * @ClassName: MyApplicationEvent 
     * @Description: 自定义监听器
     * @Author: 尚先生
     * @CreateDate: 2019/3/1 8:20
     * @Version: 1.0
     */
    @Configuration
    public class EventConfiguration {
    
            /**
             * 监听 MyApplicationEvent
             * @param event 
             */
            @EventListener
            public void onEvent(MyApplicationEvent event) {
                System.out.println("监听事件 : " + event);
            }
        }
    

    测试类

    /**
    * @ClassName: SpringEventTest 
    * @Description: Spring事件监听测试类
    * @Author: 尚先生
    * @CreateDate: 2019/3/1 8:36
    * @Version: 1.0
    */
    public class SpringEventTest {
    
       public static void main(String[] args) {
           // 创建 Annotation 驱动的 Spring 应用上下文
           AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
           // 注册 EventConfiguration 到 Spring 应用上下文
           context.register(EventConfiguration.class);
           // 启动 Spring 应用上下文
           context.refresh();
           // AnnotationConfigApplicationContext 也是 ApplicationEventPublisher
           ApplicationEventPublisher publisher = context;
           // 发布一个 MyApplicationEvent
           publisher.publishEvent(new MyApplicationEvent("Hello,World"));
           }
       }
    

    测试结果

    监听事件 : com.learn.demo.java.base.event.SpringEventTest$MyApplicationEvent[source=Hello,World]
    

    往期文章

    博客地址:https://blog.csdn.net/shang_xs
    微信公众号地址:http://mp.weixin.qq.com/mp/homepage?__biz=MzUxMzk4MDc1OQ==&hid=2&sn=c6c58c06f6f8403af27b6743648b3055&scene=18#wechat_redirect
    

    完整代码及详情

    具体依赖及相关源码参照

    https://github.com/dwyanewede/project-learn/tree/master/src/main/java/com/learn/demo/java/base/event
    

    更多文章

    事件监听机制(一)Java事件监听
    https://blog.csdn.net/shang_xs/article/details/87911756
    事件监听机制(二)Spring事件监听
    https://blog.csdn.net/shang_xs/article/details/88048545
    事件监听机制(三)Spring Cloud Bus流程分析
    https://blog.csdn.net/shang_xs/article/details/88050196
    事件监听机制(四)从Java事件监听到Spring事件监听
    https://blog.csdn.net/shang_xs/article/details/86560994
    事件监听机制(五)再话Jdk事件监听到Spring框架事件监听
    https://blog.csdn.net/shang_xs/article/details/119794917

    展开全文
  • 事件监听与移除事件监听

    千次阅读 2018-10-22 15:35:34
    addEventListener() 事件监听 emoveEventListener() 移除事件监听 element.addEventListener(event, function, useCapture); 第一个参数是事件的类型 (如 “click” 或 “mousedown”). 第二个参数是...

    Navigator onLine 属性:一个只读的布尔值,声明了系统是否处于脱机模式。
    addEventListener() 事件监听
    emoveEventListener() 移除事件监听

    element.addEventListener(event, function, useCapture);
    

    第一个参数是事件的类型 (如 “click” 或 “mousedown”).
    第二个参数是事件触发后调用的函数。
    第三个参数(可选)是个布尔值用于描述事件是冒泡还是捕获:默认值为 false, 即冒泡传递,当值为 true 时, 事件使用捕获传递。

    扩展知识:

    事件传递有两种方式:冒泡与捕获。
    事件传递定义了元素事件触发的顺序。 如果你将p元素插入到 div元素中,用户点击 p元素, 哪个元素的 “click” 事件先被触发呢?
    在 冒泡 中,内部元素的事件会先被触发,然后再触发外部元素,即: p 元素的点击事件先触发,然后会触发 div元素的点击事件。
    在 捕获 中,外部元素的事件会先被触发,然后才会触发内部元素的事件,即: div元素的点击事件先触发 ,然后再触发 p 元素的点击事件。
    addEventListener() 方法可以指定 “useCapture” 参数来设置传递类型:

    addEventListener(event, function, useCapture);
    

    注意:event不要使用 “on” 前缀。 例如,使用 “click” ,而不是使用 “onclick”。
    两种使用方式:

    element.addEventListener("click", function(){ alert("Hello World!"); });
    
    element.addEventListener("click", myFunction);
    
    function myFunction() {
        alert ("Hello World!");
    }
    

    向 Window 对象添加事件句柄

    window.addEventListener("resize", function(){
        document.getElementById("demo").innerHTML = sometext;
    });
    

    传递参数
    当传递参数值时,使用"匿名函数"调用带参数的函数:

    var p1 = 5;
    var p2 = 7;
    document.getElementById("myBtn").addEventListener("click", function() {
        myFunction(p1, p2);
    });
    function myFunction(a, b) {
        var result = a * b;
        document.getElementById("demo").innerHTML = result;
    }
    

    removeEventListener() 方法

    element.removeEventListener("mousemove", myFunction);
    

    浏览器兼容处理

    var x = document.getElementById("myBtn");
    if (x.addEventListener) {    // 所有主流浏览器,除了 IE 8 及更早版本
        x.addEventListener("click", myFunction);
    } else if (x.attachEvent) {  // IE 8 及更早版本
        x.attachEvent("onclick", myFunction);
    }
    

    所有主流浏览器使用addEventListener()和removeEventListener()两个方法处理事件,这种方法比较常见,但是,ie人家牛逼,IE中也有类似的两个方法:attachEvent()和detachEvent()。

    element.attachEvent(event, function);//事件监听
    element.detachEvent(event, function);//移除事件监听
    

    监听联网状态实例

    //联网状态
            initOnlineData(){
                    // alert(navigator.onLine);
                    this.$store.dispatch("setOnlineState",navigator.onLine);//初始化当前联网状态
                    if (window.addEventListener) {
                        window.addEventListener("online", this.online, false);
                        window.addEventListener("offline", this.offline, false);
                    } else if (window.attachEvent) {
                        window.attachEvent("ononline", this.online);
                        window.attachEvent("onoffline", this.offline);
                    } else {
                        window.ononline = this.online;
                        window.onoffline = this.offline;
                    }
            },
            //在线
            online(){
                this.$store.dispatch("setOnlineState",true);
            },
            //离线
            offline(){
                this.$store.dispatch("setOnlineState",false);
            }
    
    展开全文
  • 自定义事件监听&localstorage事件监听

    千次阅读 2020-01-02 20:47:26
    文章目录文章参考自定义事件js 自定义对象事件自定义添加localstorage事件监听自定义监听删除localstorage 事件 文章参考 监听localStorage变化(同页面监听) 漫谈js自定义事件、DOM/伪DOM自定义事件 自定义事件 ...
  • 什么是事件监听? 例如,点击按钮,弹出一个文本框,点击一个文本,文本被删除; 按钮、文本等组件就是事件源 事件就是从开始触发事件源到出现效果的一个过程 以下是一个案例,点击按钮,记录点击的次数和获取...
  • SpringBoot Event 事件监听

    千次阅读 2021-07-22 21:54:25
    ApplicationEvent以及Listener是Spring为我们提供的一个事件监听、订阅的实现,内部实现原理是观察者设计模式,设计初衷也是为了系统业务逻辑之间的解耦,提高可扩展性以及可维护性。事件发布者并不需要考虑谁去监听...
  • 事件监听包括必不可少的三个元素:事件、事件源和监听器。 事件:容易理解,点击一下鼠标是一个事件,更改某个类属性也可以抽象为一个事件。 事件源:发布事件的地方,也就是事件产生的地方。 监听器:定义事件...
  • react添加监听事件监听键盘事件

    千次阅读 2019-06-21 17:26:26
    1,react添加监听事件监听键盘事件 参考: 记录下确认框confirm代码:
  • SpringBoot重点详解--事件监听

    万次阅读 2018-02-28 00:14:50
    自定义事件监听 Springboot 启动事件监听 Springboot 事件监听为 Bean 与 Bean 之间的消息通信提供支持:当一个 Bean 做完一件事以后,通知另一个 Bean 知晓并做出相应处理,此时,需要后续 Bean 监听当前 Bean 所...
  • Layui 下拉框Select onchange事件监听

    万次阅读 2020-11-05 20:08:46
    <html> .... <div class="layui-input-block">...select name="productId" lay-verify="required" lay-search id="productSelect" lay-filter="productSelectChange">...请选择产品.
  • jQuery事件监听

    万次阅读 2018-09-26 15:35:46
    浏览器事件监听 控制或右键单击元素并选择“检查 (Inspect)”。在 javaScript 控制台标签中输入: monitorEvents($0) 现在,将鼠标悬停在该元素上时,关注或单击它, 将显示触发事件的名称及其数据。 要停止获取该...
  • Java事件监听机制

    千次阅读 2019-03-19 22:24:01
    Java中的事件监听机制的定义 Java事件监听机制在Java图形界面编程处常用。我们会对界面做一些操作,比如输入框输入数据,点击登录按钮等等。这些操作被称为事件,当采取这些操作之后,程序会采取一定的措施响应。 1....
  • Java常用事件监听器与实例分析

    千次阅读 多人点赞 2020-07-30 08:32:34
    我们知道在Java窗体中的组件,本身是不具备任何功能的,因此我们必须要给控件添加相应的事件监听,才能在界面中触发相应的事件处理,今天就来和大家分享一下在Java中常用的几个事件监听器。 监听事件简介 首先,...
  • Android截屏事件监听

    万次阅读 2016-12-23 11:52:13
    Android系统没有直接对截屏事件监听的接口,也没有广播,只能自动动手丰衣足食!
  • gojs 事件监听

    万次阅读 2018-04-28 16:17:52
    gojs事件监听gojs的事件监听比较多,比如给元素添加点击事件的话 myDiagram.addDiagramListener("ObjectSingleClicked", function(e,obj) {...}节点文本的修改事件myDiagram.addDiagramListener("...
  • 事件监听,回调事件

    千次阅读 2018-07-29 23:53:50
    一、事件监听涉及到三个类对象 1、EventSource(事件源)事件发生的场所 2、Event(事件):事件封装界面组件上面发生的特定事件 3、EventListener(事件监听器):负责监听事件源发生的事件 二、监听器就是...
  • Apache ZooKeeper - 事件监听机制详解

    千次阅读 2020-11-17 00:18:48
    文章目录事件监听机制命令Zookeeper事件类型 事件监听机制命令 针对节点的监听:一定事件触发,对应的注册立刻被移除,所以事件监听是一次性的 get -w /path // 注册监听的同时获取数据 stat -w /path // 对节点...
  • appium 事件监听

    千次阅读 2017-05-01 10:55:06
    在网上搜了好久也没找到关于appium 事件监听的实例,然后在查看appium Java client 官方例子看到了相关的用法,于是决定研究一下,发现挺好用的,希望能分享出来给大家一点点帮助
  • 事件监听: 为同一个对象的同一个事件绑定多个事件处理程序 事件绑定: 对DOM元素绑定事件处理函数 一般分为三种 1、在DOM元素中直接绑定 2、在js中绑定 3、绑定事件监听函数 事件委托: 利用冒泡的原理,把事件加到...
  • Spring之事件监听(观察者模型)

    千次阅读 2019-03-06 13:57:26
      本文介绍下Spring中的事件监听,其本质也就是观察者模型(发布/订阅模式),具体的观察者模式参考下文 Java观察者模式(Observer) 文章目录Spring事件监听一、事件监听案例1.事件类2.事件监听类3.事件发布者4.配置...
  • JS事件之事件绑定与事件监听

    千次阅读 2019-01-16 22:06:09
    抛开事件监听函数不谈,我们有两种绑定事件处理函数的方法:   1.通过HTML来绑定事件处理函数 &lt;a href="" onclick="fo()"&gt;hello&lt;/a&gt; &lt;script&gt; ...
  • flowable任务监听器 事件监听

    千次阅读 2020-03-26 16:38:00
    事件监听器:针对任意节点 使用场景:实际情况下可能会在节点开始或结束之后调用业务系统的接口去做同步数据之类的业务处理。 一、定义任务监听器 @Scope @Component(value = "taskBusinessCallListener") ...
  • 事件绑定:有三种常用的绑定事件的方法: ...3、绑定事件监听函数。 1、在DOM中直接绑定事件 我们可以在DOM元素上直接绑定事件 例如: function hello(){ alert('hello world!'); }; 2、在
  • 事件监听机制

    千次阅读 2015-05-18 19:24:05
    Java中的事件监听是整个Java消息传递的基础和关键。牵涉到两类对象:事件发生者和事件监听者。事件发生者是事件的起源,它可以是一个按钮,编辑框等。事件监听者就是事件的接受者,如果要想接收某个事件,它必须对该...
  • Java Swing 键盘事件监听

    千次阅读 2019-09-16 10:30:30
    Java Swing 键盘事件监听 开发工具与关键技术:java、 elipse2019、jdk1.8 作者:Amewin 撰写时间:2019年9月16日 键盘事件的事件源一般丐组件相关,当一个组件处于激活状态时,按下、释放或敲击键盘上的某个键时...
  • java事件监听器原理

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

    千次阅读 2017-12-09 22:22:21
    Java中对事件处理的方式是:其控制事件源(event source),例如,按钮或滚动条,到事件监听器(event listener)的传递过程,并将任何对象指派给事件监听器。当然,应该选一个能便于响应事件的对象。 事件源有一些...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 601,613
精华内容 240,645
关键字:

事件监听