Java AWT 完整教程

目录

1. 什么是 AWT？
2. AWT 的核心概念
   • 组件
   • 容器
   • 布局管理器
3. 第一个 AWT 程序：Hello World
4. 常用 AWT 组件详解
   • 按钮
   • 文本框
   • 文本区域
   • 复选框
   • 单选按钮
   • 下拉列表
   • 列表
   • 画布
5. 布局管理器详解
   • FlowLayout (流式布局)
   • BorderLayout (边界布局)
   • GridLayout (网格布局)
   • CardLayout (卡片布局)
   • GridBagLayout (网格包布局 - 进阶)
6. 事件处理模型
   • 事件监听器
   • 适配器类
   • 常见事件处理示例
7. AWT 与 Swing 的关系
8. 总结与学习建议

什么是 AWT？

AWT (Abstract Window Toolkit) 是 Java 最早的图形用户界面工具包，它位于 java.awt 包中。

核心特点：

• 平台依赖性: AWT 组件是“重量级”组件，这意味着 AWT 组件的创建和绘制是由底层的操作系统（如 Windows, macOS, Linux）的 GUI 工具完成的，这使得 AWT 程序在不同平台上看起来和感觉都不同。
• 简单易学: 由于其设计相对直接，是学习 GUI 编程的绝佳起点。
• 基础组件: 提供了构建 GUI 所需的基本元素，如按钮、文本框、菜单等。

尽管现在更推荐使用 Swing（AWT 的“轻量级”后续版本），但理解 AWT 对于掌握 Java GUI 的历史和基本原理至关重要。

AWT 的核心概念

在开始编码前，需要理解 AWT 的三个基本概念。

a. 组件

组件是 GUI 的基本构建块，如按钮、标签、文本框等，它们都是 java.awt.Component 类的子类。

• 特点: 可以在屏幕上显示,并可以与用户进行交互。
• 示例: Button, Label, TextField, Checkbox。

b. 容器

容器是一种特殊的组件，它的主要作用是“容纳”其他组件,所有组件都必须被添加到某个容器中才能显示。

• 特点: 它本身也是 Component 的子类，因此可以嵌套（一个面板可以放在另一个窗口中）。
• 两种主要容器:
  1. Window (窗口): 一个独立的顶级窗口，没有边框和菜单栏，不常用，通常使用它的子类 Frame。
  2. Panel (面板): 不能独立存在，必须被添加到另一个 Window 或 Panel 中,常用于对组件进行分组和布局管理。

c. 布局管理器

布局管理器负责决定容器中组件的排列方式、大小和位置，使用布局管理器可以确保 GUI 在不同分辨率和操作系统中都能正确显示。

• 优点: 实现了“一次编写，到处运行”的跨平台特性。
• 常用布局管理器:
  • FlowLayout: 从左到右,从上到下排列。
  • BorderLayout: 将容器分为东、南、西、北、中五个区域。
  • GridLayout: 将容器划分为一个网格,每个组件占据一个格子。
  • CardLayout: 像一叠卡片一样,每次只显示一个组件。

第一个 AWT 程序：Hello World

这是一个最简单的 AWT 程序,创建一个窗口并在其中显示一个按钮。

import java.awt.*;
// 1. 创建一个继承自 Frame 的类，作为主窗口
public class FirstWindow extends Frame {
    public FirstWindow() {
        // 2. 设置窗口标题
        setTitle("我的第一个 AWT 窗口");
        // 3. 设置窗口大小
        setSize(400, 300);
        // 4. 设置窗口的关闭操作
        // 当点击窗口的关闭按钮时，退出程序
        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        // 5. 创建一个组件（一个标签）
        Label label = new Label("你好, AWT World!");
        // 6. 将组件添加到窗口中
        add(label);
        // 7. 设置窗口可见
        setVisible(true);
    }
    // 8. 主方法，程序入口
    public static void main(String[] args) {
        // 创建窗口实例
        new FirstWindow();
    }
}

代码解释:

1. FirstWindow extends Frame: 我们创建一个类继承自 Frame,这样它就具备了窗口的所有功能。
2. setTitle(...): 设置窗口标题栏上显示的文字。
3. setSize(...): 设置窗口的宽度和高度（单位：像素）。
4. addWindowListener(...): 为窗口添加一个事件监听器，这里我们使用匿名内部类 WindowAdapter 来处理窗口关闭事件。System.exit(0) 表示程序正常退出。
5. new Label(...): 创建一个 Label 组件（标签）。
6. add(...): 将组件添加到当前的容器（FirstWindow 实例）中。
7. setVisible(true): 默认情况下，窗口是不可见的,必须调用此方法才能显示出来。
8. main 方法: 程序的入口，在这里我们创建 FirstWindow 的实例。

运行结果: 你会看到一个标题为“我的第一个 AWT 窗口”的窗口，窗口中央有一行文字“你好, AWT World!”。

常用 AWT 组件详解

示例：组合使用组件

import java.awt.*;
public ComponentExample extends Frame {
    public ComponentExample() {
        setTitle("AWT 组件示例");
        setSize(500, 400);
        setLayout(new FlowLayout()); // 使用流式布局
        // 标签
        Label nameLabel = new Label("姓名:");
        // 文本框
        TextField nameField = new TextField(20); // 20列宽
        // 按钮
        Button submitButton = new Button("提交");
        // 复选框
        Checkbox cb1 = new Checkbox("喜欢 Java");
        Checkbox cb2 = new Checkbox("喜欢 Python");
        // 单选按钮
        CheckboxGroup genderGroup = new CheckboxGroup();
        Checkbox maleRadio = new Checkbox("男", genderGroup, true);
        Checkbox femaleRadio = new Checkbox("女", genderGroup, false);
        // 下拉列表
        Choice colorChoice = new Choice();
        colorChoice.add("红色");
        colorChoice.add("绿色");
        colorChoice.add("蓝色");
        // 列表
        List fruitList = new List(3, false); // 3行可见，单选
        fruitList.add("苹果");
        fruitList.add("香蕉");
        fruitList.add("橙子");
        // 文本区域
        TextArea commentArea = new TextArea(5, 30); // 5行，30列
        commentArea.setText("请在此输入您的评论...");
        // 添加组件到窗口
        add(nameLabel);
        add(nameField);
        add(submitButton);
        add(cb1);
        add(cb2);
        add(maleRadio);
        add(femaleRadio);
        add(new Label("喜欢的颜色:"));
        add(colorChoice);
        add(new Label("喜欢的水果:"));
        add(fruitList);
        add(new Label("评论:"));
        add(commentArea);
        // 关闭窗口
        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        setVisible(true);
    }
    public static void main(String[] args) {
        new ComponentExample();
    }
}

注意: 我们在这里使用了 setLayout(new FlowLayout()),这将在下一节详细讲解。

布局管理器详解

a. FlowLayout (流式布局)

组件从左到右排列，一行放满后自动换行，这是 Panel 和 Applet 的默认布局。

// 在构造函数中设置
setLayout(new FlowLayout()); // 默认居中对齐
setLayout(new FlowLayout(FlowLayout.LEFT)); // 左对齐
setLayout(new FlowLayout(FlowLayout.RIGHT, 10, 20)); // 右对齐，水平间距10，垂直间距20

b. BorderLayout (边界布局)

将容器划分为五个区域：NORTH (北), SOUTH (南), WEST (西), EAST (东), CENTER (中)，每个区域只能添加一个组件，这是 Frame 和 Dialog 的默认布局。

setLayout(new BorderLayout());
add(new Button("North"), BorderLayout.NORTH);
add(new Button("South"), BorderLayout.SOUTH);
add(new Button("West"), BorderLayout.WEST);
add(new Button("East"), BorderLayout.EAST);
add(new Button("Center"), BorderLayout.CENTER);

c. GridLayout (网格布局)

将容器划分为一个 m 行 n 列的网格，每个组件占据一个格子,大小相同。

// 创建一个 3行4列，间距为5的网格布局
setLayout(new GridLayout(3, 4, 5, 5));
for (int i = 1; i <= 12; i++) {
    add(new Button("Button " + i));
}

d. CardLayout (卡片布局)

像一叠扑克牌，每次只显示一个组件，通常配合 Panel 使用。

CardLayout cardLayout = new CardLayout();
setLayout(cardLayout);
Panel card1 = new Panel();
card1.add(new Button("这是第一张卡片"));
add(card1, "Card1");
Panel card2 = new Panel();
card2.add(new Button("这是第二张卡片"));
add(card2, "Card2");
// 切换到第二张卡片
// ((CardLayout)getLayout()).show(this, "Card2");

e. GridBagLayout (网格包布局 - 进阶)

最强大但也最复杂的布局管理器，它允许组件跨越多个行和列，并可以精确控制组件的大小和位置，通常与 GridBagConstraints 对象一起使用，配置非常繁琐，在实际开发中，Swing 的 MigLayout 或 GroupLayout 等第三方库更受欢迎。

事件处理模型

AWT 使用“事件监听器”模式来处理用户交互（如点击按钮、输入文本等）。

基本步骤:

1. 创建事件监听器接口的实现对象,通常使用匿名内部类。
2. 为组件添加这个监听器。

常见监听器接口

适配器类

对于有多个方法的监听器接口（如 WindowListener），Java 提供了“适配器类”（如 WindowAdapter），适配器类实现了接口的所有方法，但方法体为空，我们可以继承适配器类，并只重写我们需要的方法,从而简化代码。

示例：为按钮添加点击事件

import java.awt.*;
import java.awt.event.*;
public class EventExample extends Frame {
    private Label label;
    public EventExample() {
        setTitle("事件处理示例");
        setLayout(new FlowLayout());
        Button clickButton = new Button("点击我");
        label = new Label("等待点击...");
        // 1. 为按钮添加 ActionListener
        clickButton.addActionListener(new ActionListener() {
            // 2. 实现 actionPerformed 方法
            @Override
            public void actionPerformed(ActionEvent e) {
                // 当按钮被点击时，此方法被调用
                label.setText("按钮被点击了！");
            }
        });
        add(clickButton);
        add(label);
        // 关闭窗口
        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        setSize(300, 200);
        setVisible(true);
    }
    public static void main(String[] args) {
        new EventExample();
    }
}

AWT 与 Swing 的关系

Swing 是 AWT 的升级版，Swing 组件通常以 "J" 开头（如 JFrame, JButton, JLabel），它们不依赖本地平台，提供了更强大、更一致、更美观的 GUI。

转换关系:

• Frame -> JFrame
• Button -> JButton
• Label -> JLabel
• Panel -> JPanel
• ... 以此类推。

总结与学习建议

• AWT 是基础: 虽然现在 Swing 更流行，但 AWT 的核心概念（组件、容器、布局、事件）是所有 Java GUI 框架的基础，学好 AWT，学习 Swing 会非常容易。
• 动手实践: GUI 编程光看教程是不够的，一定要亲手敲代码，尝试不同的布局组合,为不同的组件添加事件监听。
• 理解布局管理器: 这是 GUI 布局的核心难点，多花时间练习 FlowLayout, BorderLayout, GridLayout。
• 从 AWT 过渡到 Swing: 在掌握了 AWT 的基本原理后，强烈建议你转向学习 Swing，你会发现 Swing 只是在 AWT 的概念上，用更强大的“J”组件进行了重新实现,逻辑是相通的。

这份教程为你提供了 Java AWT 的全面入门指南,祝你学习愉快！