S14-01 GUI-AWT

• AWT 概述
  • 核心架构
  • 布局管理器
  • 委托事件模型
  • 绘图与图像处理
  • AWT vs Swing
  • AWT 当前定位
• 事件处理机制
  • 核心要素
  • 事件处理流程
  • 事件类型
  • 事件监听器实现演进
    • 写法1：外部独立类
    • 写法2：内部类
    • 写法3：匿名内部类
    • 写法4：Lambda 表达式
  • 示例： AWT 事件处理
  • 总结
• Component~
  • 基本语法
  • Peer 机制
  • 与 Swing 的纽带
  • API：Component
    • 构造方法
    • 几何与布局属性
    • 外观属性
    • 生命周期与状态控制
    • 绘图机制
    • 事件监听与焦点机制
  • 实战：交互式画布组件
• Container~【
• Frame~
  • 继承体系
  • 核心特性与默认行为
  • API：Frame
    • 构造方法
    • 窗体状态与外观控制
    • 窗体生命周期与全局管理
  • 监听窗口关闭事件
  • 完整代码示例
  • Frame 到 JFrame
• Graphics~
  • 坐标系统
  • 获取 Graphics 对象的途径
  • API：Graphics
    • 状态配置与管理
    • 几何图形绘制
    • 文本与图像绘制
  • 注意事项
  • 实战：数据可视化看板
• Graphics2D~【
• 其他类【
  • Stroke~【
  • Toolkit~【
  • Panel~【

[TOC]

AWT 概述

java.awt（Abstract Window Toolkit，抽象窗口工具包）是 Java 诞生之初就存在的原生 GUI（图形用户界面）开发工具包。

虽然在现代 Java 开发中，它的绝大多数界面组件已经被 Swing 和 JavaFX 所取代，但它依然是 Java 图形界面的“老祖宗”。理解 AWT 的核心机制，对于掌握 Java 的图形图像处理、事件监听以及 Swing 的底层原理至关重要。

核心架构

AWT 的设计采用了经典的组合模式（Composite Pattern）。其核心类可以分为两大类：Component（组件）和 Container（容器）。

核心基类：

• Component (组件)： 所有可视化控件的抽象父类（如按钮、文本框）。它定义了组件的大小、位置、前背景色、字体以及基本的绘制和事件处理行为。
• Container (容器)： Component 的子类，一种特殊的组件，用来“装”其他组件。它内部包含一个组件列表，并负责管理这些组件的布局。

常见的容器与组件：

• 窗口类容器：

  • Window：一个没有边框和菜单栏的空白顶级窗口（很少直接使用）。
  • Frame：最常用的顶级窗口，带有标题栏、边框、关闭/最小化按钮。
  • Dialog：对话框窗口，通常用于提示信息或输入弹窗。

• 内嵌类容器：

  • Panel：最基础的容器，不能独立存在，必须嵌套在其他窗口中，常用于局部布局管理。

• 原子组件：

  • Button（按钮）、Label（标签）、TextField（单行文本框）、TextArea（多行文本域）、Checkbox（复选框）、Choice（下拉选择框）等。

布局管理器

在 AWT 中，你不需要（也不推荐）写死组件的绝对坐标（x, y），因为不同的操作系统分辨率和窗口缩放会导致界面错位。AWT 引入了布局管理器（Layout Manager） 来自动调整组件的位置和大小。

常见的五大布局管理器：

• FlowLayout（流式布局）： Panel 的默认布局。组件像流水一样从左到右、从上到下排列，一行排不下自动换行。
• BorderLayout（边界布局）： Frame 的默认布局。将容器划分为东西南北中（EAST, WEST, SOUTH, NORTH, CENTER）五个区域，每个区域只能放一个组件。
• GridLayout（网格布局）： 将容器划分为规则的矩阵网格（如 3x3），所有网格大小完全一致，组件依次填入。
• CardLayout（卡片布局）： 像一叠扑克牌，每次只显示一张（一个组件），常用于实现选项卡切换效果。
• GridBagLayout（网格袋布局）： 最复杂、最灵活的布局，支持组件跨行跨列、按比例缩放，学习成本较高。

委托事件模型

AWT 采用了委托事件模型（Delegation Event Model）。当用户触发某个操作（如点击按钮）时，组件本身不处理这个事件，而是将事件“委托”给专门的监听器对象来处理。

这个模型包含三个核心要素：

1. 事件源 (Event Source)： 触发事件的 GUI 组件（例如 Button）。

2. 事件对象 (Event)： 封装了事件发生时的一切信息（例如 ActionEvent 包含了点击的按钮对象、时间戳等）。

3. 事件监听器 (Event Listener)： 负责接收并处理事件的接口（例如 ActionListener）。

代码示例：点击按钮关闭窗口

Frame frame = new Frame("AWT 示例");
Button btn = new Button("Click Me");

// 为按钮添加动作监听器
btn.addActionListener(new ActionListener() {
  @Override
  public void actionPerformed(ActionEvent e) {
    System.out.println("按钮被点击了！");
  }
});

为了避免实现监听器接口时必须重写所有抽象方法的麻烦，AWT 还提供了适配器类（Adapter）（如 WindowAdapter），你只需要重写你关心的那个方法即可（如 windowClosing）。

public void testActionListener() {
  Frame frame = new Frame("AWT Demo");
  Button button = new Button("Button");

  frame.add(button);
  frame.setSize(300, 200);

  frame.addWindowListener(new WindowAdapter() {
    @Override
    public void windowClosing(WindowEvent e) {
      System.exit(0);
    }
  });

  button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
      System.out.println("按钮被点击了：" + e);
    }
  });

  frame.setVisible(true);
}

绘图与图像处理

AWT 提供了强大的 2D 图形绘制能力，这主要依赖于 Graphics 类（在 Java 2D 中被扩展为 Graphics2D）。

• 工作原理： 每个 Component 都有一个 paint(Graphics g) 方法。当组件需要重绘时（如窗口首次显现、被遮挡后重新暴露、或者手动调用了 repaint()），JVM 就会自动调用这个方法。
• 常用操作：
  • 绘制线条与几何图形：g.drawLine(), g.drawRect(), g.fillOval()
  • 设置颜色与字体：g.setColor(Color.RED), g.setFont(new Font(...))
  • 绘制图片：g.drawImage(Image img, ...)

AWT vs Swing

提起 AWT，必然会谈到 Swing。它们之间最核心的区别在于组件的绘制方式：

特性	java.awt (AWT)	javax.swing (Swing)
组件类型	重量级组件 (Heavyweight)	轻量级组件 (Lightweight)
绘制原理	依赖操作系统底层的原生对等体（Peer）。AWT 的 Button 在 Windows 上就是 Windows 按钮，在 Mac 上就是 Mac 按钮。	几乎完全由 Java 代码在空白画布上“画”出来的，不依赖系统原生组件。
跨平台一致性	较差。不同操作系统上外观和行为可能不一致，甚至有些系统不支持某些特性。	极好。在任何操作系统上看起来都一模一样。
外观定制	无法轻松更改外观。	支持一键切换皮肤（如金属风、Windows 风、Mac 风）。

AWT 当前定位

既然 Swing 和 JavaFX 更好，那 AWT 是不是彻底报废了？并不是。

1. Swing 是建在 AWT 之上的： Swing 的组件（如 JFrame, JButton）全部继承自 AWT 的 Container 或 Component。Swing 的事件机制、布局管理器、字体（Font）、颜色（Color）等核心类，直接沿用了 java.awt 包中的定义。

2. 桌面集成： java.awt.Desktop 类允许 Java 程序调用操作系统的默认浏览器打开网页、调用默认邮件客户端、或者打开本地文件。

3. 系统托盘： java.awt.SystemTray 和 java.awt.TrayIcon 可以用来开发隐藏在电脑右下角（或右上角）的后台系统托盘程序。

事件处理机制

Java 中的事件处理机制是让图形用户界面（GUI）具备交互能力的灵魂。不管是点击按钮、拖动滑块，还是敲击键盘、关闭窗口，程序能够对这些用户操作做出响应，全靠这套机制在幕后运转。

Java 统一采用的是委托事件模型（Delegation Event Model）。下面为你详细拆解这套机制的核心概念、运作流程和常见实现方式。

核心要素

委托事件模型的三个核心要素：

在委托事件模型中，当一件事情发生时，产生事件的组件并不会自己去处理它，而是把这个事件“委托”给一个独立的外部对象（监听器）去处理。整个模型围绕三个核心要素展开：

• 事件源 (Event Source)：

  是谁触发的？ 它是能够产生事件的 GUI 组件，例如 Button（按钮）、TextField（文本框）、Frame（窗口）等。

• 事件对象 (Event Object)：

  发生了什么事？ 当用户操作事件源时，系统会自动创建一个对应的事件对象。这个对象封装了事件发生时的一切额外信息（比如点击的坐标、触发的时间、是哪个按钮被点了、按下了键盘的哪个键等）。所有事件类都继承自 java.util.EventObject。

• 事件监听器 (Event Listener)：

  谁来处理？ 这是一个接口（Interface），定义了收到某种事件后应该执行的方法。开发者需要编写类来实现这个接口，把具体的业务逻辑（比如“点击按钮后保存文件”）写在里面。

事件处理流程

我们可以用“邮寄快递”来形象地比喻这个过程：

1. 登记（注册监听器）： 监听器向事件源登记，告诉事件源：“如果你这里有动静，记得通知我”。对应代码：button.addActionListener(listener);

2. 触发（用户操作）： 用户用鼠标点击了按钮（事件源）。

3. 打包（生成事件对象）： 操作系统和 JVM 捕捉到操作，自动将点击行为打包成一个 ActionEvent 对象。

4. 派送（回调方法）： 按钮（事件源）把这个打包好的 ActionEvent 对象丢给之前登记过的监听器，自动调用监听器内部的 actionPerformed(e) 方法。

5. 签收（逻辑执行）： 监听器在方法内部读取事件信息，并执行相应的代码逻辑。

事件类型

Java 的 AWT 和 Swing 提供了丰富的事件类型，它们大多存放在 java.awt.event 和 javax.swing.event 包中。常见的有以下几种：

事件源操作	对应的事件类 (Event)	对应的监听器接口 (Listener)	对应的适配器类 (Adapter)
点击按钮、菜单项，文本框回车	ActionEvent	ActionListener	无（只有一个方法，无需适配器）
鼠标点击、移动、进入、离开	MouseEvent	MouseListener MouseMotionListener	MouseAdapter
键盘敲击、按下、释放	KeyEvent	KeyListener	KeyAdapter
窗口打开、关闭、最小化、激活	WindowEvent	WindowListener	WindowAdapter
下拉框选择项改变、复选框勾选	ItemEvent	ItemListener	无

💡 什么是适配器类（Adapter）

像 WindowListener 这样的接口里面定义了 7 个抽象方法（windowClosing, windowOpened 等）。如果我们直接实现接口，即使只想用其中一个关闭功能，也必须把剩下 6 个没用的方法都重写一遍，代码非常臃肿。

为此，Java 提供了对应的适配器类（如 WindowAdapter），它默认把接口里的所有方法都做成了“空实现”。我们只需要继承适配器，然后重写我们关心的那一个方法即可。

事件监听器实现演进

随着 Java 语法的演进，实现事件监听器的方法越来越简洁。我们以“点击按钮控制台打印”为例，看看它的四种写法：

写法1：外部独立类

将监听器写成一个单独的 .java 文件。缺点是难以直接访问主窗口中的其他组件变量。

// 独立定义的监听器类（独立的 .java 文件）
public class MyButtonListener implements ActionListener {
  @Override
  public void actionPerformed(ActionEvent e) {
    System.out.println("按钮被点击了！");
  }
}

// 在主窗口中使用
button.addActionListener(new MyButtonListener());

写法2：内部类

将监听器写在窗口类的内部。好处是内部类可以直接访问外部窗体的所有私有属性和组件。

public class MyWindow extends Frame {
  private Button button = new Button("Click");

  public MyWindow() {
    // 注册内部类监听器
    button.addActionListener(new ButtonClickHandler());
  }

  // 内部类
  private class ButtonClickHandler implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
      // 可以直接操作外部类的 button 对象
      button.setLabel("Clicked!");
    }
  }
}

写法3：匿名内部类

不需要给监听器类起名字，直接在 add...Listener 的参数里 new 出来。在 Java 8 之前，这是最主流的写法。

button.addActionListener(new ActionListener() {
  @Override
  public void actionPerformed(ActionEvent e) {
    System.out.println("使用匿名内部类处理点击事件");
  }
});

// 使用适配器处理窗口关闭
frame.addWindowListener(new WindowAdapter() {
  @Override
  public void windowClosing(WindowEvent e) {
    System.exit(0);
  }
});

写法4：Lambda 表达式

如果监听器接口是函数式接口（即只有一个抽象方法，如 ActionListener），可以利用 Lambda 表达式将代码精简到极致。

// 极致优雅的一行代码
button.addActionListener(e -> System.out.println("Lambda 表达式触发！"));

示例： AWT 事件处理

下面是一个完整的、包含鼠标移动和按钮点击的 Java AWT 事件处理标准示例：

import java.awt.*;
import java.awt.event.*;

public class EventDemo extends Frame {
  private Button btn = new Button("点我");
  private Label label = new Label("请将鼠标移动到窗口内...", Label.CENTER);

  public EventDemo() {
    setTitle("Java 事件处理机制演示");
    setSize(400, 300);
    setLayout(new BorderLayout());
    setLocationRelativeTo(null);

    // 组装组件
    add(btn, BorderLayout.SOUTH);
    add(label, BorderLayout.CENTER);

    // 1. 动作事件：使用 Lambda 表达式响应按钮点击
    btn.addActionListener(e -> {
      label.setText("按钮被宠幸了！触发事件的对象是: " + e.getSource().getClass().getName());
    });

    // 2. 鼠标运动事件：使用匿名内部类/适配器监听鼠标坐标
    this.addMouseMotionListener(new MouseMotionAdapter() {
      @Override
      public void mouseMoved(MouseEvent e) {
        // 实时获取鼠标当前的 X 和 Y 坐标
        label.setText("鼠标当前位置: X=" + e.getX() + ", Y=" + e.getY());
      }
    });

    // 3. 窗口事件：处理右上角的关闭按钮 'X'
    this.addWindowListener(new WindowAdapter() {
      @Override
      public void windowClosing(WindowEvent e) {
        System.out.println("窗口正在关闭，释放资源...");
        dispose();
        System.exit(0);
      }
    });
  }

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

总结

Java 的事件处理机制之所以设计得这么绕（又是对象又是接口），核心目的就是为了解耦。界面长什么样（事件源）和按下之后去干什么（监听器业务逻辑）被完全隔离开来。这种解耦思想不仅在 AWT/Swing 中使用，在现代的 Android 开发、前端 Web 事件流、甚至是后端的消息队列（MQ）架构中，都能看到它演变后的影子。

Component~

在 Java 的 GUI 编程世界中，java.awt.Component 是一个举足轻重的存在。它是除窗口菜单相关类之外，所有可视化组件的终极始祖（抽象父类）。

无论是原生的 AWT 组件（如 Button、TextField），还是现代 Swing 组件的基础（JComponent），它们的体内都流淌着 Component 的血液。理解了 Component，就等于掌握了 Java 界面控件通用行为的“总钥匙”。

基本语法

先来看看它的官方定义拓扑：

public abstract class Component implements ImageObserver, MenuContainer, Serializable

• abstract（抽象类）： 你不能直接 new Component()。它只负责定义通用规则和提供公共方法，具体的绘制和行为交由子类（如 Button、Label）去实现。
• 接口实现：
  • ImageObserver：用于异步接收关于图像加载进度的通知（早期网页/网速慢时的历史产物）。
  • MenuContainer：表明它有能力作为菜单的容器（虽然通常窗口类才会真正用到）。

Peer 机制

理解 Component 的工作原理，不能绕开 Peer（对等体） 概念。

在纯 AWT 时代，Component 内部持有一个叫 peer 的引用（ComponentPeer）。当你创建一个 java.awt.Button 时，Java 并没有真正的去画这个按钮，而是通过 Peer 机制去调用当前操作系统的底层 API（比如 Windows 的 User32.dll 或 macOS 的 Cocoa 框架），在对应位置生成一个操作系统原生的按钮。

这就导致：

• Component 是一个重量级组件。
• 它的很多销毁动作需要依赖 dispose() 或由系统回收原生资源。

与 Swing 的纽带

到了 Swing 时代，为了摆脱操作系统原生组件的限制，引入了 javax.swing.JComponent。然而，JComponent 并没有脱离 AWT，而是继承自 java.awt.Container（Container又是Component 的直接子类）。

因此：

• 你在 JButton 或 JPanel 上调用 setBounds(), setBackground(), setVisible()，实际上执行的依然是祖先类 java.awt.Component 里的代码。
• Swing 改变的是 paint() 机制，演进出了 paintComponent(), paintBorder(), paintChildren() 等更细腻的轻量级绘制流程，但其根基依然长在 Component 提供的肥沃土壤上。

API：Component

构造方法

• Component Component()：()，构造方法。初始化组件的默认状态。由于此类为抽象类，该构造方法仅供子类（如 Button、Canvas）在实例化时隐式或显式调用。

  import java.awt.Canvas;
  
  public class ComponentConstructorDemo {
    public static void main(String[] args) {
      // Component 是抽象类，通过实例化其标准子类 Canvas 来触发 Component() 构造逻辑
      Canvas customCanvas = new Canvas();
      System.out.println("组件已成功初始化，内部已执行 Component 基础构造。");
    }
  }

几何与布局属性

• int getX()：()，获取当前组件左上角的 X 坐标。返回组件相对于其父容器原点（左上角）的当前 X 轴绝对像素坐标。

• int getY()：()，获取当前组件左上角的 Y 坐标。返回组件相对于其父容器原点（左上角）的当前 Y 轴绝对像素坐标。

• int getWidth()：()，获取组件当前的宽度。返回该组件在当前屏幕渲染状态下占用的水平像素宽度。

• int getHeight()：()，获取组件当前的高度。返回该组件在当前屏幕渲染状态下占用的垂直像素高度。

• void setBounds()：(int x, int y, int width, int height)，移动组件并调整其大小。一条指令同时设定组件相对于父容器的左上角坐标（x, y）以及宽度和高度。

• Dimension getPreferredSize()：()，获取组件的首选大小。布局管理器在计算容器布局排版时，会参考此方法返回的期望尺寸来为组件分配合适的空间。

注意事项：

在激活了布局管理器（如 FlowLayout、BorderLayout）的容器中，直接调用 setSize() 或 setBounds() 调整组件大小通常会失效。因为容器在调用 layout() 进行刷新时，布局管理器会根据自身策略和组件的 getPreferredSize() 重新计算并覆盖组件的边界。若想强制改变组件在自动布局下的尺寸，应重写或调用 setPreferredSize(Dimension d)。

import java.awt.Button;
import java.awt.Dimension;

public class ComponentGeometryDemo {
  public static void main(String[] args) {
    Button button = new Button("几何属性测试按钮");

    // 手动设定组件的绝对几何位置与大小
    button.setBounds(50, 50, 150, 40);

    // 打印当前的几何空间属性
    System.out.println("X 坐标: " + button.getX());
    System.out.println("Y 坐标: " + button.getY());
    System.out.println("当前宽度: " + button.getWidth());
    System.out.println("当前高度: " + button.getHeight());

    // 获取布局管理器依赖的首选推荐尺寸
    Dimension prefSize = button.getPreferredSize();
    System.out.println("首选推荐宽度: " + prefSize.width + ", 高度: " + prefSize.height);
  }
}

外观属性

• void setBackground()：(Color c)，设置组件的背景颜色。更改组件未被子组件或文本覆盖区域的底色。

• Color getBackground()：()，获取组件的背景颜色。返回当前组件所使用的背景 Color 对象，若未显式设置则返回父容器的背景色。

• void setForeground()：(Color c)，设置组件的前景颜色。更改组件上文本、线条或标签的主要绘制颜色。

• void setFont()：(Font f)，设置组件的文本字体。指定组件中呈现文本时所使用的字体样式、大小和粗细。

注意事项：

AWT 重量级组件的外观属性具有继承性。如果某个子组件未显式调用 setBackground() 或 setFont()，它将默认返回并继承其父容器的外观属性状态。如果在未挂载到父容器前调用 getBackground()，可能会返回 null。

import java.awt.Button;
import java.awt.Color;
import java.awt.Font;

public class ComponentAppearanceDemo {
  public static void main(String[] args) {
    Button button = new Button("高对比度按钮");

    // 显式调整外观属性
    button.setBackground(Color.BLACK);
    button.setForeground(Color.GREEN);
    button.setFont(new Font("Monospaced", Font.BOLD, 16));

    // 校验外观属性
    System.out.println("背景色: " + button.getBackground());
  }
}

生命周期与状态控制

• void setVisible()：(boolean b)，设置组件的可见状态。参数为 true 时组件在屏幕上渲染，为 false 时隐藏组件且不占用屏幕绘制空间。

• boolean isVisible()：()，检查组件的可见状态。返回组件自身是否被设置为可见。

• void setEnabled()：(boolean b)，设置组件的启用状态。参数为 false 时组件进入禁用状态（通常表现为置灰），此时它将拒绝接收任何来自操作系统的鼠标或键盘输入事件。

• void invalidate()：()，标记组件为失效状态。通知其父容器该组件的几何属性或内部状态已发生改变，原有的布局缓存已失效，需要重新进行布局计算。

注意事项：

当动态地向容器内添加、移除组件或动态更改子组件的 PreferredSize 后，必须首先对该组件调用 invalidate() 标记失效，随后对其父容器调用 validate()，才能迫使布局管理器重新执行排版、计算最新尺寸并呈现在屏幕上。

import java.awt.Button;

public class ComponentLifecycleDemo {
  public static void main(String[] args) {
    Button button = new Button("控制状态按钮");

    button.setVisible(true);
    System.out.println("组件显式可见性: " + button.isVisible());

    // 禁用组件，使其无法被用户点击
    button.setEnabled(false);

    // 变更状态后标记几何结构失效，准备让父容器重新排版
    button.invalidate();
  }
}

绘图机制

• void paint()：(Graphics g)，绘制组件的底层核心方法。当组件因初次显示、窗口暴露或大小调整而需要展示自身外观时，由操作系统的 AWT 线程自动回调该方法，并传入核心画笔对象 Graphics。

• void repaint()：()，请求异步重新绘制组件。向系统的事件分发线程（EDT）发送一个异步的重绘请求，系统稍后会在最合适的时机调用该组件的 update() 方法。

• void update()：(Graphics g)，更新组件的绘制。默认实现是先使用背景色擦除组件现有区域（清屏），然后再调用 paint() 方法。

注意事项：

1. 严禁在代码中直接人工调用 paint(Graphics g) 方法。若需要刷新界面外观，必须通过调用 repaint() 触发 AWT 系统的标准化重绘流程，否则会导致绘制上下文脱离操作系统调度，引发严重的界面图形残留或闪烁。
2. AWT 重量级组件的 update() 默认执行的“全屏擦除”是导致 AWT 界面在频繁重绘时发生强烈闪烁（Flicker） 的核心原因。在编写高级自定义组件时，通常需要重写 update() 方法以跳过清屏步骤，或采用双缓冲技术（Double Buffering）进行绘制。

import java.awt.Canvas;
import java.awt.Graphics;

public class ComponentPaintingDemo {
  public static void main(String[] args) {
    // 创建一个重写了绘图生命周期方法的自定义组件
    Canvas customCanvas = new Canvas() {
      @Override
      public void paint(Graphics g) {
        // 由系统内部或 repaint() 异步引发回调
        g.drawString("自定义绘制文本", 20, 20);
      }

      @Override
      public void update(Graphics g) {
        // 重写 update 可以优化擦除逻辑，减少闪烁
        System.out.println("系统正在调度更新重绘机制...");
        super.update(g);
      }
    };

    // 发起异步重绘请求
    customCanvas.repaint();
  }
}

事件监听与焦点机制

• void addMouseListener()：(MouseListener l)，注册鼠标事件监听器。用于捕获和处理发生在当前组件几何边界内的鼠标点击、按下、释放、进入和离开等底层硬件原生输入事件。

• void addKeyListener()：(KeyListener l)，注册键盘事件监听器。用于捕获当前组件在激活状态下所接收到的键盘按键敲击、按下与释放事件。

• void setFocusable()：(boolean focusable)，设置组件是否允许接收输入焦点。如果设为 false，则该组件永远无法通过鼠标点击或 Tab 键轮转获取键盘焦点。

• void requestFocus()：()，请求获取输入焦点。强制让当前组件尝试成为键盘输入事件的直接接收目标。

注意事项：

一个组件能够成功通过 requestFocus() 夺取焦点并接收键盘事件的前提是：它必须同时满足可见（Visible == true）、启用（Enabled == true） 且可接收焦点（Focusable == true） 这三个核心前置状态，否则该焦点请求将被系统底层直接丢弃。

import java.awt.Canvas;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

public class ComponentEventDemo {
  public static void main(String[] args) {
    Canvas interactionCanvas = new Canvas();

    // 开启焦点权限
    interactionCanvas.setFocusable(true);

    // 挂载鼠标事件监听
    interactionCanvas.addMouseListener(new MouseAdapter() {
      @Override
      public void mouseClicked(MouseEvent e) {
        // 点击时主动夺取键盘焦点
        interactionCanvas.requestFocus();
        System.out.println("鼠标点击组件，触发焦点请求。");
      }
    });

    // 挂载键盘事件监听
    interactionCanvas.addKeyListener(new KeyAdapter() {
      @Override
      public void keyPressed(KeyEvent e) {
        System.out.println("组件接收到键盘按键，键码: " + e.getKeyCode());
      }
    });
  }
}

实战：交互式画布组件

以下提供一个基于原生 java.awt.Component 的高阶自定义交互式画布组件。该案例融会贯通了前文所述的几何边界探测、外观颜色继承、无闪烁双缓冲绘图、生命周期维护、键盘焦点抢占及鼠标动态事件响应。代码经过模块化严谨编写，可直接复制至独立的 .java 文件中编译运行。

import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

/**
 * 严谨设计的自定义交互式画布组件
 * 深度应用 java.awt.Component 的核心几何、绘图、外观、焦点与事件模型
 */
public class InteractiveCanvas extends Component {

  private int mouseClickCount = 0;
  private String lastPressedKey = "None";
  private boolean isMouseHovering = false;

  // 双缓冲技术专用临时离屏画布，杜绝 AWT 绘图闪烁
  private Image offScreenBufferImage = null;
  private Graphics offScreenBufferGraphics = null;

  public InteractiveCanvas() {
    // 初始化几何首选尺寸，以便布局管理器自适应收缩
    this.setPreferredSize(new Dimension(500, 350));

    // 确立组件的外观初始化配置
    this.setBackground(new Color(245, 246, 250));
    this.setForeground(new Color(47, 53, 66));
    this.setFont(new Font("Monospaced", Font.BOLD, 15));

    // 开启焦点获焦资格
    this.setFocusable(true);

    // 初始化复合型事件流监听机制
    this.initEventInteractions();
  }

  private void initEventInteractions() {
    // 鼠标行为核心交互流
    this.addMouseListener(new MouseAdapter() {
      @Override
      public void mousePressed(MouseEvent e) {
        mouseClickCount++;
        // 引导用户的交互点击抢占键盘输入焦点
        boolean focusResult = requestFocusInWindow();
        System.out.println("焦点抢占请求执行状态: " + focusResult);
        repaint(); // 请求异步更新渲染
      }

      @Override
      public void mouseEntered(MouseEvent e) {
        isMouseHovering = true;
        repaint();
      }

      @Override
      public void mouseExited(MouseEvent e) {
        isMouseHovering = false;
        repaint();
      }
    });

    // 键盘按键捕获流
    this.addKeyListener(new KeyAdapter() {
      @Override
      public void keyPressed(KeyEvent e) {
        lastPressedKey = KeyEvent.getKeyText(e.getKeyCode());
        // 当按下 ESC 键时，提供清空重置计数器的快捷交互
        if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
          mouseClickCount = 0;
          lastPressedKey = "Reset";
        }
        repaint();
      }
    });
  }

  /**
   * 覆盖底层的 update 机制，手工切断 AWT 默认清屏带来的图像闪烁
   */
  @Override
  public void update(Graphics g) {
    // AWT重量级组件默认会调用清除背景，此处直接拦截并分流至 paint 逻辑
    paint(g);
  }

  /**
   * 自定义高级渲染逻辑核心
   */
  @Override
  public void paint(Graphics g) {
    int currentWidth = this.getWidth();
    int currentHeight = this.getHeight();

    // 运用生命周期与物理尺寸，构建/重建双缓冲离屏画布
    if (offScreenBufferImage == null
        || offScreenBufferImage.getWidth(null) != currentWidth
        || offScreenBufferImage.getHeight(null) != currentHeight) {

      offScreenBufferImage = this.createImage(currentWidth, currentHeight);
      if (offScreenBufferGraphics != null) {
        offScreenBufferGraphics.dispose();
      }
      offScreenBufferGraphics = offScreenBufferImage.getGraphics();
    }

    // 获取当前离屏画笔句柄开始绘制
    Graphics bgG = offScreenBufferGraphics;

    // 1. 根据鼠标悬停状态调整背景色填充
    if (isMouseHovering) {
      bgG.setColor(new Color(220, 221, 225));
    } else {
      bgG.setColor(this.getBackground());
    }
    bgG.fillRect(0, 0, currentWidth, currentHeight);

    // 2. 几何外框线绘制
    bgG.setColor(hasFocus() ? new Color(74, 105, 189) : new Color(116, 125, 140));
    bgG.drawRect(15, 15, currentWidth - 30, currentHeight - 30);
    bgG.drawRect(17, 17, currentWidth - 34, currentHeight - 34);

    // 3. 应用继承的前景色与字体进行文本度量渲染
    bgG.setColor(this.getForeground());
    bgG.setFont(this.getFont());

    bgG.drawString("组件物理几何宽度 : " + currentWidth + " px", 40, 60);
    bgG.drawString("组件物理几何高度 : " + currentHeight + " px", 40, 95);
    bgG.drawString("左键点击计数统计 : " + mouseClickCount, 40, 140);
    bgG.drawString("最后捕获键盘按键 : [ " + lastPressedKey + " ]", 40, 185);

    // 4. 渲染当前的焦点状态指示器
    if (hasFocus()) {
      bgG.setColor(new Color(78, 205, 196));
      bgG.drawString("● 键盘控制流已激活 (按下 ESC 键重置计数)", 40, 250);
    } else {
      bgG.setColor(new Color(255, 107, 107));
      bgG.drawString("○ 处于脱焦状态 (请点击画布内部区域以激活焦点)", 40, 250);
    }

    // 5. 最终将内存中绘制就绪的离屏图像一次性拷贝至真实的系统屏幕窗口，实现零闪烁
    g.drawImage(offScreenBufferImage, 0, 0, this);
  }

  /**
   * 提供直接可运行的主函数入口，构建 AWT 的顶层生命周期容器容器环境
   */
  public static void main(String[] args) {
    // 创建 AWT 基础窗体生命周期实例
    Frame mainFrame = new Frame("AWT Component 终极实战验证架构");
    InteractiveCanvas interactiveCanvas = new InteractiveCanvas();

    // 将自定义组件装载进窗体
    mainFrame.add(interactiveCanvas);

    // 触发布局管理器计算并验证整棵组件树的大小
    mainFrame.pack();

    // 全局物理屏幕居中放置
    mainFrame.setLocationRelativeTo(null);

    // 激活底层的对等体并展示界面
    mainFrame.setVisible(true);

    // 优雅处理顶层窗体的关闭销毁生命周期
    mainFrame.addWindowListener(new WindowAdapter() {
      @Override
      public void windowClosing(WindowEvent e) {
        System.out.println("程序正常安全退出。");
        System.exit(0);
      }
    });
  }
}

Container~【

Frame~

在 Java 的 AWT 编程中，java.awt.Frame 是开发独立桌面应用程序时最核心的顶级容器。

简单来说，Frame 就是我们日常在操作系统中看到的带标题栏、带边框、带最小化/最大化/关闭按钮的“标准窗口”。与不能独立存在的 Panel 不同，Frame 是一个可以独立显示的窗口主体。

继承体系

要理解 Frame 的底层能力，先看它的家族谱系：

• Window 的子类： Window 类提供了一个没有边框和菜单栏的空白视口。Frame 继承并扩展了它，加入了标题栏、边框、菜单栏和窗口控制按钮。
• Container 的派生类： 作为一个容器，Frame 拥有容纳其他原子组件（如按钮、文本框）和管理布局（Layout）的能力。

核心特性与默认行为

在使用 Frame 时，有几个非常关键的“默认规则”需要牢记，这也是初学者最容易踩坑的地方：

• 默认不可见： 新建一个 Frame 对象后，它是隐藏在内存中的。你必须显式调用 setVisible(true)，窗口才会真正绘制在屏幕上。
• 默认布局管理器是 BorderLayout： 如果你直接向 Frame 中添加（add）组件而不指定区域，它会默认填满整个中央区域（CENTER），并且后添加的组件会覆盖先添加的组件。
• 默认大小为 0×0： 如果不使用 setSize() 或 pack()，弹出的窗口会变成一个几乎看不见的小点。
• 点击关闭按钮默认“无响应”： 这是一个经典设计的历史遗留。当你点击窗口右上角的 X 时，窗口并不会自动关闭，你必须手动编写窗口事件监听器。

API：Frame

构造方法

• Frame Frame()：()，基础构造方法。创建一个初始不可见、默认标题为空字符串的 Frame 窗口。

• Frame Frame()：(String title)，带标题的构造方法。创建一个初始不可见、使用指定标题字符串的 Frame 窗口。常用于需要明确标识应用名称的桌面端主界面。

注意事项：

所有 Frame 的构造方法在执行完毕后，生成的窗口实例默认都是不可见（visible == false）的。必须在初始化配置完成后，显式调用 setVisible(true) 才能将其呈现在屏幕上。

import java.awt.Frame;

public class FrameConstructorDemo {
  public static void main(String[] args) {
    // 1. 触发无参构造
    Frame blankFrame = new Frame();
    blankFrame.setSize(300, 200);
    blankFrame.setVisible(true);

    // 2. 触发带标题构造
    Frame titledFrame = new Frame("生产级标准标题");
    titledFrame.setSize(300, 200);
    titledFrame.setLocation(400, 100); // 错开显示位置
    titledFrame.setVisible(true);
  }
}

窗体状态与外观控制

• void setTitle()：(String title)，设置窗体标题。动态修改窗口标题栏中显示的文本内容。

• String getTitle()：()，获取窗体标题。返回当前窗口标题栏中的文本内容。若未设置则返回空字符串。

• void setResizable()：(boolean resizable)，设置窗体是否可调整大小。控制用户是否可以通过拖拽边缘或点击最大化按钮来改变窗口尺寸。

• boolean isResizable()：()，判断窗体是否可调整大小。返回当前窗口是否允许用户手动调整尺寸。

• void setUndecorated()：(boolean undecorated)，禁用或启用窗体装饰。移除或恢复窗口的标题栏、边框以及操作系统原生的控制按钮（如最小化、关闭）。

• void setExtendedState()：(int state)，设置窗口扩展状态。控制窗口的最大化、最小化或正常状态，状态值采用 Frame 类定义的整型常量（如 Frame.MAXIMIZED_BOTH 代表全屏最大化）。

注意事项：

调用 setUndecorated(true) 方法时，必须在窗口显式渲染（即调用 setVisible(true) 或 pack()）之前执行。如果窗口已经处于可显示（Displayable）状态，调用该方法将抛出 IllegalComponentStateException 运行时异常。

import java.awt.Frame;

public class FrameStateDemo {
  public static void main(String[] args) {
    Frame frame = new Frame("原始标题");

    // 动态修改标题
    frame.setTitle("更变后的技术标准标题");

    // 锁定窗体大小，禁止用户手动拖拽缩放
    frame.setResizable(false);

    // 移除操作系统默认的边框和标题栏（必须在 setVisible 之前调用）
    frame.setUndecorated(true);

    frame.setSize(500, 400);
    frame.setVisible(true);

    // 演示通过多线程延迟展示窗口最大化状态
    try {
      Thread.sleep(2000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    // 创建另一个标准窗口演示最大化状态
    Frame maxFrame = new Frame("全屏最大化窗口");
    // 设置状态为水平和垂直方向同时最大化
    maxFrame.setExtendedState(Frame.MAXIMIZED_BOTH); // windows 不支持水平/垂直最大化
    maxFrame.setVisible(true);
  }
}

窗体生命周期与全局管理

• void setVisible()：(boolean b)，Window，设置窗体可见性。参数为 true 时将窗口显示在屏幕上并调至最前，为 false 时隐藏窗口。

• void pack()：()，Window，调整窗体至最佳大小。根据窗口内部子组件的首选大小（Preferred Size）自动计算并调整当前 Frame 的内部有效尺寸。

• void dispose()：()，Window，释放窗体资源。销毁当前窗口及其所有子组件，彻底释放底层操作系统占用的原生屏幕及系统句柄资源。

• Frame[] Frame.getFrames()：()，获取所有 Frame 实例。静态工具方法，返回当前应用（JVM 进程）内创建的所有 Frame 对象的关联数组。

注意事项：

1. 监听窗口关闭事件：点击 Frame 窗口右上角的 “X” 关闭按钮时，底层 AWT 仅会触发 WindowEvent 事件，默认不会执行任何隐藏或销毁窗口的操作。必须显式调用 dispose() 或 System.exit(0)，程序才能真正退出。
2. 当应用中最后一个可显示的窗口被调用 dispose() 释放后，AWT 的事件分发线程（Event Dispatch Thread, EDT）才会安全终止，JVM 进程随之正常结束。

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

public class FrameLifecycleDemo {
  public static void main(String[] args) {
    Frame frame = new Frame("生命周期与全局管理示例");
    frame.add(new Button("AWT 核心标准按钮"));

    // 依据按钮的首选大小自动紧凑包裹窗体
    frame.pack();
    frame.setVisible(true);

    // 获取并打印当前 JVM 内激活的 Frame 数量
    Frame[] activeFrames = Frame.getFrames();
    System.out.println("当前系统中的 Frame 总数: " + activeFrames.length);

    try {
      Thread.sleep(3000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    // 释放原生屏幕资源，关闭窗口并终止 AWT 线程
    // System.exit(0); // 后续打印不会执行
    frame.dispose(); // 后续打印会执行
    System.out.println("窗体资源已安全释放。");
  }
}

监听窗口关闭事件

正如前面所提，AWT 的 Frame 在点击 X 时默认不关闭。要让它正常工作，必须利用委托事件模型，为其注册一个 WindowListener。

通常我们使用 WindowAdapter（适配器类）来简化代码，只重写 windowClosing 方法：

Frame frame = new Frame("我的窗口");

// 监听窗口关闭事件
frame.addWindowListener(new WindowAdapter() {
  @Override
  public void windowClosing(WindowEvent e) {
    // 释放窗口资源
    frame.dispose();
    // 结束 Java 虚拟机进程（如果是主窗口）
    System.exit(0);
  }
});

完整代码示例

下面是一个展示如何创建 Frame、设置布局、添加组件并处理关闭事件的完整标准示例：

import java.awt.*;
import java.awt.event.*;

public class AwtFrameDemo {
  public static void main(String[] args) {
    // 1. 创建窗口并设置标题
    Frame frame = new Frame("Java AWT Frame 示例");

    // 2. 设置窗口初始大小与在屏幕上的位置
    frame.setSize(400, 300);
    frame.setLocationRelativeTo(null); // 居中显示

    // 3. 修改默认布局为流式布局（FlowLayout），方便添加多个组件
    frame.setLayout(new FlowLayout());

    // 4. 创建并添加组件
    Label label = new Label("欢迎来到 AWT 世界！");
    Button button = new Button("点击关闭");

    frame.add(label);
    frame.add(button);

    // 5. 为按钮添加点击事件
    button.addActionListener(new ActionListener() {
      @Override
      public void actionPerformed(ActionEvent e) {
        System.exit(0);
      }
    });

    // 6. 为窗口右上角的 'X' 绑定关闭逻辑
    frame.addWindowListener(new WindowAdapter() {
      @Override
      public void windowClosing(WindowEvent e) {
        System.exit(0);
      }
    });

    // 7. 最后一步：让窗口可见
    frame.setVisible(true);
  }
}

Frame 到 JFrame

从 AWT Frame 到 Swing JFrame 的演进：

在实际开发中，如果你接触到较新的项目，你会更多地看到 javax.swing.JFrame。

JFrame 是 Frame 的直接子类，它不仅继承了 Frame 的所有窗口管理能力，还做出了以下重大改进：

1. 轻量级绘制： Frame 的边框和内部完全依赖操作系统的 Peer 渲染，而 JFrame 的内容区是由 Java 自己画出来的。

2. 内置关闭操作： JFrame 提供了 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) 方法，一行代码就能解决 AWT 时代必须写一堆监听器才能关闭窗口的痛点。

3. 多层面板架构（RootPane）： JFrame 引入了根面板、内容面板（ContentPane）和玻璃面板（GlassPane）的概念，使得在窗口上实现复杂的图层叠加、菜单挂载和动画变得极为简单。

Graphics~

在 Java 的图形界面（AWT/Swing）开发中，java.awt.Graphics 类扮演着极其重要的角色。简单来说，它就像是你的“画笔与画布”。

每个 Graphics 对象都是一个图形上下文（Graphics Context），它封装了绘制图形、文本和图像所需的状态信息（如当前颜色、字体、剪裁区域等）以及具体的绘制方法。

坐标系统

Java AWT 的坐标系与我们数学中的直角坐标系略有不同：

• 原点 $(0,0)$：位于画布的左上角。
• X 轴：从左向右水平延伸（数值变大）。
• Y 轴：从上向下垂直延伸（数值变大）。
• 单位：像素（Pixel）。

获取 Graphics 对象的途径

通常情况下，你不需要也不应该自己通过 new 去实例化一个 Graphics 对象（因为它是抽象类）。你主要通过以下两种方式获得它：

1. 系统回调（最常见）：在重写 Swing 组件的 paintComponent(Graphics g) 或 AWT 组件的 paint(Graphics g) 方法时，系统会自动传入一个 Graphics 对象。

2. 主动创建（如内存画板）：在对 BufferedImage 等图片对象进行离屏绘制时，调用 image.createGraphics() 获取，使用完毕后必须手动调用 g.dispose() 释放资源。

API：Graphics

状态配置与管理

• void setColor()：(Color c)，设置颜色。将此图形上下文的当前颜色设置为指定颜色。后续所有的几何绘制和文本渲染都将应用此颜色。

• void setFont()：(Font font)，设置字体。将此图形上下文的字体设置为指定字体。后续所有的文本绘制将使用该字体。

• void translate()：(int x, int y)，平移坐标原点。将图形上下文的坐标原点平移至当前坐标系的 (x, y) 位置。后续操作将基于新原点进行相对计算。

• void clipRect()：(int x, int y, int width, int height)，限制绘制区域。将当前区与指定的矩形相交。图形渲染将被限制在新的剪切区边界之内，超出部分将被丢弃。

  // 1. 设置渲染上下文的状态
  g.setColor(Color.BLUE);
  g.setFont(new Font("SansSerif", Font.BOLD, 14));
  
  // 2. 平移坐标原点，简化后续的相对坐标绘制
  g.translate(50, 50);
  
  // 3. 限制绘制区域，防止渲染溢出
  g.clipRect(0, 0, 300, 200);

几何图形绘制

• void drawLine()：(int x1, int y1, int x2, int y2)，绘制线段。使用当前颜色在点 (x1, y1) 和 (x2, y2) 之间绘制一条 1 像素宽度的线段。

• void drawRect()：(int x, int y, int width, int height)，绘制空心矩形。绘制指定矩形的边框。矩形的左边缘位于 x，右边缘位于 x + width，上边缘位于 y，下边缘位于 y + height。

• void fillRect()：(int x, int y, int width, int height)，绘制实心矩形。填充指定的矩形区域，使用当前颜色将其刷满。

• void drawOval()：(int x, int y, int width, int height)，绘制空心椭圆。绘制外接矩形由 (x, y, width, height) 决定的椭圆或圆形的边框。x, y位于椭圆左上角。

• void fillOval()：(int x, int y, int width, int height)，绘制实心椭圆。填充外接矩形由 (x, y, width, height) 决定的椭圆或圆形区域。x, y位于椭圆左上角。

  // 1. 绘制基本线段
  g.drawLine(10, 10, 150, 10);
  
  // 2. 绘制与填充空心/实心矩形
  g.drawRect(10, 30, 80, 40);
  g.fillRect(100, 30, 80, 40);
  
  // 3. 绘制与填充空心/实心圆（当宽高相等时为正圆）
  g.drawOval(10, 90, 60, 60);
  g.fillOval(100, 90, 60, 60);

文本与图像绘制

• void drawString()：(String str, int x, int y)，绘制文本。使用当前字体和颜色绘制指定的字符串。
  注意：(x, y) 坐标代表文本基线（Baseline）的左端点位置，而非文本矩形的左上角。

• boolean drawImage()：(Image img, int x, int y, ImageObserver observer)，绘制图像。将指定的图像绘制到当前的图形上下文。
  如果图像尚未加载完全，异步回调将通知 ImageObserver，通常在 JPanel 中 observer 可直接传入 this 或 null。

  // 1. 绘制文本，注意其 y 轴基于基线定位
  g.drawString("Production Metric: 95%", 20, 180);
  
  // 2. 绘制图像，通常在 JPanel 中 observer 可直接传入 this 或 null
  Image image = Toolkit.getDefaultToolkit().getImage("icon.png"); // 图片放在 out 目录下
  g.drawImage(image, 20, 200, null);

注意事项

1. 不要长久持有 Graphics 引用：paintComponent 里的 g 对象是临时传给你用的，方法执行完它的使命就结束了。绝不要把它存到全局变量里供其他地方调用。

2. 不要在 paintComponent 里做耗时操作：该方法在窗口缩放、遮挡恢复时会被频繁触发。如果在里面读取文件或进行大计算，会导致界面严重的卡顿。

3. 记得主动触发重绘：如果你改变了某些数据（比如小球的坐标变了），不要手动去调 paint()，而是应该调用组件的 repaint() 方法，让 JVM 找合适的时间帮你调度刷新。

实战：数据可视化看板

以下是一个完整的、可直接运行的 Java Swing 应用程序。该案例通过继承 JPanel 并重写 paintComponent 方法，利用 Graphics API 绘制一个包含网格背景、动态数据条、统计图表和标准文本的数据可视化看板。

package com.technote.graphics;

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

public class DataDashboardPanel extends JPanel {

  public DataDashboardPanel() {
    // 设置面板自身的背景色
    setBackground(new Color(240, 244, 248));
  }

  @Override
  protected void paintComponent(Graphics g) {
    // 必须优先调用父类方法，以执行正确的背景清理与组件底色渲染
    super.paintComponent(g);

    // 1. 绘制网格背景 (几何图形组应用)
    g.setColor(new Color(220, 225, 230));
    int width = getWidth();
    int height = getHeight();
    for (int i = 0; i < width; i += 40) {
      g.drawLine(i, 0, i, height);
    }
    for (int j = 0; j < height; j += 40) {
      g.drawLine(0, j, width, j);
    }

    // 2. 绘制标题与文本状态 (状态管理与文本组应用)
    g.setColor(new Color(33, 37, 41));
    g.setFont(new Font("SansSerif", Font.BOLD, 18));
    g.drawString("System Performance Monitor", 20, 35);

    // 3. 绘制进度状态条 (矩形填充应用)
    int barX = 20;
    int barY = 60;
    int barWidth = 300;
    int barHeight = 25;
    int progressValue = 75; // 模拟进度 75%
    int filledWidth = (barWidth * progressValue) / 100;

    // 绘制进度条背景
    g.setColor(Color.LIGHT_GRAY);
    g.fillRect(barX, barY, barWidth, barHeight);

    // 绘制进度条填充层
    g.setColor(new Color(40, 167, 69)); // 绿色表示正常
    g.fillRect(barX, barY, filledWidth, barHeight);

    // 绘制进度条边框
    g.setColor(Color.DARK_GRAY);
    g.drawRect(barX, barY, barWidth, barHeight);

    // 4. 绘制圆形核心指标盘 (圆形与平移操作应用)
    g.translate(200, 200); // 将原点平移至组件中心区域

    g.setColor(new Color(0, 123, 255)); // 蓝色状态
    g.fillOval(-50, -50, 100, 100);    // 以新原点为中心的圆

    g.setColor(Color.WHITE);
    g.setFont(new Font("Monospaced", Font.BOLD, 22));
    // 将文字居中对齐处理（粗略计算偏移）
    g.drawString("CPU", -20, 8);
  }

  public static void main(String[] args) {
    // 创建独立运行的宿主窗口
    JFrame frame = new JFrame("Java AWT Graphics Component Sandbox");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setSize(500, 400);

    // 组装画布面板
    DataDashboardPanel dashboard = new DataDashboardPanel();
    frame.add(dashboard);

    // 居中并展现
    frame.setLocationRelativeTo(null);
    frame.setVisible(true);
  }
}

Graphics2D~【

其他类【

Stroke~【

Toolkit~【

Panel~【