精华内容
下载资源
问答
  • Java中事件处理事件监听机制
    千次阅读
    2017-12-09 22:22:21

    学习Java用的是《Java核心技术》第9版。关于Java的时间监听机制,很有趣,这儿做一个记录。

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

    事件源有一些向其注册事件监听器的方法。当一个事件源产生一个事件时,它会向它的所有注册的事件监听器发送一个通告。

    Java将事件相关信息都封装在一个事件对象(event object)中,所有的事件对象都派生于 java.util.EventObject 类。当然,每个事件类型还有子类,例如,ActionEvent,WindowEvent.

    不同的事件源会产生不同类别的事件。例如,按钮可以发送一个ActionEvent对象,窗口可以发送WindowEvent对象。


    那么下面,给出AWT事件处理机制的概要:

     - 监听器对象是一个实现了特定监听器接口(listener interface)的实例

     - 事件源是一个能够注册监听器对象并发送事件对象的对象

     - 当事件发生时,事件源将事件发送给其注册的所有事件监听器

     - 监听器对象将利用事件对象中的信息决定如何对事件做出响应


    下面是监听器的一个实例:

       ActionLlistener listener = ...;
       JButton button = new JButton("test");
       button.addActionLlistener(listener);

    现在,只要按钮产生一个“动作事件”,listener对象就会得到一个通告。对于按钮来说,“动作事件”就是点击按钮。

    为了实现ActionListener接口,监听器类必须有一个actionPerformed方法,该方法接受一个ActionEvent对象参数。

    public class MyListener implements ActionListener{
        ...
        public void actionPerformed(ActionEvent event){
            // reaction to button click goes here
        }
    }
    只要用户点击按钮,JButton的对象就会创建一个ActionEvent对象,然后调用listener的actionPreformed传递事件对象。可以将多个监听器对象,添加到一个像按钮这样的事件源上。这样,只要点击按钮,按钮就会调用所有的监听器的actionPreformed方法。


    更多相关内容
  • 主要给大家介绍了关于java中接口和事件监听器的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用java具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 下面小编就为大家带来一篇详谈Java中事件监听机制。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了Java使用自定义注解实现为事件源绑定事件监听器操作,结合实例形式分析了java自定义注解、注解处理、事件监听与响应等相关操作技巧,需要的朋友可以参考下
  • 主要介绍了Java添加事件监听的四种方法代码实例,本文直接给出代码示例,并用注释说明,需要的朋友可以参考下
  • 主要介绍了Java SwingJList选择事件监听器ListSelectionListener用法,结合具体实例形式分析了JList选择事件监听器ListSelectionListener的功能、使用方法及相关注意事项,需要的朋友可以参考下
  • java事件监听

    千次阅读 2021-03-01 10:42:32
    进行过Java图形界面编程的同学会发现,各种控件的点击、打开、关闭等操作,都注册了对应的事件监听器,并可以根据不同的事件执行不同操作。 例如,同样是button,点击 关闭 可以直接关闭窗口;点击登录可以在后台...

    絮絮叨叨

    • 进行过Java图形界面编程的同学会发现,各种控件的点击、打开、关闭等操作,都注册了对应的事件监听器,并可以根据不同的事件执行不同操作。
    • 例如,同样是button,点击 关闭 可以直接关闭窗口;点击登录可以在后台实现用户名、密码的校验,并根据校验结果执行不同的操作。
    • 在上面的例子中:button是事件源,点击操作是事件,事件发生后,根据事件执行不同的操作(关闭窗口、校验用户名及密码),这是监听器的行为。

    总结起来

    • 事件源:执行某些操作时,产生事件;事件源中注册了监听器,将产生的事件传给监听器,由监听器处理事件
    • 事件:由事件源执行某些操作时产生,事件中包含事件源,这样监听器可以根据事件源执行特定的处理操作
    • 监听器:很多事件的处理方法,根据事件或事件源,执行不同操作

    自己的理解

    • 事件的监听、处理流程:
      在这里插入图片描述
    • 事件源、事件、监听器之间的关系:
      • 事件源通过事件监听器注册方法,为自身添加事件监听器
      • 事件监听器中,实现了事件的handler方法:根据传入的事件或事件的事件源,执行具体操作
      • 事件源的某个动作,将(主动)触发事件监听器的handler方法处理事件
        在这里插入图片描述

    编程示例

    • 事件源: 事件监听器注册方法 + 具体操作,触发事件监听器的handler方法

      package com.vivo.lucy.listener;
      
      public class Animal {
          private String name;
          private AnimalListener animalListener;
      
          public Animal(String name) {
              this.name = name;
          }
      
          public void addAnimalListener(AnimalListener animalListener) {
              this.animalListener = animalListener;
          }
      
          public void eat() {
              System.out.println("event source: Trigger event —— " + name + " will eat!");
              animalListener.eatEventHandler(new AnimalEvent(this));
          }
      
          public String getName() {
              return name;
          }
      
          public void setName(String name) {
              this.name = name;
          }
      
          public static void main(String[] args) {
              Animal dog = new Animal("dog");
              // 为事件源添加监听器
              AnimalListener listener = new AnimalListener();
              dog.addAnimalListener(listener);
      
              // 触发事件,会被事件监听器监听到
              dog.eat();
          }
      }
      
    • 事件: 继承Java自带的EventObject,自己只修改了其构造方法,打印了一些信息。

      package com.vivo.lucy.listener;
      
      import java.util.EventObject;
      
      public class AnimalEvent extends EventObject {
          public AnimalEvent(Object source) {
              super(source);
              Animal animal = (Animal) source;
              System.out.println("event: Generate event —— " + animal.getName() + " is eating!");
          }
      }
      
    • 事件监听器: 实现Java自带的EventListener,创建事件handler(入参为具体的事件)

      package com.vivo.lucy.listener;
      
      import java.util.EventListener;
      import java.util.EventObject;
      
      public class AnimalListener implements EventListener {
          public void eatEventHandler(EventObject eventObject) {
              // 从事件中获取事件源
              Animal source = (Animal) eventObject.getSource();
              // 打印事件源的名称
              System.out.println("listener: Get event —— " + source.getName() + " is eating!");
          }
      }
      
    • 执行结果如下:
      在这里插入图片描述

    • 虽然事件、事件源、监听器环环相扣,但是自己更喜欢按照下面的步骤实现事件监听

      • 定义事件:事件中将包含事件源(可以通过构造函数设置)
      • 定义监听器:监听器中有事件的handler方法,用于处理对应的事件
      • 定义事件源:包含监听器注册方法、具体的操作(生成事件,触发监听器的handler方法)

    关于事件监听器

    • EventListener是一个没有抽象方法的接口,一般JDK中的监听器接口是存在抽象方法的。

    • 在为事件源注册监听器时,需要创建匿名类并实现对应的抽象方法。

    • 例如,为java swing中的按钮注册监听器的代码如下

      button1.addActionListener(new ActionListener()
      {
          public void actionPerformed(ActionEvent e)
          {
              label.setText("按钮被单击了 "+(clicks++)+" 次");
          }
      });
      
    展开全文
  • java中事件监听

    千次阅读 2017-01-07 12:08:25
    Timer组件实现定时器功能,一个Timer对象,每隔delay时间,执行AtionEvent事件。Timer类声明如下:public class Timer implements Serializable { public Timer(int delay,ActionListener listener) //delay设置...

    【转自】http://blog.sina.com.cn/s/blog_7beb545901019010.html

    1.AWT的事件类型及其监听器

    (1)WindowEvent窗口事件

    引发原因:窗口操作
    事件监听接口是WindowListener
    接口的方法包括7个:
    1)windowActivated(WindowEvent e) //激活窗口
    2)windowClosed(WindowEvent e) //调用dispose方法关闭窗口后
    3)windowClosing(WindowEvent e) //试图利用窗口关闭框关闭窗口
    4)windowDeactivated(WindowEvent e) //本窗口成为非活动窗口
    5)windowDeiconified(WindowEvent e) //窗口从最小化恢复为普通窗口
    6)windowIconified(WindowEvent e) //窗口变为最小化图标
    7)windowOpened(WindowEvent e) //当窗口第一次打开成为可见时
    接口适配器: WindowAdapter
    注册窗口事件的方法: addWindowListener

    (2)ActionEvent活动事件

    引发原因: 单击按钮、双击列表框中的选项、选择菜单项、在文本框中回车
    事件监听接口: ActionListener
    接口方法: actionPerformed(ActionEvent e)
    注册事件方法: addActionListener

    (3)TextEvent文本事件

    引发原因: 文本框或文本区域内容改变
    事件监听接口: TextListener
    接口方法: textValueChanged(TextEvent e)
    注册事件方法: addTextListener

    (4)ItemEvent选项事件

    引发原因: 改变列表框中的选中项,改变复选框选中状态,改变下拉列表的选中项
    事件监听接口: ItemListener
    接口方法: itemStateChanged(ItemEvent e)
    注册事件方法: addItemListener

    (5)AdjustmentEvent调整事件

    引发原因: 操作滚动条以身改变滑块位置
    事件监听接口: AdjustmentListener
    接口方法: adjustmentValueChanged(AdjustmentEvent e)
    注册事件方法: addAdjustmentListener

    (6)KeyEvent键盘事件

    引发原因有三种:
    1)按下并释放键
    2)按下键
    3)释放键
    事件监听接口: KeyListener
    接口方法包括三种:
    1)keyPressed(KeyEvent e) //键已被按下时调用
    2)keyReleased(KeyEvent e) //键已被释放时调用
    3)keyTyped(KeyEvent e) //键已被按下并释放时调用
    KeyEvent方法: char ch = e.getKeyChar();
    事件监听适配器(抽象类): KeyAdapter
    注册事件方法: addKeyListener

    (7) MouseEvent事件

    引发原因: 鼠标作用在一个组件上
    鼠标事件: 鼠标键按下,鼠标键抬起,单击鼠标键,鼠标指针进入一个组件,鼠标指针离开一个组件
    鼠标移动事件: 鼠标移动,鼠标拖动
    鼠标事件监听接口1: MouseListener //接受鼠标事件
    该接口方法包括三种:
    1)mouseClicked(MouseEvent e)
    2)mouseEntered(MouseEvent e)
    3)mouseExited(MouseEvent e)
    鼠标事件监听适配器(抽象类):MouseAdapter
    注册鼠标事件方法: addMouseListener

    鼠标事件监听接口2: MouseMotionListener
    该接口方法:
    1)mouseMoved(MouseEvent e)
    2)mouseDragged(MouseEvent e)
    鼠标移动事件监听适配器: MouseMotionAdapter
    注册鼠标移动事件方法: addMouseMotionListener

    MouseEvent方法:
    1)e.getClickCount() //1为单击,2为双击
    2)Point e.getPoint() //取鼠标指针位置
    3)int e.getX()和int e.getY()//取鼠标指针位置
    e.getMotifiers() = e.BUTTON1_MASK //取标左键
    = e.BUTTON3_MASK //取标右键

    (8)FocusEvent 焦点事件

    引发原因: 组件获得焦点,组件失去焦点
    事件监听接口: FocusListener
    接口方法:
    1)focusGained(FocusEvent e)
    2)focusLost(FocusEvent e)
    接口适配器:FocusAdapter
    注册事件方法: addFocusListener

    (9)ComponentEvent组件事件

    引发原因: 当组件移动,改变大小,改变面貌可见性时引发
    事件监听接口: ComponentListener
    接口方法:
    1) componentHidden(ComponentEvent e) //组件隐藏
    2) componentMoved(ComponentEvent e) //组件移动
    3) componentResized(ComponentEvent e) ///组件改变大小
    4) componentShown(ComponentEvent e) ///组件变为可见
    接口适配器: ComponentAdapter
    注册事件方法: addComponentListener

    (10) ContainerEvent 容器事件

    引发原因: 当容器内增加或移走组件时引发
    事件监听接口: ContainerListener
    接口方法包括:
    1)componentAdded(ContainerEvent e) ///容器内加入组件
    2)componentRemoved(ContainerEvent e) //从容器中移走组件
    接口适配器: ContainerAdapter
    注册该事件方法: addContainerListener

    java事件处理机制-事件监听器的实现

    在Java的swing编程中,Java中的事件机制非常常用。
    事件监听器的参与者:
    1.事件对象:
    一般继承自java.util.EventObject对象,由开发者自行定义.
    2.事件源:
    就是触发事件的源头,不同的事件源会触发不同的事件类型.
    3.事件监听器:
    事件监听器负责监听事件源发出的事件.一个事件监听器通常实现java.util.EventListener这个标识接口.
    其整个处理过程是这样的,事件源可以注册事件监听器对象,并可以向事件监听器对象发送事件对象.事件发生后,事件源将事件对象发给已经注册的所有事件监听器.
    监听器对象随后会根据事件对象内的相应方法响应这个事件

    自身类作为事件监听器 :

    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.*;
    
    /**
     *Java事件处理机制:自身类作为事件监听器
     *@author Winty(wintys@gmail.com) 
     *@version 2008-12-3
     */
    class ThisClassEvent extends JFrame implements ActionListener{ 
        JButton btn;
    
        public ThisClassEvent(){
            super("Java事件监听机制");
            setLayout(new FlowLayout());
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
            btn=new JButton("点击");
            btn.addActionListener(this);
            getContentPane().add(btn);
    
            setBounds(200,200,300,160);
            setVisible(true);
        }
    
        /**************************************/
        public void actionPerformed (ActionEvent e){
            Container c=getContentPane();
            c.setBackground(Color.red);
        }
        /**************************************/
    
        public static void main(String args[]){
            new ThisClassEvent();
        }
    }

    外部类作为事件监听器

    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    
    /**
     *Java事件处理机制:外部类作为事件监听器
     *@author Winty(wintys@gmail.com) 
     *@version 2008-12-3
     */
    class OuterClassEvent extends JFrame{ 
        JButton btn;
    
        public OuterClassEvent(){
            super("Java事件监听机制");
            setLayout(new FlowLayout());
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
            btn=new JButton("点击");
            btn.addActionListener(new OuterClass(this));
            getContentPane().add(btn);
    
            setBounds(200,200,300,160);
            setVisible(true);
        }
    
        public static void main(String args[]){
            new OuterClassEvent();
        }
    } 
    
    /*外部类*********************************/
    class OuterClass implements ActionListener{
        OuterClassEvent oce;
    
        public OuterClass(OuterClassEvent oce){
            this.oce = oce;
        }
    
        public void actionPerformed(ActionEvent e){
            Container c=oce.getContentPane();
            c.setBackground(Color.red);
        }
    }

    匿名内部类作为事件监听器 :

    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    
    /**
     *Java事件处理机制:匿名内部类作为事件监听器
     *@author Winty(wintys@gmail.com) 
     *@version 2008-12-3
     */
    class AnonymousEvent extends JFrame{ 
        JButton btn;
    
        public AnonymousEvent(){
            super("Java事件监听机制");
            setLayout(new FlowLayout());
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
            btn=new JButton("点击");
            /*匿名内部类******************************/
            btn.addActionListener(
                new ActionListener(){
                    public void actionPerformed(ActionEvent e){
                        Container c=getContentPane();
                        c.setBackground(Color.red);
                    }
                }
            );
            /***************************************/
            getContentPane().add(btn);
    
            setBounds(200,200,300,160);
            setVisible(true);
        }
    
        public static void main(String args[]){
            new AnonymousEvent();
        }
    }

    内部类作为事件监听器:

    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    
    /**
     *Java事件处理机制:内部类作为事件监听器
     *@author Winty(wintys@gmail.com) 
     *@version 2008-12-3
     */
    class InnerClassEvent extends JFrame{ 
        JButton btn;
    
        public InnerClassEvent(){
            super("Java事件监听机制");
            setLayout(new FlowLayout());
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
            btn=new JButton("点击");
            btn.addActionListener(new InnerClass());
            getContentPane().add(btn);
    
            setBounds(200,200,300,160);
            setVisible(true);
        }
    
        /*内部类*********************************/
        class InnerClass implements ActionListener{
            public void actionPerformed (ActionEvent e){
                Container c=getContentPane();
                c.setBackground(Color.red);
            }
        }
        /**************************************/
    
        public static void main(String args[]){
            new InnerClassEvent();
        }
    }
    展开全文
  • NULL 博文链接:https://jxdwuao.iteye.com/blog/977870
  • Java事件监听器学习心得

    千次阅读 2021-03-13 03:07:26
    Java的swing编程,Java中事件机制非常常用一. 事件监听器的参与者:1.事件对象:一般继承自java.util.EventObject对象,由开发者自行定义.2.事件源:就是触发事件的源头,不同的事件源会触发不同的事件类型.3....

    在Java的swing编程中,Java中的事件机制非常常用

    一. 事件监听器的参与者:

    1.事件对象:

    一般继承自java.util.EventObject对象,由开发者自行定义.

    2.事件源:

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

    3.事件监听器:

    事件监听器负责监听事件源发出的事件.一个事件监听器通常实现java.util.EventListener这个标识接口.

    其整个处理过程是这样的,事件源可以注册事件监听器对象,并可以向事件监听器对象发送事件对象.事件发生后,事件源将事件对象发给已经注册的所有事件监听器.

    监听器对象随后会根据事件对象内的相应方法响应这个事件.

    二 具体的DEMO实例

    下面通过一下简单的DEMO来看下事件监听器的处理过程.

    1.事件对象的定义

    import java.util.EventObject;

    public class DemoEvent extends EventObject {

    private static final long serialVersionUID = -2421553409758288940L;

    public DemoEvent(Object source) {

    super(source);

    }

    }

    2.定义事件监听器

    (1)DemoEvent事件监听器接口

    import java.util.EventListener;

    public interface DemoEventListener extends EventListener {

    public void processEvent(DemoEvent demoEvent);

    }

    (2)第一个具体的事件监听器

    public class FirstEventListener implements DemoEventListener {

    public void processEvent(DemoEvent demoEvent) {

    System.out.println("First event listener process event...");

    }

    }

    (3)第二个具体的事件监听器

    public class SecondEventListener implements DemoEventListener {

    public void processEvent(DemoEvent demoEvent) {

    System.out.println("Second event listener process event...");

    }

    }

    public class EventSource {

    private List listeners = new ArrayList();

    public EventSource() {

    }

    public void addDemoListener(DemoEventListener demoListener) {

    listeners.add(demoListener);

    }

    public void notifyDemoEvent() {

    for (DemoEventListener eventListener : listeners) {

    DemoEvent demoEvent = new DemoEvent(this);

    eventListener.processEvent(demoEvent);

    }

    }

    }

    4.测试事件监听器的整个处理过程

    public class DemoEventClient {

    public static void main(String args[]) {

    //定义事件源

    EventSource eventSource = new EventSource();

    //定义并向事件源中注册事件监听器

    FirstEventListener firstEventListener = new FirstEventListener();

    eventSource.addDemoListener(firstEventListener);

    //定义并向事件源中注册事件监听器

    SecondEventListener secondEventListener=new SecondEventListener();

    eventSource.addDemoListener(secondEventListener);

    //事件通知

    eventSource.notifyDemoEvent();

    }

    }

    展开全文
  • 主要给大家介绍了关于java监听器实现和原理的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用java具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • java事件监听机制.doc

    2019-06-07 15:26:18
    java事件监听机制 java中事件机制的参与者有3种角色: .event object:就是事件产生时具体的“事件”,用于listener的相应的方法之,作为参数,一般存在与listerner的方法之
  • JAVA GUI 事件监听事件 详解 和 案例.

    千次阅读 2021-03-22 14:41:47
    GUI(图形用户界面)Graphical User Interface(图形用户接口)用图形的 方式, 来显示 计算机操作的 界面, ...需要记忆一些常用的命令, 操作不直观.Java 为 GUI 提供的 对象 都存在 java.awt 和 javax.swing 两个包中...
  • Java事件监听器即一组动作接口。如键盘事件KeyEvent对应的接口是: public interface KeyListener extends EventListener { public void keyPressed(KeyEvent ev); public void keyReleased(KeyEvent ev); public ...
  • java中事件监听是怎样实现随时监听的标签(空格分隔): Java参考文献 [1]. http://www.jcodecraeer.com/a/chengxusheji/java/2012/0822/371.html事件监听机制  Java中事件监听是整个Java消息传递的基础和...
  • 事件监听机制(一)Java事件监听

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

    千次阅读 2021-02-28 10:09:23
    java 事件监听 - 鼠标//事件监听//鼠标事件监听//鼠标事件监听有两个实现接口//1、MouseListener 普通的鼠标操作//2、MouseMotionListener 鼠标的拖拽、移动import java.awt.*;import javax.swing.*;import java.awt...
  • java监听键盘事件

    2013-06-04 11:06:43
    java开发的监听键盘事件,获取并显示键盘事件
  • Java常用事件监听器与实例分析

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

    千次阅读 多人点赞 2019-03-19 22:24:01
    Java中事件监听机制的定义 Java事件监听机制在Java图形界面编程处常用。我们会对界面做一些操作,比如输入框输入数据,点击登录按钮等等。这些操作被称为事件,当采取这些操作之后,程序会采取一定的措施响应。 1....
  • 鼠标事件监听器鼠标事件监听器由MouseListener接口和MouseMotionListener接口定义,分别定义鼠标捕获不同的鼠标操作方法。MouseListener监听器方法说明mouseClicked(MouseEvent e) 处理鼠标单击事件方法mouseEntered...
  • JAVA常用事件监听器与实例分析

    千次阅读 多人点赞 2020-08-22 01:45:56
    Java常用事件监听器与实例分析 有必要做一下说明,本人从事过后端工作两年,大学时...我们知道在Java窗体的组件,本身是不具备任何功能的,因此我们必须要给控件添加相应的事件监听,才能在界面触发相应的事件
  •  2.1Java的时间监听机制涉及到三个组件:事件源、事件监听器、事件对象  2.2当事件源上发生操作时,它会调用事件监听器的一个方法,并且调用这个方法时,会传递事件对象过来  2.3事件监听器是由开
  • java GUI 事件监听

    2011-02-26 10:31:22
    java入门:java写的一个界面,画了个棋盘,实现panel,button的事件监听
  • Java实现时间监听

    2017-12-19 21:03:25
    Java实现时间监听Java实现时间监听Java实现时间监听Java实现时间监听Java实现时间监听Java实现时间监听
  • 1. 添加事件 /** * 平台操作日志事件 */ @Data @AllArgsConstructor public class LogPlatformOperEvent{ ...2. 添加监听 /** * 添加平台操作日志 * * @param event 事件 */ @Async @Order @EventLi
  • 关于JAVA中事件分发和监听机制实现的代码实例,绝对实用代码,有说明。
  • JAVA中按钮的事件监听的三种方式

    千次阅读 2021-02-12 13:26:30
    标签:JAVA中的Swing组件,按钮的重点是进行事件监听,可以通过调用JButton的addActionListener()方法。这个方法接受一个实现ActionListener接口的对象作为参数,ActionListener接口只包含一个actionPerformed()...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 578,549
精华内容 231,419
关键字:

java中事件监听

java 订阅