Java创建图形化界面
Java创建图形化界面
目录
一、swing
Swing 的核心是 "组件 (Component)" 和 "容器 (Container)"：
- 组件：按钮、文本框、标签等可以和用户交互的元素
- 容器：用来存放组件的地方（如窗口、面板）
所有 Swing 组件都以J开头（如 JFrame、JButton）
二、JFrame
JFrame – java的GUI程序的基本思路是以JFrame为基础，它是屏幕上window的对象，能够最大化、最小化、关闭。
创建窗口
JFrame frame = new JFrame();
JFrame()构造一个最初不可见的新框架。JFrame(GraphicsConfiguration gc)在屏幕设备的指定GraphicsConfiguration和空白标题中创建一个Frame。JFrame(String title)创建一个具有指定标题的新的、最初不可见的 Frame。JFrame(String title, GraphicsConfiguration gc)创建具有指定标题和屏幕设备的指定GraphicsConfiguration的JFrame。
常用方法
| 方法名 | 作用 |
|---|---|
setTitle(String title) |
设置窗口标题 |
setSize(int width, int height) |
设置窗口大小（宽、高） |
setLocation(int x, int y) |
设置窗口在屏幕上的位置（坐标） |
setLocationRelativeTo(null) |
让窗口居中显示（相对于屏幕） |
setResizable(boolean resizable) |
设置窗口是否可调整大小（默认 true） |
setDefaultCloseOperation(int operation) |
设置窗口关闭行为（如 EXIT_ON_CLOSE） |
add(Component comp) |
向窗口添加组件（如按钮、文本框） |
setVisible(boolean visible) |
设置窗口是否可见（默认 false） |
setIconImage(Image image) |
设置窗口标题栏的图标 |
- 设置标题：
frame.setTitle(String title); - 设置窗口大小：
frame.setSize(int width, int height); - 设置窗口在屏幕上的位置:
setLocation(int x, int y); - 让窗口居中显示:
setLocationRelativeTo(null); - 设置窗口是否可调整大小（默认
true）:setResizable(boolean resizable) - 设置关闭窗口时的行为:
frame.setDefaultCloseOperation(int operation)，这个参数一般是传入定义的常量名;JFrame.DO_NOTHING_ON_CLOSE==0
关闭窗口时不执行任何操作。此时点击关闭按钮不会有任何反应，通常需要配合WindowListener监听器来自定义关闭逻辑，例如弹出确认对话框询问用户是否真的要关闭窗口。JFrame.HIDE_ON_CLOSE==1
关闭窗口时仅隐藏窗口（窗口仍然存在于内存中，并未被销毁）。之后可以通过调用setVisible(true)方法重新显示该窗口。这是 Swing 早期版本的默认行为。JFrame.DISPOSE_ON_CLOSE==2
关闭当前窗口并释放该窗口所占用的资源（销毁窗口），但不会退出整个应用程序。如果应用程序中还有其他窗口处于打开状态，程序会继续运行。JFrame.EXIT_ON_CLOSE==3
关闭窗口时退出整个应用程序，会终止 Java 虚拟机（JVM）的运行。这是大多数主窗口常用的关闭行为，确保关闭主窗口时能完全退出程序。
- 向窗口添加组件:
add(Component comp); - 设置窗口是否可见（默认
false）:setVisible(boolean visible); - 设置窗口标题栏的图标:
setIconImage(Image image);
简要代码实现
import javax.swing.JFrame;
public class FirstWindow {
public static void main(String[] args) {
// 1. 创建窗口对象
JFrame frame = new JFrame("我的第一个窗口");
// 2. 设置窗口大小（宽度, 高度）
frame.setSize(400, 300);
// 3. 设置关闭窗口时的操作（退出程序）
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// 4. 设置窗口居中显示
frame.setLocationRelativeTo(null);
// 5. 显示窗口
frame.setVisible(true);
}
}
三、JPanel
JPanel – 是 Java Swing 中的轻量级面板容器，用于组织和管理其他 Swing 组件（如按钮、文本框等），不能独立存在，必须嵌套在 JFrame 等顶级容器中使用，是构建复杂界面的基础组件。
创建面板
JPanel panel = new JPanel();
JPanel 提供了两个主要构造方法：
JPanel()构造一个默认配置的面板，默认使用FlowLayout布局管理器（组件按添加顺序从左到右排列，一行排满自动换行）。JPanel(LayoutManager layout)构造一个使用指定布局管理器的面板，可直接设置为BorderLayout、GridLayout等布局方式。
常用方法
| 方法名 | 作用 |
|---|---|
add(Component comp) |
向面板中添加组件（如按钮、文本框） |
setLayout(LayoutManager mgr) |
设置面板的布局管理器 |
setBackground(Color c) |
设置面板的背景颜色（默认透明） |
setPreferredSize(Dimension d) |
设置面板的首选大小（宽 × 高） |
setBorder(Border border) |
为面板设置边框（如空白边框、线条边框） |
remove(Component comp) |
从面板中移除指定组件 |
removeAll() |
移除面板中所有组件 |
revalidate() |
重新计算布局（组件变化后刷新界面） |
repaint() |
重绘面板（使界面变化立即生效） |
- 添加组件：
panel.add(new JButton("确定"));向面板添加按钮组件。 - 设置布局：
panel.setLayout(new GridLayout(2, 2));将面板布局设为 2 行 2 列的网格。 - 设置背景：
panel.setBackground(Color.LIGHT_GRAY);将面板背景设为浅灰色（默认透明）。 - 设置边框：
panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));为面板添加 10 像素的内边距。 - 移除组件：
panel.remove(button);移除指定组件；panel.removeAll();清空面板所有组件（需配合revalidate()和repaint()刷新）。
布局管理器搭配使用
JPanel 的核心价值在于结合不同布局管理器实现复杂界面，常见组合方式：
-
BorderLayout中嵌套GridLayout
主窗口用BorderLayout，中间区域放一个GridLayout面板，实现网格布局的表单。 -
多层面板嵌套
面板中再放面板，每层使用不同布局，例如：// 外层面板（流式布局） JPanel outerPanel = new JPanel(); // 内层面板（网格布局） JPanel innerPanel = new JPanel(new GridLayout(3, 1)); innerPanel.add(new JLabel("用户名")); innerPanel.add(new JTextField(10)); outerPanel.add(innerPanel); // 内层面板作为组件添加到外层
简要代码实现
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class JPanelDemo {
public static void main(String[] args) {
// 1. 创建主窗口
JFrame frame = new JFrame("面板综合示例");
frame.setSize(500, 300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
// 2. 创建主面板（边界布局）
JPanel mainPanel = new JPanel(new BorderLayout(10, 10));
mainPanel.setBorder(BorderFactory.createEmptyBorder(15, 15, 15, 15)); // 外边框
// 3. 创建顶部面板（流式布局，放标题）
JPanel topPanel = new JPanel();
JLabel titleLabel = new JLabel("用户注册");
titleLabel.setFont(new Font("黑体", Font.BOLD, 18));
topPanel.add(titleLabel);
// 4. 创建中间面板（网格布局，放表单）
JPanel formPanel = new JPanel(new GridLayout(3, 2, 5, 10));
formPanel.add(new JLabel("用户名："));
formPanel.add(new JTextField(15));
formPanel.add(new JLabel("密码："));
formPanel.add(new JPasswordField(15));
formPanel.add(new JLabel("邮箱："));
formPanel.add(new JTextField(15));
// 5. 创建底部面板（流式布局，放按钮）
JPanel bottomPanel = new JPanel();
JButton submitBtn = new JButton("提交");
JButton resetBtn = new JButton("重置");
bottomPanel.add(submitBtn);
bottomPanel.add(resetBtn);
// 6. 组装面板到主面板
mainPanel.add(topPanel, BorderLayout.NORTH);
mainPanel.add(formPanel, BorderLayout.CENTER);
mainPanel.add(bottomPanel, BorderLayout.SOUTH);
// 7. 添加主面板到窗口并显示
frame.add(mainPanel);
frame.setVisible(true);
}
}
注意事项
- 布局嵌套原则：复杂界面建议通过多层面板嵌套实现，每层专注于单一布局逻辑，避免单层布局过于复杂。
- 刷新机制：动态添加 / 移除组件后，必须调用
revalidate()（重新计算布局）和repaint()（重绘）才能让变化生效。 - 背景透明：
JPanel默认透明，设置setBackground()后才会显示背景色，便于区分不同功能区域。
JPanel 是界面布局的 "积木"，通过灵活组合面板和布局管理器，可构建出结构清晰、美观易用的 Swing 界面。
四、JLabel
JLabel对象可以显示文本、图像或同时显示二者。可以通过设置垂直和水平对齐方式，指定标签显示区中标签内容在何处对齐。默认情况下，标签在其显示区内垂直居中对齐。默认情况下，只显示文本的标签是开始边对齐；而只显示图像的标签则水平居中对齐。
创建标签
JLabel label = new JLabel();
JLabel 提供了多个构造方法，用于创建不同初始状态的标签：
JLabel()构造一个无文本、无图像的空标签。JLabel(String text)构造一个显示指定文本的标签（文本默认左对齐）。JLabel(Icon image)构造一个显示指定图像的标签。JLabel(String text, Icon icon, int horizontalAlignment)构造一个同时显示文本和图像的标签，并指定水平对齐方式（如左对齐、居中、右对齐）。
常用方法
| 方法名 | 作用 |
|---|---|
setText(String text) |
设置标签显示的文本内容 |
getText() |
获取标签当前显示的文本内容 |
setIcon(Icon icon) |
设置标签显示的图像（如 ImageIcon） |
setHorizontalAlignment(int alignment) |
设置文本 / 图像的水平对齐方式（如居中） |
setFont(Font font) |
设置标签文本的字体（样式、大小等） |
setForeground(Color c) |
设置标签文本的颜色 |
setToolTipText(String text) |
设置鼠标悬停在标签上时显示的提示文本 |
- 设置 / 获取文本：
label.setText("用户名：");设置文本；String text = label.getText();获取文本。 - 设置图像：
label.setIcon(new ImageIcon("logo.png"));显示本地图片（需指定正确路径）。 - 水平对齐：
label.setHorizontalAlignment(SwingConstants.CENTER);设置为居中对齐（可选值：LEFT左对齐、CENTER居中、RIGHT右对齐）。 - 设置字体：
label.setFont(new Font("宋体", Font.BOLD, 16));设置为宋体、粗体、16 号字。 - 设置文本颜色：
label.setForeground(Color.RED);将文本设置为红色。
简要代码实现
import javax.swing.*;
import java.awt.*;
public class FirstLabel {
public static void main(String[] args) {
// 1. 创建主窗口
JFrame frame = new JFrame("标签示例");
frame.setSize(400, 300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
// 2. 创建面板（使用流式布局）
JPanel panel = new JPanel();
panel.setBackground(Color.WHITE);
// 3. 创建并配置标签
// 标签1：显示文本，右对齐
JLabel label1 = new JLabel("用户名：", SwingConstants.RIGHT);
label1.setFont(new Font("微软雅黑", Font.PLAIN, 14)); // 设置字体
// 标签2：显示文本+图像（假设存在"user.png"图片）
JLabel label2 = new JLabel("用户信息", new ImageIcon("user.png"), SwingConstants.LEFT);
label2.setForeground(new Color(0, 100, 200)); // 设置文本颜色
label2.setToolTipText("这是用户信息标签"); // 鼠标悬停提示
// 4. 向面板添加标签和文本框（用于演示标签的标识作用）
panel.add(label1);
panel.add(new JTextField(15));
panel.add(new JSeparator(SwingConstants.VERTICAL)); // 垂直分隔线
panel.add(label2);
// 5. 将面板添加到窗口
frame.add(panel);
// 6. 显示窗口
frame.setVisible(true);
}
}
注意事项
JLabel是静态展示组件，默认不响应鼠标或键盘事件，若需交互需配合监听器。- 显示图像时，
ImageIcon构造方法需传入正确的图片路径（绝对路径或项目相对路径），若图片不存在则不显示任何内容。 - 水平对齐方式对布局有影响，例如右对齐的标签会在其占用的空间内靠右显示，便于与左侧组件对齐。
JLabel 是界面中最基础的组件之一，通过合理设置文本、图像和样式，可提升界面的可读性和美观度。
五、JTextField
JTextField – 是 Java Swing 中的文本输入框组件，允许用户输入和编辑单行文本，常用于获取用户输入（如用户名、密码片段、搜索关键词等）。
创建文本框
JTextField textField = new JTextField();
JTextField 提供了多个构造方法，用于创建不同初始状态的文本框：
JTextField()构造一个空的文本框，默认宽度由布局管理器决定。JTextField(int columns)构造一个指定列数的文本框（columns表示可显示的字符数，影响文本框宽度）。JTextField(String text)构造一个包含初始文本的文本框。JTextField(String text, int columns)构造一个包含初始文本且指定列数的文本框。
常用方法
| 方法名 | 作用 |
|---|---|
setText(String text) |
设置文本框中的内容 |
getText() |
获取文本框中的当前内容 |
setColumns(int columns) |
设置文本框的列数（影响宽度） |
setEditable(boolean editable) |
设置文本框是否可编辑（true 可编辑，false 只读） |
setHorizontalAlignment(int alignment) |
设置文本的水平对齐方式（左对齐、居中、右对齐） |
setFont(Font font) |
设置文本框内文字的字体 |
setForeground(Color c) |
设置文本颜色 |
setBackground(Color c) |
设置文本框的背景颜色 |
setToolTipText(String text) |
设置鼠标悬停时显示的提示文本 |
addActionListener(ActionListener l) |
为文本框添加动作监听器（如按回车触发） |
- 设置 / 获取文本：
textField.setText("默认值");设置初始文本；String input = textField.getText();获取用户输入。 - 控制编辑权限：
textField.setEditable(false);设置为只读模式（用户无法修改内容）。 - 文本对齐：
textField.setHorizontalAlignment(SwingConstants.RIGHT);设置文本右对齐（适合显示数字）。 - 响应回车事件：通过
addActionListener监听回车动作，例如用户输入后按回车提交内容。
简要代码实现
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class FirstTextField {
public static void main(String[] args) {
// 1. 创建主窗口
JFrame frame = new JFrame("文本框示例");
frame.setSize(400, 200);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
// 2. 创建面板（使用网格布局：2行2列，间距5像素）
JPanel panel = new JPanel(new GridLayout(2, 2, 5, 10));
panel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20)); // 面板边距
// 3. 创建组件
JLabel label = new JLabel("请输入内容：");
JTextField textField = new JTextField(15); // 15列宽的文本框
JButton btn = new JButton("获取内容");
JLabel resultLabel = new JLabel("结果将显示在这里");
// 4. 配置文本框
textField.setToolTipText("输入后按回车或点击按钮提交");
textField.setFont(new Font("宋体", Font.PLAIN, 14));
// 5. 为文本框添加回车事件监听
textField.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String input = textField.getText();
resultLabel.setText("你输入了：" + input);
}
});
// 6. 为按钮添加点击事件（与回车效果一致）
btn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String input = textField.getText();
resultLabel.setText("你输入了：" + input);
}
});
// 7. 添加组件到面板
panel.add(label);
panel.add(textField);
panel.add(btn);
panel.add(resultLabel);
// 8. 将面板添加到窗口
frame.add(panel);
// 9. 显示窗口
frame.setVisible(true);
}
}
注意事项
JTextField仅支持单行文本输入，若需多行输入需使用JTextArea。- 获取文本前建议判断内容合法性（如非空校验），避免空指针异常。
- 若需隐藏输入内容（如密码），应使用
JPasswordField（继承自JTextField，输入内容显示为圆点或星号）。
JTextField 是交互性很强的组件，通过与监听器结合，可实现实时验证、提交表单等功能，是数据输入的核心组件。
六、JTextArea
JTextArea – 是 Java Swing 中的多行文本区域组件，允许用户输入和编辑多行文本，支持自动换行，常用于需要大量文本输入或显示的场景（如备注信息、文本编辑器、日志显示等）。
创建文本区域
JTextArea textArea = new JTextArea();
JTextArea 提供了多个构造方法，用于创建不同初始状态的文本区域：
JTextArea()构造一个空的文本区域，默认行数和列数由布局管理器决定。JTextArea(int rows, int columns)构造一个指定行数和列数的文本区域（rows行数，columns每行可显示的字符数）。JTextArea(String text)构造一个包含初始文本的文本区域。JTextArea(String text, int rows, int columns)构造一个包含初始文本且指定行列数的文本区域。
常用方法
| 方法名 | 作用 |
|---|---|
setText(String text) |
设置文本区域中的内容 |
getText() |
获取文本区域中的所有内容 |
append(String str) |
向文本区域末尾追加内容 |
setRows(int rows) |
设置文本区域的行数 |
setColumns(int columns) |
设置文本区域的列数（影响宽度） |
setLineWrap(boolean wrap) |
设置是否自动换行（true 自动换行） |
setWrapStyleWord(boolean word) |
设置换行方式（true 按单词边界换行，更美观） |
setEditable(boolean editable) |
设置是否可编辑（false 为只读模式） |
setFont(Font font) |
设置文本字体 |
setForeground(Color c) |
设置文本颜色 |
setBackground(Color c) |
设置背景颜色 |
getDocument().getLength() |
获取文本长度（字符数） |
selectAll() |
选中所有文本 |
replaceRange(String str, int start, int end) |
替换指定范围的文本（从start到end索引） |
- 自动换行设置：
textArea.setLineWrap(true);开启自动换行；textArea.setWrapStyleWord(true);按单词换行（避免单词被截断）。 - 追加内容：
textArea.append("新内容\n");向现有文本末尾添加内容（\n表示换行）。 - 清空内容：
textArea.setText("");清除文本区域中的所有内容。
简要代码实现
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class FirstTextArea {
public static void main(String[] args) {
// 1. 创建主窗口
JFrame frame = new JFrame("文本区域示例");
frame.setSize(500, 400);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
// 2. 创建面板（使用边界布局）
JPanel panel = new JPanel(new BorderLayout());
// 3. 创建文本区域（5行，30列）
JTextArea textArea = new JTextArea(5, 30);
textArea.setLineWrap(true); // 自动换行
textArea.setWrapStyleWord(true); // 按单词换行
textArea.setFont(new Font("宋体", Font.PLAIN, 14));
textArea.setBorder(BorderFactory.createTitledBorder("请输入内容")); // 带标题的边框
// 4. 为文本区域添加滚动条（当内容超出大小时自动显示）
JScrollPane scrollPane = new JScrollPane(textArea);
// 5. 创建按钮面板
JPanel btnPanel = new JPanel();
JButton appendBtn = new JButton("追加内容");
JButton clearBtn = new JButton("清空");
JButton getBtn = new JButton("获取内容");
// 6. 按钮事件处理
appendBtn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
textArea.append("这是追加的新内容...\n");
}
});
clearBtn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
textArea.setText(""); // 清空文本
}
});
getBtn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String content = textArea.getText();
// 显示获取的内容（通过对话框）
JOptionPane.showMessageDialog(frame,
"文本内容：\n" + content,
"提示",
JOptionPane.INFORMATION_MESSAGE);
}
});
// 7. 组装组件
btnPanel.add(appendBtn);
btnPanel.add(clearBtn);
btnPanel.add(getBtn);
panel.add(scrollPane, BorderLayout.CENTER); // 文本区域放中间
panel.add(btnPanel, BorderLayout.SOUTH); // 按钮放底部
// 8. 添加到窗口并显示
frame.add(panel);
frame.setVisible(true);
}
}
注意事项
- 滚动条：
JTextArea本身不自带滚动条，通常需要将其放入JScrollPane中（如示例），当内容超出可视区域时会自动显示滚动条。 - 换行符：不同操作系统的换行符可能不同（Windows 用
\r\n，Linux 用\n），但JTextArea会自动处理，直接使用\n即可。 - 性能：对于超大文本（如几万行），建议使用
JTextPane或JEditorPane替代，它们对大文本的处理更高效。 - 监听文本变化：可通过
DocumentListener监听文本内容的实时变化，用于实时校验或字数统计。
JTextArea 是处理多行文本的核心组件，结合滚动条和事件监听，可实现功能丰富的文本编辑或显示功能。
七、JPasswordField
JPasswordField – 是 Java Swing 中的密码输入框组件，继承自 JTextField，专门用于输入密码等敏感信息。其特点是输入的文本会被特殊字符（如星号 * 或圆点 •）掩盖，保护信息安全。
创建密码框
JPasswordField pwdField = new JPasswordField();
JPasswordField 提供了与 JTextField 类似的构造方法：
JPasswordField()构造一个空的密码框，默认宽度由布局管理器决定。JPasswordField(int columns)构造一个指定列数的密码框（columns影响宽度）。JPasswordField(String text)构造一个包含初始文本的密码框（不常用，密码一般不预设）。JPasswordField(String text, int columns)构造包含初始文本且指定列数的密码框。
常用方法
| 方法名 | 作用 |
|---|---|
getPassword() |
获取密码框中的密码（返回 char[] 数组，推荐使用） |
setText(String text) |
设置密码框中的内容（一般用于清空或预设） |
setEchoChar(char c) |
设置密码的掩盖字符（如 *、# 等） |
getEchoChar() |
获取当前使用的掩盖字符 |
setColumns(int columns) |
设置列数（影响宽度） |
setEditable(boolean editable) |
设置是否可编辑（false 为只读） |
setHorizontalAlignment(int alignment) |
设置文本水平对齐方式（如居中） |
- 获取密码：
char[] password = pwdField.getPassword();返回字符数组（而非String），原因是String在 Java 中会被缓存，而字符数组可手动清空，更安全。 - 设置掩盖字符：
pwdField.setEchoChar('•');将掩盖字符改为圆点（默认通常是星号*）。 - 清空密码：
pwdField.setText("");或pwdField.setPassword(new char[0]);清除输入的密码。
简要代码实现
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class FirstPasswordField {
public static void main(String[] args) {
// 1. 创建主窗口
JFrame frame = new JFrame("密码框示例");
frame.setSize(400, 200);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
// 2. 创建面板（网格布局：2行2列，间距5像素）
JPanel panel = new JPanel(new GridLayout(2, 2, 5, 15));
panel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
// 3. 创建组件
JLabel label = new JLabel("请输入密码：");
JPasswordField pwdField = new JPasswordField(15); // 15列宽
JButton loginBtn = new JButton("登录");
JLabel tipLabel = new JLabel(""); // 用于显示提示信息
// 4. 配置密码框
pwdField.setEchoChar('•'); // 设置掩盖字符为圆点
pwdField.setToolTipText("请输入6-12位密码");
// 5. 登录按钮事件
loginBtn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// 获取密码（字符数组）
char[] password = pwdField.getPassword();
// 简单验证（实际应用中需加密处理）
if (password.length < 6) {
tipLabel.setText("密码长度不能少于6位！");
tipLabel.setForeground(Color.RED);
} else {
// 模拟登录成功（实际使用后应清空密码数组）
tipLabel.setText("登录成功！密码长度：" + password.length);
tipLabel.setForeground(Color.GREEN);
// 安全做法：清空字符数组（避免内存中残留）
java.util.Arrays.fill(password, '0');
}
}
});
// 6. 添加组件到面板
panel.add(label);
panel.add(pwdField);
panel.add(loginBtn);
panel.add(tipLabel);
// 7. 添加面板到窗口并显示
frame.add(panel);
frame.setVisible(true);
}
}
注意事项
- 安全获取密码：
务必使用getPassword()而非getText()，前者返回char[]可手动清空（如示例中的Arrays.fill()），后者返回String会在内存中保留更长时间，存在安全风险。 - 掩盖字符：
不同外观风格（Look and Feel）可能默认使用不同的掩盖字符，可通过setEchoChar()自定义（如*、#、•等）。 - 密码处理：
实际应用中，密码不应明文传输或存储，需进行加密处理（如 MD5、SHA 或加盐哈希）。 - 与
JTextField的区别：
除了掩盖输入，JPasswordField的用法与JTextField基本一致，可视为 “安全版的单行文本框”。
JPasswordField 是处理敏感输入的专用组件，通过其特性可有效保护用户密码等私密信息，是登录、注册等场景的必备组件。
八、JButton
JButton – 是 Java Swing 中的按钮组件，用于触发用户交互，当用户点击按钮时可触发相应的操作（如提交表单、执行命令等），是图形界面中最常用的交互组件之一。
创建按钮
JButton button = new JButton();
JButton 提供了多个构造方法，用于创建不同初始状态的按钮：
JButton()构造一个无文本、无图标的空按钮。JButton(String text)构造一个显示指定文本的按钮。JButton(Icon icon)构造一个显示指定图标的按钮。JButton(String text, Icon icon)构造一个同时显示文本和图标的按钮。
常用方法
| 方法名 | 作用 |
|---|---|
setText(String text) |
设置按钮上的文本内容 |
getText() |
获取按钮上的文本内容 |
setIcon(Icon icon) |
设置按钮上的图标（如 ImageIcon） |
setToolTipText(String text) |
设置鼠标悬停时显示的提示文本 |
setEnabled(boolean enabled) |
设置按钮是否可用（false 为禁用状态，呈灰色） |
addActionListener(ActionListener l) |
为按钮添加点击事件监听器（核心功能） |
setPreferredSize(Dimension d) |
设置按钮的首选大小（宽 × 高） |
setFont(Font font) |
设置按钮文本的字体 |
setForeground(Color c) |
设置按钮文本的颜色 |
setBackground(Color c) |
设置按钮的背景颜色 |
- 绑定点击事件：通过
addActionListener()为按钮添加事件监听器，当按钮被点击时执行指定代码（核心用法）。 - 禁用按钮：
button.setEnabled(false);使按钮处于不可点击状态（如表单未填写完整时禁用提交按钮）。 - 图文按钮：
button.setIcon(new ImageIcon("ok.png"));给按钮添加图标，可通过setHorizontalTextPosition()调整文本与图标的相对位置。
简要代码实现
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class FirstButton {
public static void main(String[] args) {
// 1. 创建主窗口
JFrame frame = new JFrame("按钮示例");
frame.setSize(400, 300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
// 2. 创建面板（流式布局，组件间距10像素）
JPanel panel = new JPanel(new FlowLayout(FlowLayout.CENTER, 10, 30));
// 3. 创建按钮并配置
// 按钮1：文本按钮
JButton helloBtn = new JButton("点击打招呼");
helloBtn.setFont(new Font("宋体", Font.PLAIN, 14));
helloBtn.setToolTipText("点击我会弹出问候");
// 按钮2：图标按钮（假设存在"exit.png"图片）
JButton exitBtn = new JButton(new ImageIcon("exit.png"));
exitBtn.setToolTipText("退出程序");
exitBtn.setPreferredSize(new Dimension(80, 30)); // 固定大小
// 按钮3：禁用状态按钮
JButton disabledBtn = new JButton("不可用按钮");
disabledBtn.setEnabled(false); // 禁用按钮
// 4. 为按钮1添加点击事件
helloBtn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// 弹出对话框
JOptionPane.showMessageDialog(frame, "你好！这是按钮点击事件~");
}
});
// 5. 为按钮2添加点击事件（退出程序）
exitBtn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
int result = JOptionPane.showConfirmDialog(
frame, "确定要退出吗？", "提示", JOptionPane.YES_NO_OPTION);
if (result == JOptionPane.YES_OPTION) {
System.exit(0); // 退出程序
}
}
});
// 6. 添加按钮到面板
panel.add(helloBtn);
panel.add(exitBtn);
panel.add(disabledBtn);
// 7. 添加面板到窗口并显示
frame.add(panel);
frame.setVisible(true);
}
}
注意事项
- 事件监听：
JButton的核心功能是通过ActionListener响应点击事件，所有业务逻辑（如表单提交、页面跳转）都在此实现。 - 按钮状态：通过
setEnabled(false)可临时禁用按钮，常用于防止重复提交或非法操作。 - 图标路径：使用图标时需确保图片路径正确，若图片不存在，按钮会显示空白（不报错）。
- 快捷键：可通过
setMnemonic(KeyEvent.VK_O)为按钮设置快捷键（如Alt+O），增强操作便捷性。
JButton 是用户交互的核心入口，通过与事件监听器结合，可实现各种交互逻辑，是构建响应式界面的基础组件。
九、JMenuItem
JMenuItem – 是 Java Swing 中的菜单项组件，用于创建菜单中的可点击选项，通常嵌套在 JMenu 或 JPopupMenu 中，用户点击后可触发相应操作（如文件菜单中的 "打开"、"保存" 选项）。
创建菜单项
JMenuItem item = new JMenuItem();
JMenuItem 提供了多个构造方法，用于创建不同样式的菜单项：
JMenuItem()构造一个无文本、无图标的空菜单项。JMenuItem(String text)构造一个显示指定文本的菜单项（最常用）。JMenuItem(Icon icon)构造一个显示指定图标的菜单项。JMenuItem(String text, Icon icon)构造一个同时显示文本和图标的菜单项。JMenuItem(String text, int mnemonic)构造带文本和快捷键的菜单项（mnemonic为快捷键字符，如KeyEvent.VK_O对应O键）。
常用方法
| 方法名 | 作用 |
|---|---|
setText(String text) |
设置菜单项的文本内容 |
getText() |
获取菜单项的文本内容 |
setIcon(Icon icon) |
设置菜单项的图标 |
setToolTipText(String text) |
设置鼠标悬停时的提示文本 |
setEnabled(boolean enabled) |
设置菜单项是否可用（false 为禁用，呈灰色） |
setMnemonic(int mnemonic) |
设置快捷键（如 KeyEvent.VK_S 对应 S，需配合 Alt 键使用） |
setAccelerator(KeyStroke keyStroke) |
设置加速键（无需打开菜单即可触发，如 Ctrl+S） |
addActionListener(ActionListener l) |
为菜单项添加点击事件监听器 |
- 快捷键设置：
item.setMnemonic(KeyEvent.VK_O);设置Alt+O为快捷键（需先打开菜单）。 - 加速键设置：
item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_DOWN_MASK));设置Ctrl+S为加速键（直接触发，无需打开菜单）。 - 事件响应：通过
addActionListener()绑定点击事件，实现菜单项的功能（如保存文件、退出程序）。
简要代码实现
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
public class FirstMenuItem {
public static void main(String[] args) {
// 1. 创建主窗口
JFrame frame = new JFrame("菜单项示例");
frame.setSize(500, 300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
// 2. 创建菜单栏
JMenuBar menuBar = new JMenuBar();
// 3. 创建"文件"菜单
JMenu fileMenu = new JMenu("文件(F)");
fileMenu.setMnemonic(KeyEvent.VK_F); // 菜单快捷键：Alt+F
// 4. 创建菜单项并配置
// 新建菜单项
JMenuItem newItem = new JMenuItem("新建(N)");
newItem.setMnemonic(KeyEvent.VK_N); // 菜单项快捷键：Alt+N
newItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, InputEvent.CTRL_DOWN_MASK)); // Ctrl+N
// 打开菜单项
JMenuItem openItem = new JMenuItem("打开(O)");
openItem.setMnemonic(KeyEvent.VK_O);
openItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, InputEvent.CTRL_DOWN_MASK)); // Ctrl+O
// 保存菜单项
JMenuItem saveItem = new JMenuItem("保存(S)");
saveItem.setMnemonic(KeyEvent.VK_S);
saveItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_DOWN_MASK)); // Ctrl+S
// 分隔线（用于分组菜单项）
JSeparator separator = new JSeparator();
// 退出菜单项
JMenuItem exitItem = new JMenuItem("退出(X)");
exitItem.setMnemonic(KeyEvent.VK_X);
// 5. 为菜单项添加点击事件
newItem.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(frame, "执行新建操作");
}
});
openItem.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(frame, "执行打开操作");
}
});
saveItem.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(frame, "执行保存操作");
}
});
exitItem.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.exit(0); // 退出程序
}
});
// 6. 组装菜单（菜单项添加到菜单，菜单添加到菜单栏）
fileMenu.add(newItem);
fileMenu.add(openItem);
fileMenu.add(saveItem);
fileMenu.add(separator); // 添加分隔线
fileMenu.add(exitItem);
menuBar.add(fileMenu);
// 7. 设置窗口的菜单栏
frame.setJMenuBar(menuBar);
// 8. 显示窗口
frame.setVisible(true);
}
}
注意事项
-
菜单层级：
JMenuItem必须添加到JMenu或JPopupMenu中，不能直接添加到窗口，形成 "菜单栏→菜单→菜单项" 的层级结构。 -
快捷键与加速键
：
- 快捷键（
setMnemonic）：需先打开菜单，再按Alt+字符触发（如Alt+F打开文件菜单，再按N触发新建）。 - 加速键（
setAccelerator）：无需打开菜单，直接按组合键触发（如Ctrl+S直接触发保存）。
- 快捷键（
-
分隔线：使用
JSeparator可将功能相关的菜单项分组，提升菜单可读性。 -
禁用状态：通过
setEnabled(false)可禁用暂时不可用的菜单项（如未打开文件时禁用 "保存"）。
JMenuItem 是菜单系统的核心组件，通过合理配置文本、图标和快捷键，可创建直观易用的菜单交互，是桌面应用的标准组成部分。
十一、JOptionPane
JOptionPane – 是 Java Swing 中的对话框组件，用于快速创建标准对话框（如提示信息、确认操作、输入框等），无需手动构建窗口和面板，简化了交互提示功能的实现。
对话框类型
JOptionPane 提供了多种静态方法，用于创建不同用途的对话框：
- 消息对话框（Message Dialog）：显示提示信息（如操作成功、错误提示）。
- 确认对话框（Confirm Dialog）：询问用户确认操作（如 "确定删除？"），返回用户选择结果。
- 输入对话框（Input Dialog）：获取用户输入的文本内容。
- 选项对话框（Option Dialog）：自定义选项按钮，更灵活的交互选择。
常用方法
| 方法名 | 作用 |
|---|---|
showMessageDialog(Component parent, Object message) |
显示消息对话框（默认信息图标） |
showMessageDialog(Component parent, Object message, String title, int messageType) |
显示带标题和图标的消息对话框 |
showConfirmDialog(Component parent, Object message) |
显示确认对话框（默认 "确定 / 取消" 按钮） |
showConfirmDialog(Component parent, Object message, String title, int optionType) |
显示带标题和自定义按钮的确认对话框 |
showInputDialog(Component parent, Object message) |
显示输入对话框，返回用户输入的文本 |
showOptionDialog(Component parent, Object message, String title, int optionType, int messageType, Icon icon, Object[] options, Object initialValue) |
显示自定义选项对话框 |
- 消息类型（
messageType）：决定对话框图标，可选值：JOptionPane.INFORMATION_MESSAGE：信息图标（默认）JOptionPane.WARNING_MESSAGE：警告图标JOptionPane.ERROR_MESSAGE：错误图标JOptionPane.QUESTION_MESSAGE：问号图标JOptionPane.PLAIN_MESSAGE：无图标
- 选项类型（
optionType）：决定确认对话框的按钮组合，可选值：JOptionPane.DEFAULT_OPTION：仅 "确定" 按钮JOptionPane.YES_NO_OPTION："是 / 否" 按钮JOptionPane.YES_NO_CANCEL_OPTION："是 / 否 / 取消" 按钮
简要代码实现
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class FirstJOptionPane {
public static void main(String[] args) {
// 1. 创建主窗口和按钮
JFrame frame = new JFrame("对话框示例");
frame.setSize(400, 300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
JPanel panel = new JPanel(new FlowLayout(FlowLayout.CENTER, 20, 50));
// 消息对话框按钮
JButton msgBtn = new JButton("显示消息对话框");
// 确认对话框按钮
JButton confirmBtn = new JButton("显示确认对话框");
// 输入对话框按钮
JButton inputBtn = new JButton("显示输入对话框");
// 选项对话框按钮
JButton optionBtn = new JButton("显示选项对话框");
// 2. 消息对话框示例
msgBtn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// 信息提示框
JOptionPane.showMessageDialog(frame,
"操作成功完成！",
"提示",
JOptionPane.INFORMATION_MESSAGE);
// 错误提示框
// JOptionPane.showMessageDialog(frame, "文件不存在！", "错误", JOptionPane.ERROR_MESSAGE);
}
});
// 3. 确认对话框示例
confirmBtn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
int result = JOptionPane.showConfirmDialog(frame,
"确定要删除这条记录吗？",
"确认",
JOptionPane.YES_NO_OPTION,
JOptionPane.WARNING_MESSAGE);
// 根据用户选择执行操作（0=是，1=否）
if (result == JOptionPane.YES_OPTION) {
JOptionPane.showMessageDialog(frame, "记录已删除");
} else {
JOptionPane.showMessageDialog(frame, "操作已取消");
}
}
});
// 4. 输入对话框示例
inputBtn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String input = JOptionPane.showInputDialog(frame,
"请输入您的姓名：",
"输入",
JOptionPane.QUESTION_MESSAGE);
// 判断用户是否输入内容（点击取消返回null）
if (input != null && !input.isEmpty()) {
JOptionPane.showMessageDialog(frame, "您好，" + input + "！");
} else {
JOptionPane.showMessageDialog(frame, "未输入姓名");
}
}
});
// 5. 选项对话框示例
optionBtn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// 自定义选项按钮
Object[] options = {"红色", "蓝色", "绿色"};
int choice = JOptionPane.showOptionDialog(frame,
"请选择背景颜色：",
"颜色选择",
JOptionPane.DEFAULT_OPTION,
JOptionPane.PLAIN_MESSAGE,
null,
options,
options[0]); // 默认选中第一项
// 根据选择设置面板背景
if (choice != -1) { // -1表示用户关闭对话框
switch (choice) {
case 0: panel.setBackground(Color.RED); break;
case 1: panel.setBackground(Color.BLUE); break;
case 2: panel.setBackground(Color.GREEN); break;
}
}
}
});
// 组装界面
panel.add(msgBtn);
panel.add(confirmBtn);
panel.add(inputBtn);
panel.add(optionBtn);
frame.add(panel);
frame.setVisible(true);
}
}
注意事项
-
父组件参数：方法中的
parent参数指定对话框的父窗口，对话框会相对于父窗口居中显示；若为null，则相对于屏幕居中。 -
返回值处理
：
- 确认对话框返回用户选择的按钮索引（如
YES_OPTION=0、NO_OPTION=1）。 - 输入对话框返回用户输入的字符串（点击 "取消" 返回
null）。 - 选项对话框返回选中的选项索引（关闭对话框返回
-1）。
- 确认对话框返回用户选择的按钮索引（如
-
模态特性：
JOptionPane创建的对话框默认是模态的（modal），即对话框显示时会阻塞父窗口的操作，直到对话框关闭。 -
自定义内容：对话框的
message参数不仅可以是字符串，还可以是组件（如JPanel、JLabel等），实现复杂的提示内容。
JOptionPane 简化了标准对话框的开发，通过其静态方法可快速实现常见的交互提示功能，是 Swing 中提高开发效率的重要组件。
十二、JDialog
JDialog – 是 Java Swing 中的对话框组件，用于创建独立于主窗口的弹出式窗口，通常用于接收用户输入、显示提示信息或进行简单交互（如确认操作、输入参数等）。
创建对话框
JDialog dialog = new JDialog();
JDialog 提供了多个构造方法，用于创建不同特性的对话框：
JDialog () 构造一个无标题、无父窗口的非模态对话框。
JDialog (Frame owner) 构造一个指定父窗口的非模态对话框。
JDialog (Frame owner, String title) 构造一个指定父窗口和标题的非模态对话框。
JDialog (Frame owner, String title, boolean modal) 构造一个指定父窗口、标题和模态性的对话框（modal 为 true 时为模态对话框，会阻塞父窗口操作）。
常用方法
| 方法名 | 作用 |
|---|---|
| setTitle(String title) | 设置对话框标题 |
| setSize(int width, int height) | 设置对话框大小 |
| setLocationRelativeTo(Component c) | 设置对话框位置（相对于指定组件居中，传 null 则屏幕居中） |
| setModal(boolean modal) | 设置是否为模态对话框（true 为模态） |
| setDefaultCloseOperation(int operation) | 设置关闭操作（如 DISPOSE_ON_CLOSE 关闭时释放资源） |
| add(Component comp) | 向对话框添加组件 |
| setVisible(boolean b) | 设置对话框是否可见（true 显示，false 隐藏） |
| dispose() | 关闭并释放对话框资源 |
| setResizable(boolean resizable) | 设置对话框是否可调整大小 |
模态与非模态：
- 模态对话框（modal = true）：显示时会阻塞父窗口操作，必须关闭对话框才能回到父窗口（如确认对话框）。
- 非模态对话框（modal = false）：显示时不阻塞父窗口，可同时操作两者（如工具面板）。
事件响应：
通过为对话框中的按钮等组件添加 ActionListener 实现交互逻辑，如确认、取消等操作。
简要代码实现
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class DialogExample {
public static void main(String[] args) {
// 1. 创建主窗口
JFrame frame = new JFrame("主窗口");
frame.setSize(400, 300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
// 2. 创建按钮，点击显示对话框
JButton showDialogBtn = new JButton("打开对话框");
frame.add(showDialogBtn);
// 3. 为按钮添加点击事件，创建并显示对话框
showDialogBtn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// 创建模态对话框，父窗口为frame
JDialog dialog = new JDialog(frame, "示例对话框", true);
dialog.setSize(300, 200);
dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
dialog.setLocationRelativeTo(frame); // 相对于主窗口居中
// 向对话框添加组件
JPanel panel = new JPanel();
panel.setLayout(new FlowLayout());
JLabel label = new JLabel("请输入姓名：");
JTextField textField = new JTextField(15);
JButton confirmBtn = new JButton("确认");
JButton cancelBtn = new JButton("取消");
// 确认按钮事件
confirmBtn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String name = textField.getText();
JOptionPane.showMessageDialog(dialog, "你输入的姓名是：" + name);
dialog.dispose(); // 关闭对话框
}
});
// 取消按钮事件
cancelBtn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
dialog.dispose(); // 关闭对话框
}
});
panel.add(label);
panel.add(textField);
panel.add(confirmBtn);
panel.add(cancelBtn);
dialog.add(panel);
dialog.setVisible(true); // 显示对话框
}
});
// 4. 显示主窗口
frame.setVisible(true);
}
}
注意事项
- 父窗口关联：创建对话框时建议指定父窗口，使对话框在任务栏中与父窗口关联，且关闭父窗口时会自动关闭对话框。
- 资源释放：使用 DISPOSE_ON_CLOSE 作为关闭操作，确保对话框关闭时释放资源，避免内存泄漏。
- 模态对话框阻塞性：模态对话框的 setVisible (true) 方法会阻塞当前线程，直到对话框关闭，因此不应在事件调度线程中执行耗时操作。
- 布局管理：对话框默认使用 BorderLayout，需根据需求设置合适的布局管理器来排列组件。
JDialog 是 Swing 中实现弹窗交互的核心组件，通过合理设置模态性和添加交互组件，可满足各种用户输入和信息展示需求，是桌面应用中不可或缺的交互元素。
浙公网安备 33010602011771号