黑马程序员技术交流社区

标题: 第七帖 之 事件监听机制 [打印本页]
作者: 王婷婷    时间: 2013-5-16 15:40
标题: 第七帖 之 事件监听机制
本帖最后由 王婷婷 于 2013-5-16 15:43 编辑

创建一个Frame窗口，选择合适的布局管理器，并向容器中添加按钮组件。这时，我们实现的只是将窗口最小化、最大化，当点击关闭、按钮时，窗体并没有反应。也就是说，界面中的组件并没有实现和用户交互的功能。
  1. public static void main(String[] args) {
  2.                 //创建frame对象并初始化(带有标题和边框的窗口)
  3.                 Frame f = new Frame("我的第一个Frame窗口");
  4.                 //一般是横坐标 纵坐标
  5.                 f.setSize(500,400);
  6.                 //与左边界的距离，与上边界的距离
  7.                 f.setLocation(500,100);
  8.                 Button b = new Button("退出");
  9.                 f.add(b);
  10.        f.setLayout(new FlowLayout());
  11.                 f.setVisible(true);
  12. }
复制代码
1、事件监听机制
(1)事件源：AWT/Swing包中的图形界面组件。
(2)事件：事件源所具备的对应事件和共性事件，是发生在界面上的用户交互行为。是系统对其可能处于的某种状态或某种操作的预先定义。比如，Frame中的关闭窗口。
事件一般分为三种类型：键盘事件、鼠标事件、以及组件的动作事件。
Java定义了许多事件类,来描述不同的用户行为。事件发生时，生成一个事件对象。 事件对象描述的是用户所执行的操作。
(3)监听器：用于接收的事件。
(4)事件处理方式：事件发生所采取的处理方式。事件的处理由事件处理程序完  成。每个AW组件都有自己的事件处理程序。当事件对象生成时，AWT事件处理系统就会将这个事件对象传递给所涉及的组件，由它们的事件处理程序进行相应处理。
    在JDK中，将事件源和对事件的处理分开，这样就可以将界面和事件分离，将这些功能封装成类、接口或方法等，有利于提高代码的复用性。
对于事件源上发生的事件的处理代码就在这里。如：
   f.addWindowListener(new WindowAdapter(){});
           but.addActionListener(new ActionListener(){});
    这里，调用组件的addWindowListener()、addActionListener()方法，将事件的监听器注册到GUI组件上。WindowAdapter、ActionListener是接口，接口中定义了窗体和Action事件的抽象方法，让其子类具体实现这些方法，并在方法体中自定义处理的代码。
2、窗体和Action事件
在上面的例子中，事件就是Frame窗体及其中的组件应该具有哪些与用户交互的操作动作(比如要关闭窗口或点击按钮希望出现什么回应等)，事件源就是Frame窗体，监听器就是Frame类下的window类的addWindowListener()方法，其中接收的就是WindowAdapter接口的子类对象，WindowAdapter接口中有对应的方法用于对窗口所发生的事件作出处理。按钮的监听器是addActionListener()。
  1. import java.awt.*;
  2. import java.awt.event.*;
  3. class FrameDemo {
  4.         //定义该图形中所需的组件的引用
  5.         private Frame f;
  6.         private Button but;
  7.         FrameDemo(){
  8.                 //调用niit初始化方法，
  9.                 init();
  10.         }
  11.         //定义初始化方法，用于设置窗体的属性等操作
  12.         public void init(){
  13.                 //图形化界面初始化  创建组件对象
  14.                 f = new Frame("Frame窗口");

  16.                 //对frame进行基本设置  intx,inty   宽，高
  17.                 f.setBounds(300,100,500,400);
  18.                 //不设置默认填充整个frame
  19.                 f.setLayout(new FlowLayout());
  20.                
  21.                 //初始化按钮组件
  22.                 but = new Button("按钮");
  23.                 //将组件添加到frame中
  24.                 f.add(but);

  26.                 //调用事件方法
  27.                 myEvent();

  29.                 //设置窗体为可见
  30.                 f.setVisible(true);
  31.         }
  32.         //自定义事件方法
  33.         public void myEvent()        {
  34.                 //添加frame窗体监听事件
  35.                 //当接口中的方法超过3个，则需使用适配器
  36.                 f.addWindowListener(new WindowAdapter()        {
  37.                         //复写WindowAdapter接口中的windowClosing方法，并接收事件对象
  38.                         public void windowClosing(WindowEvent e)        {
  39.                                 //自定义处理代码
  40.                                 System.out.println("关闭窗口");
  41.                                 //用于退出窗体
  42.                                 System.exit(0);
  43.                         }
  44.                 }        
  45.                 );

  47.                 //添加Button监听事件(点击按钮，窗体会退出)
  48.                 but.addActionListener(new ActionListener(){
  49.                         //复写ActionListener接口中的actionPerformed方法，
  50.                         public void actionPerformed(ActionEvent e)        {
  51.                                 //自定义处理方式
  52.                                 System.out.println("点我，奇迹就会出现");
  53.                                 System.exit(0);
  54.                         }
  55.                 }
  56.                         );
  57.         }
  58.         public static void main(String[] args) {
  59.                 //创建对象
  60.                 //FrameDemo fd =
  61.                  new FrameDemo();
  62.         }
  63. }
复制代码
3、鼠标事件
在图形用户界面中，我们可以单击或双击文件来完成一些操作。如，单击文件出现菜单，双击文件打开文件等。在一些网站上，当鼠标经过一些文字或图片时，也会做出一些回应，要么出现阴影，要么出现说明文字等。
这里则在窗体中的按钮(Button)组件上添加一些事件，用于实现单击、双击、鼠标经过时的交互情况。当双击鼠标时，经过按钮的单击这两个动作会先于双击执行，当双击完后，单击动作也会触发。
  1. 　　import java.awt.*;
  2. 　　import java.awt.event.*;
  3. 　　//定义一个类，用于封装实现鼠标事件的功能
  4. 　　class MouseEventDemo {
  5. 　　        private Frame f;
  6. 　　        private Button but;
  7. 　　        MouseEventDemo()        {
  8. 　　                init();
  9. 　　        }
  10. 　　        public void init()        {
  11. 　　                f = new Frame("My Frame");
  12. 　　                f.setBounds(300,100,500,400);
  13. 　　                f.setLayout(new FlowLayout());
  14. 　　
  15. 　　                but = new Button("我的按钮");
  16. 　　                f.add(but);
  17. 　　        
  18. 　　                myEvent();
  19. 　　                f.setVisible(true);
  20. 　　        }
  21. 　　        public void myEvent(){
  22. 　　                //添加窗体事件
  23. 　　                f.addWindowListener(new WindowAdapter()        {
  24. 　　                        public void windowClosing(WindowEvent e)        {
  25. 　　                                System.out.println("关闭窗口动作");
  26. 　　                                System.exit(0);
  27. 　　                        }
  28. 　　                });
  29. 　　
  30. 　　                //添加按钮事件，按钮是当前事件源
  31. 　　                but.addActionListener(new ActionListener(){        
  32. 　　                        public void actionPerformed(ActionEvent e){
  33. 　　                                System.out.println("点击动作");
  34. 　　                        }
  35. 　　                });
  36. 　　               
  37. 　　                //添加鼠标事件
  38. 　　                //接收MouseAdapter接口的子类对象
  39. 　　                but.addMouseListener(new MouseAdapter()        {
  40. 　　                        //定义一个当鼠标经过和点击时的计数变量，
  41. 　　                        private int count = 1;
  42. 　　                        private int clickCount = 1;
  43. 　　                        //复写接口中的mouseClicked方法
  44. 　　                        public void mouseClicked(MouseEvent e){
  45. 　　                                //当鼠标被点击2下时，clickCount自增，并打印，测试
  46. 　　                                if (e.getClickCount()==2)        {
  47. 　　                                        System.out.println("双击我"+clickCount++);
  48. 　　                                }        
  49. 　　                        }
  50. 　　                        //复写mouseEntered方法
  51. 　　                        public void mouseEntered(MouseEvent e){
  52. 　　                                System.out.println("飘过"+count++);
  53. 　　                        }
  54. 　　                });
  55. 　　        }
  56. 　　        public static void main(String[] args) {
  57. 　　                new MouseEventDemo();
  58. 　　        }
  59. 　　}
复制代码

作者: 王婷婷    时间: 2013-5-16 15:43
本帖最后由 王婷婷 于 2013-5-16 15:48 编辑

4、键盘事件
添加键盘事件：



  4. //当前事件源为button，只要点击按钮，则触发一些事件，就可以进行键盘操作。

  6. but.addKeyListener(new KeyAdapter(){

  8. public void keyPressed(KeyEvent e) {

  10. //当用键盘录入时，就会在控制台打印输入的键盘符和键盘符对应的整数

  12. //System.out.println(e.getKeyChar()+"-----"+e.getKeyCode());

  14. //根据键盘码获得诸如"shift"、"capslk"这样字符串所对应的键盘码

  16. //System.out.println(KeyEvent.getKeyText(e.getKeyCode())+"----"+e.getKeyCode()

  18. //如果触发事件，并按下的键盘符为Esc，则程序退出

  20. if (e.getKeyCode() == KeyEvent.VK_ESCAPE)

  22. System.exit(0);



  26. //组合键的录入。当按下ctrl  和 enter键时，触发该事件

  28. if (e.isControlDown() && e.getKeyCode() == KeyEvent.VK_ENTER)

  30. {

  32. System.out.println("Control+Enter----");

  34. }

  36. }

  38. });



  42. 添加一个文本框组件，并对其添加事件。

  44.      private TextField tf;

  46.         //文本框可以指定列数

  48. tf = new TextField(30);

  50. f.add(tf);



  54. tf.addKeyListener(new KeyAdapter(){

  56. public void keyPressed(KeyEvent e){

  58. int code = e.getKeyCode();

  60. if (!(code>=KeyEvent.VK_0 && code<=KeyEvent.VK_9)) {

  62. System.out.println(code+"非法输入");

  64. //当向文本框中输入非法数据时，该非法数据不会显示在文本框中

  66. e.consume();

  68. }

  70. }

  72. });
复制代码
5、Item Event 指定项被选中或取消的事件
(1)   
ItemListener:接收项事件的监听器接口。特别适于处理项事件的类实现此接口。然后，使用组件的 addItemListener 方法向该组件注册由此类创建的对象。选定项事件发生时，调用侦听器对象的 itemStateChanged 方法。
ItemEvent
指示项被选定或取消选定的语义事件。该事件被传递到每个 ItemListener 对象，这些对象都已使用组件的 addItemListener 方法注册接收此类事件。
实现 ItemListener 接口的对象将在事件发生时获取此 ItemEvent。
运用到Item Event事件的组件有：
    JRadioButton(单选按钮)通常是成组使用的，可以通过ButtonGroup类进行管理。
    JComboBox(组合框)是一种“多选一”的组件，可编辑每项的内容，而且每项的内容可以是任意类，当用户选取组合框中的某一选择项时，可激发ItemEvent事件。
JCheckBox(复选框)有选中和未选中两种状态，允许用户从一组选项中进行多个选择。
(2)JCheckBox(复选框)举例说明
   JCheckBox(复选框)事件响应：用户点击复选框使其选中状态发生变化时会ItemEvent事件。这时就会实现ItemListener接口的itemStateChanged()方法。
创建如下窗口，包含三个复选框和一个面板，选中某一复选框后，面板的背就变成相应的颜色。
  1. package wangtingting;
  2. import java.awt.Color;
  3. import java.awt.event.ItemEvent;
  4. import javax.swing.JCheckBox;
  5. import javax.swing.JFrame;
  6. import javax.swing.JPanel;
  7. public class CheckBoxTest {
  8.         private JFrame  f;     
  9.         private JPanel  p1, p2;
  10.         private JCheckBox  ck1,ck2,ck3;
  11.         CheckBoxTest(){
  12.                 init();
  13.         }
  14.         public void init(){
  15.                 //JFrame是Swing中的容器，该容器中可以放置其他组件
  16.             f = new JFrame ("CheckBoxTest");
  17.             
  18.         ck1=new  JCheckBox("红色");
  19.         ck2=new  JCheckBox("黄色");
  20.         ck3=new  JCheckBox("蓝色");
  21.         
  22.         //JPanel面板是容器组件，依赖于顶级容器，不能独立存在。
  23.         p1=new JPanel();        
  24.         p2=new JPanel();
  25.         
  26.         //将JPanel面板添加到JFrame容器中。p1中放置复选框，p2中放置显示的颜色
  27.         f.add(p1,"North");      
  28.         f.add(p2);
  29.         
  30.         //将复选框添加到p1面板上
  31.         p1.add(ck1);      
  32.         p1.add(ck2);      
  33.         p1.add(ck3);
  34.         
  35.         myEvent();
  36.       
  37.         //调用框架的setSize方法,设定合适的框架大小。
  38.        f.setSize(400, 200);   
  39.        //调用框架的相应方法,显示框架(默认情况下，框架在建立时是不可见的)。
  40.        f.setVisible (true);         
  41.         }
  42.         public void myEvent(){
  43.                 // 复写ItemListener接口中的itemStateChanged方法，添加处理方式的代码
  44.                 ck1.addItemListener(new ItemListener()        {
  45.                         // 调用ItemEvent的父类(AWTEvent)中的setSource(Object newSource)方法
  46.                         //用于将事件的目标更改为新的源。
  47.                         public void itemStateChanged(ItemEvent e)          {        
  48. 　　if(e.getSource()==ck1)
  49.                                 p2.setBackground(Color.red);
  50.                                else if(e.getSource()==ck2)
  51.                                             p2.setBackground(Color.yellow);
  52.                                   else
  53.                                           p2.setBackground(Color.blue);
  54.                       }        
  55.                 });
  56.                 ck2.addItemListener(new ItemListener(){
  57.                         public void itemStateChanged(ItemEvent e)         {        
  58. 　　if(e.getSource()==ck1)
  59.                                  p2.setBackground(Color.red);
  60.                           else if(e.getSource()==ck2)
  61.                                       p2.setBackground(Color.yellow);
  62.                                else
  63.                                       p2.setBackground(Color.blue);
  64.                       }        
  65.                 });
  66.                 ck3.addItemListener(new ItemListener(){
  67.                         public void itemStateChanged(ItemEvent e)            {        
  68. 　　if(e.getSource()==ck1)
  69.                                   p2.setBackground(Color.red);
  70.                           else if(e.getSource()==ck2)
  71.                                                   p2.setBackground(Color.yellow);
  72.                                   else
  73.                                           p2.setBackground(Color.blue);
  74.                                 }        
  75.                 });
  76.         }
  77.         public static void main(String[] args) {
  78.                 // TODO Auto-generated method stub
  79.                 new CheckBoxTest();
  80.         }
  81. }
复制代码
总结：
在添加交互行为的时候，就是不断确定事件源(将事件注册到哪)、确定事件(以便调用事件对应的方法)、确定监听器(具有监听和处理事件的功能)、确定处理方式(处理代码，想要出现怎样的交互效果)的过程。基本的步骤就是：
如果接口中的方法大于等于3个，那么就要用适配器。
组件.addXxxListner(new XxxAdapter(){
      //复写接口中的方法，接收事件对象，
      public void xxxYyy(XxxEvent e){
        //自定义事件的处理代码
}
});
其实，Swing组件的使用和AWT中的组件使用方法是相似的。因为Swing是以AWT为基础，用java语言编写的，只是对AWT 的功能进行了扩充。AWT 是基于本地方法的C/C++程序，其运行速度比较快；Swing是基于AWT 的Java程序，其运行速度比较慢事件的响应等工作还是要用awt来完成。


ItemListener方法.png (3.58 KB, 下载次数: 0)

ItemListener方法

ItemListener方法
作者: 王婷婷    时间: 2013-5-16 15:51
版主 有空看看 ，多批评指正呀，，，
辛苦了  {:soso_e121:}
作者: 王安琪    时间: 2013-5-16 17:12
王婷婷 发表于 2013-5-16 15:51
版主 有空看看 ，多批评指正呀，，，
辛苦了

辛苦 辛苦啊 ！给你两个嚒庅吃！别累着啊
作者: 曹睿翔    时间: 2013-5-16 17:18
刚敲代码了，看了，非常不错
作者: 王婷婷    时间: 2013-5-16 18:47
王婷婷 发表于 2013-5-16 15:43
4、键盘事件添加键盘事件：5、Item Event 指定项被选中或取消的事件(1)    ItemListener:接收项事件的监听 ...

不会闲代码多吧？？？
作者: 王婷婷    时间: 2013-5-16 18:51
曹睿翔 发表于 2013-5-16 17:18
刚敲代码了，看了，非常不错

要是博客 这样写 不会闲 代码太多吧？？



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2