1.Swing的概述（JFrame和JDialog）

发布时间：2024年01月18日

GUI

GUI全称是Graphical User Interface，及图形化用户界面。GUI可以让用户直接操作的图形化界面，包括窗口、菜单、按钮、工具栏和其他各种图形化界面元素。

Java针对GUI设计提供了丰富的类库，这些类库分别位于java.awt和java.swing包中，简称AWT和Swing。

AWT引入了大量的Windows函数，因此称为中重量级组件。

Swing是以AWT为基础构建的轻量级图形界面组件。

1. Swing概述

Swing是Java的图形用户界面（GUI）工具包，旨在提供丰富且可定制的界面组件，用于开发跨平台的桌面应用程序。它以抽象的窗口工具包（AWT）为基础，使跨平台应用程序可以使用可拔插的外观风格。

它是Java Foundation Classes（JFC）的一部分，设计用于替代早期的Abstract Window Toolkit（AWT）。

1.1 功能及特点

关于Swing的主要特点和概述：

  1. 跨平台性：Swing是基于Java的，因此可以实现跨平台的能力。这意味着您可以编写一次代码，并在Windows、Mac和Linux等操作系统上运行，而无需对源代码进行修改。

  2. 丰富的UI组件：Swing提供了大量的可定制的用户界面组件，如按钮、标签、下拉框、文本框、表格等。这些组件可以轻松地进行布局和样式的修改，以满足应用程序的特定需求。

  3. 可扩展性：Swing具有强大的扩展性，允许开发人员根据自己的需求创建自定义组件或修改现有的组件。使用Swing，您可以根据应用程序的要求创建独特的用户界面元素。

  4. MVC架构：Swing采用了Model-View-Controller（MVC）架构模式，该模式将应用程序的数据逻辑、用户界面和用户输入分离开来，以便更好地管理和维护代码。

  5. 支持轻量级绘图：与AWT相比，Swing使用了一种轻量级的绘图模型，这使得它能够提供更快的响应时间和更好的性能。

1.2 Swing组件

在java中所有的Swing组件都保存在javax.swing包中。

Swing组件的所有类都继承Container类，然后根据GUI的功能扩展了两个主要分支，分别是容器分支和组件分支。

容器分支是为了实现图形化用户界面窗口的容器而设计的，而组件分支则是为了实现向容器中填充数据、元素和交互组件等功能。

Swing组件继承关系

  • Container（容器）：Container是一个抽象类，是Swing组件的父类。它表示一个包含其他组件的容器，用于存放和布局其他组件。Container提供添加和移除组件的方法，并通过布局管理器来确定组件的位置和大小。

  • Window（窗口）：Window是一个抽象类，表示一个顶级窗口。它是所有窗口类的父类，包括JFrame、JDialog等。Window提供基本的窗口操作，如显示、隐藏、调整大小等。

  • JWindow：JWindow是继承自Window的Swing组件，它表示一个无边框的窗口。JWindow通常用于创建自定义的弹出窗口或者非模态的辅助窗口。

  • Frame（框架）：Frame是继承自Window的Swing组件，它表示一个具有标题栏、边框和可调整大小的窗口。Frame通常用作应用程序的主窗口。

  • JFrame（窗体）：JFrame是Swing应用程序中最基本的顶级窗口容器。它具有标题栏、边框和可调整大小的能力。

  • Dialog（对话框）：Dialog是继承自Window的Swing组件，它表示一个模态对话框。Dialog通常用于获取用户输入或显示信息，并阻塞用户对其他窗口的操作。

  • JDialog：JDialog是基于Window的对话框类，用于创建模态或非模态的对话框窗口。它通常用于获取用户输入、显示信息或执行特定操作。

  • JComponent：JComponent是一个抽象类，是所有Swing组件的超类。它扩展自AWT的Component类，并提供了更多的扩展功能，如双缓冲、透明度控制等。

  • JPanel（面板）：JPanel是一个轻量级容器，可用于组织和布局其他组件。它通常被用作JFrame的内容面板。

  • JDialog：JDialog是基于Window的对话框类，用于创建模态或非模态的对话框窗口。它通常用于获取用户输入、显示信息或执行特定操作。

  • JScrollPane（滚动面板）：JScrollPane可以将任何其他组件（如文本框、列表）包装在一个可滚动的容器中，使得内容超出可视区域时可以滚动查看。

  • JMenuBar（菜单栏）：JMenuBar是一个用于显示菜单的容器组件。它通常位于窗口的顶部，包含多个JMenu组件。

  • AbstractButton（抽象按钮）：AbstractButton是一个抽象类，是所有按钮组件（如JButton、JCheckbox等）的父类。它提供了按钮的基本功能，如文本、图标、事件处理等。

  • JButton（按钮）：JButton是一个可点击的按钮，用于触发事件。它可以显示文本、图标或两者结合。

  • JMenuItem（菜单项）：JMenuItem是一个标准菜单中的一个选项。它可以被点击，并触发关联的动作。JMenuItem通常被放置在JMenu或JPopupMenu中。

  • JMenu（菜单）：JMenu是一个用于显示菜单项的容器组件。它可以包含多个JMenuItem或JMenu，形成一个多级菜单。

  • JToggleButton（切换按钮）：JToggleButton是一个可以切换状态的按钮。它可以表示两种状态（选中和未选中），并触发相关的动作。

  • JCheckBox（复选框）：JCheckBox用于提供多个选项，用户可以从中可选或取消选项。它可以单独使用，也可以作为组件的一部分。

  • JRadioButton（单选按钮）：JRadioButton用于提供一组互斥的选项，用户只能选择其中一个选项。

  • JComboBox（下拉列表框）：JComboBox是一个组合框，可以用于在一个下拉列表中选择一个选项。用户可以点击下拉按钮展开选项列表。

  • JTextComponent：是用于编辑和显示文本内容的Swing组件的父类。JTextComponent可以用于单行或多行的文本输入和显示。

  • JTextField（文本框）：JTextField是一个用于输入和显示单行文本的组件。它允许用户在文本框中输入文字，并可以通过编程方式获取输入的内容。

  • JTextArea（文本域）：JTextArea是一个多行文本输入框，用于输入和显示大段的文本信息。

  • JPopupMenu（弹出菜单）：JPopupMenu表示一个弹出式菜单，可在用户请求时显示。它通常用于响应鼠标右键点击，并提供上下文相关的操作选项。

  • JLabel（标签）：JLabel用于显示文本或图像。通常用于GUI中提供说明、标题或其他需要展示静态文本的地方。

  • JTable（表格）：JTable是一个用于显示和编辑表格数据的组件。它可以包含多列和多行的数据，并提供了丰富的功能来管理表格数据的展示和编辑。

  • JPasswordField（密码框）：JPasswordField是一个用于输入密码的文本框。输入的文本内容会被隐藏，只显示一些特定字符（如星号）。

  • JList（列表）：JList用于显示一个可选择的单元或一组单元的列表。用户可以从列表中选择一个或多个项目。

2.swing顶级容器

当涉及到Swing的主要顶级容器时，通常会提到三个容器，它们是JFrame、JDialog和JWindow。这些容器提供了不同的功能和特性，以满足不同类型的应用程序需求。

  • JFrame

    JFrame是Swing的主要顶级容器，它代表了一个标准的窗口。

    JFrame提供了基本的窗口功能，例如标题栏、最大化、最小化和关闭按钮等。它可以包含其他Swing组件，例如按钮、文本框和标签等。通常情况下，JFrame被用作应用程序的主窗口。

  • JDialog

    JDialog是一个对话框顶级容器，用于显示模态或非模态对话框。

    模态对话框是一个阻塞用户交互的窗口，直到用户完成对话框的操作，而非模态对话框则允许用户在对话框打开的同时进行其他操作。JDialog通常用于显示一些临时性的窗口，例如警告、确认框或消息框等。

  • JWindow

    JWindow是无边框的顶级窗口容器。

    它没有标题栏和边框，通常被用作自定义窗口的基础。JWindow可以用于创建特殊的窗口布局和样式，比如不需要标题栏和边框的弹出图形或动画窗口。

2.1 JFrame

JFrame是Swing中最常用的顶级容器之一，用于创建和管理可调整大小的窗口。它是一个独立存在的顶级容器（窗口），不能放置在其他容器里。

2.1.1 构造方法

以下是JFrame的构造方法以表格形式列出，并提供详细的举例说明：

构造方法描述举例
JFrame()创建一个无标题的空白窗口。JFrame frame = new JFrame();
JFrame(String title)创建一个具有指定标题的窗口。JFrame frame = new JFrame(“My Window”);
JFrame(String title, GraphicsConfiguration gc)创建一个具有指定标题和GraphicsConfiguration对象的窗口。GraphicsConfiguration gc = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
JFrame frame = new JFrame(“My Window”, gc);
JFrame(GraphicsConfiguration gc)创建一个具有指定GraphicsConfiguration对象的无标题窗口。GraphicsConfiguration gc = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
JFrame frame = new JFrame(gc);
JFrame(Rectangle bounds)创建具有指定边界的无标题窗口。JFrame frame = new JFrame(new Rectangle(50, 50, 400, 300));
JFrame(String title, Rectangle bounds)创建具有指定标题和边界的窗口。JFrame frame = new JFrame(“My Window”, new Rectangle(50, 50, 400, 300));
JFrame(Frame owner)创建一个具有指定拥有者的无标题窗口。Frame owner = new Frame();
JFrame frame = new JFrame(owner);
JFrame(String title, Frame owner)创建一个具有指定标题和拥有者的窗口。Frame owner = new Frame();
JFrame frame = new JFrame(“My Window”, owner);
JFrame(String title, Frame owner, GraphicsConfiguration gc)创建具有指定标题、拥有者和GraphicsConfiguration对象的窗口。Frame owner = new Frame();
GraphicsConfiguration gc = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
JFrame frame = new JFrame(“My Window”, owner, gc);
JFrame(Frame owner, GraphicsConfiguration gc)创建具有指定拥有者和GraphicsConfiguration对象的无标题窗口。Frame owner = new Frame();
GraphicsConfiguration gc = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
JFrame frame = new JFrame(owner, gc);

2.1.2 常用方法

好的，下面是一张表格，其中列出了 JFrame 类的常用方法及其详细举例：

方法描述举例
JFrame()创建一个无标题的、不可调整大小的 JFrame 窗口JFrame frame = new JFrame();
JFrame(String title)创建一个具有指定标题的、不可调整大小的 JFrame 窗口JFrame frame = new JFrame("My Window");
setTitle(String title)设置 JFrame 窗口的标题frame.setTitle("New Title");
setDefaultCloseOperation(int operation)设置 JFrame 窗口的关闭操作frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(int width, int height)设置 JFrame 窗口的大小frame.setSize(500, 400);
setLocation(int x, int y)设置 JFrame 窗口的位置frame.setLocation(100, 100);
setVisible(boolean visible)设置 JFrame 窗口是否可见frame.setVisible(true);
setLayout(LayoutManager manager)设置 JFrame 窗口的布局管理器frame.setLayout(new FlowLayout());
add(Component comp)向 JFrame 窗口添加组件frame.add(component);
pack()调整 JFrame 窗口的大小以适应其所有组件frame.pack();
setResizable(boolean resizable)设置 JFrame 窗口是否可调整大小frame.setResizable(false);
setContentPane(Container contentPane)设置 JFrame 窗口的内容面板frame.setContentPane(contentPane);
setJMenuBar(JMenuBar menuBar)设置 JFrame 窗口的菜单栏frame.setJMenuBar(menuBar);
setCursor(Cursor cursor)设置 JFrame 窗口的光标形状frame.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
setIconImage(Image image)设置 JFrame 窗口的图标frame.setIconImage(iconImage);

2.1.3 代码示例

展示了如何使用 JFrame 创建一个包含多个组件和布局管理器的窗口：

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.SpringLayout;

public class MyWindow {
    public static void main(String[] args) {
        // 创建一个 JFrame 窗口对象
        JFrame frame = new JFrame("My Window");

        // 创建一个 JPanel 面板
        JPanel panel = new JPanel();
        
        // 创建标签和文本框
        JLabel nameLabel = new JLabel("Name: ");
        JTextField nameField = new JTextField(20);
        
        JLabel ageLabel = new JLabel("Age: ");
        JTextField ageField = new JTextField(10);
        
        // 创建按钮
        JButton submitButton = new JButton("Submit");

        // 创建布局管理器
        SpringLayout layout = new SpringLayout();
        panel.setLayout(layout);
        
        // 添加组件到面板
        panel.add(nameLabel);
        panel.add(nameField);
        panel.add(ageLabel);
        panel.add(ageField);
        panel.add(submitButton);

        // 设置组件的布局约束
        layout.putConstraint(SpringLayout.WEST, nameLabel, 10, SpringLayout.WEST, panel);
        layout.putConstraint(SpringLayout.NORTH, nameLabel, 10, SpringLayout.NORTH, panel);
        
        layout.putConstraint(SpringLayout.WEST, nameField, 10, SpringLayout.EAST, nameLabel);
        layout.putConstraint(SpringLayout.NORTH, nameField, 10, SpringLayout.NORTH, panel);
        
        layout.putConstraint(SpringLayout.WEST, ageLabel, 10, SpringLayout.WEST, panel);
        layout.putConstraint(SpringLayout.NORTH, ageLabel, 10, SpringLayout.SOUTH, nameLabel);
        
        layout.putConstraint(SpringLayout.WEST, ageField, 10, SpringLayout.EAST, ageLabel);
        layout.putConstraint(SpringLayout.NORTH, ageField, 10, SpringLayout.SOUTH, nameField);
        
        layout.putConstraint(SpringLayout.WEST, submitButton, 10, SpringLayout.WEST, panel);
        layout.putConstraint(SpringLayout.NORTH, submitButton, 10, SpringLayout.SOUTH, ageLabel);
        
        // 将面板设置为窗口的内容面板
        frame.setContentPane(panel);

        // 设置窗口大小
        frame.setSize(300, 200);

        // 设置窗口位置居中
        frame.setLocationRelativeTo(null);

        // 设置窗口关闭操作
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // 设置窗口可见
        frame.setVisible(true);
    }
}

以上代码创建了一个标题为 “My Window” 的 JFrame 窗口，其中包含一个面板（JPanel）作为内容面板。面板上放置了两个标签（JLabel），两个文本框（JTextField）和一个按钮（JButton）。通过 SpringLayout 布局管理器，将这些组件按照一定的布局规则进行排列。

2.1.4 注意事项

  1. 创建 JFrame 对象：使用 JFrame frame = new JFrame("窗口标题") 来创建一个新的 JFrame 对象。您可以在括号中指定窗口的标题。

  2. 设置窗口大小：使用 frame.setSize(width, height) 来设置窗口的大小，其中 width 和 height 分别是窗口的宽度和高度。

  3. 设置窗口关闭操作：使用 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) 来设置窗口的关闭操作。默认情况下，窗口关闭时程序会继续运行，但如果您希望在关闭窗口时结束程序运行，可以使用 JFrame.EXIT_ON_CLOSE。

  4. 添加组件：使用 frame.add(component) 来添加组件到窗口中，其中 component 是您希望添加的组件对象。

  5. 设置布局管理器：使用 frame.setLayout(layoutManager) 来设置窗口的布局管理器，布局管理器用于确定组件的位置和大小。常见的布局管理器包括 BorderLayout、FlowLayout 和 GridLayout。

  6. 设定可见性：使用 frame.setVisible(true) 来设置窗口可见。只有在调用此方法后，窗口才会显示在屏幕上。

  7. 处理窗口事件：可以通过添加窗口监听器来处理窗口事件，例如窗口关闭事件、窗口最小化事件等。您可以使用 frame.addWindowListener(listener) 来添加窗口监听器。

2.2 JDialog

JDialog 是 Java 中的一个窗口类，用于创建和管理对话框。JDialog对话框可以分为两种：模拟对话框和非模拟对话框。

模拟对话框：指用户需要处理完当前对话框够才能继续与其他窗口交互的对话框。

非模拟对话框：指允许用户在处理对话框的同时与其他窗口交互的对话框。

2.2.1 构造方法

构造方法描述示例
JDialog()创建一个具有默认所有者和模态性质的 JDialog 对象。JDialog dialog = new JDialog();
JDialog(Dialog owner)使用指定的所有者创建一个具有模态性质的 JDialog 对象。JDialog dialog = new JDialog(owner);
JDialog(Dialog owner, boolean modal)使用指定的所有者和模态性质创建 JDialog 对象。JDialog dialog = new JDialog(owner, modal);
JDialog(Dialog owner, String title)使用指定的所有者和标题创建一个具有模态性质的 JDialog 对象。JDialog dialog = new JDialog(owner, title);
JDialog(Dialog owner, String title, boolean modal)使用指定的所有者、标题和模态性质创建 JDialog 对象。JDialog dialog = new JDialog(owner, title, modal);
JDialog(Dialog owner, String title, boolean modal, GraphicsConfiguration gc)使用指定的所有者、标题、模态性质和 GraphicsConfiguration 创建 JDialog 对象。JDialog dialog = new JDialog(owner, title, modal, gc);
JDialog(Frame owner)使用指定的所有者创建一个具有模态性质的 JDialog 对象。JDialog dialog = new JDialog(owner);
JDialog(Frame owner, boolean modal)使用指定的所有者和模态性质创建 JDialog 对象。JDialog dialog = new JDialog(owner, modal);
JDialog(Frame owner, String title)使用指定的所有者和标题创建一个具有模态性质的 JDialog 对象。JDialog dialog = new JDialog(owner, title);
JDialog(Frame owner, String title, boolean modal)使用指定的所有者、标题和模态性质创建 JDialog 对象。JDialog dialog = new JDialog(owner, title, modal);
JDialog(Frame owner, String title, boolean modal, GraphicsConfiguration gc)使用指定的所有者、标题、模态性质和 GraphicsConfiguration 创建 JDialog 对象。JDialog dialog = new JDialog(owner, title, modal, gc);

其中，owner参数表示对话框的所有者，可以是Dialog对象或Frame对象；modal参数表示对话框是否是模态对话框，true表示模态对话框，false表示非模态对话框；title参数表示对话框的标题；gc参数表示GraphicsConfiguration对象，用于指定对话框的图形配置。

2.2.2 常用方法

方法名描述示例
JDialog()创建一个默认的 JDialog 对象JDialog dialog = new JDialog();
JDialog(Frame owner, boolean modal)创建一个具有指定所有者 Frame 以及模态性的 JDialog 对象JDialog dialog = new JDialog(frame, true);
void setDefaultCloseOperation(int operation)设置关闭操作dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
void setSize(int width, int height)设置对话框的尺寸dialog.setSize(400, 300);
void setLocationRelativeTo(Component c)设置对话框相对于指定组件的位置dialog.setLocationRelativeTo(frame);
void setTitle(String title)设置对话框的标题dialog.setTitle(“My Dialog”);
void setResizable(boolean resizable)设置是否可调整对话框的大小dialog.setResizable(false);
void setModal(boolean modal)设置对话框是否模态dialog.setModal(true);
void setVisible(boolean visible)设置对话框的可见性dialog.setVisible(true);
void pack()调整对话框的大小以适应其内容dialog.pack();
Component getContentPane()返回对话框的内容面板JPanel contentPane = (JPanel) dialog.getContentPane();
void setContentPane(Component contentPane)设置对话框的内容面板dialog.setContentPane(contentPane);
void add(Component comp)向对话框增加一个组件dialog.add(new JLabel(“Hello World”));
void remove(Component comp)从对话框中移除一个组件dialog.remove(label);
void dispose()释放对话框及其资源dialog.dispose();

注意：上述示例中的 frame 是指包含 JDialog 的主窗口对象，label 是 JPanel 中的一个组件对象。

2.2.3 代码示例

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class MyDialog extends JDialog {
    private JLabel label;

    public MyDialog(Frame owner, String title, boolean modal) {
        super(owner, title, modal);

        // 创建一个标签并添加到对话框上
        label = new JLabel("Hello from the dialog!");
        add(label);

        // 创建一个关闭按钮并添加到对话框的南部（底部）
        JButton closeButton = new JButton("Close");
        closeButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                dispose(); // 调用dispose方法关闭对话框
            }
        });
        add(closeButton, BorderLayout.SOUTH);

        // 设置对话框的大小、位置和可否调整大小
        setSize(300, 200);
        setLocationRelativeTo(owner); // 将对话框位置设置为相对于主窗口居中
        setResizable(false);
    }

    public static void main(String[] args) {
        // 创建一个主窗口
        JFrame frame = new JFrame("Main Frame");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(500, 400);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);

        // 创建一个按钮用于打开对话框
        JButton button = new JButton("Open Dialog");
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 创建并显示一个对话框
                MyDialog dialog = new MyDialog(frame, "My Dialog", true);
                dialog.setVisible(true);
            }
        });

        // 将按钮添加到主窗口的中央位置
        frame.getContentPane().add(button, BorderLayout.CENTER);
    }
}

2.2.4 注意事项

  1. 确定对话框的模式：JDialog 可以设置为模态（modal）或非模态（non-modal）。

    模态对话框会阻塞用户对主窗口或其他对话框的操作，直到它被关闭。非模态对话框允许用户与其他窗口进行交互。在创建 JDialog 实例时，通过设置 modal 参数来确定对话框的模式。

  2. 设置对话框的所有者：对话框可以有一个所有者（owner），通常是一个 JFrame 或 JDialog 实例。

    设置所有者可确保对话框位于其所有者的上层，并在所有者关闭时自动关闭。在创建 JDialog 实例时，通过将所有者作为第一个参数传递给构造函数来设置所有者。

  3. 添加组件并布局：使用 JDialog 的 add() 方法将组件添加到对话框中。

    可以使用容器（如 JPanel 或其他容器）来组织并布局这些组件。可以使用布局管理器来自动管理组件的位置和大小。

  4. 处理用户交互：通过使用适当的组件和监听器，可以处理用户与对话框的交互。

    例如，可以为按钮添加 ActionListener 来处理按钮的单击事件。

  5. 显示和关闭对话框：使用对话框的 setVisible(true) 方法可以显示对话框。

    对话框将在窗口中心显示，用户将无法与其所有者进行交互。要关闭对话框，可以使用 dispose() 方法。

  6. 自定义对话框的外观和行为：JDialog 提供了许多方法和选项来自定义对话框的外观和行为。

    例如，可以设置对话框的大小、位置、标题栏、图标、是否可调整大小等。

文章来源:https://blog.csdn.net/kuxiaoyang/article/details/135670999
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
最新文章