1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

public class JpanelExample {
    static final int WIDTH = 300;
    static final int HEIGHT = 150;

    public static void main(String[] args) {
        JFrame frame = new JFrame("JPanel测试程序");
        frame.setSize(WIDTH, HEIGHT);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JPanel panel = new JPanel();
        panel.setLayout(new java.awt.BorderLayout());
        frame.setContentPane(panel);

        JPanel panel1 = new JPanel(new java.awt.FlowLayout());
        JPanel panel2 = new JPanel(new java.awt.FlowLayout());
        JPanel panel3 = new JPanel(new java.awt.FlowLayout());
        JPanel panel4 = new JPanel(new java.awt.FlowLayout());
        JPanel panel5 = new JPanel(new java.awt.FlowLayout());

        JButton button1 = new JButton("小赵");
        JButton button2 = new JButton("小李");
        JButton button3 = new JButton("小敢");
        JButton button4 = new JButton("小武");
        JButton button5 = new JButton("姓");
        JButton button6 = new JButton("小钱");
        JButton button7 = new JButton("小周");
        JButton button8 = new JButton("小王");
        JButton button9 = new JButton("小孙");

        panel1.add(button1);
        panel1.add(button2);
        panel2.add(button3);
        panel2.add(button4);
        panel3.add(button5);
        panel3.add(button6);
        panel4.add(button7);
        panel4.add(button8);
        panel5.add(button9);

        panel.add(panel1, "North");
        panel.add(panel2, "South");
        panel.add(panel3, "East");
        panel.add(panel4, "West");
        panel.add(panel5, "Center");

        frame.setVisible(true);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public class JScrollPaneExample {
    static final int WIDTH = 300;
    static final int HEIGHT = 150;

    public static void main(String[] args) {
        JFrame frame = new JFrame("JScrollPane测试程序");
        frame.setSize(WIDTH, HEIGHT);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JTextArea textArea = new JTextArea("放大交流封疆大吏发冷风机阿拉基反垃圾发啦");
        JScrollPane scrollPane = new JScrollPane(textArea,
                JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
                JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);

        frame.setContentPane(scrollPane);
        frame.setVisible(true);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

public class JSplitPaneExample {
    public static void main(String[] args) {
        // 创建主窗体
        JFrame frame = new JFrame("JSplitPane 示例");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 300);

        // 创建两个JPanel面板 p1 和 p2
        JPanel p1 = new JPanel();
        JPanel p2 = new JPanel();

        // 设置面板背景色
        p1.setBackground(Color.CYAN);
        p2.setBackground(Color.LIGHT_GRAY);

        // 在 p1 面板中添加两个按钮
        JButton button1 = new JButton("按钮 1");
        JButton button2 = new JButton("按钮 2");

        // 将按钮添加到 p1 面板
        p1.setLayout(new FlowLayout()); // 使用 FlowLayout 管理按钮
        p1.add(button1);
        p1.add(button2);

        // 在 p2 面板中添加两个按钮
        JButton button3 = new JButton("按钮 3");
        JButton button4 = new JButton("按钮 4");

        // 将按钮添加到 p2 面板
        p2.setLayout(new FlowLayout()); // 使用 FlowLayout 管理按钮
        p2.add(button3);
        p2.add(button4);

        // 创建 JSplitPane，设置水平分割
        JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, p1, p2);

        // 设置分隔条的位置，0.5代表在中间
        splitPane.setDividerLocation(200);

        // 设置分隔条是否可以通过点击和拖动来进行调整，默认是可以的
        splitPane.setOneTouchExpandable(true); // 使得分隔条可以通过点击来展开或收缩
        // splitPane.setOneTouchExpandable(false); // 如果需要禁用点击展开/收缩功能，可以设置为 false

        // 设置布局是否连续更新。默认情况下，JSplitPane 会在用户调整分隔条时立即更新布局。
        splitPane.setContinuousLayout(true); // 启用连续布局，调整分隔条时，面板会立即重新布局
        // splitPane.setContinuousLayout(false); // 禁用连续布局，可以减少频繁的界面更新

        // 设置 JSplitPane 的分割方向，水平分割还是垂直分割
        // JSplitPane.HORIZONTAL_SPLIT：水平分割
        // JSplitPane.VERTICAL_SPLIT：垂直分割
        splitPane.setOrientation(JSplitPane.HORIZONTAL_SPLIT); // 默认是水平分割
        // splitPane.setOrientation(JSplitPane.VERTICAL_SPLIT); // 如果需要垂直分割，可以改为垂直分割

        // 设置分隔条的位置。单位是像素，可以通过改变此位置来调整初始分隔条位置
        splitPane.setDividerLocation(200); // 设置分隔条在 200 像素的位置

        // 将 JSplitPane 添加到主窗体
        frame.add(splitPane);
        frame.setVisible(true);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

public class JTabbedPaneExample {
    public static void main(String[] args) {
        // 创建一个新的窗口框架并设置标题
        JFrame frame = new JFrame("JTabbedPane测试程序");
        // 设置窗口的大小
        frame.setSize(400, 300);
        // 设置窗口关闭时退出程序
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // 创建多个面板，用于放置不同的收入情况标签
        JPanel panel1 = new JPanel(new java.awt.FlowLayout());
        JPanel panel2 = new JPanel(new java.awt.FlowLayout());
        JPanel panel3 = new JPanel(new java.awt.FlowLayout());
        JPanel panel4 = new JPanel(new java.awt.FlowLayout());
        JPanel panel5 = new JPanel(new java.awt.FlowLayout());

        // 创建多个标签，用于展示个人收入情况的详细信息
        JLabel label1 = new JLabel("个人收入情况");
        JLabel label2 = new JLabel("工资情况 3000/月");
        JLabel label3 = new JLabel("奖金情况 500/月");
        JLabel label4 = new JLabel("津贴情况 1000/月");
        JLabel label5 = new JLabel("社保情况 1000/月");

        // 将标签添加到对应的面板中
        panel1.add(label1);
        panel2.add(label2);
        panel3.add(label3);
        panel4.add(label4);
        panel5.add(label5);

        // 创建一个标签页组件
        JTabbedPane tabbedPane = new JTabbedPane();
        // 添加多个标签页，每个标签页展示一个面板的内容
        tabbedPane.addTab("个人收入情况", panel1);
        tabbedPane.setEnabledAt(0, true);
        tabbedPane.addTab("工资", panel2);
        tabbedPane.setEnabledAt(1, true);
        tabbedPane.addTab("奖金", panel3);
        tabbedPane.setEnabledAt(2, true);
        tabbedPane.addTab("津贴", panel4);
        tabbedPane.setEnabledAt(3, true);
        tabbedPane.addTab("社保", panel5);
        tabbedPane.setEnabledAt(4, true);

        // 设置标签页组件的首选尺寸和标签位置，以及标签布局策略
        tabbedPane.setPreferredSize(new Dimension(500, 200));
        tabbedPane.setTabPlacement(JTabbedPane.TOP);
        tabbedPane.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);

        // 将标签页组件添加到窗口框架中
        frame.add(tabbedPane);
        // 显示窗口
        frame.setVisible(true);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

public class JInternalFrameExample {
    public static void main(String[] args) {
        // 创建主窗体
        JFrame frame = new JFrame("JInternalFrame 示例");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(800, 600);

        // 创建桌面面板 JDesktopPane，不设置布局管理器
        JDesktopPane desktop = new JDesktopPane();

        // 创建两个JInternalFrame窗口
        JInternalFrame internalFrame1 = createInternalFrame("窗口 1", "这是第一个内部窗口。");
        JInternalFrame internalFrame2 = createInternalFrame("窗口 2", "这是第二个内部窗口。");

        // 设置每个内部窗口的位置，避免重叠
        internalFrame1.setLocation(50, 50); // 第一个窗口位置
        internalFrame2.setLocation(400, 50); // 第二个窗口位置，稍微偏移

        // 将内部窗口添加到桌面面板
        desktop.add(internalFrame1);
        desktop.add(internalFrame2);

        // 将桌面面板添加到主窗体
        frame.add(desktop);
        frame.setVisible(true);

        // 显示内部窗口
        internalFrame1.setVisible(true);
        internalFrame2.setVisible(true);
    }

    // 创建一个内部窗口，并在其中添加一个 JLabel，使用流式布局
    public static JInternalFrame createInternalFrame(String title, String labelText) {
        // 创建内部窗口，设置窗口标题、大小和是否可关闭
        JInternalFrame internalFrame = new JInternalFrame(title, true, true, true, true);
        internalFrame.setSize(300, 200);

        // 设置内部窗口的布局管理器为 FlowLayout
        internalFrame.setLayout(new FlowLayout());

        // 创建 JLabel 并添加文本
        JLabel label = new JLabel(labelText);
        label.setFont(new Font("Serif", Font.PLAIN, 16)); // 设置字体

        // 将 JLabel 添加到内部窗口
        internalFrame.add(label);

        // 设置内部窗口的可见性和布局
        internalFrame.setDefaultCloseOperation(JInternalFrame.DISPOSE_ON_CLOSE);

        return internalFrame;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

public class JLayeredPaneExample {
    public static void main(String[] args) {
        // 创建主窗口
        JFrame frame = new JFrame("JLayeredPane 按钮切换层级");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 300);

        // 创建JLayeredPane组件
        JLayeredPane layeredPane = new JLayeredPane();
        frame.add(layeredPane);

        // 创建两个按钮
        JButton button1 = new JButton("按钮1");
        JButton button2 = new JButton("按钮2");

        // 设置按钮初始位置
        button1.setBounds(50, 50, 100, 40); // 第一个按钮位置
        button2.setBounds(80, 80, 100, 40); // 第二个按钮位置，部分重叠

        // 添加按钮到JLayeredPane
        layeredPane.add(button1, Integer.valueOf(200));
        layeredPane.add(button2, Integer.valueOf(300));

        // 为按钮1添加点击事件，交换按钮的层级
        button1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                if (e.getActionCommand().equals("按钮1")) {
                    // 交换两个按钮的层级
                    layeredPane.setLayer(button1, 300);
                    layeredPane.setLayer(button2, 200);
                }
            }
        });

        // 为按钮2添加点击事件，交换按钮的层级
        button2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                if (e.getActionCommand().equals("按钮2")) {
                    // 交换两个按钮的层级
                    layeredPane.setLayer(button1, 200);
                    layeredPane.setLayer(button2, 300);
                }
            }
        });

        // 显示窗口
        frame.setVisible(true);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

public class JRootPaneExample {
    public static void main(String[] args) {
        // 创建 JFrame
        JFrame frame = new JFrame("JRootPane 示例");

        // 创建一个JRootPane实例
        JRootPane rootPane = frame.getRootPane();

        // 设置JMenuBar（菜单栏）
        JMenuBar menuBar = new JMenuBar();
        JMenu fileMenu = new JMenu("文件");
        JMenuItem openItem = new JMenuItem("打开");
        JMenuItem exitItem = new JMenuItem("退出");
        fileMenu.add(openItem);
        fileMenu.add(exitItem);
        menuBar.add(fileMenu);
        frame.setJMenuBar(menuBar); // 设置菜单栏

        // 设置内容面板
        JPanel contentPanel = new JPanel();
        contentPanel.setLayout(new BorderLayout());
        contentPanel.add(new JLabel("这是内容面板", JLabel.CENTER), BorderLayout.CENTER);

        // 在内容面板中添加按钮
        JButton button1 = new JButton("按钮 1");
        JButton button2 = new JButton("按钮 2");
        JPanel buttonPanel = new JPanel();
        buttonPanel.add(button1);
        buttonPanel.add(button2);
        contentPanel.add(buttonPanel, BorderLayout.SOUTH); // 按钮放在底部

        frame.setContentPane(contentPanel); // 设置内容面板

        // 设置分层面板
        JLayeredPane layeredPane = rootPane.getLayeredPane();
        layeredPane.setLayer(contentPanel, JLayeredPane.DEFAULT_LAYER);

        // 设置玻璃面板
        JPanel glassPanel = new JPanel();
        glassPanel.setBackground(new Color(0, 0, 0, 100)); // 半透明黑色
        glassPanel.setLayout(new BorderLayout());
        glassPanel.add(new JLabel("这是玻璃面板", JLabel.CENTER), BorderLayout.CENTER);
        frame.setGlassPane(glassPanel); // 设置玻璃面板
        glassPanel.setVisible(false); // 默认不显示, true则看不到菜单和按钮

        // 设置默认按钮（如果需要）
        JButton defaultButton = new JButton("默认按钮");
        frame.getRootPane().setDefaultButton(defaultButton);
        contentPanel.add(defaultButton, BorderLayout.NORTH); // 将默认按钮添加到北部（顶部）

        // 设置窗口关闭操作
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 300);
        frame.setVisible(true);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

public class ClearTextExample {

    public static void main(String[] args) {
        // 创建 JFrame 窗口
        JFrame frame = new JFrame("清空文本域");

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

        // 创建一个文本域 JTextArea
        JTextArea textArea = new JTextArea(10, 30);
        textArea.setBorder(BorderFactory.createLineBorder(Color.BLACK)); // 设置边框
        textArea.setLineWrap(true); // 自动换行
        textArea.setMargin(new Insets(10, 10, 10, 10)); // 设置文本域的内边距（上下左右为10）

        // 创建一个按钮 JButton
        JButton clearButton = new JButton("清空文本");

        // 设置按钮的事件监听器且为匿名事件监听器
        clearButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 当按钮被点击时，清空文本域的内容
                textArea.setText("");
            }
        });

        // 创建一个面板 JPanel，并设置其布局为 BorderLayout
        JPanel panel = new JPanel();
        panel.setLayout(new BorderLayout()); // 使用 BorderLayout 布局

        // 将文本域和按钮添加到面板
        panel.add(new JScrollPane(textArea), BorderLayout.CENTER); // 文本域放在中心
        panel.add(clearButton, BorderLayout.SOUTH); // 按钮放在底部

        // 设置面板的外边距（间隙）
        panel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20)); // 上右下左都为20像素的间隙

        // 将面板设置为窗口的内容面板
        frame.setContentPane(panel);

        // 设置窗口的大小和显示
        frame.setSize(400, 300);
        frame.setVisible(true);
    }
}

1
2
3
4
5
6
7
8
9

public interface WindowListener {
    void windowOpened(WindowEvent e);      // 窗口打开时触发,当窗口第一次显示时调用。
    void windowClosing(WindowEvent e);     // 窗口正在关闭时触发,当窗口正在关闭时调用，通常会弹出确认对话框，询问用户是否真的要关闭窗口。
    void windowClosed(WindowEvent e);      // 窗口已关闭时触发,窗口关闭后调用，通常用于释放资源等操作。
    void windowIconified(WindowEvent e);   // 窗口最小化时触发,当窗口最小化时调用。
    void windowDeiconified(WindowEvent e); // 窗口还原时触发,当窗口还原时调用。
    void windowActivated(WindowEvent e);   // 窗口激活时触发,当窗口激活时调用，通常指的是窗口被点击、获得焦点。
    void windowDeactivated(WindowEvent e); // 窗口失去焦点时触发,当窗口失去焦点时调用，通常指的是其他窗口被激活。
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public class WindowListenerExample {
    public static void main(String[] args) {
        // 创建 JFrame 窗口
        JFrame frame = new JFrame("Window Listener Example");

        // 添加 WindowListener 监听器
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                // 弹出确认对话框
                int option = JOptionPane.showConfirmDialog(
                        frame, // 父窗口
                        "系统出错了，是否确认退出?", // 对话框内容
                        "警告", // 对话框标题
                        JOptionPane.YES_NO_OPTION, // 按钮选项（是/否）
                        JOptionPane.WARNING_MESSAGE // 弹出警告图标
                );

                if (option == JOptionPane.YES_OPTION) {
                    // 如果点击“确定”，关闭窗口
                    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                } else {
                    // 如果点击“取消”，不关闭窗口
                    frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
                }
            }
        });

        // 设置窗口的大小、关闭操作和可见性
        frame.setSize(400, 300);
        frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); // 默认不关闭窗口
        frame.setVisible(true);
    }
}

1
2
3
4

public abstract class FocusAdapter implements FocusListener {
    public void focusGained(FocusEvent e) {}  // 当组件获得焦点时触发
    public void focusLost(FocusEvent e) {}    // 当组件失去焦点时触发
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public class FocusAdapterExample {
    public static void main(String[] args) {
        // 创建一个 JFrame 窗口
        JFrame frame = new JFrame("FocusAdapter Example");
        frame.setLayout(new FlowLayout());

        // 创建文本框和按钮
        JTextField textField = new JTextField(20);
        JButton button = new JButton("点击按钮");

        // 添加焦点监听器给文本框
        textField.addFocusListener(new FocusAdapter() {
            @Override
            public void focusGained(FocusEvent e) {
                // 当文本框获得焦点时，改变按钮的文本
                button.setText("已获取焦点");
            }

            @Override
            public void focusLost(FocusEvent e) {
                // 当文本框失去焦点时，恢复按钮的文本
                button.setText("点击按钮");
            }
        });

        // 将文本框和按钮添加到窗口
        frame.add(textField);
        frame.add(button);

        // 设置窗口的大小、关闭操作和可见性
        frame.setSize(300, 150);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

public class ListBoxWithBorderExample {
    public static void main(String[] args) {
        // 创建窗口
        JFrame frame = new JFrame("List Box with Borders");
        frame.setLayout(new FlowLayout());

        // 1. 第一个列表框使用数组创建，并添加 TitledBorder
        String[] fruits = { "苹果", "香蕉", "橙子", "葡萄", "西瓜" };
        JList<String> list1 = new JList<>(fruits);
        list1.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder(Color.BLACK), "你喜欢的水果"));
        list1.setPreferredSize(new Dimension(150, 150)); // 调整列表框宽度和高度

        // 2. 第二个列表框使用Vector创建，并添加 TitledBorder
        Vector<String> colors = new Vector<>(Arrays.asList("红色", "蓝色", "绿色", "黄色", "紫色"));
        JList<String> list2 = new JList<>(colors);
        list2.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder(Color.BLACK), "你最喜欢的颜色"));
        list2.setPreferredSize(new Dimension(150, 150)); // 调整列表框宽度和高度

        // 3. 第三个列表框使用ListModel创建，并添加 TitledBorder
        DefaultListModel<String> listModel3 = new DefaultListModel<>();
        listModel3.addElement("选项 A");
        listModel3.addElement("选项 B");
        listModel3.addElement("选项 C");
        JList<String> list3 = new JList<>(listModel3);
        list3.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder(Color.BLACK), "选择哪一个"));
        list3.setPreferredSize(new Dimension(150, 150)); // 调整列表框宽度和高度

        // 4. 第四个列表框用于接收移动过来的项，并添加 TitledBorder
        DefaultListModel<String> listModel4 = new DefaultListModel<>();
        JList<String> list4 = new JList<>(listModel4);
        list4.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder(Color.BLACK), "被移除到这里"));

        // 创建一个 JTextField 用来显示选择项
        JTextField textField = new JTextField(20);
        textField.setEditable(false);

        // 创建一个 JLabel 用来显示第三个列表框选择的项
        JLabel label = new JLabel("选择的项将显示在这里");
        label.setPreferredSize(new Dimension(250, 30)); // 设置标签的尺寸

        // 监听第一个列表框单击事件
        list1.addListSelectionListener(e -> {
            if (!e.getValueIsAdjusting()) { // 方法用于判断当前操作是否仍在进行,返回 true 表示操作尚未完成，返回 false 表示操作完成
                String selectedValue = list1.getSelectedValue();
                textField.setText(selectedValue); // 设置文本框显示选中的内容
            }
        });

        // 监听第二个列表框双击事件
        list2.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                if (e.getClickCount() == 2) {
                    String selectedValue = list2.getSelectedValue();
                    if (selectedValue != null) {
                        // 将选项从第二个列表框移到第四个列表框
                        listModel4.addElement(selectedValue);
                        // 从第二个列表框中删除该选项
                        colors.remove(selectedValue);
                        list2.setListData(colors);
                    }
                }
            }
        });

        // 监听第三个列表框选择事件，将选择的项显示到 JLabel 上
        list3.addListSelectionListener(e -> {
            if (!e.getValueIsAdjusting()) {
                String selectedValue = list3.getSelectedValue();
                label.setText("你选择了: " + selectedValue); // 设置标签显示选中的内容
            }
        });

        // 将列表框添加到窗口中
        frame.add(new JScrollPane(list1)); // 第一个列表框
        frame.add(new JScrollPane(list2)); // 第二个列表框
        frame.add(new JScrollPane(list3)); // 第三个列表框
        frame.add(new JScrollPane(list4)); // 第四个列表框
        frame.add(textField); // 显示选择项的文本框
        frame.add(label); // 显示选择项的标签

        // 设置窗口的大小、关闭操作和可见性
        frame.setSize(600, 400);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

public class FontSizeComboBoxExample {
    public static void main(String[] args) {
        // 创建窗口
        JFrame frame = new JFrame("字体大小、颜色和水果选择");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLayout(new FlowLayout());

        // 字符串类型的字体大小数组
        String[] fontSizes = { "12", "14", "16", "18", "20", "22", "24", "26", "28" };

        // 字符串类型的颜色数组
        Vector<String> colors = new Vector<>();
        colors.add("红");
        colors.add("黄");
        colors.add("蓝");
        colors.add("绿");
        colors.add("紫");
        colors.add("橙");

        // 字符串类型的水果数组
        String[] fruits = { "苹果", "橘子", "柿子", "葡萄", "西瓜" };

        // 1. 创建字体大小的 JComboBox，设置为可编辑模式，并将字体大小数组添加到下拉框中
        JComboBox<String> fontSizeComboBox = new JComboBox<>(fontSizes);
        fontSizeComboBox.setEditable(true);
        fontSizeComboBox.setBorder(BorderFactory.createTitledBorder("请选择你要的文字大小"));
        fontSizeComboBox.setPreferredSize(new Dimension(200, 50)); // 设置宽度为200，高度为50

        // 2. 创建颜色选择的 JComboBox，并将颜色数组添加到下拉框中
        JComboBox<String> colorComboBox = new JComboBox<>(colors);
        colorComboBox.setEditable(true);
        colorComboBox.setBorder(BorderFactory.createTitledBorder("请选择字体颜色"));
        colorComboBox.setPreferredSize(new Dimension(200, 50)); // 设置宽度为200，高度为50

        // 3. 创建水果选择的 JComboBox，使用 ComboBoxModel 创建
        ComboBoxModel<String> fruitComboBoxModel = new DefaultComboBoxModel<>(fruits);
        JComboBox<String> fruitComboBox = new JComboBox<>(fruitComboBoxModel);
        fruitComboBox.setEditable(false);
        fruitComboBox.setBorder(BorderFactory.createTitledBorder("请选择水果"));
        fruitComboBox.setPreferredSize(new Dimension(200, 50)); // 设置宽度为200，高度为50

        // 4. 创建 JLabel，显示默认提示信息
        JLabel label = new JLabel("Swing目前字形大小：");
        label.setFont(new Font("SansSerif", Font.PLAIN, Integer.parseInt(fontSizes[0]))); // 设置默认字体大小为12
        label.setForeground(Color.RED); // 默认字体颜色为红色

        // 5. 监听 JComboBox 字体大小的选择事件，更新 JLabel 的字体大小
        fontSizeComboBox.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 获取 JComboBox 中选中的字体大小（它是一个字符串）
                Object selectedItem = fontSizeComboBox.getSelectedItem();

                // 确保选择的是有效的字体大小
                if (selectedItem instanceof String) {
                    String fontSizeString = (String) selectedItem;

                    try {
                        // 将字符串转换为整数
                        int fontSize = Integer.parseInt(fontSizeString);

                        // 更新 JLabel 的字体大小
                        label.setFont(new Font("SansSerif", Font.PLAIN, fontSize));

                        // 更新 JLabel 的文本内容，显示新的字体大小
                        label.setText("Swing目前字形大小：" + fontSize);
                    } catch (NumberFormatException ex) {
                        // 如果字符串无法转换为数字，则处理异常
                        JOptionPane.showMessageDialog(frame, "请选择一个有效的字体大小！", "无效输入", JOptionPane.ERROR_MESSAGE);
                    }
                }
            }
        });

        // 6. 监听 JComboBox 颜色选择的事件，更新 JLabel 的字体颜色
        colorComboBox.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 获取 JComboBox 中选中的颜色（它是一个字符串）
                Object selectedItem = colorComboBox.getSelectedItem();

                // 确保选择的是有效的颜色
                if (selectedItem instanceof String) {
                    String colorString = (String) selectedItem;
                    Color newColor = Color.RED; // 默认颜色

                    switch (colorString) {
                        case "红":
                            newColor = Color.RED;
                            break;
                        case "黄":
                            newColor = Color.YELLOW;
                            break;
                        case "蓝":
                            newColor = Color.BLUE;
                            break;
                        case "绿":
                            newColor = Color.GREEN;
                            break;
                        case "紫":
                            newColor = Color.MAGENTA;
                            break;
                        case "橙":
                            newColor = Color.ORANGE;
                            break;
                        default:
                            break;
                    }

                    // 更新 JLabel 的字体颜色
                    label.setForeground(newColor);
                }
            }
        });

        // 7. 监听 JComboBox 水果选择的事件，更新 JLabel 的文本
        fruitComboBox.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 获取 JComboBox 中选中的水果（它是一个字符串）
                Object selectedItem = fruitComboBox.getSelectedItem();

                // 确保选择的是有效的水果
                if (selectedItem instanceof String) {
                    String fruit = (String) selectedItem;
                    label.setText("您选择了水果： " + fruit);
                }
            }
        });

        // 将 JComboBox 和 JLabel 添加到窗口中
        frame.add(fontSizeComboBox);
        frame.add(colorComboBox);
        frame.add(fruitComboBox);
        frame.add(label);

        // 设置窗口的大小并显示
        frame.setSize(300, 250);
        frame.setVisible(true);
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

public class SwingExample {
    private JProgressBar progressBar;
    private JButton startButton, stopButton, restartButton;
    private JSlider slider;
    private JLabel sliderLabel;
    private JSeparator separator;
    private Timer timer;
    private int progress = 0;

    public SwingExample(JFrame frame) {
        // JFrame 设置
        frame.setTitle("Swing Example");
        frame.setSize(400, 300);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLayout(new FlowLayout(FlowLayout.CENTER, 10, 20)); // 调整水平和垂直间距

        // JProgressBar (进度条) 设置
        progressBar = new JProgressBar(0, 100);
        progressBar.setPreferredSize(new Dimension(300, 30));
        progressBar.setStringPainted(true); // 用于显示当前进度值
        frame.add(progressBar);

        // JSeparator (分隔线) 设置
        separator = new JSeparator();
        separator.setPreferredSize(new Dimension(300, 1));
        frame.add(separator);

        // 添加垂直空白以增加 JSlider 和 JProgressBar 之间的距离
        frame.add(Box.createVerticalStrut(20)); // 这里设置增加间距

        // JSlider (滑动条) 设置
        slider = new JSlider(0, 100, 0);
        slider.setPreferredSize(new Dimension(300, 40));
        slider.setPaintTicks(true); // 显示刻度线
        slider.setPaintLabels(true); // 显示标签
        slider.setMajorTickSpacing(20); // 主刻度每 20 个单位
        slider.setMinorTickSpacing(5); // 次刻度每 5 个单位
        slider.addChangeListener(new ChangeListener() {
            @Override
            public void stateChanged(ChangeEvent e) {
                // 滑动条值改变时更新 JLabel
                sliderLabel.setText("Slider Value: " + slider.getValue());
            }
        });
        frame.add(slider);

        // JLabel 显示滑动条值
        sliderLabel = new JLabel("Slider Value: 0");
        frame.add(sliderLabel);

        // 开始按钮
        startButton = new JButton("开始");
        startButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 启动定时器开始更新进度条
                if (timer == null || !timer.isRunning()) {
                    timer = new Timer(100, new ActionListener() { // 该定时器每隔指定的时间（delay）触发一次 ActionEvent
                        @Override
                        public void actionPerformed(ActionEvent e) {
                            if (progress < 100) {
                                progress++;
                                progressBar.setValue(progress);
                            } else {
                                timer.stop();
                            }
                        }
                    });
                    timer.start();
                }
            }
        });
        frame.add(startButton);

        // 停止按钮
        stopButton = new JButton("停止");
        stopButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 停止定时器更新进度条
                if (timer != null && timer.isRunning()) {
                    timer.stop();
                }
            }
        });
        frame.add(stopButton);

        // 重新开始按钮
        restartButton = new JButton("重新开始");
        restartButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 重置进度条并重新开始
                if (timer != null && timer.isRunning()) {
                    timer.stop(); // 停止当前的定时器
                }
                progress = 0; // 重置进度
                progressBar.setValue(progress); // 更新进度条
                // 重新启动定时器
                timer = new Timer(100, new ActionListener() {
                    @Override
                    public void actionPerformed(ActionEvent e) {
                        if (progress < 100) {
                            progress++;
                            progressBar.setValue(progress);
                        } else {
                            timer.stop();
                        }
                    }
                });
                timer.start(); // 启动定时器
            }
        });
        frame.add(restartButton);
    }

    public static void main(String[] args) {
        // 创建 JFrame 实例
        JFrame frame = new JFrame();
        // 创建 SwingExample 实例并传入 JFrame
        SwingExample example = new SwingExample(frame);
        // 设置可见
        frame.setVisible(true);
    }
}