97、Java Swing GUI编程组件介绍

rust6ferris

于 2025-07-13 14:35:04 发布

阅读量42

点赞数

CC 4.0 BY-SA版权

分类专栏： Java编程之道：从入门到精通文章标签： Java Swing GUI编程 JScrollPane

本文链接：https://blog.youkuaiyun.com/rust6ferris/article/details/149374353

Java编程之道：从入门到精通专栏收录该内容

100 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

Java Swing GUI编程组件介绍

在Java的Swing库中，有许多强大的组件可以用于创建图形用户界面（GUI）。下面将为大家详细介绍几个常用的组件：JScrollPane、JList、JComboBox、JTree和JTable。

JScrollPane

JScrollPane是一个轻量级容器，它能够自动处理另一个组件的滚动。被滚动的组件可以是单个组件（如表格），也可以是包含在另一个轻量级容器（如JPanel）中的一组组件。如果被滚动的对象大于可视区域，将自动提供水平和/或垂直滚动条，用户可以通过滚动条在面板中滚动组件。

JScrollPane的默认行为是根据需要动态添加或删除滚动条。例如，如果组件比视口高，将添加垂直滚动条；如果组件完全适合视口，则移除滚动条。

JScrollPane定义了多个构造函数，常用的是 JScrollPane(Component comp) ，其中 comp 指定要滚动的组件。当面板的内容超过视口的尺寸时，滚动条将自动显示。

使用JScrollPane的步骤如下：
1. 创建要滚动的组件。
2. 创建JScrollPane实例，并将需要滚动的对象传递给它。
3. 将滚动面板添加到内容面板中。

以下是一个示例代码：

// Demonstrate JScrollPane.
import java.awt.*;
import javax.swing.*;
/*
  <applet code="JScrollPaneDemo" width=300 height=250>
  </applet>
*/

public class JScrollPaneDemo extends JApplet {

  public void init() {
    try {
      SwingUtilities.invokeAndWait(
        new Runnable() {
          public void run() {
            makeGUI();
          }
        }
      );
    } catch (Exception exc) {
      System.out.println("Can't create because of " + exc);
    }
  }

  private void makeGUI() {
    // Add 400 buttons to a panel.
    JPanel jp = new JPanel();
    jp.setLayout(new GridLayout(20, 20));
    int b = 0;

    for(int i = 0; i < 20; i++) {
      for(int j = 0; j < 20; j++) {
        jp.add(new JButton("Button " + b));
        ++b;
      }
    }

    // Create the scroll pane.
    JScrollPane jsp = new JScrollPane(jp);

    // Add the scroll pane to the content pane.
    // Because the default border layout is used,
    // the scroll pane will be added to the center.
    add(jsp, BorderLayout.CENTER);
  }
}

JList

在Swing中，基本的列表类是JList，它支持从列表中选择一个或多个项目。列表通常由字符串组成，但也可以创建几乎任何可显示对象的列表。

从JDK 7开始，JList变成了泛型类，声明为 class JList<E> ，其中 E 表示列表中项目的类型。

JList提供了多个构造函数，常用的是 JList(E[] items) ，它创建一个包含指定数组中项目的JList。

JList基于两个模型：ListModel和ListSelectionModel。ListModel接口定义了如何访问列表数据，ListSelectionModel接口定义了确定选择哪些列表项的方法。

虽然JList本身可以正常工作，但大多数情况下会将其包装在JScrollPane中，这样长列表将自动可滚动，简化了GUI设计，也便于更改列表中的条目数量而无需更改JList组件的大小。

当用户进行或更改选择时，JList会生成ListSelectionEvent事件。该事件在用户取消选择项目时也会生成，通过实现ListSelectionListener来处理该事件，该监听器只指定一个方法 valueChanged(ListSelectionEvent le) 。

默认情况下，JList允许用户选择列表中的多个范围的项目，但可以通过调用 setSelectionMode(int mode) 方法来更改此行为， mode 必须是ListSelectionModel定义的值之一：
- SINGLE_SELECTION：单选模式。
- SINGLE_INTERVAL_SELECTION：单区间选择模式。
- MULTIPLE_INTERVAL_SELECTION：多区间选择模式。

可以通过调用 getSelectedIndex() 方法获取第一个选择项的索引，如果没有选择任何项目，则返回 -1；也可以通过调用 getSelectedValue() 方法获取与选择关联的值，如果没有选择任何值，则返回null。

以下是一个简单的JList示例代码：

// Demonstrate JList.
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;

/*
  <applet code="JListDemo" width=200 height=120>
  </applet>
*/

public class JListDemo extends JApplet {
  JList<String> jlst;
  JLabel jlab;
  JScrollPane jscrlp;

  // Create an array of cities.
  String Cities[] = { "New York", "Chicago", "Houston",
                      "Denver", "Los Angeles", "Seattle",
                      "London", "Paris", "New Delhi",
                      "Hong Kong", "Tokyo", "Sydney" };

  public void init() {
    try {
      SwingUtilities.invokeAndWait(
        new Runnable() {
          public void run() {
            makeGUI();
          }
        }
      );
    } catch (Exception exc) {
      System.out.println("Can't create because of " + exc);
    }
  }

  private void makeGUI() {
    // Change to flow layout.
    setLayout(new FlowLayout());

    // Create a JList.
    jlst = new JList<String>(Cities);

    // Set the list selection mode to single selection.
    jlst.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

    // Add the list to a scroll pane.
    jscrlp = new JScrollPane(jlst);

    // Set the preferred size of the scroll pane.
    jscrlp.setPreferredSize(new Dimension(120, 90));

    // Make a label that displays the selection.
    jlab = new JLabel("Choose a City");

    // Add selection listener for the list.
    jlst.addListSelectionListener(new ListSelectionListener() {
      public void valueChanged(ListSelectionEvent le) {
        // Get the index of the changed item.
        int idx = jlst.getSelectedIndex();

        // Display selection, if item was selected.
        if(idx != -1)
          jlab.setText("Current selection: " + Cities[idx]);
        else // Otherwise, reprompt.
          jlab.setText("Choose a City");
      }
    });

    // Add the list and label to the content pane.
    add(jscrlp);
    add(jlab);
  }
}

JComboBox

Swing通过JComboBox类提供了组合框（文本字段和下拉列表的组合）。组合框通常显示一个条目，但也会显示一个下拉列表，允许用户选择不同的条目，还可以创建允许用户在文本字段中输入选择的组合框。

从JDK 7开始，JComboBox变成了泛型类，声明为 class JComboBox<E> ，其中 E 表示组合框中项目的类型。

示例中使用的JComboBox构造函数是 JComboBox(E[] items) ，它使用指定数组初始化组合框。

JComboBox使用ComboBoxModel，可变组合框（其条目可以更改）使用MutableComboBoxModel。

除了传递要在下拉列表中显示的项目数组外，还可以通过 addItem(E obj) 方法动态添加项目到选择列表中，但此方法只能用于可变组合框。

当用户从列表中选择项目时，JComboBox会生成动作事件；当选择状态更改时（即选择或取消选择项目），会生成项目事件。通常，只需监听动作事件即可，但两种事件类型都可供使用。

可以通过调用 getSelectedItem() 方法获取列表中选择的项目，需要将返回值强制转换为列表中存储的对象类型。

以下是一个JComboBox示例代码：

// Demonstrate JComboBox.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
/*
  <applet code="JComboBoxDemo" width=300 height=200>
  </applet>
*/

public class JComboBoxDemo extends JApplet {
  JLabel jlab;
  ImageIcon hourglass, analog, digital, stopwatch;
  JComboBox<String> jcb;

  String timepieces[] = { "Hourglass", "Analog", "Digital", "Stopwatch" };

  public void init() {
    try {
      SwingUtilities.invokeAndWait(
        new Runnable() {
          public void run() {
            makeGUI();
          }
        }
      );
    } catch (Exception exc) {
      System.out.println("Can't create because of " + exc);
    }
  }

  private void makeGUI() {
    // Change to flow layout.
    setLayout(new FlowLayout());

    // Instantiate a combo box and add it to the content pane.
    jcb = new JComboBox<String>(timepieces);
    add(jcb);

    // Handle selections.
    jcb.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent ae) {
        String s = (String) jcb.getSelectedItem();
        jlab.setIcon(new ImageIcon(s + ".png"));
      }
    });

    // Create a label and add it to the content pane.
    jlab = new JLabel(new ImageIcon("hourglass.png"));
    add(jlab);
  }
}

JTree

树是一种以层次结构显示数据的组件，用户可以展开或折叠各个子树。在Swing中，树由JTree类实现。

JTree提供了多个构造函数，例如：
- JTree(Object obj [ ]) ：从指定数组的元素构造树。
- JTree(Vector<?> v) ：从向量的元素构造树。
- JTree(TreeNode tn) ：指定根节点构造树。

JTree依赖于两个模型：TreeModel和TreeSelectionModel。它会生成多种事件，其中与树相关的三个主要事件是TreeExpansionEvent（节点展开或折叠时发生）、TreeSelectionEvent（用户选择或取消选择树中的节点时生成）和TreeModelEvent（树的数据或结构更改时触发）。

要监听TreeSelectionEvent事件，需要实现TreeSelectionListener接口，该接口只定义一个方法 valueChanged(TreeSelectionEvent tse) ，可以通过调用 tse.getPath() 方法获取选择对象的路径。

TreeNode接口声明了获取树节点信息的方法，MutableTreeNode接口扩展了TreeNode接口，声明了插入和删除子节点或更改父节点的方法。

DefaultMutableTreeNode类实现了MutableTreeNode接口，代表树中的一个节点，常用构造函数是 DefaultMutableTreeNode(Object obj) 。

使用JTree时，通常将其放置在JScrollPane中，以便通过较小的视口滚动大型树。

使用JTree的步骤如下：
1. 创建JTree实例。
2. 创建JScrollPane并指定树为要滚动的对象。
3. 将树添加到滚动面板中。
4. 将滚动面板添加到内容面板中。

以下是一个JTree示例代码：

// Demonstrate JTree.
import java.awt.*;
import javax.swing.event.*;
import javax.swing.*;
import javax.swing.tree.*;
/*
  <applet code="JTreeDemo" width=400 height=200>
  </applet>
*/

public class JTreeDemo extends JApplet {
  JTree tree;
  JLabel jlab;

  public void init() {
    try {
      SwingUtilities.invokeAndWait(
        new Runnable() {
          public void run() {
            makeGUI();
          }
        }
      );
    } catch (Exception exc) {
      System.out.println("Can't create because of " + exc);
    }
  }

  private void makeGUI() {
    // Create top node of tree.
    DefaultMutableTreeNode top = new DefaultMutableTreeNode("Options");

    // Create subtree of "A".
    DefaultMutableTreeNode a = new DefaultMutableTreeNode("A");
    top.add(a);
    DefaultMutableTreeNode a1 = new DefaultMutableTreeNode("A1");
    a.add(a1);
    DefaultMutableTreeNode a2 = new DefaultMutableTreeNode("A2");
    a.add(a2);

    // Create subtree of "B"
    DefaultMutableTreeNode b = new DefaultMutableTreeNode("B");
    top.add(b);
    DefaultMutableTreeNode b1 = new DefaultMutableTreeNode("B1");
    b.add(b1);
    DefaultMutableTreeNode b2 = new DefaultMutableTreeNode("B2");
    b.add(b2);
    DefaultMutableTreeNode b3 = new DefaultMutableTreeNode("B3");
    b.add(b3);

    // Create the tree.
    tree = new JTree(top);

    // Add the tree to a scroll pane.
    JScrollPane jsp = new JScrollPane(tree);

    // Add the scroll pane to the content pane.
    add(jsp);

    // Add the label to the content pane.
    jlab = new JLabel();
    add(jlab, BorderLayout.SOUTH);

    // Handle tree selection events.
    tree.addTreeSelectionListener(new TreeSelectionListener() {
      public void valueChanged(TreeSelectionEvent tse) {
        jlab.setText("Selection is " + tse.getPath());
      }
    });
  }
}

JTable

JTable是一个用于显示数据行和列的组件。用户可以拖动列边界来调整列的大小，也可以将列拖动到新位置。根据其配置，还可以选择表中的行、列或单元格，并更改单元格内的数据。

JTable基于三个模型：TableModel、TableColumnModel和ListSelectionModel。TableModel接口定义了以二维格式显示数据的相关内容，TableColumnModel表示表列模型，ListSelectionModel确定如何选择项目。

JTable会生成多种事件，其中最基本的两个事件是ListSelectionEvent（用户在表中进行选择时生成）和TableModelEvent（表的数据发生更改时触发）。

使用JTable显示数据的步骤如下：
1. 创建JTable实例。
2. 创建JScrollPane对象并指定表为要滚动的对象。
3. 将表添加到滚动面板中。
4. 将滚动面板添加到内容面板中。

以下是一个简单的JTable示例代码：

// Demonstrate JTable.
import java.awt.*;
import javax.swing.*;
/*
  <applet code="JTableDemo" width=400 height=200>
  </applet>
*/

public class JTableDemo extends JApplet {

  public void init() {
    try {
      SwingUtilities.invokeAndWait(
        new Runnable() {
          public void run() {
            makeGUI();
          }
        }
      );
    } catch (Exception exc) {
      System.out.println("Can't create because of " + exc);
    }
  }

  private void makeGUI() {
    // Initialize column headings.
    String[] colHeads = { "Name", "Extension", "ID#" };

    // Initialize data.
    Object[][] data = {
      { "Gail", "4567", "865" },
      { "Ken", "7566", "555" },
      { "Viviane", "5634", "587" },
      { "Melanie", "7345", "922" },
      { "Anne", "1237", "333" },
      { "John", "5656", "314" },
      { "Matt", "5672", "217" },
      { "Claire", "6741", "444" },
      { "Erwin", "9023", "519" },
      { "Ellen", "1134", "532" },
      { "Jennifer", "5689", "112" },
      { "Ed", "9030", "133" },
      { "Helen", "6751", "145" }
    };

    // Create the table.
    JTable table = new JTable(data, colHeads);

    // Add the table to a scroll pane.
    JScrollPane jsp = new JScrollPane(table);

    // Add the scroll pane to the content pane.
    add(jsp);
  }
}

通过以上介绍，相信大家对Java Swing中的这些常用组件有了更深入的了解，可以根据实际需求选择合适的组件来创建丰富的GUI应用程序。

Java Swing GUI编程组件介绍（续）

组件特性对比

为了更清晰地了解这些组件的特点和适用场景，我们可以通过一个表格来进行对比：
| 组件名称 | 主要功能 | 常用构造函数 | 关联模型 | 主要事件 | 适用场景 |
| ---- | ---- | ---- | ---- | ---- | ---- |
| JScrollPane | 自动处理组件滚动 | JScrollPane(Component comp) | 无 | 无 | 当组件内容超过可视区域时，提供滚动功能 |
| JList | 支持选择一个或多个列表项 | JList(E[] items) | ListModel、ListSelectionModel | ListSelectionEvent | 展示可选择的列表项，如城市列表、选项列表等 |
| JComboBox | 文本字段和下拉列表组合 | JComboBox(E[] items) | ComboBoxModel、MutableComboBoxModel | ActionEvent、ItemEvent | 提供下拉选择项，也可允许用户输入 |
| JTree | 以层次结构显示数据 | JTree(Object obj [ ]) 等 | TreeModel、TreeSelectionModel | TreeExpansionEvent、TreeSelectionEvent、TreeModelEvent | 展示具有层次关系的数据，如文件目录、选项菜单等 |
| JTable | 显示数据行和列 | JTable(Object data[ ][ ], Object colHeads[ ]) | TableModel、TableColumnModel、ListSelectionModel | ListSelectionEvent、TableModelEvent | 展示表格形式的数据，如人员信息、数据统计等 |

组件使用流程总结

下面通过一个mermaid流程图来总结这些组件的通用使用流程：

graph TD
    A[创建组件相关对象] --> B[配置组件属性和模型]
    B --> C[处理组件事件（可选）]
    C --> D[将组件添加到滚动面板（可选）]
    D --> E[将滚动面板或组件添加到内容面板]

实际应用案例分析

假设我们要开发一个简单的员工信息管理系统，需要展示员工列表、员工详细信息表格以及一些可选择的操作选项。我们可以综合使用上述组件来实现这个系统。

import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.tree.*;
import java.util.Vector;

public class EmployeeManagementSystem extends JFrame {
    JList<String> employeeList;
    JTable employeeTable;
    JComboBox<String> operationComboBox;
    JTree optionTree;

    public EmployeeManagementSystem() {
        setTitle("员工信息管理系统");
        setSize(800, 600);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new BorderLayout());

        // 创建员工列表
        String[] employees = {"张三", "李四", "王五"};
        employeeList = new JList<>(employees);
        JScrollPane listScrollPane = new JScrollPane(employeeList);
        add(listScrollPane, BorderLayout.WEST);

        // 创建员工信息表格
        String[] colHeads = {"姓名", "部门", "职位"};
        Object[][] data = {
                {"张三", "技术部", "开发工程师"},
                {"李四", "市场部", "营销专员"},
                {"王五", "财务部", "会计"}
        };
        employeeTable = new JTable(data, colHeads);
        JScrollPane tableScrollPane = new JScrollPane(employeeTable);
        add(tableScrollPane, BorderLayout.CENTER);

        // 创建操作选项组合框
        String[] operations = {"查看详情", "编辑信息", "删除员工"};
        operationComboBox = new JComboBox<>(operations);
        operationComboBox.addActionListener(e -> {
            String selectedOperation = (String) operationComboBox.getSelectedItem();
            JOptionPane.showMessageDialog(this, "你选择了：" + selectedOperation);
        });
        add(operationComboBox, BorderLayout.NORTH);

        // 创建选项树
        DefaultMutableTreeNode top = new DefaultMutableTreeNode("系统选项");
        DefaultMutableTreeNode sub1 = new DefaultMutableTreeNode("员工管理");
        top.add(sub1);
        sub1.add(new DefaultMutableTreeNode("添加员工"));
        sub1.add(new DefaultMutableTreeNode("批量导入"));
        optionTree = new JTree(top);
        JScrollPane treeScrollPane = new JScrollPane(optionTree);
        add(treeScrollPane, BorderLayout.EAST);

        setVisible(true);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(EmployeeManagementSystem::new);
    }
}

在这个案例中，我们使用了JList展示员工列表，JTable展示员工详细信息，JComboBox提供操作选项，JTree展示系统的选项菜单。通过综合使用这些组件，我们可以创建一个功能丰富、界面友好的员工信息管理系统。

注意事项和常见问题

在使用这些组件时，还需要注意以下几点：
1. 布局管理 ：不同的布局管理器会影响组件的显示效果和排列方式，需要根据实际需求选择合适的布局管理器，如FlowLayout、BorderLayout、GridLayout等。
2. 事件处理 ：不同的组件会产生不同的事件，需要正确实现相应的事件监听器来处理这些事件，避免出现事件处理不当导致的问题。
3. 资源管理 ：在创建和使用组件时，要注意资源的释放和管理，避免出现内存泄漏等问题。

通过掌握这些组件的使用方法和注意事项，你可以在Java Swing中创建出更加复杂和强大的GUI应用程序。希望本文对你有所帮助，祝你在Java GUI编程的道路上取得更好的成果！