JavaGUI-Java圖形用戶界面

、Java GUI 概述

GUI（Graphical User Interface，簡稱 GUI，圖形用戶界面）是指采用圖形方式顯示的計算機操作用戶界面，與早期計算機使用的命令行界面相比，圖形界面對于用戶來說在視覺上更易于接受。
Java GUI主要有兩個核心庫，分別是AWT（java.awt：Abstract Windows ToolKit(抽象窗口工具包)）和Swing（javax.swing：AWT的擴展），AWT需要調用本地系統方法來實現功能，屬重量級控件，而Swing是在AWT的基礎上，建立的一套圖像界面系統，其中提供了更多的組件，而且完全由Java實現，增強了移植性，屬輕量級組件。

2、容器

容器（Container）是組件（Component）的子類，一個容器可以容納多個組件，并使他們成為一個整體。容器可以簡化圖形化界面的設計，以整體結構來布置界面，所有的組件都可以通過add()方法加入容器中。容器共有四種類型，分別是窗口（JFrame）、彈窗（JDialog）、面板（JPanel）、滾動面板（JScrollPanel）。

2、1 窗口

Frame或JFrame類用于創建一個具有標題欄的框架窗口作為程序的主要界面，它不依賴其他容器可以單獨存在。

public class JFrameUse {
    public static void main(String[] args) {
        // 初始化窗口
        JFrame jFrame = new JFrame("這個是窗口的標題");
        // 設置窗口的位置和大小
        jFrame.setBounds(400, 300, 500, 500);
        // 設置窗口的背景顏色
        jFrame.setBackground(new Color(175, 114, 114));
        // 設置窗口是否可見
        jFrame.setVisible(true);
        // 設置窗口是否可以縮放
        jFrame.setResizable(false);
        /**
         * 設置窗口的相對位置。
         * 如果 comp 整個顯示區域在屏幕內, 則將窗口放置到 comp 的中心;
         * 如果 comp 顯示區域有部分不在屏幕內, 則將該窗口放置在最接近 comp 中心的一側;
         * comp 為 null, 表示將窗口放置到屏幕中心。
         */
        jFrame.setLocationRelativeTo(null);
        /**
         * 設置窗口關閉按鈕點擊后的默認操作, 參考值:
         *     WindowConstants.DO_NOTHING_ON_CLOSE: 不執行任何操作。
         *     WindowConstants.HIDE_ON_CLOSE: 隱藏窗口（不會結束進程）, 再次調用 setVisible(true) 將再次顯示。
         *     WindowConstants.DISPOSE_ON_CLOSE: 銷毀窗口, 如果所有可顯示的窗口都被 DISPOSE, 則可能會自動結束進程。
         *     WindowConstants.EXIT_ON_CLOSE: 退出進程。
         */
        jFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
}

2、2 彈窗和對話框

JDialog，對話框，使用 JDialog 類可以創建自定義有的對話框，或者調用 JOptionPane 中的多個靜態方法快速創建各種標準的對話框。
JOptionPane是JavaSwing內部已實現好的，以靜態方法的形式提供調用，能夠快速方便的彈出要求用戶提供值或向其發出通知的標準對話框。主要具有以下幾種那類型：

showMessageDialog：消息對話框，向用戶展示一個消息，沒有返回值。
showConfirmDialog：確認對話框，詢問一個問題是否執行。
showInputDialog：輸入對話框，要求用戶提供某些輸入。
showOptionDialog：選項對話框，上述三項的大統一，自定義按鈕文本，詢問用戶需要點擊哪個按鈕。

上述四個類型的方法（包括其若干重載）的參數遵循一致的模式，下面介紹各參數的含義:

parentComponent: 對話框的父級組件，決定對話框顯示的位置，對話框的顯示會盡量緊靠組件的中心，如果傳 null，則顯示在屏幕的中心。
title: 對話框標題。
message: 消息內容。
optionType: 選項按鈕的類型。
selectionValues、initialSelectionValue: 提供的輸入選項，以及默認選中的選項。
icon: 自定義的對話框圖標，如果傳 null，則圖標類型由 messageType 決定。
messageType: 消息類型，主要是提供默認的對話框圖標。可能的值為：JOptionPane.PLAIN_MESSAGE 簡單消息（不使用圖標）JOptionPane.INFORMATION_MESSAGE 信息消息（默認）JOptionPane.QUESTION_MESSAGE 問題消息JOptionPane.WARNING_MESSAGE 警告消息JOptionPane.ERROR_MESSAGE 錯誤消息

對話框

class JOptionPaneUse {
    public JOptionPaneUse() {
        final JFrame jf = new JFrame("測試窗口");
        jf.setSize(400, 400);
        jf.setLocationRelativeTo(null);
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        /*
         * 1. 消息對話框（信息消息）
         */
        JButton btn01 = new JButton("showMessageDialog（信息消息）");
        btn01.addActionListener(e -> {
            // 消息對話框無返回, 僅做通知作用
            JOptionPane.showMessageDialog(jf, "通知信息", "消息標題", JOptionPane.INFORMATION_MESSAGE
            );
        });

        /*
         * 2. 消息對話框（警告消息）
         */
        JButton btn02 = new JButton("showMessageDialog（警告消息）");
        btn02.addActionListener(e -> {
            // 消息對話框無返回, 僅做通知作用
            JOptionPane.showMessageDialog(jf, "警告信息", "消息標題", JOptionPane.WARNING_MESSAGE);
        });

        /*
         * 3. 確認對話框
         */
        JButton btn03 = new JButton("showConfirmDialog");
        btn03.addActionListener(e -> {
            /*
             * 返回用戶點擊的選項, 值為下面三者之一:
             *     是:   JOptionPane.YES_OPTION
             *     否:   JOptionPane.NO_OPTION
             *     取消: JOptionPane.CANCEL_OPTION
             *     關閉: JOptionPane.CLOSED_OPTION
             */
            int result = JOptionPane.showConfirmDialog(jf, "確認刪除？", "提示", JOptionPane.YES_NO_CANCEL_OPTION);
            System.out.println("選擇結果: " + result);
        });

        /*
         * 4. 輸入對話框（文本框輸入）
         */
        JButton btn04 = new JButton("showInputDialog（文本框輸入）");
        btn04.addActionListener(e -> {
            // 顯示輸入對話框, 返回輸入的內容
            String inputContent = JOptionPane.showInputDialog(jf, "輸入你的名字:", "默認內容");
            System.out.println("輸入的內容: " + inputContent);
        });

        /*
         * 5. 輸入對話框（下拉框選擇）
         */
        JButton btn05 = new JButton("showInputDialog（下拉框選擇）");
        btn05.addActionListener(e -> {
            Object[] selectionValues = new Object[]{"香蕉", "雪梨", "蘋果"};
            // 顯示輸入對話框, 返回選擇的內容, 點擊取消或關閉, 則返回null
            Object inputContent = JOptionPane.showInputDialog(jf, "選擇一項: ", "標題",
                    JOptionPane.PLAIN_MESSAGE, null, selectionValues, selectionValues[0]);
            System.out.println("輸入的內容: " + inputContent);
        });

        /*
         * 6. 選項對話框
         */
        JButton btn06 = new JButton("showOptionDialog");
        btn06.addActionListener(e -> {
            // 選項按鈕
            Object[] options = new Object[]{"香蕉", "雪梨", "蘋果"};
            // 顯示選項對話框, 返回選擇的選項索引, 點擊關閉按鈕返回-1
            int optionSelected = JOptionPane.showOptionDialog(jf, "請點擊一個按鈕選擇一項", "對話框標題",
                    JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.ERROR_MESSAGE, null,
                    options,    // 如果傳null, 則按鈕為 optionType 類型所表示的按鈕（也就是確認對話框）
                    options[0]
            );
            if (optionSelected >= 0) {
                System.out.println("點擊的按鈕: " + options[optionSelected]);
            }
        });

        // 垂直排列按鈕
        Box vBox = Box.createVerticalBox();
        vBox.add(btn01);
        vBox.add(btn02);
        vBox.add(btn03);
        vBox.add(btn04);
        vBox.add(btn05);
        vBox.add(btn06);

        JPanel panel = new JPanel();
        panel.add(vBox);

        jf.setContentPane(panel);
        jf.setVisible(true);
    }
}

自定義彈窗

class JDialogUse {
    public JDialogUse() {
        final JFrame jf = new JFrame("測試窗口");
        jf.setSize(300, 300);
        jf.setLocationRelativeTo(null);
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        JButton btn = new JButton("顯示自定義對話框");
        btn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                showCustomDialog(jf, jf);
            }
        });

        JPanel panel = new JPanel();
        panel.add(btn);

        jf.setContentPane(panel);
        jf.setVisible(true);
    }

    /**
     * 顯示一個自定義的對話框
     *
     * @param owner           對話框的擁有者
     * @param parentComponent 對話框的父級組件
     */
    private static void showCustomDialog(Frame owner, Component parentComponent) {
        // 創建一個模態對話框
        final JDialog dialog = new JDialog(owner, "提示", true);
        // 設置對話框的寬高
        dialog.setSize(250, 150);
        // 設置對話框大小不可改變
        dialog.setResizable(false);
        // 設置對話框相對顯示的位置
        dialog.setLocationRelativeTo(parentComponent);

        // 創建一個標簽顯示消息內容
        JLabel messageLabel = new JLabel("對話框消息內容");

        // 創建一個按鈕用于關閉對話框
        JButton okBtn = new JButton("確定");
        okBtn.addActionListener(e -> {
            // 關閉對話框
            dialog.dispose();
        });

        // 創建對話框的內容面板, 在面板內可以根據自己的需要添加任何組件并做任意是布局
        JPanel panel = new JPanel();

        // 添加組件到面板
        panel.add(messageLabel);
        panel.add(okBtn);

        // 設置對話框的內容面板
        dialog.setContentPane(panel);
        // 顯示對話框
        dialog.setVisible(true);
    }
}

2、3 面板

面板也是一個容器，但是它不能單獨存在，只能存在于窗口中，一個面板對象代表了一個長方形的區域，在這個區域中可以容納其他組件，在程序中通常會使面板來實現一些特殊的布局。

普通面板

public class JPanelUse {
    public static void main(String[] args) {
        // 初始化窗口
        JFrame jFrame = new JFrame("面板窗口");
        jFrame.setVisible(true);
        jFrame.setSize(400, 400);
        jFrame.setLocationRelativeTo(null);
        jFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        
        // 初始化面板：采用默認的流式布局或指定布局
        JPanel jPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
        // 設置面板大小
        jPanel.setSize(100, 100);
        // 設置面板背景顏色
        jPanel.setBackground(new Color(164, 24, 24));
        // 將面板添加到窗口
        jFrame.add(jPanel);
    }
}

滾動面板

JScrollPane，滾動面板，支持水平和垂直滾動視圖。文本區域、表格等需要顯示較多數據而空間又有限時，通常使用 JScrollPane 進行包裹以實現滾動顯示。

public class JScrollPaneUse {
    public JScrollPaneUse() {
        JFrame jFrame = new JFrame("面板窗口");

        // 創建文本區域組件
        JTextArea textArea = new JTextArea("這是一個文本");
        // 自動換行
        textArea.setLineWrap(true);
        // 設置字體
        textArea.setFont(new Font(null, Font.PLAIN, 18));

        // 初始化滾動面板面板
        /**
         * 全參構造參數說明：
         *     view: 需要滾動顯示的視圖組件
         *     vsbPolicy: 垂直滾動條的顯示策略
         *         ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED    // 需要時顯示（默認）
         *         ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER        // 從不顯示
         *         ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS       // 總是顯示
         *     hsbPolicy: 水平滾動條的顯示策略
         *         ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED  // 需要時顯示（默認）
         *         ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER      // 從不顯示
         *         ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS     // 總是顯示
         * 常用方法
         *     設置滾動顯示視圖內容組件：setViewportView(Component view)
         *     設置垂直滾動條的顯示策略：setVerticalScrollBarPolicy(int policy)
         *     設置水平滾動條的顯示策略：setHorizontalScrollBarPolicy(int policy)
         */
        JScrollPane jScrollPane = new JScrollPane(
                textArea,
                ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS,
                ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER
        );
        jFrame.setContentPane(jScrollPane);

        // 窗口設置為公共代碼，后面全部省略
        jFrame.setVisible(true);
        jFrame.setSize(400, 400);
        jFrame.setLocationRelativeTo(null);
        jFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
}

分隔面板

JSplitPane，分隔面板，用于分隔兩個（只能兩個）組件，兩個組件通過水平/垂直分隔條分別左右或上下顯示，并且可以拖動分隔條調整兩個組件顯示區域的大小。

class JSplitPaneUse{
    public JSplitPaneUse() {
        JFrame jFrame = new JFrame("分隔面板窗口");

        /**
         * 全參構造參數說明
         *      orientation: 分隔的方向(默認水平)，HORIZONTAL_SPLIT：水平左右分隔；VERTICAL_SPLIT：垂直上下分隔
         *      continuousLayout: 拖動分隔條時，是否連續重繪組件，如果為flase，則拖動分隔條停止后才重繪組件。
         *      leftComponent: 左邊/上面 顯示的組件
         *      rightComponent: 右邊/下面 顯示的組件
         * 常用方法
         *    setOrientation(int orientation)： 設置分隔的方向，水平(左右) 或 垂直(上下) 分隔
         *    setLeftComponent(Component comp)：設置 左邊/上面 顯示的組件
         *    setRightComponent(Component comp)：設置 左邊/下面 顯示的組件
         *    setContinuousLayout(boolean continuousLayout)： 設置 拖動分隔條 時是否 連續重繪 組件
         *    setOneTouchExpandable(boolean newValue)：分隔條上是否顯示快速 折疊/展開 兩邊組件的小按鈕
         *    setDividerSize(int newSize)：設置分隔條的大小（寬度）
         *    setDividerLocation(int location)：設置分隔條的位置，相對于 左邊/頂部 的像素長度
         */
        JSplitPane jSplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true, new JButton("左邊按鈕"), new JButton("右邊按鈕"));
        jSplitPane.setDividerLocation(200);

        jFrame.setContentPane(jSplitPane);
        // 省略公共代碼
    }
}

選項卡面板

JTabbedPane，選項卡面板。它允許用戶通過點擊給定標題或圖標的選項卡，在一組組件之間進行切換顯示。

class JTabbedPaneUse {
    public JTabbedPaneUse() {
        JFrame jFrame = new JFrame("選項卡面板窗口");

        /**
         * 全參構造參數說明:
         *     tabPlacement: 選項卡標題的位置, 值為 JTabbedPane.TOP/BOTTOM/LEFT/RIGHT, 默認為 TOP
         *     tabLayoutPolicy: 選項卡位置不能放入所有的選項卡時，放置選項卡的策略，值JTabbedPane.WRAP_TAB_LAYOUT/SCROLL_TAB_LAYOUT
         * 常用方法
         *     addTab(String 標題, Icon 圖標, Component 內容組件, String 提示文本)：添加選擇項卡
         *     insertTab(String title, Icon icon, Component component, String tip, int index)：在指定位置插入選項卡
         *     remove(Component component)：移除指定內容控件的選項卡
         *     remove(int index)：移除指定位置的選項
         *     setSelectedIndex(int index)：設置當前選中的選項卡
         *     getSelectedIndex()：獲取當前選中的選項卡索引
         *     getSelectedComponent()：獲取當前選中的選項卡對應的內容組件
         *     setTitleAt(int index, String title)：設置 index 位置的選項卡的標題
         *     setIconAt(int index, Icon icon)：設置 index 位置的選項卡的圖標
         *     setEnabledAt(int index, boolean enabled)：設置 index 位置的選項卡是否可用
         *     setComponentAt(int index, Component component)：將 index 位置的內容組件設置為 component
         */
        // 初始化一個選項面板，默認選項卡在頂部，放不下了換行
        JTabbedPane jTabbedPane = new JTabbedPane(JTabbedPane.TOP, JTabbedPane.WRAP_TAB_LAYOUT);

        // 創建選項卡
        jTabbedPane.addTab("選項卡1", new JButton("測試按鈕"));
        jTabbedPane.addTab("選項卡2", new JButton("測試按鈕"));
        jFrame.setContentPane(jTabbedPane);

        // 省略公共代碼
    }
}

3、布局

3.1、流式布局

FlowLayout，流式布局管理器，按水平方向依次排列放置組件，排滿一行，換下一行繼續排列。排列方向（左到右或右到左）取決于容器的componentOrientation屬性（該屬性屬于Component），它可能的值如下:

ComponentOrientation.LEFT_TO_RIGHT（默認）
ComponentOrientation.RIGHT_TO_LEFT

同一行（水平方向）的組件的對齊方式由 FlowLayout 的align屬性確定，它可能的值如下:

FlowLayout.LEFT : 左對齊
FlowLayout.CENTER : 居中對齊（默認）
FlowLayout.RIGHT : 右對齊
FlowLayout.LEADING : 與容器方向的開始邊對齊，例如，對于從左到右的方向，則與左邊對齊
FlowLayout.TRAILING : 與容器方向的結束邊對齊，例如，對于從左到右的方向，則與右邊對齊。

class FlowLayoutUse {
    public FlowLayoutUse() {
        JFrame jFrame = new JFrame("流式布局窗口");

        // 創建面板并指定為流式布局
        JPanel jPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
        // 創建兩個按鈕
        JButton jButton1 = new JButton("按鈕1");
        JButton jButton2 = new JButton("按鈕2");
        // 將按鈕添加到面板中
        jPanel.add(jButton1);
        jPanel.add(jButton2);
        // 將面板添加到窗口中
        jFrame.setContentPane(jPanel);

        // 省略公共代碼
    }
}

3.2、網格布局

GridLayout，網格布局管理器，它以矩形網格形式對容器的組件進行布置，把容器按行列分成大小相等的矩形網格，一個網格中放置一個組件，組件寬高自動撐滿網格。
以行數和總數優先: 通過構造方法或 setRows 和 setColumns 方法將行數和列數都設置為非零值時，指定的列數將被忽略。列數通過指定的行數和布局中的組件總數來確定。因此，例如，如果指定了三行和兩列，在布局中添加了九個組件，則它們將顯示為三行三列。僅當將行數設置為零時，指定列數才對布局有效。

class GridLayoutUse {
    public GridLayoutUse() {
        JFrame jFrame = new JFrame("網格布局窗口");

        // 創建一個面板并使用網格布局
        JPanel jPanel = new JPanel(new GridLayout(2, 2));
        // 創建五個按鈕，測試2行2列超出效果
        JButton jButton1 = new JButton("按鈕1");
        JButton jButton2 = new JButton("按鈕2");
        JButton jButton3 = new JButton("按鈕3");
        JButton jButton4 = new JButton("按鈕4");
        JButton jButton5 = new JButton("按鈕5");
        jPanel.add(jButton1);
        jPanel.add(jButton2);
        jPanel.add(jButton3);
        jPanel.add(jButton4);
        jPanel.add(jButton5);
        jFrame.setContentPane(jPanel);

        // 省略公共代碼
    }
}

3.3、邊框布局

BorderLayout，邊界布局管理器,它把 Container 按方位分為 5 個區域（東、西、南、北、中），每個區域放置一個組件。

class BorderLayoutUse {
    public BorderLayoutUse() {
        JFrame jFrame = new JFrame("網格布局窗口");

        // 創建一個面板并使用邊框布局
        JPanel jPanel = new JPanel(new BorderLayout());
        // 創建五個按鈕，測試2行2列超出效果
        JButton jButton1 = new JButton("東");
        JButton jButton2 = new JButton("西");
        JButton jButton3 = new JButton("南");
        JButton jButton4 = new JButton("北");
        JButton jButton5 = new JButton("中");
        jPanel.add(jButton1, BorderLayout.EAST);
        jPanel.add(jButton2, BorderLayout.WEST);
        jPanel.add(jButton3, BorderLayout.SOUTH);
        jPanel.add(jButton4, BorderLayout.NORTH);
        jPanel.add(jButton5, BorderLayout.CENTER);
        jFrame.setContentPane(jPanel);

        // 省略公共代碼
    }
}

4、組件

4.1、基本組件

標簽

JLabel，標簽，主要用于展示文本或圖片，也可以同時顯示文本和圖片。

class JLabelUse {
    public JLabelUse() {
        JFrame jFrame = new JFrame("標簽窗口");
        JPanel jPanel = new JPanel();

        // 只顯示文本的標簽
        JLabel textLabel = new JLabel("只顯示文本的標簽");
        textLabel.setFont(new Font(null, Font.PLAIN, 25));
        jPanel.add(textLabel);

        // 只顯示圖片的標簽
        JLabel imgLabel = new JLabel(new ImageIcon("bj.jpg"));
        jPanel.add(imgLabel);

        // 同時顯示文本和圖片的標簽：水平方向文本在圖片中心
        JLabel jLabel = new JLabel("顯示文本", new ImageIcon("bj.jpg"), SwingConstants.CENTER);
        jPanel.add(jLabel);
		
        jFrame.setContentPane(jPanel);
        // 省略公共代碼
    }
}

按鈕

class JButtonAndRadioAndCheckBox {
    public JButtonAndRadioAndCheckBox() {
        JFrame jFrame = new JFrame("標簽窗口");
        JPanel jPanel = new JPanel();

        /**
         * 普通圖片按鈕
         */
        JButton jButton = new JButton("圖片按鈕", new ImageIcon("bj.jpg"));
        jButton.addActionListener(e -> {
            System.out.println("圖片按鈕被點擊了");
        });
        jPanel.add(jButton);

        /**
         * 單選按鈕
         */
        // 創建按鈕組，將單選按鈕添加到該組，確保只能選擇其一
        ButtonGroup buttonGroup = new ButtonGroup();
        // 創建單選按鈕
        JRadioButton man = new JRadioButton("男");
        JRadioButton woman = new JRadioButton("女");
        // 設置第一個被選中
        man.setSelected(true);
        // 將按鈕添加到按鈕組中
        buttonGroup.add(man);
        buttonGroup.add(woman);
        // 將按鈕添加到面板中
        jPanel.add(man);
        jPanel.add(woman);

        /**
         * 多選按鈕
         */
        // 添加多選按鈕
        JCheckBox jCheckBox1 = new JCheckBox("香蕉");
        JCheckBox jCheckBox2 = new JCheckBox("蘋果");
        JCheckBox jCheckBox3 = new JCheckBox("梨子");
        JCheckBox jCheckBox4 = new JCheckBox("黃瓜");
        // 添加事件監聽，添加第一個復選框的狀態被改變的監聽（其他復選框如果需要監聽狀態改變，則可按此方法添加監聽）
        jCheckBox1.addChangeListener(e -> {
            // 獲取事件源（即復選框本身）
            JCheckBox jCheckBox = (JCheckBox) e.getSource();
            System.out.println(jCheckBox.getText() + " 是否選中: " + jCheckBox.isSelected());
        });
        jCheckBox1.setSelected(true);
        jPanel.add(jCheckBox1);
        jPanel.add(jCheckBox2);
        jPanel.add(jCheckBox3);
        jPanel.add(jCheckBox4);


        jFrame.setContentPane(jPanel);
       // 省略公共代碼
    }
}

列表

JComboBox，下拉框。JComboBox以下列列表的形式展示多個選項，用戶可以從下拉列表中選擇一個值。如果設置JComboBox為可編輯狀態，除了選擇指定的選項值外，還允許用戶自行輸入值（自行輸入的值索引為-1）。

JList，列表框。JList 以列表的形式展示多個選項，允許用戶選擇一個或多個選項。其中的選項內容由一個 ListModel 實例來維護。JList 不實現直接滾動，需要滾動顯示，可以結合 JScrollPane 實現滾動效果。

class JComboBoxAndJList {
    public JComboBoxAndJList() {
        JFrame jFrame = new JFrame("列表窗口");
        JPanel jPanel = new JPanel();
        JLabel jLabel = new JLabel("水果");

        /**
         * 下拉框：這里的數組列表可以使用Vector<String>集合進行
         */
        final JComboBox<String> jComboBox = new JComboBox<>(new String[]{"香蕉", "雪梨", "蘋果", "荔枝"});
        // 添加條目選中狀態改變的監聽器
        jComboBox.addItemListener(e -> {
            // 只處理選中的狀態
            if (e.getStateChange() == ItemEvent.SELECTED) {
                System.out.println("選中: " + jComboBox.getSelectedIndex() + " = " + jComboBox.getSelectedItem());
            }
        });
        jPanel.add(jLabel);
        jPanel.add(jComboBox);

        /**
         * 列表框
         */
        final JList<String> jList = new JList<>();
        // 設置一下首選大小
        jList.setPreferredSize(new Dimension(200, 100));
        // 允許可間斷的多選
        jList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
        // 設置選項數據（內部將自動封裝成 ListModel ），這里的數組列表可以使用Vector<String>集合進行
        jList.setListData(new String[]{"香蕉", "雪梨", "蘋果", "荔枝"});
        // 添加選項選中狀態被改變的監聽器
        jList.addListSelectionListener(e -> {
            // 獲取所有被選中的選項索引
            int[] indices = jList.getSelectedIndices();
            // 獲取選項數據的 ListModel
            ListModel<String> listModel = jList.getModel();
            // 輸出選中的選項
            for (int index : indices) {
                System.out.println("選中: " + index + " = " + listModel.getElementAt(index));
            }
            System.out.println();
        });
        jPanel.add(jList);

        jFrame.setContentPane(jPanel);
      // 省略公共代碼
    }
}

文本框

JTextField，文本框。JTextField 用來編輯單行的文本。

JPasswordField，密碼框。JPasswordField 繼承自 JTextField，只是顯示輸入的內容時用特定的字符替換顯示（例如 * 或 ●），用法和 JTextField 基本一致。

JTextArea，文本區域。JTextArea 用來編輯多行的文本。JTextArea 除了允許多行編輯外，其他基本用法和 JTextField 基本一致。

class JTextFieldAndJPasswordFieldAndJTextAreaUse {
    public JTextFieldAndJPasswordFieldAndJTextAreaUse() {
        JFrame jFrame = new JFrame("列表窗口");
        JPanel jPanel = new JPanel(new GridLayout(3,1));

        /**
         * 文本框
         */
        final JTextField jTextField = new JTextField(10);
        jTextField.setFont(new Font(null, Font.PLAIN, 20));
        jPanel.add(new JLabel("用戶名"));
        jPanel.add(jTextField);

        /**
         * 密碼框
         */
        final JPasswordField jPasswordField = new JPasswordField(32);
        jPanel.add(new JLabel("密 碼"));
        jPanel.add(jPasswordField);

        /**
         * 文本域
         */
        // 創建一個 5 行 10 列的文本區域
        JTextArea jTextArea = new JTextArea(5, 10);
        // 自動換行
        jTextArea.setLineWrap(true);
        jPanel.add(new JLabel("文本域"));
        jPanel.add(jTextArea);

        jFrame.setContentPane(jPanel);
        // 省略公共代碼
    }
}

進度條和滑塊

JProgressBar，進度條。以可視化形式顯示某些任務進度的組件，進度條中心可顯示進度百分比的文本表示形式。一個任務的進度長度未知時，可將進度條設置為不確定模式。不確定模式的進度條持續地顯示動畫來表示正進行的操作。當可以確定任務長度和進度量時，則可設置進度條的最大最小值，以及更新進度條的進度值，將其切換回確定模式。

JSlider，滑塊。以圖形方式在有界區間內通過移動滑塊來選擇值的組件。滑塊可以顯示主刻度標記以及主刻度之間的次刻度標記。刻度標記之間的值的個數由 setMajorTickSpacing(int) 和 setMinorTickSpacing(int) 來控制。刻度標記的繪制由 setPaintTicks(boolean) 控制。滑塊也可以在固定時間間隔（或在任意位置）沿滑塊刻度打印文本標簽。標簽的繪制由 setLabelTable(Dictionary) 和 setPaintLabels(boolean) 控制。
PS: 當滑塊獲得焦點后，按鍵盤上的上下左右鍵也可以滑動滑塊。

class JProgressBarAndJSliderUse {
    public JProgressBarAndJSliderUse() {
        JFrame jFrame = new JFrame("列表窗口");
        JPanel jPanel = new JPanel(new GridLayout(3, 1));

        /**
         * 進度條：
         *     全參構造參數說明：JProgressBar(int orient, int min, int max)
         *         orient: 進度條的方向，SwingConstants.VERTICAL 或 SwingConstants.HORIZONTAL，默認為水平方向
         *         min: 最小進度值；max: 最大進度值
         *     常用方法：
         *         設置最小進度值、最大進度值和當前進度值：setMinimum(int min)，setMaximum(int max)，setValue(int n)
         *         獲取當前進度值：getValue()
         *         獲取當前進度的百分比：getPercentComplete()
         *         是否繪制百分比文本（進度條中間顯示的百分數）：setStringPainted(boolean b)
         *         設置進度條進度是否為不確定模式：setIndeterminate(boolean newValue)
         *         設置進度條的方向，SwingConstants.VERTICAL 或 SwingConstants.HORIZONTAL：setOrientation(int newOrientation)
         *         添加進度條的進度改變監聽器：addChangeListener(ChangeListener l)
         */
        JProgressBar jProgressBar = new JProgressBar(0, 100);
        jProgressBar.setValue(20);
        jProgressBar.addChangeListener(e -> {
            System.out.println("當前進度值: " + jProgressBar.getValue() + "; " +
                    "進度百分比: " + jProgressBar.getPercentComplete());
        });
        jPanel.add(jProgressBar);

        /**
         * 滑塊：
         *     全參構造參數說明：JSlider(int orientation, int min, int max, int value)
         *         orientation: 滑塊的方向，SwingConstants.VERTICAL 或 SwingConstants.HORIZONTAL，默認為水平方向
         *         min: 滑塊的最小值； max: 滑塊的最大值
         *         value: 滑塊的初始值（默認為 最小值 和 最大值 之間的 中間值）
         *     常用方法：
         *         設置滑塊的最小值、最大值、當前值：setMinimum(int min)，setMaximum(int max)，setValue(int n)
         *         獲取滑塊的當前值：getValue()
         *         設置主刻度標記間隔：setMajorTickSpacing(int n)
         *         設置單個主刻度內的次刻度標記間隔：setMinorTickSpacing(int n)
         *         設置是否繪制刻度線：setPaintTicks(boolean b)
         *         設置是否繪制刻度標簽（刻度值文本）：setPaintLabels(boolean b)
         *         設置是否繪制滑道：setPaintTrack(boolean b)
         *         設置是否顛倒刻度值（刻度值從大到小）：setInverted(boolean b)
         *         設置滑塊是否對齊到刻度。設置為 true，則滑塊最終只能在有刻度的位置取值，即滑塊取值不連續：setSnapToTicks(boolean b)
         *         添加滑塊的值改變監聽器：addChangeListener(ChangeListener l)
         */
        JSlider jSlider = new JSlider(0, 20, 10);
        // 設置主刻度間隔
        jSlider.setMajorTickSpacing(5);
        // 設置次刻度間隔
        jSlider.setMinorTickSpacing(1);
        // 繪制刻度和標簽
        jSlider.setPaintTicks(true);
        jSlider.setPaintLabels(true);
        jSlider.addChangeListener(e -> {
            System.out.println("當前值: " + jSlider.getValue());
        });
        jPanel.add(jSlider);

        jFrame.setContentPane(jPanel);
        // 省略公共代碼
    }
}

4.2、復雜組件

文件和顏色選擇器

JFileChooser，文件選取器。JFileChooser為用戶選擇文件提供了一種簡單的機制，包括打開文件和保存文件。
構造方法和常用方法如下：

方法	功能
JFileChooser(String currentDirectoryPath)	currentDirectoryPath: 打開文件選取器時默認顯示的文件夾（默認為用戶文件夾）
JFileChooser(File currentDirectory)	currentDirectory: 打開文件選取器時默認顯示的文件夾（默認為用戶文件夾）
void setCurrentDirectory(File dir)	設置默認顯示的文件夾
void setFileSelectionMode(int mode)	設置文件選擇模式，FILES_AND_DIRECTORIES: 文件和文件夾都可以選，其他的二選一
void setMultiSelectionEnabled(boolean b)	設置是否允許同時選擇多個（默認為不允許）
void addChoosableFileFilter(FileFilter filter)	添加可供用戶選擇的文件過濾器
void setFileFilter(FileFilter filter)	設置默認使用的文件過濾器
void setSelectedFile(File file)	設置默認被選中的文件
File[] getSelectedFiles()	獲取選擇的文件（一般在用戶選擇完文件點擊了確認或保存后通過該方法獲取選中的文件）

class FileSelectedUse {
    public FileSelectedUse() {
        JFrame jFrame = new JFrame();
        JPanel jPanel = new JPanel();

        /**
         * 顯示 打開文件 或 保存文件 的對話框（線程將被阻塞, 直到選擇框被關閉）：showOpenDialog(Component parent), showSaveDialog(Component parent)
         *     參數：
         *         parent: 文件選取器對話框的父組件, 對話框將會盡量顯示在靠近 parent 的中心; 如果傳 null, 則顯示在屏幕中心。
         *     返回值：
         *         JFileChooser.CANCEL_OPTION: 點擊了取消或關閉
         *         JFileChooser.APPROVE_OPTION: 點擊了確認或保存
         *         JFileChooser.ERROR_OPTION: 出現錯誤
         */
        final JTextArea jTextArea = new JTextArea(10, 30);
        jTextArea.setLineWrap(true);
        jPanel.add(jTextArea);

        JButton openBtn = new JButton("打開");
        openBtn.addActionListener(e -> showFileOpenDialog(jFrame, jTextArea));
        jPanel.add(openBtn);

        JButton saveBtn = new JButton("保存");
        saveBtn.addActionListener(e -> showFileSaveDialog(jFrame, jTextArea));
        jPanel.add(saveBtn);

        jFrame.setContentPane(jPanel);
        // 省略公共代碼
    }

    /**
     * 打開文件
     * @param parent 組件
     * @param msgTextArea 文本域
     */
    private static void showFileOpenDialog(Component parent, JTextArea msgTextArea) {
        // 創建一個默認的文件選取器
        JFileChooser fileChooser = new JFileChooser();
        // 設置默認顯示的文件夾為當前文件夾
        fileChooser.setCurrentDirectory(new File("."));
        // 設置文件選擇的模式（只選文件、只選文件夾、文件和文件均可選）
        fileChooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
        // 設置是否允許多選
        fileChooser.setMultiSelectionEnabled(true);
        // 添加可用的文件過濾器（FileNameExtensionFilter 的第一個參數是描述, 后面是需要過濾的文件擴展名 可變參數）
        fileChooser.addChoosableFileFilter(new FileNameExtensionFilter("zip(*.zip, *.rar)", "zip", "rar"));
        // 設置默認使用的文件過濾器
        fileChooser.setFileFilter(new FileNameExtensionFilter("image(*.jpg, *.png, *.gif)", "jpg", "png", "gif"));
        // 打開文件選擇框（線程將被阻塞, 直到選擇框被關閉）
        int result = fileChooser.showOpenDialog(parent);
        if (result == JFileChooser.APPROVE_OPTION) {
            // 如果點擊了"確定", 則獲取選擇的文件路徑
            File file = fileChooser.getSelectedFile();
            // 如果允許選擇多個文件, 則通過下面方法獲取選擇的所有文件
            msgTextArea.append("打開文件: " + file.getAbsolutePath() + "\n\n");
        }
    }

    /**
     * 選擇文件保存路徑
     * @param parent 組件
     * @param msgTextArea 文本域
     */
    private static void showFileSaveDialog(Component parent, JTextArea msgTextArea) {
        // 創建一個默認的文件選取器
        JFileChooser fileChooser = new JFileChooser();
        // 設置打開文件選擇框后默認輸入的文件名
        fileChooser.setSelectedFile(new File("測試文件.zip"));
        // 打開文件選擇框（線程將被阻塞, 直到選擇框被關閉）
        int result = fileChooser.showSaveDialog(parent);
        if (result == JFileChooser.APPROVE_OPTION) {
            // 如果點擊了"保存", 則獲取選擇的保存路徑
            File file = fileChooser.getSelectedFile();
            msgTextArea.append("保存到文件: " + file.getAbsolutePath() + "\n\n");
        }
    }
}

JColorChooser，顏色選取器。JColorChooser提供一個用于允許用戶操作和選擇顏色的控制器對話框。

class ColorSelectedUse {
    public ColorSelectedUse() {
        JFrame jFrame = new JFrame();
        JPanel jPanel = new JPanel();
        final JLabel jLabel = new JLabel();
        jLabel.setPreferredSize(new Dimension(150, 150));
        jLabel.setOpaque(true);
        jPanel.add(jLabel);

        JButton jButton = new JButton("選擇顏色");
        jButton.addActionListener(e -> {
            /**
             * 顯示一個顏色選取器對話框（線程將被阻塞, 直到對話框被關閉）
             *     參數說明:
             *          component: 對話框的父組件, 對話框將緊靠 component 的中心顯示; 如果傳 null, 則對話框顯示在屏幕中心。
             *          title: 對話框標題。
             *          initialColor: 初始選中的顏色; 如果傳 null, 則默認為非透明白色。
             *      返回值：
             *          返回選擇的顏色; 如果點擊了取消或關閉, 則返回 null。
             */
            Color color = JColorChooser.showDialog(jFrame, "選取顏色", null);
            // 如果用戶取消或關閉窗口, 則返回的 color 為 null
            if (color == null) {
                return;
            }
            // 把選取的顏色設置為標簽的背景
            jLabel.setBackground(color);
            // 獲取顏色的 ARGB 各個分量值
            int alpha = color.getAlpha();
            int red = color.getRed();
            int green = color.getGreen();
            int blue = color.getBlue();
            jLabel.setText("A=" + String.format("%02x", alpha) + ", " +
                    String.format("#%02x%02x%02x", red, green, blue));
        });
        jPanel.add(jButton);

        jFrame.setContentPane(jPanel);
        // 省略公共代碼
    }
}

菜單欄和工具欄

JMenuBar，菜單欄。菜單欄組件添加到 JFrame 窗口后，在窗口的內容顯示區域的頂部出現。實現一個菜單欄主要涉及三種類:

JMenuBar：表示一個菜單欄。
JMenu：表示菜單欄上的一個一級菜單。
JMenuItem, JCheckBoxMenuItem, JRadioButtonMenuItem：表示一級菜單下的一個子菜單項，三者分別表示普通的子菜單、帶復選框的子菜單、帶單選按鈕的子菜單。

PS: JMenu 繼承自 JMenuItem，所以一個 JMenu 也可以當做是一個二級子菜單項，通過 JMenu 和 JMenuItem 之間的嵌套，可實現多級子菜單效果。
構造參數和常用方法如下

類	方法	功能
JMenuItem	void setText(String text)	設置菜單顯示的文本
JMenuItem	void setIcon(Icon defaultIcon)	設置菜單顯示的圖標
全參構造	JMenuItem(String text, Icon icon)	text: 菜單顯示的文本，icon: 菜單顯示的圖標
JMenuItem	void setMnemonic(int mnemonic)	設置菜單的鍵盤助記符
JMenuItem	void setAccelerator(KeyStroke keyStroke)	設置修改鍵，使用鍵盤快捷鍵直接觸發菜單項的動作
JMenuItem	void addActionListener(ActionListener l)	添加菜單被點擊的監聽器
JMenuItem	void setActionCommand(String actionCommand)	可以再監聽器回調時通過命令名稱區別是哪個菜單項觸發的動作。
JMenu	JMenuItem add(JMenuItem menuItem)	添加子菜單到JMenu中
JMenu	void addSeparator()	添加一個子菜單分割線

class JMenuBarUse{
    public JMenuBarUse() {
        JFrame jFrame = new JFrame();
        JPanel jPanel = new JPanel();

        // 創建一個菜單欄
        JMenuBar jMenuBar = new JMenuBar();
        
        // 創建一級菜單
        JMenu fileMenu = new JMenu("文件");
        JMenu editMenu = new JMenu("編輯");
        // 將一級菜單添加到菜單欄
        jMenuBar.add(fileMenu);
        jMenuBar.add(editMenu);
        
        // 創建文件菜單的子菜單
        JMenuItem openMenuItem  = new JMenuItem("打開");
        JMenuItem newMenuItem  = new JMenuItem("新建");
        fileMenu.add(newMenuItem);
        fileMenu.add(openMenuItem);

        jPanel.add(jMenuBar);
        // 省略公共代碼
    }
}

JToolBar，工具欄。JToolBar 提供了一個用來顯示常用控件的容器組件。
對于大多數的外觀，用戶可以將工具欄拖到其父容器四“邊”中的一邊，并支持在單獨的窗口中浮動顯示。為了正確執行拖動，建議將 JToolBar 實例添加到容器四“邊”中的一邊（其中容器的布局管理器為 BorderLayout），并且不在其他四“邊”中添加任何子級。
構造方法和常用方法如下：

方法	功能
JToolBar(String name, int orientation)	name: 工具欄名稱，懸浮顯示時為懸浮窗口的標題。orientation: 工具欄方向，默認水平
Component add(Component comp)	添加工具組件到工具欄
void addSeparator(Dimension size)	添加分隔符組件到工具欄
Component getComponentAtIndex(int index)	獲取工具欄中指定位置的組件（包括分隔符）
void setFloatable(boolean b)	設置工具欄是否可拖動
void setOrientation(int o)	設置工具欄方向，值為 SwingConstants.HORIZONTAL 或 SwingConstants.VERTICAL
void setMargin(Insets m)	設置工具欄邊緣和其內部工具組件之間的邊距（內邊距）
void setBorderPainted(boolean b)	是否需要繪制邊框

class JToolBarUse{
    public JToolBarUse() {
        JFrame jFrame = new JFrame();
        JPanel jPanel = new JPanel();

        // 創建一個工具欄
        JToolBar jToolBar = new JToolBar("測試工具欄");
        JButton jButton = new JButton("按鈕");
        jToolBar.add(jButton);

        jPanel.add(jToolBar);
        // 省略公共代碼
    }
}

5、事件

5.1、鼠標監聽事件

class MouseListenerUse {
    public MouseListenerUse() {
        JFrame jFrame = new JFrame("鼠標監聽");
        JPanel jPanel = new JPanel();

        /**
         * 鼠標監聽器
         */
        jPanel.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                System.out.println("鼠標進入組件區域");
            }

            @Override
            public void mouseExited(MouseEvent e) {
                System.out.println("鼠標離開組建區域");
            }

            @Override
            public void mousePressed(MouseEvent e) {
                // 獲取按下的坐標（相對于組件）
                System.out.println("相對組件" + e.getPoint() + "，橫坐標：" + e.getX() + ", 縱坐標：" + e.getY());
                // 獲取按下的坐標（相對于屏幕）
                System.out.println("相對屏幕" + e.getLocationOnScreen() + "，橫坐標：" + e.getXOnScreen() + ", 縱坐標：" + e.getYOnScreen());
            }

            @Override
            public void mouseReleased(MouseEvent e) {
                System.out.println("鼠標釋放");
            }

            @Override
            public void mouseClicked(MouseEvent e) {
                // 鼠標在組件區域內按下并釋放（中間沒有移動光標）才識別為被點擊
                System.out.println("鼠標點擊");
            }
        });

        /**
         * 鼠標移動/拖動監聽器
         */
        jPanel.addMouseMotionListener(new MouseMotionAdapter() {
            @Override
            public void mouseDragged(MouseEvent e) {
                // 鼠標保持按下狀態移動即為拖動
                System.out.println("鼠標拖動");
            }
            @Override
            public void mouseMoved(MouseEvent e) {
                System.out.println("鼠標移動");
            }
        });


        /**
         * 鼠標滾輪監聽器
         */
        jPanel.addMouseWheelListener(new MouseWheelListener() {
            @Override
            public void mouseWheelMoved(MouseWheelEvent e) {
                // e.getWheelRotation() 為滾輪滾動多少的度量
                System.out.println("mouseWheelMoved: " + e.getWheelRotation());
            }
        });

       // 省略公共代碼
    }
}

5.2、鍵盤監聽事件

組件監聽鍵盤的按鍵，該組件必須要獲取到焦點。

如果一個窗口內沒有可獲取焦點的組件，一般打開窗口后焦點為窗口所有，可以把鍵盤監聽器設置到窗口（JFrame）身上。

如果窗口內還有其他組件可獲取焦點（例如按鈕、文本框），窗口打開后焦點會被內部組件獲得，如果想要在窗口打開期間都能監聽鍵盤按鍵，可以為所有可獲得焦點的組件都設置一個鍵盤監聽器。

class KeyListenerUse{
    public KeyListenerUse() {
        JFrame jFrame = new JFrame("鍵盤監聽");
        jFrame.addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                // 獲取鍵值，和 KeyEvent.VK_XXXX 常量比較確定所按下的按鍵
                System.out.println("按下: " + e.getKeyCode() + "，鍵值為：" + e.getKeyCode());
            }

            @Override
            public void keyTyped(KeyEvent e) {
                // e.getKeyChar() 獲取鍵入的字符
                System.out.println("鍵入: " + e.getKeyChar());
            }

            @Override
            public void keyReleased(KeyEvent e) {
                System.out.println("釋放: " + e.getKeyCode());
            }
        });
        jFrame.setVisible(true);
    }
}

5.3、窗口監聽事件

窗口監聽器只有窗口類組件支持，例如 JFrame、JDialog。目前經過測試，使用最多的莫過于窗口關閉和窗口激活。

class WindowListenerUse{
    public WindowListenerUse() {
        JFrame jFrame = new JFrame("窗口監聽");
        jFrame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.out.println("窗口被關閉了");
            }

            @Override
            public void windowActivated(WindowEvent e) {
                System.out.println("窗口被激活了");
            }
        });
        jFrame.setVisible(true);
    }
}

1、Java GUI 概述
2、容器
2、1 窗口
2、2 彈窗和對話框
對話框
自定義彈窗
2、3 面板
普通面板
滾動面板
分隔面板
選項卡面板
3、布局
3.1、流式布局
3.2、網格布局
3.3、邊框布局
4、組件
4.1、基本組件
標簽
按鈕
列表
文本框
進度條和滑塊
4.2、復雜組件
文件和顏色選擇器
菜單欄和工具欄
5、事件
5.1、鼠標監聽事件
5.2、鍵盤監聽事件
5.3、窗口監聽事件

本文作者： 靜守己心、笑淡浮華

出處： https://www.cnblogs.com/mmgmj/p/16397070.html

Panel（github.com/1Panel-dev/1Panel）是一款現代化、開源的Linux服務器運維管理面板，它致力于通過開源的方式，幫助用戶簡化建站與運維管理流程。為了方便廣大用戶快捷安裝部署相關軟件應用，1Panel特別開通應用商店，精選各類高質量的開源工具和應用軟件，為用戶的應用安裝與升級操作提供便利。

目前，1Panel應用商店已經上架了超過100款精品軟件并且定期更新維護，基本涵蓋了大部分用戶的基本裝機需求。自2024年1月起，1Panel開源項目組特別開設“應用推薦”專欄，為大家推薦1Panel應用商店中的寶藏開源軟件。

本期推薦應用

Uptime Kuma

-官方網站-

https://uptime.kuma.pet

-開源許可協議-

MIT license

-應用描述-

Uptime Kuma是一款開源的服務器監控和狀態檢測工具，它能夠幫助用戶跟蹤服務器的可用性、性能和健康狀態。

-開發語言-

JavaScript、Vue

-上架版本-

v1.23.13

-GitHub Star-

50,000+

-GitHub Fork-

4,400+

整合營銷服務商