Swing 程序设计（java界面）

• Swing概述：

•         主要用来开发GUI（graphical user interface）程序，GUI是应用程序提供给用户操作的图形界面，包括窗体，菜单， 按钮等图形界面元素，Swing提供了丰富的组件

          Swing组件是完全由java语言编写的组件，因为java语言不依赖于本地平台，即不依赖操作系统，所以Swing组件可以被应用于任何平台上，基于“跨平台”这一特性，所以Swing组件被称作“轻量级”组件。

          Swing是JDK的第二代GUI框架，但是由于推出时间太早，市面上大多数桌面窗体程序都不是由java开发的，Swing技术也逐渐呗开发人员淘汰

• Swing基本要素：

• 窗体
• 组件
• 布局
• 容器
• 创建表格

• 重要组件：

• JFrame（窗体）：顶级窗口，用于包含和组织其他组件。
• JPanel（面板）：用于组织和管理其他组件，可以嵌套在 JFrame 中。
• JButton（按钮）：用于触发操作或事件。
• JTextField（文本框）：允许用户输入单行文本。
• JTextArea（文本区域）：允许用户输入多行文本。
• JLabel（标签）：用于显示文本或图像。
• JCheckBox（复选框） 和 JRadioButton（单选按钮）：用于选择一个或多个选项。
• JComboBox（下拉列表）：允许用户从预定义列表中选择一个选项。
• JList（列表） 和 JTable（表格）：显示数据列表或表格。
• JScrollPane（滚动窗格）：提供滚动功能，使得容器可以显示超出其可见区域的内容。
• 这些组件是构建 Swing 用户界面时最常用的一些基本元素。通过组合和定制这些组件，可以创建出各种复杂和交互性强的用户界面。

• JFrame：

• 设置标题：

  JFrame frame = new JFrame();
  frame.setTitle("My Swing App");
  

• ---

  设置大小：

  frame.setSize(600, 400); // 设置宽度和高度
  

• ---

  设置窗体关闭行为：

  frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置关闭窗体时的行为
  

  常见的选项包括：

• JFrame.EXIT_ON_CLOSE：关闭窗口时退出应用程序。
• JFrame.DISPOSE_ON_CLOSE：默认行为，关闭窗口时释放窗口资源但不退出应用程序。
• JFrame.DO_NOTHING_ON_CLOSE：什么也不做，需要自己通过监听器来处理关闭事件。
• JFrame.HIDE_ON_CLOSE：关闭窗口时隐藏窗口，但不退出应用程序。

• ---

  设置窗体位置：

它接受的参数可以是：

null：将窗体放置在屏幕中央。

另一个组件对象：将窗体相对于这个指定的组件进行定位，例如另一个 JFrame、JPanel 或者其他组件。

• frame.setLocationRelativeTo(null); // 将窗体位置设置为屏幕中心
  // 或者指定位置
  frame.setLocation(x, y); // x 和 y 是坐标值
  

  JFrame frame = new JFrame();
  // 获取屏幕尺寸
  Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
  // 计算窗体的 x 和 y 坐标使其居中
  int x = (screenSize.width - frame.getWidth()) / 2;
  int y = (screenSize.height - frame.getHeight()) / 2;
  // 设置窗体位置
  frame.setLocation(x, y);
  

• 设置可见性：

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

• 禁止或允许调整窗体大小：

  frame.setResizable(false); // 禁止调整窗体大小
  

• 添加其他组件：

  // 添加其他组件到窗体中
  JPanel panel = new JPanel();
  // 添加到窗体的内容面板
  frame.getContentPane().add(panel);
  

• 自定义关闭行为：

  // 自定义关闭行为（例如，执行其他操作再关闭）
  frame.addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
          // 在关闭窗体之前执行操作
          // 例如：保存数据、清理资源等
          System.exit(0); // 关闭程序
      }
  });
  

• 这些设置只是一些基本的示例。你可以根据需要对 JFrame 进行更多的定制化，以适应你的应用程序的要求和设计。

JDialog对话框

与JDialog对话框与JFrame窗体类似，被使用时也需要先调用getContentPane（）方法把JDialog对话框进行设置

构造方法：

JDialog(Frame owner, String title, boolean modal)

参数解释如下：

• owner：对话框的拥有者，一般是一个 Frame（比如 JFrame）。如果传入 null，对话框将没有拥有者。
• title：对话框的标题，显示在标题栏上。
• modal：一个布尔值，指定对话框是否是模态的。如果为 true，则创建一个模态对话框；如果为 false，则创建一个非模态对话框。

示例代码：

JFrame ownerFrame = new JFrame("Owner Frame"); // 创建一个拥有者窗体
JDialog dialog = new JDialog(ownerFrame, "Dialog Title", true); // 创建一个模态对话框

演示案例：

要求：创建MyJDialog类，使之继承JDialog窗体，在父窗中添加按钮，当用户单击按钮时，弹出对话框

package text;

import javax.swing.*;
import java.awt.*;

public class MyJDialog extends JDialog {
    public MyJDialog(MyFrame frame){
        super(frame,"第一个Jdialog窗体",true);
        Container container = getContentPane();
        container.add(new JLabel("这是一个对话框"));
        setSize(150,150);
        setLocationRelativeTo(null);
    }
}

package text;

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

public class MyFrame extends JFrame {
    public MyFrame() {
        Container container = getContentPane();
        container.setLayout(null);
        JButton bl = new JButton("弹出对话框");
        bl.setBounds(10,10,100,21);
        bl.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                MyJDialog dialog = new MyJDialog(MyFrame.this);
                dialog.setVisible(true);
            }
        });
        container.add(bl);

        setSize(200,200);
        setLocationRelativeTo(null);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setVisible(true);
    }

    public static void main(String[] args) {
        new MyFrame();
    }
}

JOptionPane小型对话框

是什么？

是一个非常简便的小型对话框类，该类用于创建对话框的方法都是静态方法，无须创建对象即可弹出

JOptionPane构造方法

 JOptionPane 类提供的4种创建对话框的方法

showCarfmDiog（）	确认框，询问一个确认问题，如yes/no/cancel
showInpuiDialog（）	输入框，可以让用户向程序中输入某些值
showMessageDialog（）	通知框，告知用户某事已发生
showOptionDialog（）	自定义对话框，集合了上述3种对话框的全部功能

下面分别介绍这4种对话框的外观样式和使用方法

1、自定义对话框

import javax.swing.*;
import java.awt.*;
import java.io.ObjectOutputStream;

// Press Shift twice to open the Search Everywhere dialog and type `show whitespaces`,
// then press Enter. You can now see whitespace characters in your code.
public class Main {
    public static void main(String[] args) {
        Object o[] = {new JButton("是的"),new JButton("再想想")};
        Icon icon = new ImageIcon("D:\\jdk\\code\\GUI\\png\\gantan.jpg");
        JOptionPane.showOptionDialog(
                null,
                "您做好准备了嘛",
                "注意了!",
                JOptionPane.DEFAULT_OPTION,
                JOptionPane.DEFAULT_OPTION,
                icon, o, null);
    }
}

2、确认框

import javax.swing.*;
import java.awt.*;
import java.io.ObjectOutputStream;

public class Main {
    public static void main(String[] args) {
       int answer = JOptionPane.showConfirmDialog(null,
               "您确定离开嘛",
               "标题",
               JOptionPane.YES_NO_OPTION);
    }
}

3、输入框

import javax.swing.*;
import java.awt.*;
import java.io.ObjectOutputStream;

public class Main {
    public static void main(String[] args) {
        String name = JOptionPane.showInputDialog(null, "请输入您的名字>>>");
        System.out.println(name);
    }
}

4、通知框

import javax.swing.*;
import java.awt.*;
import java.io.ObjectOutputStream;

public class Main {
    public static void main(String[] args) {
        JOptionPane.showMessageDialog(null,
                "您与服务器断开了链接",
                "发生错误",
                JOptionPane.ERROR_MESSAGE);
    }
}

---

常用布局管理器：

null绝对布局管理器：

作用：

绝对布局也叫null布局，其特点是影星指定组件再容器中的位置和大熊啊，组件的位置通过绝对坐标的方式来指定

使用：

使用绝对布局首先要使用Container.setlayout(nill)方法取消容器的布局管理器，然后使用Component.setBounds(int x, int y, int width, int height)方法设置每个组件在容器中的位置

import javax.swing.*;
import java.awt.*;
import java.io.ObjectOutputStream;

public class Main {
    public static void main(String[] args) {
        new absoluteposition();
    }

    public static class absoluteposition extends JFrame{
        public absoluteposition(){
            setTitle("本窗体使用绝对布局");
            setLayout(null);
            setBounds(0,0,300,150);
            Container c = getContentPane();
            JButton b1 = new JButton("按钮1");
            JButton b2 = new JButton("按钮2");
            b1.setBounds(10,30,80,30);
            b2.setBounds(60,70,100,20);
            c.add(b1);
            c.add(b2);
            setVisible(true);
            setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        }
    }
}

流布局管理器：

FLowLayout是Swing中最基本的布局管理器。使用流布局管理器摆放组件时，组件会呗从左到右摆放。当组件占据了当前行的所有空间时，组件会被移动到当前行的下一行。默认情况下，行组件的排列方式被指定为居中对齐，但是通过设置可以更改每一行的排列方式

构造方法：

FlowLayout()
FlowLayout(int align)
FlowLayout(int align, int hgap, int vgap)

• FlowLayout()：这是最简单的构造方法，创建一个默认对齐方式（左对齐）、水平间距为 5 像素、垂直间距为 5 像素的 FlowLayout 对象。
• FlowLayout(int align)：这个构造方法允许你指定对齐方式。align 参数可以是以下值之一：FlowLayout.LEFT（左对齐，默认值）、FlowLayout.CENTER（居中对齐）、FlowLayout.RIGHT（右对齐）、FlowLayout.LEADING（组件会在容器的开头对齐，通常是从左到右的方向）、FlowLayout.TRAILING（组件会在容器的末尾对齐，通常是从右到左的方向）。
• FlowLayout(int align, int hgap, int vgap)：这个构造方法允许你指定对齐方式、水平间距和垂直间距。hgap 参数表示组件之间的水平间距，vgap 参数表示组件之间的垂直间距。

例子：

import javax.swing.*;
import java.awt.*;

public class Main {
    public static void main(String[] args) {
        new FlowLayoutPosition();
    }

    static class FlowLayoutPosition extends JFrame{
        public FlowLayoutPosition(){
            setTitle("本窗体使用流布局管理器");
            Container c = getContentPane();

            setLayout(new FlowLayout(FlowLayout.CENTER,10,10));
            for (int i = 0; i < 10; i++) {
                c.add(new JButton("button" + (i+1)));
            }
            setSize(200,300);
            setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
            setVisible(true);
        }
    }
}

BoderLayout边界布局管理器

使用Swing创建窗体后，容器默认布局管理器是边界布局，边界布局管理器把容器划分为东、南、西、北、中五个区域

当组件被添加到被设置为边界布局管理器的容器时，需要使用borderlayout类中的成员变量指定被添加的组件在边界布局管理器的区域

在BorderLayout中，有五个成员变量用于指定组件的位置：

1. NORTH（北）：放置在容器的北部。
2. SOUTH（南）：放置在容器的南部。
3. EAST（东）：放置在容器的东部。
4. WEST（西）：放置在容器的西部。
5. CENTER（中心）：放置在容器的中心。

add方法用于实现向容器中添加组件的功能，她可以设置组件的白那个位置，add（）方法常用的语法格式如下：

public void add(comp,constraints)

comp：被添加的组件

constraints：被添加组件的布局约束对象

import javax.swing.*;
import java.awt.*;

public class Main {
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        frame.setLocation(600,200);
        frame.setSize(400, 300);

        // 使用 BorderLayout
        frame.setLayout(new BorderLayout());

        JButton button1 = new JButton("North");
        frame.add(button1, BorderLayout.NORTH);

        JButton button2 = new JButton("South");
        frame.add(button2, BorderLayout.SOUTH);

        JButton button3 = new JButton("East");
        frame.add(button3, BorderLayout.EAST);

        JButton button4 = new JButton("West");
        frame.add(button4, BorderLayout.WEST);

        JButton button5 = new JButton("Center");
        frame.add(button5, BorderLayout.CENTER);

        frame.setVisible(true);
    }
}

GirdLayout网格布局管理器

GridLayout 是 Java 中的一种布局管理器，它将组件按照行和列的网格形式布置在容器中。这个布局管理器将容器划分为固定数量的行和列，然后将组件放置在这个网格中。

在 GridLayout 中，你可以指定网格的行数和列数，并且将组件按顺序放置在这个网格中。当向容器添加组件时，它们会按照从左到右、从上到下的顺序依次填充网格。

import javax.swing.*;
import java.awt.*;

public class Main {
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        frame.setLocation(600,200);
        frame.setSize(700, 400);


        // 创建一个 2 行 3 列的网格布局
        GridLayout gridLayout = new GridLayout(2, 3);

        // 设置网格布局
        frame.setLayout(gridLayout);

        // 向网格布局中添加按钮
        for (int i = 1; i <= 7; i++) {
            JButton button = new JButton("Button " + i);
            frame.add(button);
        }

        frame.setVisible(true);
    }
}

---

常用面板：

在Swing程序设计中，面板是一个容器，用于容纳其他组件，但将面板必须添加到其他容器中。Swing中常用的面板包括JFrame面板和JScrollPane面板。下面将分别予以讲解。

JPanel面板：

JPanel面板必须在窗体容器中使用，无法脱离窗体显示

package text;

import javax.swing.*;
import java.awt.*;

public class JPaneTest extends JFrame {
    public JPaneTest(){
        Container c = getContentPane();
        c.setLayout(new GridLayout(2,2,10,10));

        JPanel p1 = new JPanel(new GridLayout(1,4,10,10));
        JPanel p2 = new JPanel(new BorderLayout());
        JPanel p3 = new JPanel(new GridLayout(1,2,10,10));
        JPanel p4 = new JPanel(new GridLayout(2,1,10,10));

        p1.setBorder(BorderFactory.createTitledBorder("面板1"));
        p2.setBorder(BorderFactory.createTitledBorder("面板2"));
        p3.setBorder(BorderFactory.createTitledBorder("面板3"));
        p4.setBorder(BorderFactory.createTitledBorder("面板4"));

        p1.add(new JButton("b1"));
        p1.add(new JButton("b1"));
        p1.add(new JButton("b1"));
        p1.add(new JButton("b1"));

        p2.add(new JButton("b2"),BorderLayout.WEST);
        p2.add(new JButton("b2"),BorderLayout.EAST);
        p2.add(new JButton("b2"),BorderLayout.CENTER);
        p2.add(new JButton("b2"),BorderLayout.NORTH);
        p2.add(new JButton("b2"),BorderLayout.SOUTH);

        p3.add(new JButton("b3"));
        p3.add(new JButton("b3"));

        p4.add(new JButton("b4"));
        p4.add(new JButton("b4"));

        c.add(p1);
        c.add(p2);
        c.add(p3);
        c.add(p4);
        setTitle("在这个窗体使用了面板");
        setSize(500,300);
        setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);

    }

    public static void main(String[] args) {
        JPaneTest test = new JPaneTest();
        test.setVisible(true);
    }
}

JScrollPane滚动面板

JScrollPane面板是带滚动条的面板，用于在较小的长提中显示较大的蝙蝠的内容们需要注意的是JScrollPane滚动面板泵使用布局管理器，而且只能容纳一个组件，如果需要向JScrollPane滚动面板中添加多个组件，那么需要先将组件添加到JPanel面板中，再将JPanel面板添加到JScrollPane滚动面板中

package text;

import javax.swing.*;
import java.awt.*;

public class JScrollPaneTest extends JFrame {
    public JScrollPaneTest(){
        Container c = getContentPane();

        JTextArea ta = new JTextArea(20,50);
        JScrollPane sp = new JScrollPane(ta);
        c.add(sp);
        setTitle("带滚动条的文字编译器");
        setSize(400,200);
        setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);

    }

    public static void main(String[] args) {
        JScrollPaneTest test = new JScrollPaneTest();
        test.setVisible(true);
    }
}

JLabel标签

JLabel 是 Swing 中用来显示文本或图像的组件。它通常用于在 GUI 界面中展示静态文本或简单图像，并且不接收用户输入。

例：

import javax.swing.*;

public class JLabelExample {
    public static void main(String[] args) {
        // 创建一个 JFrame
        JFrame frame = new JFrame();
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // 创建一个 JLabel 显示文本
        JLabel textLabel = new JLabel("Hello, I'm a JLabel!");
        
        // 将 JLabel 添加到 JFrame 中
        frame.add(textLabel);

        frame.setVisible(true);
    }
}

例：

import javax.swing.*;
import java.awt.*;

public class JLabelImageExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // 创建一个 ImageIcon 对象，用来加载图像
        ImageIcon icon = new ImageIcon("path/to/your/image.jpg");
        
        // 创建一个 JLabel 显示图像
        JLabel imageLabel = new JLabel(icon);

        // 将 JLabel 添加到 JFrame 中
        frame.add(imageLabel);

        frame.setVisible(true);
    }
}

JButton按钮：

JButton 类有几个不同的构造方法可供使用，其中最常用的是：

• JButton()：创建一个没有文本和图标的按钮。
• JButton(String text)：创建一个带有指定文本的按钮。
• JButton(Icon icon)：创建一个带有指定图标的按钮。
• JButton(String text, Icon icon)：创建一个同时具有文本和图标的按钮。

// 创建一个没有文本和图标的按钮
JButton button1 = new JButton();

// 创建一个带有指定文本的按钮
JButton button2 = new JButton("Click Me");

// 创建一个带有指定图标的按钮
Icon icon = new ImageIcon("path/to/your/icon.png");
JButton button3 = new JButton(icon);

// 创建一个同时具有文本和图标的按钮
JButton button4 = new JButton("OK", icon);

它的外观、行为和其他方面。以下是一些常见的设置选项：

文本和图标： 使用 setText() 方法设置按钮上显示的文本，使用 setIcon() 方法设置按钮的图标。

JButton button = new JButton();
button.setText("Click Me"); // 设置按钮文本
button.setIcon(icon); // 设置按钮图标

字体和颜色： 可以设置按钮上文本的字体和颜色。

button.setFont(new Font("Arial", Font.BOLD, 12)); // 设置字体
button.setForeground(Color.BLUE); // 设置文本颜色

背景和边框： 控制按钮的背景色和边框样式。

button.setBackground(Color.YELLOW); // 设置背景色
button.setBorder(BorderFactory.createLineBorder(Color.BLACK)); // 设置边框

启用和禁用： 使用 setEnabled() 方法可以启用或禁用按钮。

button.setEnabled(false); // 禁用按钮

监听器： 添加事件监听器来处理按钮点击等操作。

button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        // 处理按钮点击事件
    }
});

提示信息： 设置工具提示文本，鼠标悬停在按钮上时显示的信息。

button.setToolTipText("Click this button"); // 设置提示信息

JRadioButton单选按钮

在 Swing 中，单选按钮使用的类是 JRadioButton。JRadioButton 类也有几个不同的构造方法，常用的包括：

• JRadioButton()：创建一个没有文本和图标的单选按钮。
• JRadioButton(String text)：创建一个带有指定文本的单选按钮。
• JRadioButton(String text, boolean selected)：创建一个带有指定文本和初始选择状态的单选按钮。
• JRadioButton(Icon icon)：创建一个带有指定图标的单选按钮。
• JRadioButton(Icon icon, boolean selected)：创建一个带有指定图标和初始选择状态的单选按钮。
• JRadioButton(String text, Icon icon)：创建一个同时具有文本和图标的单选按钮。
• JRadioButton(String text, Icon icon, boolean selected)：创建一个同时具有文本、图标和初始选择状态的单选按钮。

按钮组

在 Swing 中，按钮组（ButtonGroup）是用来管理一组单选按钮（JRadioButton）的对象。按钮组确保在同一时间只能选择组中的一个单选按钮，类似于在一个组中进行单选操作。

import javax.swing.*;
import java.awt.*;

public class RadioButtonGroupExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // 创建单选按钮
        JRadioButton radioButton1 = new JRadioButton("Option 1");
        JRadioButton radioButton2 = new JRadioButton("Option 2");
        JRadioButton radioButton3 = new JRadioButton("Option 3");

        // 创建按钮组
        ButtonGroup buttonGroup = new ButtonGroup();

        // 将单选按钮添加到按钮组中
        buttonGroup.add(radioButton1);
        buttonGroup.add(radioButton2);
        buttonGroup.add(radioButton3);

        // 将单选按钮添加到 JFrame 中
        JPanel panel = new JPanel();
        panel.add(radioButton1);
        panel.add(radioButton2);
        panel.add(radioButton3);
        frame.add(panel);

        frame.setVisible(true);
    }
}

在这个例子中，创建了三个单选按钮，并将它们添加到一个 ButtonGroup 中。当单选按钮属于同一个按钮组时，只能选择其中的一个，选择其中一个按钮会自动取消其他按钮的选择状态。

JCheckBox复选框

在 Swing 中，复选框使用的类是 JCheckBox。JCheckBox 类也有几个常用的构造方法，允许你创建不同类型的复选框：

• JCheckBox()：创建一个没有文本和初始选择状态的复选框。
• JCheckBox(String text)：创建一个带有指定文本的复选框。
• JCheckBox(String text, boolean selected)：创建一个带有指定文本和初始选择状态的复选框。

// 创建一个没有文本和初始选择状态的复选框
JCheckBox checkBox1 = new JCheckBox();

// 创建一个带有指定文本的复选框
JCheckBox checkBox2 = new JCheckBox("Option 1");

// 创建一个带有指定文本和初始选择状态的复选框
JCheckBox checkBox3 = new JCheckBox("Option 2", true);

列表组件

JComboBox：下拉列表

在 Java Swing 中，JComboBox 类有几个常用的构造方法，用于创建下拉列表框并设置其初始化状态：

1. JComboBox()： 创建一个空的下拉列表框，没有任何初始选项。

2. JComboBox(Object[] items)： 使用给定的对象数组作为初始选项创建下拉列表框。

3. JComboBox(Vector<?> items)： 使用给定的向量作为初始选项创建下拉列表框。

4. JComboBox(ComboBoxModel<?> aModel)： 使用给定的数据模型（ComboBoxModel）创建下拉列表框。

JComboBox方法与属性：

方法：

1. addItem(Object anObject)： 向下拉列表框添加一个新项。

2. removeItem(Object anObject)： 从下拉列表框中移除指定的项。

3. setSelectedItem(Object anObject)： 设置下拉列表框中的选定项。

4. getSelectedItem()： 返回当前选定的项。

5. addActionListener(ActionListener listener)： 添加一个监听器来响应下拉列表框的选择变化。

6. getModel()： 获取下拉列表框的数据模型。

属性：

1. selectedItem： 表示当前选定的项。

2. selectedItemOrNull： 表示当前选定的项，允许为 null。

3. actionCommand： 下拉列表框动作的命令字符串。

4. prototypeDisplayValue： 用于定义下拉列表框的显示宽度。

5. editable： 表示下拉列表框是否可编辑。

6. selectedItemReminder： 用于设置选择项的提醒文本。

7. visibleRowCount： 设置下拉列表框在展开时可见的行数。

// 创建一个空的下拉列表框
JComboBox<String> comboBox1 = new JComboBox<>();

// 使用对象数组作为初始选项创建下拉列表框
String[] items = {"Option 1", "Option 2", "Option 3"};
JComboBox<String> comboBox2 = new JComboBox<>(items);

// 使用向量作为初始选项创建下拉列表框
Vector<String> vectorItems = new Vector<>(Arrays.asList("Option A", "Option B", "Option C"));
JComboBox<String> comboBox3 = new JComboBox<>(vectorItems);

// 使用数据模型（ComboBoxModel）创建下拉列表框
DefaultComboBoxModel<String> model = new DefaultComboBoxModel<>(items);
JComboBox<String> comboBox4 = new JComboBox<>(model);

import javax.swing.*;

public class JComboBoxExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // 创建下拉列表项数据
        String[] data = {"Option 1", "Option 2", "Option 3", "Option 4", "Option 5"};

        // 创建 JComboBox，并设置数据模型
        JComboBox<String> comboBox = new JComboBox<>(data);

        // 设置首选选择项
        comboBox.setSelectedIndex(0); // 选择第一个选项

        // 将 JComboBox 添加到 JFrame 中
        frame.add(comboBox);

        frame.setVisible(true);
    }
}

JList：列表框

JList 类的构造方法允许你使用不同的数据源来初始化列表。以下是 JList 中常用的构造方法：

1. JList()： 创建一个空的列表。

2. JList(Object[] listData)： 使用对象数组作为数据源创建列表。

3. JList(Vector<?> listData)： 使用向量作为数据源创建列表。

4. JList(ListModel<?> dataModel)： 使用列表数据模型（ListModel）创建列表。

import javax.swing.*;

public class JListExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // 创建列表项数据
        String[] data = {"Item 1", "Item 2", "Item 3", "Item 4", "Item 5"};

        // 创建 JList 并设置数据模型
        JList<String> list = new JList<>(data);

        // 将 JList 添加到 JScrollPane 中，以支持滚动
        JScrollPane scrollPane = new JScrollPane(list);

        // 将 JScrollPane 添加到 JFrame 中
        frame.add(scrollPane);

        frame.setVisible(true);
    }
}

JTextField文本框

在 Java Swing 中，JTextField 的构造方法提供了多种方式来创建文本框实例，以适应不同的需求和场景。以下是常用的 JTextField 构造方法：

1. JTextField()：

   • 创建一个默认大小的空文本框。

2. JTextField(int columns)：

   • 创建一个指定列数的文本框，列数影响文本框的宽度，但不限制输入字符数。

3. JTextField(String text)：

   • 创建一个带有初始文本内容的文本框。

4. JTextField(String text, int columns)：

   • 创建一个带有初始文本内容和指定列数的文本框。

5. JTextField(Document doc, String text, int columns)：

   • 使用给定的文档模型（Document）创建一个带有初始文本内容和指定列数的文本框。

package text;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.jar.JarFile;

public class JTextFieldTEst extends JFrame {
    public JTextFieldTEst(){
        Container c = getContentPane();
        c.setLayout(new FlowLayout());
        JTextField jt = new JTextField("请点击清楚按钮");
        jt.setColumns(20);
        jt.setFont(new Font("宋体",Font.PLAIN,20));
        JButton jb = new JButton("清除");
        jt.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                jt.setText("触发事件");
            }
        });
        jb.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println(jt.getText());
                jt.setText("");
                jt.requestFocus();
            }
        });
        c.add(jt);
        c.add(jb);
        setBounds(100,100,250,110);
        setVisible(true);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        new JTextFieldTEst();
    }
}

JPasswordField密码框：

构造方法：

1. JPasswordField()：

   • 创建一个空的密码框，允许用户输入密码。

2. JPasswordField(int columns)：

   • 创建一个具有指定列数的密码框，用于控制密码框的宽度。

3. JPasswordField(String text)：

   • 创建一个带有初始密码的密码框。

4. JPasswordField(String text, int columns)：

   • 创建一个带有指定初始密码和列数的密码框。

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

public class Main {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Password Field Example");

        // 创建密码框
        JPasswordField passwordField = new JPasswordField(20); // 创建一个具有 20 列的密码框

        // 创建一个按钮
        JButton button = new JButton("Show Password");

        // 设置按钮的点击事件监听器
        button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                // 获取密码框中的密码
                char[] password = passwordField.getPassword();
                // 将密码转换为字符串
                String passwordString = new String(password);
                // 在控制台中显示密码（仅为演示目的，实际应用中慎用）
                System.out.println("Entered Password: " + passwordString);
                // 弹出对话框显示密码（仅为演示目的，实际应用中慎用）
                JOptionPane.showMessageDialog(frame, "Entered Password: " + passwordString);
            }
        });

        // 创建一个面板并添加密码框和按钮
        JPanel panel = new JPanel();
        panel.add(passwordField);
        panel.add(button);

        // 将面板添加到 JFrame 中
        frame.add(panel);

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

JTextArea文本域

1. JTextArea()：

   • 创建一个默认的空文本域。

2. JTextArea(int rows, int columns)：

   • 创建一个具有指定行数和列数的文本域。
   • rows 参数指定文本域的行数，columns 参数指定文本域的列数。

3. JTextArea(String text)：

   • 创建一个带有指定文本内容的文本域。

4. JTextArea(String text, int rows, int columns)：

   • 创建一个带有指定文本内容、行数和列数的文本域。

5. JTextArea(Document doc)：

   • 使用给定的文档模型（Document）创建一个文本域。

import javax.swing.*;
import java.awt.*;

public class JTextAreaExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("TextArea Example");

        // 创建文本域并设置行数和列数
        JTextArea textArea = new JTextArea(10, 30); // 创建一个10行30列的文本域

        // 设置文本域的换行策略（自动换行）
        textArea.setLineWrap(true);
        textArea.setWrapStyleWord(true);

        // 创建滚动面板，以便文本域中的文本超出可见范围时可以滚动显示
        JScrollPane scrollPane = new JScrollPane(textArea);

        // 创建一个面板并添加滚动面板
        JPanel panel = new JPanel();
        panel.add(scrollPane);

        // 将面板添加到 JFrame 中
        frame.add(panel);

        // 设置 JFrame 的大小和关闭操作
        frame.setSize(400, 300);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

表格组件

创建表格

1. JTable()：

   • 创建一个空的表格。

2. JTable(int numRows, int numColumns)：

   • 创建一个具有指定行数和列数的空表格。

3. JTable(Object[][] rowData, Object[] columnNames)：

   • 创建一个具有指定数据和列名的表格。
   • rowData 是一个二维数组，表示表格中的数据行。
   • columnNames 是一个一维数组，表示表格的列名。

4. JTable(TableModel dm)：

   • 使用指定的数据模型（TableModel）来创建表格。

5. JTable(TableModel dm, TableColumnModel cm)：

   • 使用指定的数据模型（TableModel）和列模型（TableColumnModel）来创建表格。

6. JTable(TableModel dm, TableColumnModel cm, ListSelectionModel sm)：

   • 使用指定的数据模型（TableModel）、列模型（TableColumnModel）和选择模型（ListSelectionModel）来创建表格。

package text;

import javax.swing.*;
import java.awt.*;

public class JTableDemo extends JFrame {
    public JTableDemo(){
        setTitle("创建可以滚动的表格");
        setBounds(100,100,240,150);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        String[] columnNames = {"A","B"};
        String[][] tableValues = {{"A1","B1"},{"A2","B2"},{"A3","B3"},{"A4","B4"},{"A5","B5"}};

        JTable table = new JTable(tableValues,columnNames);
        JScrollPane scrollPane = new JScrollPane(table);
        getContentPane().add(scrollPane, BorderLayout.CENTER);
    }

    public static void main(String[] args) {
        JTableDemo frame = new JTableDemo();
        frame.setVisible(true);
    }
}

表格数据模型

DefaultTableModel 有几种构造方法可以用于初始化表格模型：

空构造方法：这个构造方法创建了一个空的表格模型，没有任何行或列。

DefaultTableModel model = new DefaultTableModel();

指定列名和行数的构造方法：这个构造方法创建了一个包含指定列名和行数的表格模型，但没有设置任何数据。

String[] columnNames = {"Name", "Age", "Gender"};
int rowCount = 5;
DefaultTableModel model = new DefaultTableModel(columnNames, rowCount);

指定初始数据和列名的构造方法：这个构造方法创建了一个包含指定初始数据和列名的表格模型。它以一个二维对象数组作为数据输入，每个内部数组代表表格中的一行数据。

String[] columnNames = {"Name", "Age", "Gender"};
Object[][] data = {
        {"Alice", 25, "Female"},
        {"Bob", 30, "Male"},
        {"Charlie", 22, "Male"},
        {"Diana", 28, "Female"}
};
DefaultTableModel model = new DefaultTableModel(data, columnNames);

指定初始数据和列名，以及行数的构造方法：这个构造方法创建了一个包含指定初始数据和列名，并设置了指定行数的表格模型。如果初始数据行数少于指定的行数，模型会自动添加空行来填充差距；如果初始数据行数多于指定的行数，模型会忽略多余的数据。

String[] columnNames = {"Name", "Age", "Gender"};
int rowCount = 5;
Object[][] data = {
        {"Alice", 25, "Female"},
        {"Bob", 30, "Male"},
        {"Charlie", 22, "Male"},
        {"Diana", 28, "Female"}
};
DefaultTableModel model = new DefaultTableModel(data, columnNames);
model.setRowCount(rowCount);

案例：表格自动排序

package text;

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableRowSorter;
import java.awt.*;

public class SortingTable extends JFrame {
    private static final long serialVersionUID = 1L;
    public SortingTable(){
        setTitle("表格模型与表格");
        setBounds(100,100,240,150);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JScrollPane scrollPane = new JScrollPane();
        getContentPane().add(scrollPane, BorderLayout.CENTER);
        String[] columnNames = {"A","B"};

        String[][] tableValues = {{"A1","B1"},{"A2","B2"},{"A3","B3"}};

        DefaultTableModel tableModel = new DefaultTableModel(tableValues,columnNames);
        JTable table = new JTable(tableModel);
        table.setRowSorter(new TableRowSorter<>(tableModel));
        scrollPane.setViewportView(table);
    }

    public static void main(String[] args) {
        SortingTable table = new SortingTable();
        table.setVisible(true);
    }
}

维护表格模型

package addanddelettext;

import text.JScrollPaneTest;

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableRowSorter;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.jar.JarFile;

public class AddAndDeleteDemo extends JFrame {
    private DefaultTableModel tableModel;
    private JTable table;
    private JTextField aTextField;
    private JTextField bTextField;

    public static void main(String[] args) {
        AddAndDeleteDemo frame = new AddAndDeleteDemo();
        frame.setVisible(true);
    }

    public AddAndDeleteDemo(){
        setTitle("维护表格模型");
        setBounds(100,100,520,200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        final JScrollPane scrollPane = new JScrollPane();
        getContentPane().add(scrollPane, BorderLayout.CENTER);
        String[] columnNames = {"A","B"};
        String[][] tableValues = {{"A1","B1"},{"A2","B2"},{"A3","B3"}};
        tableModel = new DefaultTableModel(tableValues,columnNames);
        table = new JTable(tableModel);
        table.setRowSorter(new TableRowSorter<>(tableModel));
        table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        table.addMouseListener(new MouseAdapter() {
            public void mouseClicked(MouseEvent e){
                int selectedRow = table.getSelectedRow();
                Object oa = tableModel.getValueAt(selectedRow,0);
                Object ob = tableModel.getValueAt(selectedRow,1);
                aTextField.setText(oa.toString());
                bTextField.setText(ob.toString());
            }
        });
        scrollPane.setViewportView(table);
        JPanel panel = new JPanel();
        getContentPane().add(panel,BorderLayout.SOUTH);
        panel.add(new JLabel("A:"));
        aTextField = new JTextField("A4",10);
        panel.add(aTextField);
        panel.add(new JLabel("B:"));
        bTextField = new JTextField("B4",10);
        panel.add(bTextField);
        JButton addButton = new JButton("添加");
        addButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String[] rowValues = {aTextField.getText(),bTextField.getText()};
                tableModel.addRow(rowValues);
                int rowCount = table.getRowCount()+1;
                aTextField.setText("A"+rowCount);
                bTextField.setText("B"+rowCount);
            }
        });
        panel.add(addButton);
        JButton updbutton = new JButton("修改");
        updbutton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                int selectedRow = table.getSelectedRow();
                if (selectedRow != -1){
                    tableModel.setValueAt(aTextField.getText(),selectedRow,0);
                    tableModel.setValueAt(bTextField.getText(),selectedRow,1);
                }
            }
        });
        panel.add(updbutton);
        JButton delbutton = new JButton("删除");
        delbutton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                int selectedRow = table.getSelectedRow();
                if (selectedRow != -1){
                    tableModel.removeRow(selectedRow);
                }
            }
        });
        panel.add(delbutton);
    }
}

---

事件监听器

ActionEvent动作事件

动作事件监听器是swing中比较常用的事件监听器，很多组建的动作都会使用它进行监听，如按钮被单击等。

package text;

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

public class SimpleEvent extends JFrame {
    private JButton jb = new JButton("我是按钮，请点击我");

    public SimpleEvent(){
        setLayout(null);
        setSize(200,100);
        setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
        Container cp = getContentPane();
        cp.add(jb);
        jb.setBounds(10,10,150,30);
        jb.addActionListener(new jbAction());
        setVisible(true);
    }

    class jbAction implements ActionListener{
        @Override
        public void actionPerformed(ActionEvent e) {
            jb.setText("我被点击了");
        }
    }

    public static void main(String[] args) {
        new SimpleEvent();
    }
}

KeyEvent键盘事件：

当向文本框中输入内容时，将发生键盘事件。keyevent类负责捕获键盘事件，可以通过为组件添加是西安了keylistenser接口的监听器来处理相应的键盘事件。

当用户在键盘上敲击键盘时，KeyListener 可以捕获三种不同类型的事件：

1. keyTyped(KeyEvent e): 当用户敲击键盘上的某个键时触发，这个方法捕获并处理敲击键盘的字符。

2. keyPressed(KeyEvent e): 当用户按下键盘上的某个键时触发，这个方法捕获并处理键的按下事件。可以检测特定键的按下。

3. keyReleased(KeyEvent e): 当用户释放键盘上的某个键时触发，这个方法捕获并处理键的释放事件。

常用方法：

1. int getKeyCode()： 返回一个整数值，表示按下或释放的键的唯一标识符。

2. char getKeyChar()： 返回表示按下或释放的键所代表字符的 Unicode 字符。如果无法转换为字符，将返回 CHAR_UNDEFINED。

3. int getKeyLocation()： 返回按键的位置。可能的值包括 KeyEvent.KEY_LOCATION_STANDARD、KeyEvent.KEY_LOCATION_LEFT、KeyEvent.KEY_LOCATION_RIGHT、KeyEvent.KEY_LOCATION_NUMPAD 等。

4. int getID()： 返回事件的类型。可能的值包括 KeyEvent.KEY_PRESSED、KeyEvent.KEY_TYPED 或 KeyEvent.KEY_RELEASED。

5. boolean isShiftDown(), boolean isControlDown(), boolean isAltDown()： 这些方法用于检查是否按下了 Shift、Control 或 Alt 键。

6. void consume()： 标记此事件已被使用，防止其进一步被传播或处理。

MouseEvent鼠标事件

• MouseEvent 类： 代表鼠标事件。它包含了鼠标事件的信息，比如鼠标的位置、按钮状态等。

• 常用方法：

  • getX() 和 getY()：获取鼠标事件发生时的 X 和 Y 坐标。
  • getButton()：获取鼠标按键（左键、右键、中键）。
  • getID()：获取事件的类型，如 MOUSE_CLICKED、MOUSE_PRESSED、MOUSE_RELEASED 等。
  • getSource()：获取触发事件的对象（事件源）。
  • isAltDown()、isCtrlDown()、isShiftDown()：检查是否按下了 Alt、Ctrl、Shift 等修饰键。

MouseListener 接口和 MouseAdapter 类

• MouseListener 接口： 处理鼠标事件的监听器接口。它定义了一系列用于处理鼠标事件的方法，如 mouseClicked()、mousePressed()、mouseReleased()、mouseEntered() 和 mouseExited()。

• MouseAdapter 类： 是 MouseListener 接口的适配器类，实现了 MouseListener 接口的所有方法但什么都不做。可以继承 MouseAdapter 并覆盖需要的方法，而不必实现接口中的所有方法。