Java之JFC——Swing组件（JFrame、JPanel、JLabel、JButton......）

以下笔记小编也是学习了众多大佬的文章总结的，如有雷同请私信小编删除。希望这篇笔记对你能有所帮助。

Java图形化界面设计——容器（JFrame）

程序是为了方便用户使用的，因此实现图形化界面的程序编写是所有编程语言发展的必然趋势，在命令提示符下运行的程序可以让我们了解java程序的基本知识体系结构，现在就进入java图形化界面编程。

一、JFC组成

Java Foundation Classes (JFC) 是一组用于构建图形用户界面（GUI）和图形功能的Java类库。JFC包括以下主要部分：

1. Swing：这是JFC最核心的部分，提供了一组丰富的GUI组件（如按钮、文本框、表格、树、列表等），这些组件都是用纯Java实现的，具有平台独立性。Swing组件可以高度定制化，并支持复杂的图形界面开发。

2. AWT (Abstract Window Toolkit)：这是JFC的基础，提供了用于创建和管理图形界面的基本组件和工具。AWT组件依赖于底层操作系统的GUI功能，因此可能在不同的平台上表现有所不同。

3. Java 2D：这是JFC的一部分，提供了高级的二维图形绘制功能。Java 2D API允许开发者绘制复杂的形状、文本和图像，并支持高级图形操作，如反锯齿、透明度和渐变效果。

4. Accessibility API：这个API使得开发者可以创建可访问性更高的应用程序，确保软件可以被有特殊需求的用户使用，例如视力或听力障碍的用户。

5. Drag and Drop：这个API提供了在应用程序之间或应用程序内部实现拖放操作的功能，增强了用户界面的交互性。

JFC (Java Foundation Classes) 是Java中用于构建图形用户界面的基础框架，包括了Swing、AWT、Java 2D、Accessibility API和Drag and Drop等部分。这些工具和API使得Java开发者可以创建功能强大、跨平台的GUI应用程序。

1. AWT

AWT（Abstract Window Toolkit）是Java的原始GUI工具包，提供了基本的GUI组件和图形绘制功能。AWT组件是重量级的，直接使用本地操作系统的GUI资源，通过本地方法实现其功能。

1）特点和问题

• 重量级组件：AWT组件依赖于操作系统的原生组件，因此它们被称为重量级组件。
• 平台依赖性：由于AWT高度依赖于各操作系统的绘图功能，跨平台的一致性较差。开发者必须了解各平台的差异，这违背了Java语言的跨平台一致性初衷。
• 旧的双界面库：作为一个较旧的库，AWT通过较小的设计来吸收和去除各操作系统之间的差异，导致其跨平台绘图表现不一致，受到批评。

2）在JFC中的角色

AWT（1.1及以上版本）是JFC的核心，为JFC提供了以下基本结构：

• 代理事件模型
• 轻量组件
• 剪贴板和数据传输
• 打印和无鼠标操作

3）局限性

• 图形函数与操作系统对应：AWT中的图形函数与操作系统提供的图形函数有一一对应关系。
• 平台无关性：AWT通过牺牲功能来实现平台无关性。
• 不满足现代需求：AWT不能满足现代图形用户界面发展的需要。

总结而言，AWT作为Java的初代GUI工具包，通过直接使用本地操作系统资源实现基本的图形功能，尽管提供了跨平台的基本能力，但其平台依赖性和功能局限性限制了其应用，未能满足现代GUI发展的需求。

import java.awt.Button;
import java.awt.Frame;

public class AWTExample {
    public static void main(String[] args) {
        Frame frame = new Frame("AWT Example");
        frame.setSize(400, 300);

        Button button = new Button("Click Me");
        frame.add(button);

        frame.setVisible(true);
    }
}

2. Swing

Swing是JFC中最重要的部分，它提供了一组更强大和灵活的GUI组件。Swing组件与AWT组件不同，它们完全用Java实现，不依赖于本地平台的GUI组件。

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class SwingExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Swing Example");
        frame.setSize(400, 300);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JPanel panel = new JPanel();
        JButton button = new JButton("Click Me");
        panel.add(button);

        frame.add(panel);
        frame.setVisible(true);
    }
}

为了解决AWT组件的缺陷，特别是跨平台问题，Java在JDK 1.2版本后引入了新的Swing包，由javax.swing提供。Swing是在AWT基础上构建的一套全新的图形界面组件，所有组件均由Java编写，具有良好的跨平台性。

1）特点

由于Swing不使用本地方法实现图形功能，因此被称为轻量级组件。需要注意的是，Swing是建立在AWT基础上的扩展，而不是替代AWT。AWT是根基，Swing是其发展。

Swing组件几乎都是轻量级的，但顶层容器（如窗体、应用程序窗口和对话框）除外。这些顶层容器是重量级组件，因为轻量组件需要在重量级容器中绘制。因此，Swing的顶层容器必须是重量级组件，以便提供绘制轻量组件的窗口。

2）AWT和Swing

AWT（Abstract Window Toolkit）是Java的最早的图形界面工具包，其主要特点和作用包括：

• 与本地图形界面交互：AWT提供了一套与操作系统的图形库进行交互的接口。
• Peers机制：AWT中的图形函数与操作系统提供的图形函数之间有一一对应的关系，称为peers。
• 平台依赖性：由于不同操作系统的图形库功能不同，为实现“编译一次，到处运行”，AWT只能提供各操作系统图形功能的交集，这限制了其功能。
• 重量级控件：AWT依赖本地方法实现功能，因此被称为重量级控件。

为了解决AWT的跨平台问题，Java引入了Swing。Swing的主要特点和作用包括：

• 基于AWT：Swing是在AWT基础上构建的，提供了AWT的所有功能并进行了扩展。
• 纯Java实现：Swing控件用100%的Java代码实现，具有良好的跨平台性。它不依赖本地方法，因此称为轻量级控件。
• 功能扩展：Swing提供了如树形控件等复杂组件的支持，这些组件在某些操作系统中并不存在。

AWT和Swing的区别

• 实现方式：AWT基于本地方法实现，速度较快；Swing基于AWT，纯Java实现，速度较慢。
• 使用场景：
  • 嵌入式应用：由于硬件资源有限，运行速度关键，AWT是首选。
  • 标准Java应用：在硬件资源充足的PC或工作站上，Swing更受欢迎，尽管运行速度较慢，但功能更强大。

总结

• AWT：Java最早的图形界面开发包，依赖本地方法，提供基本图形功能，是重量级控件。
• Swing：为解决AWT问题而开发的包，基于AWT构建，使用纯Java实现，提供更强大的图形界面功能，是轻量级控件。

3. Java 2D

Java 2D API提供了用于绘制二维图形的高级功能，适用于创建图表、游戏和图形应用程序。

import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Color;

public class Java2DExample extends JPanel {
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g;
        g2d.setColor(Color.BLUE);
        g2d.fillRect(50, 50, 100, 100);
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("Java 2D Example");
        frame.setSize(400, 300);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        frame.add(new Java2DExample());
        frame.setVisible(true);
    }
}

4. Accessibility API

Accessibility API允许开发者为残障用户创建更加友好的应用程序。这些API帮助应用程序与辅助技术（如屏幕阅读器）进行交互。

5. Drag and Drop

拖放API使得应用程序的交互更加直观和用户友好。例如，可以实现文件在应用程序之间拖放的功能。

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

public class DragAndDropExample extends JFrame {
    public DragAndDropExample() {
        JLabel label = new JLabel("Drag something here");
        label.setTransferHandler(new TransferHandler("text"));

        new DropTarget(label, new DropTargetAdapter() {
            @Override
            public void drop(DropTargetDropEvent dtde) {
                dtde.acceptDrop(DnDConstants.ACTION_COPY);
                Transferable transferable = dtde.getTransferable();
                try {
                    String text = (String) transferable.getTransferData(DataFlavor.stringFlavor);
                    label.setText(text);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        add(label);
        setSize(400, 300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }

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

二、Swing基本框架

上图列举了AWT和Swing的关系，也可以看出Swing是继承自AWT的。本文主要利用Swing来设计图形化界面程序。

1.Swing常用组件

• JButton：按钮
• JLabel：标签
• JTextField：单行文本框
• JTextArea：多行文本框
• JComboBox：下拉列表
• JCheckBox：复选框
• JRadioButton：单选按钮
• JPanel：面板，用于组织其他组件
• JScrollPane：滚动面板，用于包含可能超出可视范围的组件

Swing包括250多个类，其中一些是UI组件，另一些是支持类。为了区分UI组件和支持类，Swing组件的名字以J开头。下面列出了Swing提供的一些UI组件，斜体字表示AWT组件的替代组件：

• JButton
• JToggleButton
• JCheckBox
• JRadioButton
• JLabel
• JList
• JComboBox
• JTextField
• JTextArea
• JPasswordField
• JTable
• JTree
• JScrollPane
• JTabbedPane
• JSplitPane
• JToolBar
• JToolTip
• JProgressBar
• JSlider
• JSpinner

组件类　　　　　　　　　描述
　　─────────────────────────────────
　　JApplet Java.applet.Applet类的扩展，它含有JRootPane的一个实例
　　JButton 能显示文本和图形的按钮，它是AWT按钮组件的替代组件
　　JCheckBox 能显示文本和图形的复选框，它是AWT选择组件的替代组件
　　JCheckBoxMenuItem 一个复选框菜单项，它是AWT的复选框菜单项组件的替代组件
　　JComboBox 带下拉列表的文本框，它是AWT选择组件的替代组件
　　JComponent 所有轻量J组件的基类
　　JDesktopPane 内部窗体的容器
　　JDialog　Swing对话框的基类，它扩展了AWT Dialot类
　　JEditorPane 用于编辑文本的文本窗格
　　JFrame 扩展java.awt.Frame的外部窗体
　　JInternalFrame 在JDesktopPane中出现的内部窗体
　　JLabel 可显示文本和图标的标签，它是AWT标签组件的替代组件
　　JLayeredPane 能够在不同层上显示组件的容器
　　JList 显示选项列表的组件，它是AWT列表组件的替代组件
　　JMenu 菜单条中显示的一个菜单，它是AWT菜单组件的替代组件
　　JMenuBar 用于显示菜单的菜单条，它是AWT菜单条组件的替代组件
　　JMenuItem 菜单项，它是AWT菜单项组件的替代组件
　　JOptionPane 显示标准的对话框，如：消息和问题对话框
　　JPanel 通用容器，它是AWT面板和画布组件的替代组件
　　JPasswordfield JTextField的扩展，使输入的字符不可见
　　JPopupMenu 弹出式菜单，它是AWT弹出式菜单组件的替代组件
　　JProgressBar 进度指示器
　　JRadioButton 单选按钮，它是AWT复选框组件的替代组件
　　JRootPane 顶层容器，它包含一个玻璃窗格，一个层窗格，一个内容窗格和一个可选的菜单条
　　JScrollBar 滚动条，它是AWT滚动条组件的替代组件
　　JScrollPane 滚动窗格，它是AWT滚动窗格组件的替代组件
　　JSeparator 水平或垂直分隔条
　　JSlider 滑杆
　　JSplitPane 有两个分隔区的容器，这两个分隔区可以水平排列或者垂直排列且分隔区的大小能自动调整
　　JTabbedPane 带选项卡的窗格
　　JTable 表格
　　JTableHeader 表格头
　　JTextArea 用于输入多行文本的文本域，它是AWT文本域组件的替代组件
　　JTestComponent 文本组件的基类，它替代AWT的TextComponent类
　　JTextField 单行文本域，它替代AWT的单行文本域组件
　　JTextPane 简单的文本编辑器
　　JToggleButton 两种状态的按钮，它是JCheckBox和JRadioButton组件的基类
　　JToolBar 工具条
　　JToolTip 当光标停留在一个组件上时，该组件上显示的一行文字
　　JTree 用于按钮层次组织数据的结构控件
　　JViesport 用于浏览可滚动组件的视口
　　JWindow 外部窗口，它是java.awt.Window的扩展
　　━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
　　注：斜体字表示的是AWT的替代组件

2.布局管理器

setLayout() 方法用于设置容器的布局管理器，即确定容器中组件的排列方式。在 Java 中，布局管理器负责确定容器中组件的位置和大小，以便在容器大小改变时调整它们的位置和大小。

1）setLayout()

• 功能：设置容器的布局管理器。
• 参数：layout - 一个 LayoutManager 对象，表示要应用于容器的布局管理器。
• 返回类型：void

Container container = new Container();
container.setLayout(new FlowLayout()); // 使用 FlowLayout 布局管理器

2）常见的布局管理器

1. FlowLayout：按照添加顺序从左到右排列组件，当一行放不下时自动换行。
2. BorderLayout：将容器划分为五个区域：北、南、东、西和中。每个区域可以放置一个组件。
3. GridLayout：将容器划分为网格，组件按照行列排列。
4. GridBagLayout：高级的网格布局，可以更精确地控制组件的位置和大小。
5. BoxLayout：沿着一个方向排列组件，可以是水平或垂直。
6. CardLayout：一次只显示一个组件，多个组件叠加在同一位置，通过切换卡片来显示不同的组件。

3）示例

以下是一个简单的示例，演示如何使用 setLayout() 方法设置容器的布局管理器：

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

public class LayoutExample {
    public static void main(String[] args) {
        // 创建一个 JFrame 实例
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        // 创建一个 JPanel 实例作为容器
        JPanel panel = new JPanel();
        
        // 设置容器的布局管理器为 BorderLayout
        panel.setLayout(new BorderLayout());
        
        // 在容器中添加几个按钮，分别放置在不同的方位
        panel.add(new JButton("North"), BorderLayout.NORTH);
        panel.add(new JButton("South"), BorderLayout.SOUTH);
        panel.add(new JButton("East"), BorderLayout.EAST);
        panel.add(new JButton("West"), BorderLayout.WEST);
        panel.add(new JButton("Center"), BorderLayout.CENTER);
        
        // 将容器设置为内容面板
        frame.setContentPane(panel);
        
        // 设置窗口大小并显示窗口
        frame.setSize(400, 300);
        frame.setVisible(true);
    }
}

在这个示例中，我们创建了一个 JFrame 窗口和一个 JPanel 容器，并使用 setLayout() 方法将容器的布局管理器设置为 BorderLayout。然后，我们在容器中添加了五个按钮，分别放置在不同的方位，最后将容器设置为窗口的内容面板并显示窗口。

3.JFrame常用方法

JFrame 是 Swing 库中用来创建和管理应用程序主窗口的类。它继承自 java.awt.Frame，因此包含了 Frame 和 Window 类的所有方法。以下是 JFrame 类的一些常用方法：

1）构造方法

• JFrame()
• JFrame(String title)

2）设置和获取属性

• void setTitle(String title)
• String getTitle()
• void setSize(int width, int height)
• void setSize(Dimension d)
• Dimension getSize()
• void setLocation(int x, int y)
• void setLocation(Point p)
• Point getLocation()
• void setBounds(int x, int y, int width, int height)
• void setBounds(Rectangle r)
• Rectangle getBounds()
• void setResizable(boolean resizable)
• boolean isResizable()
• void setDefaultCloseOperation(int operation)
• int getDefaultCloseOperation()
• void setExtendedState(int state)
• int getExtendedState()
• void setIconImage(Image image)
• Image getIconImage()

setTitle()

设置窗口的标题。

void setTitle(String title)

• title：一个字符串，表示窗口的新标题。

JFrame frame = new JFrame();
frame.setTitle("My Application");

getTitle()

String getTitle()

• 功能：获取窗口的标题。
• 返回值：返回一个字符串，表示当前窗口的标题。

String title = frame.getTitle();
System.out.println("Window Title: " + title);

setSize()

void setSize(int width, int height)

• 功能：设置窗口的宽度和高度。
• 参数：width - 窗口的宽度（以像素为单位）。height - 窗口的高度（以像素为单位）。

frame.setSize(800, 600);

void setSize(Dimension d)

• 功能：设置窗口的大小，使用 Dimension 对象。
• 参数：d - 一个 Dimension 对象，包含窗口的宽度和高度。

Dimension size = new Dimension(800, 600);
frame.setSize(size);

getSize()

Dimension getSize()

• 功能：获取窗口的当前大小。
• 返回值：返回一个 Dimension 对象，包含窗口的宽度和高度。

Dimension size = frame.getSize();
System.out.println("Width: " + size.width + ", Height: " + size.height);

setLocation()

void setLocation(int x, int y)

• 功能：设置窗口在屏幕上的位置。
• 参数：x - 窗口左上角的 X 坐标（以像素为单位）。y - 窗口左上角的 Y 坐标（以像素为单位）。

frame.setLocation(100, 150);

void setLocation(Point p)

• 功能：设置窗口在屏幕上的位置，使用 Point 对象。
• 参数：p - 一个 Point 对象，包含窗口左上角的 X 和 Y 坐标。

Point location = new Point(100, 150);
frame.setLocation(location);

getLocation()

获取窗口在屏幕上的位置。

Point getLocation()

• 返回一个 Point 对象，包含窗口左上角的 X 和 Y 坐标。

JFrame frame = new JFrame();
Point location = frame.getLocation();
System.out.println("Window Location: " + location);

setBounds()

设置窗口的位置和大小。

void setBounds(int x, int y, int width, int height)

• x：窗口左上角的 X 坐标（以像素为单位）。
• y：窗口左上角的 Y 坐标（以像素为单位）。
• width：窗口的宽度（以像素为单位）。
• height：窗口的高度（以像素为单位）。

JFrame frame = new JFrame();
frame.setBounds(100, 100, 800, 600);

设置窗口的位置和大小，使用 Rectangle 对象。

void setBounds(Rectangle r)

• r：一个 Rectangle 对象，包含窗口的位置和大小。

JFrame frame = new JFrame();
Rectangle bounds = new Rectangle(100, 100, 800, 600);
frame.setBounds(bounds);

getBounds()

获取窗口的位置和大小。

Rectangle getBounds()

• 返回一个 Rectangle 对象，包含窗口的位置和大小。

JFrame frame = new JFrame();
Rectangle bounds = frame.getBounds();
System.out.println("Window Bounds: " + bounds);

setResizable()

设置窗口是否可调整大小。

void setResizable(boolean resizable)

• resizable：一个布尔值，表示窗口是否可调整大小。

JFrame frame = new JFrame();
frame.setResizable(false); // 设置窗口不可调整大小

isResizable()

检查窗口是否可调整大小。

boolean isResizable()

• 返回一个布尔值，表示窗口是否可调整大小。

JFrame frame = new JFrame();
boolean resizable = frame.isResizable();
System.out.println("Resizable: " + resizable);

setDefaultCloseOperation()

设置窗口关闭时的操作。

void setDefaultCloseOperation(int operation)

• operation：一个整数值，表示窗口关闭时的操作。

JFrame frame = new JFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

getDefaultCloseOperation()

获取窗口关闭时的操作。

int getDefaultCloseOperation()

• 返回值：一个整数值，表示窗口关闭时的操作。可能的取值包括：
  • WindowConstants.DO_NOTHING_ON_CLOSE：不执行任何操作。
  • WindowConstants.HIDE_ON_CLOSE：隐藏窗口，但不终止程序。
  • WindowConstants.DISPOSE_ON_CLOSE：关闭窗口并释放与之关联的所有资源。
  • WindowConstants.EXIT_ON_CLOSE：关闭窗口并终止程序。

JFrame frame = new JFrame();
int operation = frame.getDefaultCloseOperation();
System.out.println("Default Close Operation: " + operation);

setExtendedState()

设置窗口的扩展状态，如最大化、最小化等。

void setExtendedState(int state)

• 参数：state - 一个整数值，表示窗口的扩展状态。可能的取值包括：
  • Frame.NORMAL：正常状态。
  • Frame.MAXIMIZED_BOTH：最大化状态。
  • Frame.MAXIMIZED_HORIZ：水平最大化状态。
  • Frame.MAXIMIZED_VERT：垂直最大化状态。
  • Frame.ICONIFIED：最小化状态。

JFrame frame = new JFrame();
frame.setExtendedState(Frame.MAXIMIZED_BOTH); // 设置窗口最大化

getExtendedState()

获取窗口的扩展状态。

int getExtendedState()

• 返回值：一个整数值，表示窗口的扩展状态。可能的取值参考 setExtendedState(int state) 方法的参数说明。

JFrame frame = new JFrame();
int state = frame.getExtendedState();
System.out.println("Extended State: " + state);

setIconImage()

设置窗口的图标。

void setIconImage(Image image)

• 参数：image - 一个 Image 对象，表示窗口的图标。

JFrame frame = new JFrame();
Image icon = Toolkit.getDefaultToolkit().getImage("icon.png");
frame.setIconImage(icon);

getIconImage()

获取窗口的图标。

Image getIconImage()

• 返回值：一个 Image 对象，表示窗口的图标。

JFrame frame = new JFrame();
Image icon = frame.getIconImage();

以上方法可以帮助你获取和设置 JFrame 窗口的关闭操作、扩展状态和图标，定制窗口的行为和外观，提升用户体验。

3）显示和隐藏窗口

• void setVisible(boolean b)
• boolean isVisible()
• void pack()

setVisible()

设置窗口的可见性。

void setVisible(boolean b)

• 参数：b - 一个布尔值。如果为 true，窗口将变为可见；如果为 false，窗口将变为不可见。

JFrame frame = new JFrame("My Application");
frame.setSize(400, 300);
frame.setVisible(true); // 使窗口可见

isVisible()

检查窗口当前是否可见。

boolean isVisible()

• 返回值：一个布尔值。如果窗口当前可见，返回 true；否则返回 false。

JFrame frame = new JFrame("My Application");
frame.setSize(400, 300);
frame.setVisible(true);
boolean visibility = frame.isVisible(); // 检查窗口是否可见
System.out.println("Is frame visible? " + visibility);

pack()

调整窗口大小以适应其子组件的首选大小和布局。

void pack()

• 功能：根据子组件的首选大小和布局自动调整窗口的大小。

JFrame frame = new JFrame("My Application");
JButton button = new JButton("Click me!");
frame.add(button);
frame.pack(); // 调整窗口大小以适应按钮
frame.setVisible(true);

4）窗口状态

• void setState(int state)
• int getState()
• void toFront()
• void toBack()

5）添加和管理内容

• Container getContentPane()
• void setContentPane(Container contentPane)
• JMenuBar getJMenuBar()
• void setJMenuBar(JMenuBar menubar)
• JLayeredPane getLayeredPane()
• void setLayeredPane(JLayeredPane layeredPane)
• JRootPane getRootPane()
• GlassPane getGlassPane()
• void setGlassPane(Component glassPane)

6）事件处理

• void addWindowListener(WindowListener l)
• void removeWindowListener(WindowListener l)
• WindowListener[] getWindowListeners()

三、图形化设计步骤

用java编程的相关设计步骤来分解上面的的程序运行过程如下图所示：

使用Swing来创建图形用户界面（GUI）主要涉及以下步骤：

1. 创建主框架（JFrame）：这是应用程序的主窗口。
2. 添加组件：向主框架添加各种Swing组件，如按钮（JButton）、标签（JLabel）、文本字段（JTextField）等。
3. 设置布局管理器：决定组件在框架中的排列方式。
4. 处理事件：为组件添加事件监听器以响应用户交互。
5. 显示窗口：设置框架的可见性。

以下是一个简单的Swing应用程序示例，展示了如何创建一个基本的GUI窗口，并添加一个按钮和一个标签。

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

public class SwingExample {
    public static void main(String[] args) {
        // 创建主框架
        JFrame frame = new JFrame("Swing Example");
        
        // 设置关闭操作
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        // 设置窗口大小
        frame.setSize(400, 300);

        // 创建一个面板
        JPanel panel = new JPanel();

        // 创建一个标签并添加到面板
        JLabel label = new JLabel("Hello, Swing!");
        panel.add(label);

        // 创建一个按钮并添加到面板
        JButton button = new JButton("Click Me");
        panel.add(button);

        // 添加按钮点击事件监听器
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                label.setText("Button Clicked!");
            }
        });

        // 将面板添加到框架的内容面板
        frame.getContentPane().add(panel);

        // 设置框架可见
        frame.setVisible(true);
    }
}

1.创建顶层容器

对应于程序的初始显现窗口，窗口中放入其它菜单、工具栏、文本框、按钮等组件

顶层容器图形化界面显示的基础，其它所有的组件（控件）都是直接或间接显示在顶层容器中的。在java中顶层容器有三种，分别是JFrame（框架窗口，即通常的窗口）、JDialog（对话框）、JApplet（用于设计嵌入在网页中的java小程序）。

顶层窗口类（框架）JFrame

（1）JFrame类是用于描述顶层窗口，JFrame就代表Swing中的窗口组件

（2）JFrame的修饰部件（按钮，标题栏，图标等）是由用户的窗口系统绘制，不由Swing绘制

阅读下面例子，需要理解的几个API

EventQueue.invokeLater(new Runnable(){ … }) 只需要将其看作是启动Swing程序的作用即可

Component的API:

boolean isVisible()

void setVisible(boolean b) 设置显示与否，一般组件默认是可见的，只有JFrame例外

void setSize(int width, int height)

void setLocation(int x, int y) 设置组件的位置。JFrame则是相对屏幕左上角而言，其它组件则是相对包含它的容器左上角而言

void setBounds(int x, int y, int w, int h)

Dimension getSize() 获得当前组件的size属性，又可以通过size获得width和height

void setSize(Dimension d) 设置当前组件的size属性

Window的API:

void toFront() 将该窗口显示在其它窗口前面

void toBack()

boolean isLocationByPlatform()

void setLocationByPlatform(boolean b) 这个属性在窗口显示之前被设置，由平台选择一个合适的位置放该窗口

Frame的API:

boolean isResizable()

void setResiable(boolean b) 设置该属性后，用户可以对框架变大变小

String getTitle()

void setTitle(String s) 设置框架标题栏中的文字

Image getIconImage()

void setIconImage(Image img) 这个属性确定了框架的图标

boolean isUndecorated()

void setUndecorated(boolean b) 框架显示前调用，true则该框架不会显示标题栏和关闭按钮等装饰

int getExtendedState()

void setExtendedState(int state) 设置窗口状态（Frame.NORMAL等5种）

Toolkit的API:

static Toolkit getDefaultToolkit() 返回默认的工具箱

Dimension getScreenSize() 返回用户屏幕的尺寸

ImageIcon的API:

ImageIcon(String filename) 根据一个文件路径构造一个图标,其图像存储在一个文件中

Image getImage() 获得该图标的图像

package GUI;
 
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Image;
import java.awt.Toolkit;
 
import javax.swing.ImageIcon;
import javax.swing.JFrame;
 
public class JFrameDemo {
	public static void main(String[] args) {
		/*所有的Swing组件必须由事件分派线程进行配置*/
		EventQueue.invokeLater(new Runnable() {
			@Override
			public void run() {
				SimpleFrame frame = new SimpleFrame();//初始化窗口
				frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置:关闭窗口，则程序退出
				frame.setVisible(true);//显示窗口
			}
		});
	}
}
 
class SimpleFrame extends JFrame{
	private static final long serialVersionUID = 1L;
	
	private static final int DEFAULT_WIDTH = 300;
	private static final int DEFAULT_HEIGHT = 200;
	public SimpleFrame() {
		this.setSize(DEFAULT_WIDTH,DEFAULT_HEIGHT);
		
		/*setLocation(x,y)仅设置窗口显示位置，相对屏幕左上角*/
//		this.setLocation(500, 500);
		
		/*setBounds(x,y,width,height)重置窗口显示位置和大小*/
//		this.setBounds(200, 200, 500, 400);
		
		/*让窗口系统控制窗口的位置*/
		this.setLocationByPlatform(true);
		
		/*设置窗口标题*/
		setTitle("贪吃蛇");
		
		/*先获得屏幕大小，再设置窗口大小是屏幕大小的一半*/
		Toolkit kit = Toolkit.getDefaultToolkit();
		Dimension screenSize = kit.getScreenSize();
		int screenWidth = screenSize.width;
		int screenHeight = screenSize.height;
		setSize(screenWidth/2, screenHeight/2);
		
		/*设置窗口图标*/
//		Image img = new ImageIcon("src/icon.jpg").getImage();
//		setIconImage(img);
		
		
	}
}

2.创建中间容器、组件

对应于程序中出现的菜单、工具栏（中间容器）、文本框、按钮、单选框、复选框等控件。

有很多Swing组件可以使用，见前面的SwingUI组件表。

3.将组件加入容器

在java中创建组件后，还需要将组件放入相应的容器，才能在顶层容器，如窗口中显示出组件。

4.设置容器内组件的位置

组件添加到容器中，还必须设置好组件的显示位置，一般有两种方法来设置组建的显示位置，一是按照与容器的相对距离（以像素为单位），精确固定控件的位置；二是用布局管理器来管理组件在容器内的位置。

5.处理组件所产生的事件

即用户执行选择菜单、单击按钮等操作时，就要执行相应的命令，进行相关的程序处理，这就需要设置组件的事件。

1）绘制2D图形

可能会用到的API

double getCenterX() 获得矩形中心x坐标值

double getMinX() 获得最小的x坐标值

double getMaxX() 获得最大的x坐标值

double getWidth() 获得矩形的宽

double getHeight() 获得矩形的高

double getX() 获得矩形左上角的x坐标

Rectangle2D.Double(double x,double y,double w,double h) 利用给定的左上角和宽高，构造一个矩形

Rectangle2D.Float(float x,float y,float w,float h) 利用给定的左上角和宽高，构造一个矩形

Ellipse2D.Double(double x,double y,double w,double h) 利用给定的左上角和宽高的外接矩形，构造一个椭圆(宽高相同时就是圆)

Point2D.Double(double x,double y) 利用给定坐标构造一个点

Line2D.Double(Point2D start, Point2D end) 构造一条直线

Line2D.Double(double startX,double startY,double endX,double endY) 构造一条直线

package GUI;
 
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Rectangle2D;
 
import javax.swing.JComponent;
import javax.swing.JFrame;
 
public class DrawTest {
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			@Override
			public void run() {
				DrawFrame frame = new DrawFrame();//初始化窗口
				frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置:关闭窗口，则程序退出
				frame.setVisible(true);//显示窗口
			}
		});
	}
}
 
@SuppressWarnings("serial")
class DrawFrame extends JFrame{
	public DrawFrame() {
		add(new DrawComponent());
		pack();
	}
}
 
@SuppressWarnings("serial")
class DrawComponent extends JComponent{
	private static final int DEFAULT_WIDTH = 500;
	private static final int DEFAULT_HEIGHT = 400;
	
	@Override
	public void paintComponent(Graphics g) {
		Graphics2D g2 = (Graphics2D)g;
		
		//绘制一个矩形
		double leftX = 100;
		double topY = 100;
		double width = 200;
		double height = 150;
		Rectangle2D rect = new Rectangle2D.Double(leftX, topY, width, height);
		g2.draw(rect);//描绘边框
		
		g2.setPaint(Color.RED);//设置颜色
		g2.fill(rect);//填充颜色，右侧和下方少绘制一个像素的颜色
		
	}
	
	@Override
	public Dimension getPreferredSize() {
		return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT);
	}
}

2）设置颜色

（1）获取和改变当前颜色，所有后续的绘图操作都使用这个新颜色

Color getColor( )

void setColor( Color c )

创建一个颜色对象：Color( int r, int g, int b )

（2）获取和设置这个图形环境的绘制属性，即设置画笔的颜色

Paint getPaint( )

void setPaint( Paint p )

void fill( Shape s )

（3）背景色和前景色

setBackground( Color c )

setForeground( Color c )

3）文本使用特殊字体

package GUI;
 
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.font.FontRenderContext;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
 
import javax.swing.JComponent;
import javax.swing.JFrame;
 
public class FontTest {
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			@Override
			public void run() {
				JFrame frame = new FontFrame();//初始化窗口
				frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置:关闭窗口，则程序退出
				frame.setVisible(true);//显示窗口
			}
		});
	}
}
 
@SuppressWarnings("serial")
class FontFrame extends JFrame{
	public FontFrame() {
		add(new FontComponent());
		pack();
	}
}
 
@SuppressWarnings("serial")
class FontComponent extends JComponent{
	private static final int DEFAULT_WIDTH = 300;
	private static final int DEFAULT_HEIGHT = 200;
	
	@Override
	public Dimension getPreferredSize() {
		return new Dimension(DEFAULT_WIDTH,DEFAULT_HEIGHT);
	}
	
	@Override
	public void paintComponent(Graphics g) {
		Graphics2D g2 = (Graphics2D)g;
		
		String msg = "Hello World";
		
		//创建一个新字体对象，字体名，字体风格，字体大小
		Font f = new Font("Serif", Font.BOLD, 36);
		g2.setFont(f);
		
		//----要想字符串在面板的中央位置
		//返回指定字体特征的字体绘制环境
		FontRenderContext context = g2.getFontRenderContext();
		//返回包围字符串的矩形
		Rectangle2D bounds = f.getStringBounds(msg, context);
		double x = (getWidth() - bounds.getWidth()) / 2;
		double y = (getHeight() - bounds.getHeight()) / 2; 
		double ascent = -bounds.getY();
		double baseY = y + ascent;
		g2.drawString(msg, (int)x, (int)baseY);
		
		//---显示基线
		g2.draw(new Line2D.Double(x, baseY, x+bounds.getWidth(), baseY));
		
	}
}

四、组件容器的使用

Java中组件容器包含顶层容器和中间容器。

在java中顶层容器有三种，分别是JFrame（框架窗口，即通常的窗口）、JDialog（对话框）、JApplet（用于设计嵌入在网页中的java小程序），顶层容器是容纳其它组件的基础，即设计图形化程序必须要有顶层容器。

Java中间容器是可以包含其它相应组件的容器，但是中间容器和组件一样，不能单独存在，必须依附于顶层容器。

常见的中间容器有：

JPanel：最灵活、最常用的中间容器。

JScrollPane：与JPanel类似，但还可在大的组件或可扩展组件周围提供滚动条。

JTabbedPane：包含多个组件，但一次只显示一个组件。用户可在组件之间方便地切换。

JToolBar：按行或列排列一组组件（通常是按钮）。

1.JFrame框架窗口的使用

以上是JFrame的常用方法即说明，下面举例说明。

实例1：直接定义Jframe类的对象创建一个窗口

// JFrameDemo1.java
import javax.swing.*;
//使用Swing类，必须引入Swing包
public class JFrameDemo1{
	public staticvoid main( String args[]) {
		//定义一个窗体对象f，窗体名称为"一个简单窗口"    
		Jframe f = new JFrame("一个简单窗口");
		/*设置窗体左上角与显示屏左上角的坐标，
离显示屏上边缘300像素，离显示屏左边缘300像素   */
		f.setLocation(300, 300);
		//f.setLocationRelativeTo(null);本语句实现窗口居屏幕中央
		f.setSize(300,200);
		//设置窗体的大小为300*200像素大小
		f.setResizable(false);
		//设置窗体是否可以调整大小，参数为布尔值
		//设置窗体可见，没有该语句，窗体将不可见，此语句必须有，否则没有界面就没有如何意义了
		f.setVisible( true);
		//用户单击窗口的关闭按钮时程序执行的操作
		f.setDefaultCloseOperation(f.EXIT_ON_CLOSE);
	}
}
123456789101112131415161718192021

程序运行结果如下图所示：

可以根据程序代码的注释，依次修改相应的方法参数查看效果。

setDefaultCloseOperation(intoperation)：设置用户在此窗体上发起"close"时默认执行的操作。方法中的参数解释如下：

l为“0”或DO_NOTHING_ON_CLOSE：

（在WindowConstants中定义）：不执行任何操作；要求程序在已注册的WindowListener对象的windowClosing方法中处理该操作。

比如实例程序代码中更改为f.setDefaultCloseOperation(f.DO_NOTHING_ON_CLOSE);或者f.setDefaultCloseOperation(0),然后查看效果，可以发现窗口无法关闭，下面是相同用法，不再解释了。

l为“1”或HIDE_ON_CLOSE

调用任意已注册的WindowListener对象后自动隐藏该窗体。此时没有关闭程序，只是将程序界面隐藏了。

可以打开任务管理器，可以看到一个叫“java.exe”的进程（如果调试运行了多个java程序，则会看到多个“java.exe”的进程），如果此时用EditPlus测试程序，会发现当单击窗口的关闭按钮关闭窗口后，却无法再次对程序进行调试，因为程序线程没有关闭，在任务管理器中关闭java.exe（如果有多个“java.exe”的进程，则先都关闭掉，再来测试该问题）基础后，EditPlus才可以重新编译改程序。

l为“2”或DISPOSE_ON_CLOSE

调用任意已注册WindowListener的对象后自动隐藏并释放该窗体。但继续运行应用程序，释放了窗体中占用的资源。

l为“3”EXIT_ON_CLOSE（在JFrame中定义）：使用Systemexit方法退出应用程序。仅在应用程序中使用。结束了应用程序。

默认情况下，该值被设置为HIDE_ON_CLOSE。

当注释掉实例中的f.setDefaultCloseOperation(f.EXIT_ON_CLOSE);语句时，起到的效果和f.setDefaultCloseOperation(f.HIDE_ON_CLOSE);或者f.setDefaultCloseOperation(1);一样。

实例2：创建类继承JFrame类创建一个窗口

// JFrameDemo2.java
importjavax.swing.*;
//创建子类MyFrame继承父类JFrame
class MyFrameextends JFrame{
	//定义构造函数，带有四个参数，用于设置窗口位置和大小
	MyFrame(int x,int y,int h,int w){
		super("一个简单窗口");
		//重写父类方法，为窗口定义标题
		/*以下的方法调用前面没有添加对象名，也不可能添加，要创建的对象名称是什么都不知道，也就不可能添加。但是创建对象后，对象自动获取这些初始值。*/
		setLocation(x,y);
		setSize(h,w);
		setResizable(false);
		setVisible(true);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
	}
}
publicclass JFrameDemo2{
	public static void main( String args[]) {
		//实例化类对象，提示设置参数
		MyFrame f = new MyFrame(300,300,300,200);
	}
}

上面的例子也可以不使用构造函数，可以和实例一方式一样，代码可以改为如下模式。

实例3：一个简单窗口

// JframeDemo3.java
importjavax.swing.*;
class MyFrameextends JFrame{
	MyFrame(){
	}
}
publicclass JframeDemo3{
	public static void main( String args[]) {
		MyFrame f = new MyFrame();
		f.setTitle("一个简单窗口");
		f.setLocationRelativeTo(null);
		f.setSize(300,200);
		f.setResizable(false);
		f.setVisible( true);
		f.setDefaultCloseOperation(3);
	}
}

总结

，释放了窗体中占用的资源。

l为“3”EXIT_ON_CLOSE（在JFrame中定义）：使用Systemexit方法退出应用程序。仅在应用程序中使用。结束了应用程序。

默认情况下，该值被设置为HIDE_ON_CLOSE。

当注释掉实例中的f.setDefaultCloseOperation(f.EXIT_ON_CLOSE);语句时，起到的效果和f.setDefaultCloseOperation(f.HIDE_ON_CLOSE);或者f.setDefaultCloseOperation(1);一样。

实例2：创建类继承JFrame类创建一个窗口

// JFrameDemo2.java
importjavax.swing.*;
//创建子类MyFrame继承父类JFrame
class MyFrameextends JFrame{
	//定义构造函数，带有四个参数，用于设置窗口位置和大小
	MyFrame(int x,int y,int h,int w){
		super("一个简单窗口");
		//重写父类方法，为窗口定义标题
		/*以下的方法调用前面没有添加对象名，也不可能添加，要创建的对象名称是什么都不知道，也就不可能添加。但是创建对象后，对象自动获取这些初始值。*/
		setLocation(x,y);
		setSize(h,w);
		setResizable(false);
		setVisible(true);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
	}
}
publicclass JFrameDemo2{
	public static void main( String args[]) {
		//实例化类对象，提示设置参数
		MyFrame f = new MyFrame(300,300,300,200);
	}
}

上面的例子也可以不使用构造函数，可以和实例一方式一样，代码可以改为如下模式。

实例3：一个简单窗口

// JframeDemo3.java
importjavax.swing.*;
class MyFrameextends JFrame{
	MyFrame(){
	}
}
publicclass JframeDemo3{
	public static void main( String args[]) {
		MyFrame f = new MyFrame();
		f.setTitle("一个简单窗口");
		f.setLocationRelativeTo(null);
		f.setSize(300,200);
		f.setResizable(false);
		f.setVisible( true);
		f.setDefaultCloseOperation(3);
	}
}

总结

以上就是本文关于Java图形化界面设计之容器（JFrame）详解的全部内容。许多人说Java图形化设计不重要，用的人也不多，事实上也确实如此。不过，既然它如此简单，而且看起来挺有趣的，抽时间学一下也无妨。