死磕Java系列之GUI 组件和事件监听

阳光穿透心脏的1/2处 2022-04-03 12:46 453阅读 0赞

当我们搭建好图形界面窗体的时候，需要向窗体中加入各种组件，便于用户操作，用户在窗体中都会有哪些操作呢？窗体是程序与使用者可交互的接口，比如说登录界面，用户可以输入姓名和密码，点击登录按钮，登录到另一个界面，在下一个界面有更多的操作，比如说有多个选择组成的菜单，需要输入文本的文本框，用来标记的标签等。综上，一个窗体中有多个组件，组件有文本组件，按钮组件，标签组件和列表组件。当然了，一个窗体中有组件是不够的，还需要在窗体中加入监听事件，监听事件也就是说当用户点击相应的组件的时候，程序作出的响应反应，比如说登录界面点击登录按钮以后，监听器事件就是检测密码是否正确，然后选择跳入到另一个界面，这样的话，如何在窗体中加入组件呢？监听器事件有哪些类型，如何定义呢？

（一）组件

在窗体中加入各种组件便于用户操作，组件有文本组件，按钮组件，标签组件和列表组件。
在这里插入图片描述
具体的组件设计方式可见Java Swing 图形界面开发（目录）

1. 文本组件

  1. JTextField 是一个轻量级组件，它允许编辑单行文本。
    JavaSwing_2.6: JTextField（文本框）
    在这里插入图片描述在这里插入图片描述
  2. JPasswordField 是一个轻量级组件，允许编辑单行文本，其视图指示键入内容，但不显示原始字符，显示为密码框。
    JavaSwing_2.7: JPasswordField（密码框）
    在这里插入图片描述

  3. JTextArea 是一个显示纯文本的多行区域。
    JavaSwing_2.8: JTextArea（文本区域）
    在这里插入图片描述
    示例代码：

    package VideoTest;
    import javax.swing.JFrame;
    import javax.swing.JPanel;
    import javax.swing.JPasswordField;
    import javax.swing.JTextArea;
    import javax.swing.JTextField;

    public class TEST02 extends JFrame
    {
    public TEST02()
    {

    1.   super("SwingDemo");//定义名称
    2.   JPanel root = new JPanel();//实例化容器
    3.   root.add(new JTextField("我是JTextField"));//加入文本框
    4.   root.add(new JPasswordField("我是JPasswordField"));//加入密码框
    5.   root.add(new JTextArea("我是JTextArea"));//加入文本域
    6.   add(root);
    7.   //定义窗体相关参数
    8.   setSize(400, 300);
    9.   setDefaultCloseOperation(EXIT_ON_CLOSE);
    10.   setVisible(true);

    }

    public static void main(String[] args)
    {

    1.   new TEST02();

    }
    }

运行结果：
在这里插入图片描述

2. 按钮组件

  • JButton 其表现形式为一个按钮。
    在这里插入图片描述
  • JToggleButton有两个状态：按下和弹起。
    JavaSwing_2.5: JToggleButton（开关按钮）在这里插入图片描述

-单选按钮（JRadioButton）， 实现一个单选按钮，此按钮项可被选择或取消选择，并可为用户显示其状态。与 ButtonGroup 对象配合使用可创建一组按钮，一次只能选择其中的一个按钮。
JavaSwing_2.3: JRadioButton（单选按钮）在这里插入图片描述

3. 标签组件

  • 标签 ，使用JComponent的子类JLabel类创建标签，标签为用户提供信息提示。
    JavaSwing_2.1: JLabel（标签）
    4. 列表组件
    窗口中的菜单条、菜单、菜单项是我们所熟悉的组件，菜单放在菜单条里，菜单项放在菜单中菜单条 。菜单条，菜单，菜单项的关系是：菜单项是菜单的具体名称，菜单加入到菜单条中，菜单条加入容器中，菜单条是将菜单放入窗体的方法，具体而言，饭店的菜单上，菜单条就是大饭店的菜单本，菜单就是饭店菜单的菜单页， 菜单项就是具体的某一个菜的名称。
  • JMenubar 是一个菜单条，JFrame类用一个把菜单条放到窗口的方法：

setJMenuBar( JMenuBar bar);
该方法将菜单条添加到窗口的顶端，需要注意的是，只能向窗口添加一个菜单条。
JavaSwing_4.5: JMenuBar（菜单栏）

  • 菜单 JMenu负责创建菜单。
  • 菜单项 JMenuItem负责创建菜单项

JMenuItem(String text, Icon icon)

  1. package VideoTest;
  3. import java.awt.event.InputEvent;
  4. import java.awt.event.KeyEvent;
  5. import javax.swing.JFrame;
  6. import javax.swing.JMenu;
  7. import javax.swing.JMenuBar;
  8. import javax.swing.JMenuItem;
  9. import javax.swing.KeyStroke;
  10. import javax.swing.WindowConstants;
  12. /**
  13.  * 菜单条，菜单，菜单项的关系是：菜单项是菜单的具体名称，菜单加入到菜单条中，菜单条加入容器中，
  14.  * 菜单条是将菜单放入窗体的方法，具体而言，饭店的菜单上，菜单条就是大饭店的菜单本，菜单就是饭店菜单的菜单页
  15.  * 菜单项就是具体的某一个菜的名称。
  16.  */
  17. public class TEST02 extends JFrame {
  18.     JMenuBar menubar;//实例化 菜单条
  19.     JMenu menu, subMenu;//实例化菜单
  20.     JMenuItem item1, item2;//实例化菜单项
  21.     public static void main(String[] args) {
  22.         TEST02 win = new TEST02("带窗口的菜单", 20, 30, 400, 500);
  23.     }
  24.     public TEST02() {
  25.     }
  26.     //定义方法设置窗体的参数，输入窗体的大小，名称，和位置
  27.     public TEST02(String s, int x, int y, int w, int h) {
  28.         init(s);
  29.         setLocation(x, y);
  30.         setSize(w, h);
  31.         setVisible(true);
  32.         setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
  33.     }
  35.     void init(String s) {
  36.         setTitle(s);
  37.         menubar = new JMenuBar();
  38.         menu = new JMenu("菜单"); // JMnud的实例就是一个菜单
  39.         /**
  40.          * 一级菜单项
  41.          */
  42.         subMenu = new JMenu("软件项目"); // 子菜单
  43.         item1 = new JMenuItem("Java话题"); // 创建菜单项
  45.         //使用JMenuItem的构造方法设置图标
  46.         item2 = new JMenuItem("动画话题" );
  47.         item1.setAccelerator(KeyStroke.getKeyStroke('A'));
  48.         item2.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_MASK));
  50.         //菜单项加入菜单中。
  51.         menu.add(item1);
  52.         menu.addSeparator();
  53.         menu.add(item2);
  54.         menu.add(subMenu);
  55.         /**
  56.          * 添加二级菜单项
  57.          */
  58.         subMenu.add(new JMenuItem("汽车销售系统" ));
  59.         subMenu.add(new JMenuItem("农场信息系统" ));
  60.         menubar.add(menu); // 菜单条中加入菜单
  61.         setJMenuBar(menubar); // 添加一个菜单条
  63.     }
  64. }

运行结果：
在这里插入图片描述

常见组件组合的实例：

  1. import java.awt.FlowLayout;
  3. import javax.swing.ButtonGroup;
  4. import javax.swing.JButton;
  5. import javax.swing.JCheckBox;
  6. import javax.swing.JComboBox;
  7. import javax.swing.JFrame;
  8. import javax.swing.JLabel;
  9. import javax.swing.JPasswordField;
  10. import javax.swing.JRadioButton;
  11. import javax.swing.JScrollPane;
  12. import javax.swing.JTextArea;
  13. import javax.swing.JTextField;
  15. /*
  16.  * 这个里最包含了JavaGUI中的多个组件，
  17.  */
  18. public class TEST02 extends JFrame {
  20.     JTextField text;//实例化文本
  21.     JButton button;//实例化按钮
  22.     JCheckBox checkBox1, checkBox2, checkBox3;
  23.     JRadioButton radio1, radio2;//实例化单选按钮
  24.     ButtonGroup group;//实例化按钮组件
  25.     JComboBox<Object> comBox;
  26.     JTextArea area;//定义文本域
  27.     JPasswordField password;//定义密码框
  28.     public static void main(String[] args) {
  29.         TEST02 win = new   TEST02();
  30.         win.setBounds(100, 100, 520, 510);
  31.         win.setTitle("常用组件");
  32.     }
  34.     public TEST02() {
  35.         init();
  36.         setVisible(true);
  37.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  38.     }
  40.     void init() {
  41.         setLayout(new FlowLayout()); // 设置布局
  43.         //定义文本框及其相关参数
  44.         add(new JLabel("文本框:"));
  45.         text = new JTextField(10);
  46.         add(text);
  48.         //定义按钮及其相关参数
  49.         add(new JLabel("按钮:"));
  50.         button = new JButton("确认");
  51.         add(button);
  53.         //定义密码框及其相关参数
  54.         add(new JLabel("密码框:"));
  55.         password = new JPasswordField(10);
  56.         add(password);
  58.         //定义按钮标签及其相关参数
  59.         add(new JLabel("按钮:"));
  60.         button = new JButton("确认");
  61.         add(button);
  63.         //定义 选择框及其相关参数
  64.         add(new JLabel("选择框:"));
  65.         checkBox1 = new JCheckBox("喜欢音乐");
  66.         checkBox2 = new JCheckBox("喜欢旅游");
  67.         checkBox3 = new JCheckBox("喜欢篮球");
  68.         add(checkBox1);
  69.         add(checkBox2);
  70.         add(checkBox3);
  72.       //定义单选按钮及其相关参数
  73.         add(new JLabel("单选按钮:"));
  74.         group = new ButtonGroup();
  75.         radio1 = new JRadioButton("男");
  76.         radio2 = new JRadioButton("女");
  77.         group.add(radio1);
  78.         group.add(radio2);
  79.         add(radio1);
  80.         add(radio2);
  82.       //定义 下拉列表及其相关参数
  83.         add(new JLabel("下拉列表:"));
  84.         comBox = new JComboBox<>();
  85.         comBox.addItem("音乐天地");
  86.         comBox.addItem("武术天地");
  87.         comBox.addItem("象棋乐园");
  88.         add(comBox);
  90.       //定义文本区及其相关参数
  91.         add(new JLabel("文本区"));
  92.         area = new JTextArea(6, 13);// 文本区设置行数和列数
  93.         add(new JScrollPane(area));
  94.     }
  95. }

运行结果：
在这里插入图片描述
在组件的设计中，树和表格是比较少用的，

  • JTree，树。将分层数据显示为树状轮廓的组件
    JavaSwing_4.9: JTree（树）
  • JTable，表格。JTable 是用来显示和编辑常规二维单元表。
    JavaSwing_4.8: JTable（表格）

（二）监听器事件

任何支持GUI的操作环境都需要不断地监听按键或者点击鼠标这样的事件，操作环境将这些事件报告给正在运行的程序，如果事件发生，每个程序将决定如何对他们做出反应，当事件发生时，事件源将事件对象传递给注册的监听器对象，监听器对象将利用事件的信息决定如何对事件做出反应。
Java监听器事件主要有事件源，事件监听器和事件组成。
1.事件对象：
一般继承自java.util.EventObject对象,由开发者自行定义.
2.事件源：
就是触发事件的源头,注册监听器对象，并发送事件对象，不同的事件源会触发不同的事件类型.
3.事件监听器：
事件监听器负责监听事件源发出的事件.一个事件监听器通常实现java.util.EventListener这个标识接口.
在这里插入图片描述

监听器事件的处理流程： 事件源可以注册事件监听器对象,并可以向事件监听器对象发送事件对象.事件发生后,事件源将事件对象发给已经注册的所有事件监听器.
监听器对象随后会根据事件对象内的相应方法响应这个事件.换句话来说，事件监听器监听到事件源的发生以后，执行事件的行为。

在这里插入图片描述
常见的监听器类型有：
常见的监听器类型
基于鼠标的监听器事件：

  1. import java.awt.*;
  2. import java.awt.event.*;
  3. import javax.swing.*;
  4. /**
  5.  *  这段程序的作用在于在窗体中加入三个按钮，点击不同的按钮，窗体的颜色会发生变化。
  6.  */
  7. public class Test01 extends JFrame{
  8.    private JPanel buttonPanel;
  9.    private static final int DEFAULT_WIDTH = 300;
  10.    private static final int DEFAULT_HEIGHT = 200;
  11.    public static void main(String[] args)
  12.       {
  13.       EventQueue.invokeLater(new Runnable()
  14.          {
  15.             public void run()
  16.             {
  17.                 //定义窗体
  18.              Test01 frame = new Test01();
  19.                frame.setTitle("ButtonTest");
  20.                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  21.                frame.setVisible(true);
  22.             }
  23.          });
  24.    }
  25.    public Test01()
  26.    {      
  27.      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
  28.       // create buttons
  29.       JButton yellowButton = new JButton("Yellow");
  30.       JButton blueButton = new JButton("Blue");
  31.       JButton redButton = new JButton("Red");     
  32.       buttonPanel = new JPanel();
  33.       // add buttons to panel
  34.       buttonPanel.add(yellowButton);
  35.       buttonPanel.add(blueButton);
  36.       buttonPanel.add(redButton);
  37.        // add panel to frame
  38.       add(buttonPanel);
  40.       // create button actions
  41.       ColorAction yellowAction = new ColorAction(Color.YELLOW);
  42.       ColorAction blueAction = new ColorAction(Color.BLUE);
  43.       ColorAction redAction = new ColorAction(Color.RED);
  45.       // associate actions with buttons
  46.       yellowButton.addActionListener(yellowAction);
  47.       blueButton.addActionListener(blueAction);
  48.       redButton.addActionListener(redAction);    
  49.    }
  50.    /**
  51.     * An action listener that sets the panel's background color.
  52.     */
  53.    private class ColorAction implements ActionListener
  54.    {
  55.       private Color backgroundColor;
  56.       public ColorAction(Color c)
  57.       {
  58.          backgroundColor = c;
  59.       }
  60.       public void actionPerformed(ActionEvent event)
  61.       {        
  62.           buttonPanel.setBackground(backgroundColor);
  63.       }
  64.    }
  65. }

运行结果：
在这里插入图片描述

基于鼠标的监听器事件：

  1. import java.awt.*;
  2. import java.awt.event.KeyEvent;
  3. import java.awt.event.KeyListener;
  4. import java.awt.event.MouseEvent;
  5. import java.awt.event.MouseListener;
  6. import java.awt.event.MouseMotionListener; 
  7. import javax.swing.*;
  8. /*
  9. *这个程序定义一个窗体，然后窗体监听鼠标事件，当鼠标出现在窗体中时，通过监听鼠标事件
  10. *点击窗体，则显示鼠标所在的位置，以及点击次数等
  11. **/
  12. public class Test01 extends JFrame{
  13.     My_Panel mp = null;
  14.     public Test01() {
  16.         mp = new My_Panel();
  17.         this.add(mp);
  18.         // 注册监听
  19.         this.addMouseListener(mp); // 监听鼠标
  20.         this.addKeyListener(mp); // 监听键盘
  21.         this.addMouseMotionListener(mp); // 监听鼠标移动
  22.         //定义窗体的相关参数
  23.         this.setSize(300, 300); // 设置框体大小
  24.         this.setLocation(400,150); //设置框体显示的位置
  25.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置框体退出
  26.         this.setVisible(true); // 显示框体
  27.     }
  28.     public static void main(String[] args) {
  30.         Test01 d = new Test01();
  31.     }
  33. }
  35. class My_Panel extends JPanel implements MouseListener,KeyListener,MouseMotionListener{
  36.     public void paint(Graphics g){
  37.         super.paint(g);
  38.     }
  39.     //鼠标点击
  40.     @Override
  41.     public void mouseClicked(MouseEvent e) {
  42.         // TODO Auto-generated method stub
  43.         System.out.println("鼠标点击");
  44.         System.out.println("鼠标位置 x = "+e.getX()+" y = "+e.getY());
  45.         System.out.println("鼠标键 = "+e.getButton() + " 点击次数 "+e.getClickCount()); // 输出1是左键，2是中键，3是右键
  46.     }
  50.     //鼠标移动到My_Panel
  51.     @Override
  52.     public void mouseEntered(MouseEvent e) {
  53.         // TODO Auto-generated method stub
  54.     //    System.out.println("鼠标移动到My_Panel");
  55.     }
  56.     //鼠标离开My_Panel
  57.     @Override
  58.     public void mouseExited(MouseEvent e) {
  59.         // TODO Auto-generated method stub
  60.     //    System.out.println("鼠标离开My_Panel");
  61.     }
  62.     //鼠标按下
  63.     @Override
  64.     public void mousePressed(MouseEvent e) {
  65.         // TODO Auto-generated method stub
  66.     //    System.out.println("鼠标按下");
  67.     }
  68.     //鼠标松开
  69.     @Override
  70.     public void mouseReleased(MouseEvent e) {
  71.         // TODO Auto-generated method stub
  72.     //    System.out.println("鼠标松开");
  73.     }
  74.     //键按下
  75.     @Override
  76.     public void keyPressed(KeyEvent e) {
  77.         // TODO Auto-generated method stub
  78.         System.out.println("键  = "+e.getKeyChar());
  80.     }
  81.     //键松开
  82.     @Override
  83.     public void keyReleased(KeyEvent e) {
  84.         // TODO Auto-generated method stub
  86.     }
  87.     //键输入
  88.     @Override
  89.     public void keyTyped(KeyEvent e) {
  90.         // TODO Auto-generated method stub
  92.     }
  93.     //鼠标按键在组件上按下并拖动时调用
  94.     @Override
  95.     public void mouseDragged(MouseEvent e) {
  96.         // TODO Auto-generated method stub
  97.     //    System.out.println("鼠标按键在组件上按下并拖动时调用");
  98.     }
  99.     //鼠标光标移动到组件上但无按键按下时调用
  100.     @Override
  101.     public void mouseMoved(MouseEvent e) {
  102.         // TODO Auto-generated method stub
  103.     //    System.out.println("鼠标光标移动到组件上但无按键按下时调用");
  104.     }
  105. }

运行效果如图：

在这里插入图片描述

以上

JAVA图形界面设计部分完成了，整个模块包括常用窗体，布局方式，常用组件和监听事件这四个部分，图形界面设计和在饭店点菜的逻辑类似，进入大饭店点菜就是监听器事件，出事做好饭后端上来放在桌子上，桌子就是窗体，当然了，饭菜不能说直接放在桌子上要盘子盛着，盘子就是中层容器面板，桌子上有很多的菜，也有很多其他的小东西，如牙签，筷子，餐巾纸等，那么，这些东西就和图形界面设计中的组件一样，在窗体中有一些作用，那么用吃饭来形容监听器事件或许更加形象一点，综上，图形界面设计是Java设计程序时和用户交互的工具，设计窗体并加入组件，当使用者采取下一步行动以后，监听器事件发生作用，监听事件的发生，并决定如何行动。

发表评论

表情：
评论列表 （有 0 条评论，453人围观）

还没有评论，来说两句吧...

相关阅读