Java 高级事件处理

高级事件处理


  • 高级事件包括键盘事件、鼠标事件、窗体事件和选项事件。

1、键盘事件

  • KeyEvent 类负责捕获键盘事件,可以通过为组件添加实现了 KeyListener 接口的监听器来处理相应的键盘事件。

  • KeyListener 接口共有 3 个 抽象方法:击键事件(按下并释放按键)、按键被按下(按下按键但未松开)和按键释放(被按下的按键被松开)

  • KeyListener 接口的具体定义如下:

    public interface KeyListener extends EventListener{
        public void keyTyped(KeyEvent e);  // 发生击键事件时触发
        public void keyPressed(KeyEvent e); // 按键被按下时触发
        public void keyReleased(KeyEvent e); // 按键被释放时触发
    }
    
  • KeyEvent 类的常用方法如下:

    方法 功能简介
    getSource() 用来获得触发此次事件的组件对象,返回值为 Object 类型
    getKeyChar() 用来获得与此事件中的键相关联的字符
    getKeyCode() 用来获得与此事件中的键相关联的整数 keyCode
    getKeyText(int KeyCode) 用来获得描述 keyCode 的标签,如 A、F1 和 HOME 等
    isActionKey() 用来查看此事件中的键是否为“动作”键
    isControlDown() 用来查看 Ctrl 键在此次事件中是否被按下,当返回 true 时表示被按下
    isAltDown() 用来查看 Alt 键在此次事件中是否被按下,当返回 true 时表示被按下
    isShiftDown() 用来查看 Shift 键在此次事件中是否被按下,当返回 true 时表示被按下
  • 在 KeyEvent 类中以“VK_”开头的静态常量代表各个按键的 keyCode,可以通过这些静态常量判断事件中的按键,获得按键的标签。

  • 实例

    import javax.swing.*;
    import javax.swing.border.EmptyBorder;
    import javax.swing.border.TitledBorder;
    import java.awt.*;
    import java.awt.event.KeyAdapter;
    import java.awt.event.KeyEvent;
    import java.util.*;
    
    /**
     * 虚拟键盘(键盘的按下与释放)
     */
    public class KeyBoard extends JFrame {
        private Color green = Color.GREEN;//定义Color对象,用来表示按下键的颜色
        private Color white = Color.WHITE;//定义Color对象,用来表示释放键的颜色
    
        // 定义一个集合用来存储所有的按键ID
        private ArrayList<JButton> btns = new ArrayList<JButton>();
    
        // 自定义一个方法,用来将容器中的所有 JButton 组件添加到集合中
        private void addButtons() {
            for (Component cmp : getComponents()) {  // 遍历面板中所有的组件
                if (cmp instanceof JButton) {
                    btns.add((JButton) cmp);
                }
            }
        }
    
        private KeyBoard() {
            setTitle("虚拟按键(模拟按键的按下和释放)");
            setResizable(false); // 不可改变窗体的宽高
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            setBounds(100, 100, 548, 280);
            /*
             * 创建JPanel面板contentPane置于JFrame窗体中,并设置面板的背景色、边距和布局
             */
            //声明窗体中的成员组件
            JPanel contentPane = new JPanel();
            contentPane.setBackground(Color.WHITE);
            contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
            setContentPane(contentPane);
            contentPane.setLayout(null);
            /*
             * 创建 26 个字母对应的按键并置于面板contentPane中,设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
             */
            JButton btnQ = new JButton("Q");
            btnQ.setBackground(white);
            btnQ.setVerticalAlignment(SwingConstants.TOP);
            btnQ.setHorizontalAlignment(SwingConstants.LEADING);
            btnQ.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnQ.setBounds(0, 60, 47, 45);
            contentPane.add(btnQ);
    
            JButton btnW = new JButton("W");
            btnW.setBackground(white);
            btnW.setVerticalAlignment(SwingConstants.TOP);
            btnW.setHorizontalAlignment(SwingConstants.LEADING);
            btnW.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnW.setBounds(55, 60, 49, 45);
            contentPane.add(btnW);
    
            JButton btnE = new JButton("E");
            btnE.setBackground(white);
            btnE.setVerticalAlignment(SwingConstants.TOP);
            btnE.setHorizontalAlignment(SwingConstants.LEADING);
            btnE.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnE.setBounds(110, 60, 45, 45);
            contentPane.add(btnE);
    
            JButton btnR = new JButton("R");
            btnR.setBackground(white);
            btnR.setVerticalAlignment(SwingConstants.TOP);
            btnR.setHorizontalAlignment(SwingConstants.LEADING);
            btnR.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnR.setBounds(165, 60, 45, 45);
            contentPane.add(btnR);
    
            JButton btnF = new JButton("F");
            btnF.setBackground(white);
            btnF.setVerticalAlignment(SwingConstants.TOP);
            btnF.setHorizontalAlignment(SwingConstants.LEADING);
            btnF.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnF.setBounds(195, 125, 45, 45);
            contentPane.add(btnF);
    
            JButton btnD = new JButton("D");
            btnD.setBackground(white);
            btnD.setVerticalAlignment(SwingConstants.TOP);
            btnD.setHorizontalAlignment(SwingConstants.LEADING);
            btnD.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnD.setBounds(137, 125, 45, 45);
            contentPane.add(btnD);
    
            JButton btnT = new JButton("T");
            btnT.setVerticalAlignment(SwingConstants.TOP);
            btnT.setHorizontalAlignment(SwingConstants.LEADING);
            btnT.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnT.setBackground(white);
            btnT.setBounds(220, 60, 45, 45);
            contentPane.add(btnT);
    
            JButton btnY = new JButton("Y");
            btnY.setVerticalAlignment(SwingConstants.TOP);
            btnY.setHorizontalAlignment(SwingConstants.LEADING);
            btnY.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnY.setBackground(white);
            btnY.setBounds(275, 60, 45, 45);
            contentPane.add(btnY);
    
            JButton btnU = new JButton("U");
            btnU.setVerticalAlignment(SwingConstants.TOP);
            btnU.setHorizontalAlignment(SwingConstants.LEADING);
            btnU.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnU.setBackground(white);
            btnU.setBounds(330, 60, 45, 45);
            contentPane.add(btnU);
    
            JButton btnI = new JButton("I");
            btnI.setVerticalAlignment(SwingConstants.TOP);
            btnI.setHorizontalAlignment(SwingConstants.LEADING);
            btnI.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnI.setBackground(white);
            btnI.setBounds(385, 60, 45, 45);
            contentPane.add(btnI);
    
            JButton btnO = new JButton("O");
            btnO.setVerticalAlignment(SwingConstants.TOP);
            btnO.setHorizontalAlignment(SwingConstants.LEADING);
            btnO.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnO.setBackground(white);
            btnO.setBounds(440, 60, 46, 45);
            contentPane.add(btnO);
    
            JButton btnP = new JButton("P");
            btnP.setVerticalAlignment(SwingConstants.TOP);
            btnP.setHorizontalAlignment(SwingConstants.LEADING);
            btnP.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnP.setBackground(white);
            btnP.setBounds(495, 60, 45, 45);
            contentPane.add(btnP);
    
            JButton btnA = new JButton("A");
            btnA.setVerticalAlignment(SwingConstants.TOP);
            btnA.setHorizontalAlignment(SwingConstants.LEADING);
            btnA.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnA.setBackground(white);
            btnA.setBounds(23, 125, 45, 45);
            contentPane.add(btnA);
    
            JButton btnS = new JButton("S");
            btnS.setVerticalAlignment(SwingConstants.TOP);
            btnS.setHorizontalAlignment(SwingConstants.LEADING);
            btnS.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnS.setBackground(white);
            btnS.setBounds(82, 125, 45, 45);
            contentPane.add(btnS);
    
            JButton btnG = new JButton("G");
            btnG.setVerticalAlignment(SwingConstants.TOP);
            btnG.setHorizontalAlignment(SwingConstants.LEADING);
            btnG.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnG.setBackground(white);
            btnG.setBounds(251, 125, 45, 45);
            contentPane.add(btnG);
    
            JButton btnH = new JButton("H");
            btnH.setVerticalAlignment(SwingConstants.TOP);
            btnH.setHorizontalAlignment(SwingConstants.LEADING);
            btnH.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnH.setBackground(white);
            btnH.setBounds(306, 125, 45, 45);
            contentPane.add(btnH);
    
            JButton btnJ = new JButton("J");
            btnJ.setVerticalAlignment(SwingConstants.TOP);
            btnJ.setHorizontalAlignment(SwingConstants.LEADING);
            btnJ.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnJ.setBackground(white);
            btnJ.setBounds(361, 125, 45, 45);
            contentPane.add(btnJ);
    
            JButton btnK = new JButton("K");
            btnK.setVerticalAlignment(SwingConstants.TOP);
            btnK.setHorizontalAlignment(SwingConstants.LEADING);
            btnK.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnK.setBackground(white);
            btnK.setBounds(416, 125, 47, 45);
            contentPane.add(btnK);
    
            JButton btnL = new JButton("L");
            btnL.setVerticalAlignment(SwingConstants.TOP);
            btnL.setHorizontalAlignment(SwingConstants.LEADING);
            btnL.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnL.setBackground(white);
            btnL.setBounds(471, 125, 45, 45);
            contentPane.add(btnL);
    
            JButton btnZ = new JButton("Z");
            btnZ.setVerticalAlignment(SwingConstants.TOP);
            btnZ.setHorizontalAlignment(SwingConstants.LEADING);
            btnZ.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnZ.setBackground(white);
            btnZ.setBounds(39, 190, 45, 45);
            contentPane.add(btnZ);
    
            JButton btnX = new JButton("X");
            btnX.setVerticalAlignment(SwingConstants.TOP);
            btnX.setHorizontalAlignment(SwingConstants.LEADING);
            btnX.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnX.setBackground(white);
            btnX.setBounds(107, 190, 45, 45);
            contentPane.add(btnX);
    
            JButton btnC = new JButton("C");
            btnC.setVerticalAlignment(SwingConstants.TOP);
            btnC.setHorizontalAlignment(SwingConstants.LEADING);
            btnC.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnC.setBackground(white);
            btnC.setBounds(178, 190, 45, 45);
            contentPane.add(btnC);
    
            JButton btnV = new JButton("V");
            btnV.setVerticalAlignment(SwingConstants.TOP);
            btnV.setHorizontalAlignment(SwingConstants.LEADING);
            btnV.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnV.setBackground(white);
            btnV.setBounds(250, 190, 45, 45);
            contentPane.add(btnV);
    
            JButton btnB = new JButton("B");
            btnB.setVerticalAlignment(SwingConstants.TOP);
            btnB.setHorizontalAlignment(SwingConstants.LEADING);
            btnB.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnB.setBackground(white);
            btnB.setBounds(315, 190, 45, 45);
            contentPane.add(btnB);
    
            JButton btnN = new JButton("N");
            btnN.setVerticalAlignment(SwingConstants.TOP);
            btnN.setHorizontalAlignment(SwingConstants.LEADING);
            btnN.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnN.setBackground(white);
            btnN.setBounds(382, 190, 47, 45);
            contentPane.add(btnN);
    
            JButton btnM = new JButton("M");
            btnM.setVerticalAlignment(SwingConstants.TOP);
            btnM.setHorizontalAlignment(SwingConstants.LEADING);
            btnM.setFont(new Font("Times New Roman", Font.PLAIN, 16));
            btnM.setBackground(white);
            btnM.setBounds(449, 190, 48, 45);
            contentPane.add(btnM);
            /*
             * 创建面板panel置于面板contentPane中,设置面板panel的位置、宽高、TitledBorder、背景色以及布局方式(边界布局)
             */
            JPanel panel = new JPanel();
            panel.setBorder(new TitledBorder(null, "文本显示区", TitledBorder.LEADING, TitledBorder.TOP, null, null));
            panel.setBackground(Color.WHITE);
            panel.setBounds(0, 0, 540, 45);
            contentPane.add(panel);
            panel.setLayout(new BorderLayout(0, 0));
            /*
             * 创建文本框textField置于面板panel的中间
             */
            JTextField textField ;
            textField = new JTextField();
            textField.addKeyListener(new KeyAdapter() { //文本框添加键盘事件的监听
                char word;
                @Override
                public void keyPressed(KeyEvent e) { //按键被按下时被触发
                    word=e.getKeyChar();//获取按下键表示的字符
                    for(int i=0;i<btns.size();i++){//遍历存储按键ID的ArrayList集合
                        //判断按键是否与遍历到的按键的文本相同
                        if(String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())){
                            btns.get(i).setBackground(green);//将指定按键颜色设置为绿色
                        }
                    }
                }
                @Override
                public void keyReleased(KeyEvent e) { //按键被释放时被触发
                    word=e.getKeyChar();//获取释放键表示的字符
                    for(int i=0;i<btns.size();i++){//遍历存储按键ID的ArrayList集合
                        //判断按键是否与遍历到的按键的文本相同
                        if(String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())){
                            btns.get(i).setBackground(white);//将指定按键颜色设置为白色
                        }
                    }
                }
                @Override
                public void keyTyped(KeyEvent e){
                    word=e.getKeyChar();//获取按下键表示的字符
                    for(int i=0;i<btns.size();i++){//遍历存储按键ID的ArrayList集合
                        //判断按键是否与遍历到的按键的文本相同
                        if(String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())){
                            btns.get(i).setBackground(green);//将指定按键颜色设置为绿色
                        }
                    }
                }
            });
            panel.add(textField, BorderLayout.CENTER);
            textField.setColumns(10);
        }
    
        public static void main(String[] args) {
            EventQueue.invokeLater(() -> {
                try {
                    KeyBoard frame = new KeyBoard();
                    frame.addButtons(); // 初始化存储所有按键的集合
                    frame.setVisible(true);
    
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
    }
    

2、鼠标事件

  • 鼠标事件,由 MouseEvent 类负责捕获;由 MouseListener 接口的监听器负责处理相应的事件。

  • MouseListener 接口共有 5 个抽象方法,分别是光标移入和移出组件、鼠标键被按下或释放和发生单击事件。

  • MouseListener 接口的具体定义如下:

    public interface MouseListener extends EventListener{
        public void mouseEntered(MouseEvent e);  // 光标移入组件时触发
        public void mousePressed(MouseEvent e);  // 鼠标按键被按下时触发
        public void mouseRelesed(MouseEvent e);  // 鼠标按键被释放时触发
        public void mouseClicked(MouseEvent e); // 发生单击事件时触发
        public void mouseExited(MouseEvent e);   // 光标移出组件时触发
    }
    
  • MouseEvent 类中的常用方法如下:

    方法 功能简介
    getSource() 用来获得触发此次事件的组件对象,返回值是 Object 类对象
    getButton() 用来获得代表此次按下、释放或单击的按键的 int 型值
    getClickCount() 用来获得单击按键的次数
  • MouseEvent 类中代表鼠标按键的静态常量

    静态常量 常量值 代表的键
    BUTTON1 1 鼠标左键
    BUTTON2 2 鼠标滚轮(中键)
    BUTTON3 3 鼠标右键
  • 实例:

    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.MouseEvent;
    import java.awt.event.MouseListener;
    
    public class MouseEvent_Example extends JFrame {
        private static final long serialVersionUID = 1L;
    
        public static void main(String args[]) {
            MouseEvent_Example frame = new MouseEvent_Example();
            frame.setVisible(true); // 设置窗体可见,默认为不可见
        }
    
        private void mouseOper(MouseEvent e){
            int i = e.getButton(); // 通过该值可以判断按下的是哪个键
            if (i == MouseEvent.BUTTON1)
                System.out.println("按下的是鼠标左键");
            else if (i == MouseEvent.BUTTON2)
                System.out.println("按下的是鼠标滚轮");
            else if (i == MouseEvent.BUTTON3)
                System.out.println("按下的是鼠标右键");
        }
    
        private MouseEvent_Example(){
            super(); // 继承父类的构造方法
            setTitle("鼠标事件示例"); // 设置窗体的标题
            setBounds(100, 100, 500, 375); // 设置窗体的显示位置及大小
            // 设置窗体关闭按钮的动作为退出
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
            final JLabel label = new JLabel();
            label.addMouseListener(new MouseListener() {
                public void mouseEntered(MouseEvent e) {// 光标移入组件时被触发
                    System.out.println("光标移入组件");
                }
    
                public void mousePressed(MouseEvent e) {// 鼠标按键被按下时被触发
                    System.out.print("鼠标按键被按下,");
                    mouseOper(e);
                }
    
                public void mouseReleased(MouseEvent e) {// 鼠标按键被释放时被触发
                    System.out.print("鼠标按键被释放,");
                    mouseOper(e);
                }
    
                public void mouseClicked(MouseEvent e) {// 发生单击事件时被触发
                    System.out.print("单击了鼠标按键,");
                    mouseOper(e);
                    int clickCount = e.getClickCount();//获取鼠标单击次数
                    System.out.println("单击次数为" + clickCount + "下");
                }
    
                public void mouseExited(MouseEvent e) {// 光标移出组件时被触发
                    System.out.println("光标移出组件");
                }
            });
            getContentPane().add(label, BorderLayout.CENTER);
            //
        }
    }
    /*
    光标移入组件
    光标移出组件
    光标移入组件
    鼠标按键被按下,按下的是鼠标右键
    鼠标按键被释放,按下的是鼠标右键
    单击了鼠标按键,按下的是鼠标右键
    单击次数为1下
    鼠标按键被按下,按下的是鼠标左键
    鼠标按键被释放,按下的是鼠标左键
    单击了鼠标按键,按下的是鼠标左键
    单击次数为1下
    鼠标按键被按下,按下的是鼠标左键
    鼠标按键被释放,按下的是鼠标左键
    单击了鼠标按键,按下的是鼠标左键
    单击次数为1下
    鼠标按键被按下,按下的是鼠标左键
    鼠标按键被释放,按下的是鼠标左键
    单击了鼠标按键,按下的是鼠标左键
    单击次数为2下
    鼠标按键被按下,按下的是鼠标左键
    鼠标按键被释放,按下的是鼠标左键
    单击了鼠标按键,按下的是鼠标左键
    单击次数为3下
    鼠标按键被按下,按下的是鼠标右键
    鼠标按键被释放,按下的是鼠标右键
    单击了鼠标按键,按下的是鼠标右键
    单击次数为1下
    鼠标按键被按下,按下的是鼠标右键
    鼠标按键被释放,按下的是鼠标右键
    单击了鼠标按键,按下的是鼠标右键
    单击次数为2下
    鼠标按键被按下,按下的是鼠标右键
    鼠标按键被释放,按下的是鼠标右键
    单击了鼠标按键,按下的是鼠标右键
    单击次数为3下
    光标移出组件
    光标移入组件
    光标移出组件
    */
    

3、窗体事件

  • 捕获窗体事件,可以通过 WindowFocusListener、WindowStateListener 和 WindowListener 三个事件监听器来实现。

3.1、捕获窗体焦点变化事件

  • 捕获窗体焦点变化事件,由实现了的 WindowFocusListener 接口的事件监听器来完成,该接口的具体定义如下:

    public interface WindowFocusListener extends EventListener{
        public void WindowGainedFocus(WindowEvent e);  // 窗体获得焦点时触发
        public void WindowLostFocus(WindowEvent e);  // 窗体失去焦点时触发
    }
    
  • 实例:

    import javax.swing.*;
    import javax.swing.border.EmptyBorder;
    import java.awt.*;
    import java.awt.event.WindowEvent;
    import java.awt.event.WindowFocusListener;
    
    public class Focus extends JFrame {
        private JLabel lbLight;
        private JLabel lbTip;
    
    
        public static void main(String[] args) {
            Focus frame = new Focus();
            frame.setVisible(true);
        }
    
        private class myWindowFocusListener implements WindowFocusListener {
            @Override
            public void windowGainedFocus(WindowEvent e) {
                // 设置标签中的图标,显示灯亮
                lbLight.setIcon(new ImageIcon(Focus.class.getResource("light.png")));
                lbTip.setText("JFrame 窗体获得焦点后,灯亮了。。。");
            }
    
            @Override
            public void windowLostFocus(WindowEvent e) {
                // 设置标签中的图标,显示灯灭
                lbLight.setIcon(new ImageIcon(Focus.class.getResource("dark.png")));
                lbTip.setText("JFrame 窗体失去焦点后,灯灭了...");
            }
        }
    
        private Focus() {
            addWindowFocusListener(new myWindowFocusListener());  // 为窗体添加焦点事件监听器
            setAutoRequestFocus(false);  // JFrame 窗体失去焦点
            setResizable(false);  // 卟可改变窗体大小
            setTitle("焦点事件的监听");
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            setBounds(100, 100, 500, 400);
            // 创建JPanel面板contentPane置于JFrame窗体中,并设置面板的背景色、边距和布局
    
            JPanel contentPane = new JPanel();
            contentPane.setBackground(Color.BLACK);
            contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
            contentPane.setLayout(new BorderLayout(0, 0));
            setContentPane(contentPane);
            // 创建标签lblTip置于JFrame窗体中的南侧,设置标签label_1中字体的颜色、样式以及水平居中
    
            lbTip = new JLabel("JFrame 窗体失去焦点时,灯没亮!");
            lbTip.setForeground(Color.CYAN);
            lbTip.setFont(new Font("楷体", Font.PLAIN, 24));
            lbTip.setHorizontalAlignment(SwingConstants.CENTER);
            contentPane.add(lbTip,BorderLayout.SOUTH);
            //  创建标签lblLight置于JFrame窗体中的中间,设置标签label_2中的图标位置和样式
    
            lbLight = new JLabel("");
            lbLight.setHorizontalAlignment(SwingConstants.CENTER);
            lbLight.setIcon(new ImageIcon(Focus.class.getResource("dark.png")));
            contentPane.add(lbLight,BorderLayout.NORTH);
        }
    }
    
  • 运行效果:

    [外链图片转存失败(img-xRBOpKtY-1564019575807)(D:\编程笔记\java\灯灭.jpg)]

    [外链图片转存失败(img-zlqX4W8q-1564019575808)(D:\编程笔记\java\灯亮.jpg)]

3.2、捕获窗体状态变化事件

  • 要捕获窗体状态变化事件,可由实现了 WindowStateListener 接口的事件监听器来处理。

  • WindowStateListener 接口的具体定义如下:

    public interface WindowStateListener extends EventListener{
        public void WindowStateChanged(WindowEvent e); // 窗体状态变化时触发
    }
    
  • WindowEvent 类中由以下两个常用方法,用来获得窗体的状态,均返回一个 int 值

    1)getNewState():用来获得窗体现在的状态。

    2)getOldState():用来获得窗体以前的状态。

  • Frame 类中代表窗体状态的静态常量:

    静态常量 常量值 代表的键
    NORMAL 0 代表窗体处于“正常化”状态
    MAXIMIZED_BOTH 6 代表窗体处于“最大化”状态
  • 实例:

import javax.swing.*;
import java.awt.*;
import java.awt.event.WindowEvent;
import java.awt.event.WindowStateListener;

public class WindowStateListener_Example extends JFrame {
    public static void main(String[] args) {
        WindowStateListener_Example frame = new WindowStateListener_Example();
        frame.setVisible(true);
    }

    private WindowStateListener_Example() {
        super();
        addWindowStateListener(new myWindowStateListener());
        setTitle("捕获窗体状态事件");
        setBounds(100, 100, 600, 400);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    private class myWindowStateListener implements WindowStateListener {

        @Override
        public void windowStateChanged(WindowEvent e) {
            int oldState = e.getOldState();
            int newState = e.getNewState();
            String from;
            String to;
            from = getString(oldState);
            to = getString(newState);
            System.out.println(from+"->"+to);
        }

        private String getString(int newState) {
            String to;
            switch (newState) {
                case Frame.NORMAL:
                    to = "正常化";
                    break;
                case Frame.MAXIMIZED_BOTH:
                    to = "最大化";
                    break;
                default:
                    to = "最小化";
            }
            return to;
        }
    }
}
/*
正常化->最小化
最小化->正常化
正常化->最大化
最大化->正常化
正常化->最大化
最大化->最小化
最小化->最大化
最大化->正常化
*/

3.3、捕获其他窗体事件

  • 其他与窗体有关的事件,由实现了 WindowListener 接口的监听器完成。

  • WindowListener 接口的具体定义如下:

    public interface extends EventListener {
        public void windowActivated(WindowEvent e); // 窗体被激活时触发
        public void windowOpened(WindowEvent e); // 窗体被打开时触发
        public void windowIconified(WindowEvent e); // 窗体虫正常状态变为最小化时触发
        public void windowDeiconified(WindowEvent e); // 窗体从最小化变为正常状态时触发
        public void windowClosing(WindowEvent e); // 窗体将要被关闭时触发
        public void windowDeactivated(WindowEvent e); // 窗体不再处于激活状态时触发
        public void windowClosed(WindowEvent e); // 窗体已经被关闭时触发
    }
    
  • 窗体激活事件和获得焦点事件的区别如下

    1)窗体激活事件是 WindowListener 接口中提供的事件,而获得焦点事件是 WindowFocusListener 接口提供的事件。

    2)执行顺序不一样:窗体激活——获得焦点——失去焦点——窗体不再处于激活状态

  • 实例:

    import javax.swing.*;
    import java.awt.event.WindowEvent;
    import java.awt.event.WindowListener;
    
    public class WindowListener_Example extends JFrame {
        private class MyWindowListener implements WindowListener{
    
            @Override
            public void windowOpened(WindowEvent e) {
                System.out.println("窗口被打开!");
            }
    
            @Override
            public void windowClosing(WindowEvent e) {
                System.out.println("窗口将要被关闭!");
            }
    
            @Override
            public void windowClosed(WindowEvent e) {
                System.out.println("窗口已经被关闭!");
            }
    
            @Override
            public void windowIconified(WindowEvent e) {
                System.out.println("窗口被最小化!");
            }
    
            @Override
            public void windowDeiconified(WindowEvent e) {
                System.out.println("窗口恢复正常大小!");
            }
    
            @Override
            public void windowActivated(WindowEvent e) {
                System.out.println("窗口被激活!");
            }
    
            @Override
            public void windowDeactivated(WindowEvent e) {
                System.out.println("窗口失去激活!");
            }
        }
        private WindowListener_Example(){
            super();
            addWindowListener(new MyWindowListener());
            setTitle("捕获其他窗体事件");
            setBounds(100,100,500,375);
            setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        }
    
        public static void main(String[] args) {
            WindowListener_Example frame = new WindowListener_Example();
            frame.setVisible(true);
        }
    }
    /*
    窗口被激活!
    窗口被打开!
    窗口被最小化!
    窗口失去激活!
    窗口恢复正常大小!
    窗口被激活!
    窗口失去激活!
    窗口被激活!
    窗口将要被关闭!
    窗口失去激活!
    窗口已经被关闭!
    */
    

4、选项事件

  • 选项事件,由 ItemEvent 类捕获。可以通过为组件添加实现了 ItemListener 接口的监听器来处理相应的选项事件。

  • ItemListener 接口只有一个抽象方法,在修改依次下拉菜单选中项的过程中,该方法将被触发两次,依次是由取消原来选中项的选中状态触发的,另一次是由选中新选项触发的。

  • ItemListener 接口的具体定义如下:

    public interface ItemListener extends EventListener{
        public void itemStateChanged(ItemEvent e);
    }
    
  • ItemEvent 类有以下两个常用方法:

    1)getItem():用来获得出发此次事件的选项,返回值是 Object 类型。

    2)getStateChange():用来获得此次事件的类型,返回一个 int 型值,可以通过 ItemEvent 类中如下的静态常量来判断此次事件的具体类型:

    a、SELECTED:如果返回值等于该静态常量,说明此次事件是由选中新选项触发的。

    b、DESELECTED:如果返回值等于该静态常量,说明此次事件是由取消原来的选中项触发的。

  • 实例:

    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.ItemEvent;
    
    public class HouseRegister extends JFrame {
    
        private JComboBox<String> cboxNCity;
        private JComboBox<String> cboxCity;
        //存储黑龙江省的所有地级市
        private String[] strHLJ={ "哈尔滨", "齐齐哈尔", "牡丹江", "大庆", "伊春", "双鸭山","鹤岗", "鸡西", "佳木斯", "七台河", "黑河", "绥化", "大兴安岭" };
        //存储吉林省的所有地级市
        private String[] strJL={ "长春", "延边", "吉林", "白山", "白城", "四平", "松原", "辽源", "大安", "通化" };
        //存储辽宁省的所有地级市
        private String[] strLN={ "沈阳", "大连", "葫芦岛", "旅顺", "本溪", "抚顺","铁岭", "辽阳", "营口", "阜新", "朝阳", "锦州", "丹东", "鞍山" };
        /*
         * 根据选择的省显示其所有地级市
         * @param item ItemEvent类型,表示下拉列表中的选择项
         * @param cbox JComboBox类型,表示JComboBox组件
         */
        private void getCity(ItemEvent item, JComboBox<String> cbox){
            String strProvince=String.valueOf(item.getItem());//获取选中项
            switch (strProvince) {
                case "黑龙江省":
                    cbox.setModel(new DefaultComboBoxModel<>(strHLJ));
                    break;
                case "吉林省":
                    cbox.setModel(new DefaultComboBoxModel<>(strJL));
                    break;
                case "辽宁省":
                    cbox.setModel(new DefaultComboBoxModel<>(strLN));
                    break;
            }
        }
        /**
         * 主方法
         */
        public static void main(String[] args) {
            try{
                new HouseRegister().setVisible(true); // 创建HouseRegister对象frame
            } catch (Exception e){
                e.printStackTrace();
            }
        }
    
        /**
         * 创建JFrame窗体
         */
        private HouseRegister() { // HouseRegister的构造方法
            setTitle("户口本(局部)"); // 设置窗体题目
            NPanel contentPanel = new NPanel();// 创建一个面板对象
            contentPanel.setLayout(null);// 设置面板为绝对布局
            getContentPane().add(contentPanel);// 将面板添加到窗体上
            setResizable(false); // 不可改变窗体大小
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置窗体关闭的方式
            setBounds(100, 100, 592, 190);
    
            /*
             * 创建下拉列表cboxProvince置于面板contentPane中,设置复选框里的Model值、复选框的大小
             */
            // 声明“户口本”类中的成员组件
            JComboBox<String> cboxProvince = new JComboBox<>();
            //存储省份
            String[] strProvinces = {"黑龙江省", "吉林省", "辽宁省"};
            cboxProvince.setModel(new DefaultComboBoxModel<>(strProvinces));
            //添加选项事件监听器
            cboxProvince.addItemListener(arg0 -> {//重写选项发生变化时的方法
                getCity(arg0,cboxCity);//调用自定义方法实现省市联动
            });
            cboxProvince.setBounds(69, 97, 85, 21);
            contentPanel.add(cboxProvince);
            /*
             * 创建下拉列表“市”,设置该下拉列表中的选项值,横坐标、纵坐标、宽高,把下拉列表“市”放到面板contentPane中
             */
    
            cboxCity = new JComboBox<>(); // 创建下拉列表cboxCity
            cboxCity.setModel(new DefaultComboBoxModel<>(strHLJ));
            cboxCity.setBounds(158, 97, 85, 21); // 设置下拉列表的大小
            contentPanel.add(cboxCity); // 将下拉列表cboxCity置于面板panel中
    
            /*
             * 创建下拉列表cboxNProvince置于面板contentPane中,设置复选框里的Model值、复选框的大小
             */
            JComboBox<String> cboxNProvince = new JComboBox<>();
            cboxNProvince.setModel(new DefaultComboBoxModel<>(strProvinces));
            //添加选项事件监听器
            cboxNProvince.addItemListener(arg0 -> {//重写选项发生变化时的方法
                getCity(arg0,cboxNCity);//调用自定义方法实现省市联动
            });
            cboxNProvince.setBounds(69, 131, 85, 21);
            contentPanel.add(cboxNProvince);
            /*
             * 创建下拉列表“市”,设置该下拉列表中的选项值,横坐标、纵坐标、宽高,把下拉列表“市”放到面板contentPane中
             */
    
            cboxNCity = new JComboBox<>(); // 创建下拉列表cboxNProvince
            cboxNCity.setModel(new DefaultComboBoxModel<>(strHLJ));
            cboxNCity.setBounds(158, 131, 85, 21); // 设置下拉列表的大小
            contentPanel.add(cboxNCity); // 将下拉列表cboxNProvince置于面板panel中
        }
    
        class NPanel extends JPanel {// 重绘面板
            @Override
            protected void paintComponent(Graphics arg0) {// 重写事件,用来重绘面板背景
                int x = 0;// 定义重绘的起始点坐标
                int y = 0;
                // 使用指定图片创建ImageIcon对象
                ImageIcon imgBack;
                imgBack = new ImageIcon(HouseRegister.class.getResource("back.png"));
                // 按面板大小重绘图片
                arg0.drawImage(imgBack.getImage(), x, y, getSize().width, getSize().height, this);
                while (true) {
                    arg0.drawImage(imgBack.getImage(), x, y, this);// 按原始大小重绘图片
                    if (x > getSize().width && y > getSize().height)
                        break;
                    // 保证窗口大于图片时,图片仍能够覆盖整个窗口
                    if (x > getSize().width) {
                        x = 0;
                        y += imgBack.getIconHeight();
                    } else
                        x += imgBack.getIconWidth();
                }
            }
        }
    }
    
  • 运行效果:

Java 高级事件处理_第1张图片

你可能感兴趣的:(编程语言学习笔记,Java,Java学习)