AWT简介

当 JDK 1.0发布时， Sun 提供了 一套基本的GUI类库，这个GUI类库希望可以在所有平台下都能运行 ， 这套基本类库被称为”抽象窗口工具集 CAbstract Window Toolkit )”，它为Java应用程序提供了基本的图形组件 。 AWT是窗口框架，它从不同平台的窗口系统中抽取出共同组件 ， 当程序运行时，将这些组件的创建和动作委托给程序所在的运行平台 。 简而言之 ，当使用 AWT 编写图形界面应用 时， 程序仅指定了界面组件的位置和行为，并未提供真正的实现，JVM调用操作系统本地的图形界面来创建和平台 一致的对等体 。
使用AWT创建的图形界面应用和所在的运行平台有相同的界面风格 ， 比如在 Windows 操作系统上，它就表现出 Windows 风格 ; 在 UNIX 操作系统上，它就表现出UNIX 风格 。 Sun 希望采用这种方式来实现 “ Write Once, Run Anywhere “ 的目标 。

AWT继承体系

所有和 AWT 编程相关的类都放在 java.awt 包以及它的子包中， AWT 编程中有两个基类 :**Component**和 **MenuComponent**。

• Component：代表一个能以图形化方式显示出来，并可与用户交互的对象，例如 Button 代表一个按钮，TextField 代表 一个文本框等；
• MenuComponent：则代表图形界面的菜单组件，包括 MenuBar (菜单条)、 Menultem (菜单项)等子类。

其中 Container 是一种特殊的 Component，它代表一种容器，可以盛装普通的 Component。
AWT中还有一个非常重要的接口叫LayoutManager ，如果一个容器中有多个组件，那么容器就需要使用LayoutManager来管理这些组件的布局方式。

Container容器

Container继承体系

• Winow是可以独立存在的顶级窗口,默认使用BorderLayout管理其内部组件布局;
• Panel可以容纳其他组件，但不能独立存在，它必须内嵌其他容器中使用，默认使用FlowLayout管理其内部组件布局；
• ScrollPane 是 一个带滚动条的容器，它也不能独立存在，默认使用 BorderLayout 管理其内部组件布局；

  常见API

  Component作为基类，提供了如下常用的方法来设置组件的大小、位置、可见性等。

Container作为容器根类，提供了如下方法来访问容器中的组件

容器演示

Window

import java.awt.*;
public class FrameDemo {
    public static void main(String[] args) {
        //1.创建窗口对象
        Frame frame = new Frame("这是第一个窗口容器");
        //设置窗口的位置和大小
        frame.setBounds(100,100,500,300);
        //设置窗口可见
        frame.setVisible(true);
    }
}

Panel

public class PanelDemo {
    public static void main(String[] args) {
        //1.创建Frame容器对象
        Frame frame = new Frame("这里在测试Panel");
        //2.创建Panel容器对象
        Panel panel = new Panel();
        //3.往Panel容器中添加组件
        panel.add(new TextField("这是一个测试文本"));
        panel.add(new Button("这是一个测试按钮"));
        //4.把Panel添加到Frame中
        frame.add(panel);
        //5.设置Frame的位置和大小
        frame.setBounds(30,30,500,300);
        //6.设置Frame可见
        frame.setVisible(true);
    }
}

由于IDEA默认使用utf-8进行编码，但是当前我们执行代码是是在windows系统上，而windows操作系统的默认编码是gbk，所以会乱码，如果出现了乱码，那么只需要在运行当前代码前，设置一个jvm参数 -Dfile.encoding=gbk即可。

ScrollPane

import java.awt.*;
public class ScrollPaneDemo {
    public static void main(String[] args) {
        //1.创建Frame窗口对象
        Frame frame = new Frame("这里测试ScrollPane");
        //2.创建ScrollPane对象，并且指定默认有滚动条
        ScrollPane scrollPane = new ScrollPane(ScrollPane.SCROLLBARS_ALWAYS);
        //3.往ScrollPane中添加组件
        scrollPane.add(new TextField("这是测试文本"));
        scrollPane.add(new Button("这是测试按钮"));
        //4.把ScrollPane添加到Frame中
        frame.add(scrollPane);
        //5.设置Frame的位置及大小
        frame.setBounds(30,30,500,300);
        //6.设置Frame可见
        frame.setVisible(true);
    }
}

程序明明向 ScrollPane 容器中添加了 一个文本框和一个按钮，但只能看到 一个按钮，却看不到文本框 ，这是为什么 呢?这是因为ScrollPane 使用 BorderLayout 布局管理器的缘故，而 BorderLayout 导致了该容器中只有一个组件被显示出来 。 下一节将向详细介绍布局管理器的知识 。

LayoutManager布局管理器

之前，我们介绍了Component中有一个方法 setBounds() 可以设置当前容器的位置和大小，但是我们需要明确一件事，如果我们手动的为组件设置位置和大小的话，就会造成程序的不通用性，例如：Label label = new Label("你好，世界");

创建了一个lable组件（标签类，用于放置提示性文本），很多情况下，我们需要让lable组件的宽高和“你好，世界”这个字符串自身的宽高一致，这种大小称为最佳大小。由于操作系统存在差异，例如在windows上，我们要达到这样的效果，需要把该Lable组件的宽和高分别设置为100px,20px,但是在Linux操作系统上，可能需要把Lable组件的宽和高分别设置为120px，24px，才能达到同样的效果。
如果要让我么的程序在不同的操作系统下，都有相同的使用体验，那么手动设置组件的位置和大小，无疑是一种灾难，因为有太多的组件，需要分别设置不同操作系统下的大小和位置。为了解决这个问题，Java提供了LayoutManager布局管理器，可以根据运行平台来自动调整组件大小，程序员不用再手动设置组件的大小和位置了，只需要为容器选择合适的布局管理器即可。

FlowLayout

在 FlowLayout 布局管理器 中，组件像水流一样向某方向流动 (排列) ，遇到障碍(边界)就折回，重头开始排列 。在默认情况下， FlowLayout 布局管理器从左向右排列所有组件，遇到边界就会折回下一行重新开始。

FlowLayout 中组件的排列方向(从左向右、从右向左、从中间向两边等) ， 该参数应该使用FlowLayout类的静态常量 : FlowLayout. LEFT 、 FlowLayout. CENTER 、 FlowLayout. RIGHT ，默认是左对齐。
FlowLayout 中组件中间距通过整数设置，单位是像素，默认是5个像素。
代码演示：

import java.awt.*;
public class FlowLayoutDemo {
    public static void main(String[] args) {
        //1.创建Frame对象
        Frame frame = new Frame("这里测试FlowLayout");
        //2.修改Frame容器的布局管理器为FlowLayout
        frame.setLayout(new FlowLayout(FlowLayout.LEFT,20,20));
        //3.往Frame中添加100个button
        for (int i = 0; i < 100; i++) {
            frame.add(new Button("按钮"+i));
        }
        //4.设置Frame为最佳大小
        frame.pack();
        //5.设置Frame可见
        frame.setVisible(true);
    }
}

BorderLayout

BorderLayout 将容器分为 EAST 、 SOUTH 、 WEST 、 NORTH 、 CENTER五个区域，普通组件可以被放置在这 5 个区域的任意一个中 。 BorderLayout布局 管理器的布局示意图如图所示 。

当改变使用 BorderLayout 的容器大小时， NORTH 、 SOUTH 和 CENTER区域水平调整，而 EAST 、 WEST 和 CENTER 区域垂直调整。使用BorderLayout 有如下两个注意点:

1. 当向使用 BorderLayout 布局管理器的容器中添加组件时 ， 需要指定要添加到哪个区域中 。 如果没有指定添加到哪个区域中，则默认添加到中间区域中；
2. 如果向同一个区域中添加多个组件时 ， 后放入的组件会覆盖先放入的组件； | 构造方法 | 方法功能 | | —- | —- | | BorderLayout() | 使用默认的水平间距、垂直 间距创建 BorderLayout 布局管理器 。 | | BorderLayout(int hgap,int vgap): | 使用指定的水平间距、垂直间距创建 BorderLayout 布局管理器。 |

代码演示1:

import java.awt.*;
public class BorderLayoutDemo1 {
    public static void main(String[] args) {
        //1.创建Frame对象
        Frame frame = new Frame("这里测试BorderLayout");
        //2.指定Frame对象的布局管理器为BorderLayout
        frame.setLayout(new BorderLayout(30,5));
        //3.往Frame指定东南西北中各添加一个按钮组件
        frame.add(new Button("东侧按钮"), BorderLayout.EAST);
        frame.add(new Button("西侧按钮"), BorderLayout.WEST);
        frame.add(new Button("南侧按钮"), BorderLayout.SOUTH);
        frame.add(new Button("北侧按钮"), BorderLayout.NORTH);
        frame.add(new Button("中间按钮"), BorderLayout.CENTER);
        //4.设置Frame为最佳大小
        frame.pack();
        //5.设置Frame可见
        frame.setVisible(true);
    }
}

如果不往某个区域中放入组件，那么该区域不会空白出来，而是会被其他区域占用
代码演示2:

import java.awt.*;
public class BorderLayoutDemo2 {
    public static void main(String[] args) {
        //1.创建Frame对象
        Frame frame = new Frame("这里测试BorderLayout");
        //2.指定Frame对象的布局管理器为BorderLayout
        frame.setLayout(new BorderLayout(30,5));
        //3.往Frame指定南，北，放入一个按钮，往中间区域放入一个Panel
        frame.add(new Button("南侧按钮"), BorderLayout.SOUTH);
        frame.add(new Button("北侧按钮"), BorderLayout.NORTH);
        Panel panel = new Panel();
        panel.add(new TextField("测试文本"));
        panel.add(new Button("中间按钮"));
        frame.add(panel, BorderLayout.CENTER);
        //4.设置Frame为最佳大小
        frame.pack();
        //5.设置Frame可见
        frame.setVisible(true);
    }
}

GridLayout

GridLayout 布局管理器将容器分割成纵横线分隔的网格 ， 每个网格所占的区域大小相同。当向使用 GridLayout 布局管理器的容器中添加组件时， 默认从左向右、 从上向下依次添加到每个网格中 。 与 FlowLayout不同的是，放置在 GridLayout 布局管理器中的各组件的大小由组件所处的区域决定(每 个组件将自动占满整个区域) 。

案例：
使用Frame+Panel，配合FlowLayout和GridLayout完成一个计算器效果。

代码：

import java.awt.*;
public class GridLayoutDemo{
    public static void main(String[] args) {
        //1.创建Frame对象，并且标题设置为计算器
        Frame frame = new Frame("计算器");
        //2.创建一个Panel对象，并且往Panel中放置一个TextField组件
        Panel p1 = new Panel();
        p1.add(new TextField(30));
        //3.把上述的Panel放入到Frame的北侧区域
        frame.add(p1,BorderLayout.NORTH);
        //4.创建一个Panel对象，并且设置其布局管理器为GridLayout
        Panel p2 = new Panel();
        p2.setLayout(new GridLayout(3,5,4,4));
        //5.往上述Panel中，放置15个按钮，内容依次是：0,1,2,3,4,5,6，7,8,9，+，-，*，/,.
        for (int i = 0; i < 10; i++) {
            p2.add(new Button(i+""));
        }
        p2.add(new Button("+"));
        p2.add(new Button("-"));
        p2.add(new Button("*"));
        p2.add(new Button("/"));
        p2.add(new Button("."));
        //6.把上述Panel添加到Frame的中间区域中国
        frame.add(p2);
        //7.设置Frame为最佳大小
        frame.pack();
        //8.设置Frame可见
        frame.setVisible(true);
    }
}

GridBagLayout

GridBagLayout 布局管理器的功能最强大 ， 但也最复杂，与 GridLayout 布局管理器不同的是， 在GridBagLayout 布局管理器中，一个组件可以跨越一个或多个网格 ， 并可以设置各网格的大小互不相同，从而增加了布局的灵活性 。 当窗口的大小发生变化时 ， GridBagLayout 布局管理器也可以准确地控制窗口各部分的拉伸 。

由于在GridBagLayout 布局中，每个组件可以占用多个网格，此时，我们往容器中添加组件的时候，就需要具体的控制每个组件占用多少个网格，java提供的GridBagConstaints类，与特定的组件绑定，可以完成具体大小和跨越性的设置。

GridBagConstraints API:

GridBagLayout使用步骤：

1.创建GridBagLaout布局管理器对象，并给容器设置该布局管理器对象；
2.创建GridBagConstraints对象，并设置该对象的控制属性：
    gridx: 用于指定组件在网格中所处的横向索引；
    gridy: 用于执行组件在网格中所处的纵向索引；
    gridwidth: 用于指定组件横向跨越多少个网格；
    gridheight: 用于指定组件纵向跨越多少个网格；
3.调用GridBagLayout对象的setConstraints(Component c,GridBagConstraints gbc )方法，把即将要添加到容器中的组件c和GridBagConstraints对象关联起来；
4. 把组件添加到容器中；

案例：
使用Frame容器，设置GridBagLayout布局管理器，实现下图中的效果：

演示代码：

import java.awt.*;
public class GridBagLayoutDemo {
    public static void main(String[] args) {
        //1.创建Frame对象
        Frame frame = new Frame("这里是GridBagLayout测试");
        //2.创建GridBagLayout对象
        GridBagLayout gbl = new GridBagLayout();
        //3.把Frame对象的布局管理器设置为GridBagLayout
        frame.setLayout(gbl);
        //4.创建GridBagConstraints对象
        GridBagConstraints gbc = new GridBagConstraints();
        //5.创建容量为10的Button数组
        Button[] bs = new Button[10];
        //6.遍历数组，初始化每一个Button
        for (int i = 0; i < bs.length; i++) {
            bs[i] = new Button("按钮"+(i+1));
        }
        //7.设置所有的GridBagConstraints对象的fill属性为GridBagConstraints.BOTH,当有空白区域时，组件自动扩大占满空白区域
        gbc.fill=GridBagConstraints.BOTH;
        //8.设置GridBagConstraints对象的weightx设置为1,表示横向扩展比例为1
        gbc.weightx=1;
        //9.往frame中添加数组中的前3个Button
        addComponent(frame,bs[0],gbl,gbc);
        addComponent(frame,bs[1],gbl,gbc);
        addComponent(frame,bs[2],gbl,gbc);
        //10.把GridBagConstraints的gridwidth设置为GridBagConstraints.REMAINDER,则表明当前组件是横向最后一个组件
        gbc.gridwidth=GridBagConstraints.REMAINDER;
        //11.把button数组中第四个按钮添加到frame中
        addComponent(frame,bs[3],gbl,gbc);
        //12.把GridBagConstraints的weighty设置为1，表示纵向扩展比例为1
        gbc.weighty=1;
        //13.把button数组中第5个按钮添加到frame中
        addComponent(frame,bs[4],gbl,gbc);
        //14.把GridBagConstaints的gridheight和gridwidth设置为2，表示纵向和横向会占用两个网格
        gbc.gridheight=2;
        gbc.gridwidth=2;
        //15.把button数组中第6个按钮添加到frame中
        addComponent(frame,bs[5],gbl,gbc);
        //16.把GridBagConstaints的gridheight和gridwidth设置为1，表示纵向会占用1个网格
        gbc.gridwidth=1;
        gbc.gridheight=1;
        //17.把button数组中第7个按钮添加到frame中
        addComponent(frame,bs[6],gbl,gbc);
        //18.把GridBagConstraints的gridwidth设置为GridBagConstraints.REMAINDER,则表明当前组件是横向最后一个组件
        gbc.gridwidth=GridBagConstraints.REMAINDER;
        //19.把button数组中第8个按钮添加到frame中
        addComponent(frame,bs[7],gbl,gbc);
        //20.把GridBagConstaints的gridwidth设置为1，表示纵向会占用1个网格
        gbc.gridwidth=1;
        //21.把button数组中第9、10个按钮添加到frame中
        addComponent(frame,bs[8],gbl,gbc);
        addComponent(frame,bs[9],gbl,gbc);
        //22.设置frame为最佳大小
        frame.pack();
        //23.设置frame可见
        frame.setVisible(true);
    }
    public static void addComponent(Container container,Component c,GridBagLayout gridBagLayout,GridBagConstraints gridBagConstraints){
        gridBagLayout.setConstraints(c,gridBagConstraints);
        container.add(c);
    }
}

CardLayout

CardLayout布局管理器以时间而非空间来管理它里面的组件，它将加入容器的所有组件看成一叠卡片（每个卡片其实就是一个组件），每次只有最上面的那个 Component 才可见。就好像一副扑克牌，它们叠在一起，每次只有最上面的一张扑克牌才可见.

案例：
使用Frame和Panel以及CardLayout完成下图中的效果，点击底部的按钮，切换卡片

演示代码：

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class CardLayoutDemo {
    public static void main(String[] args) {
        //1.创建Frame对象
        Frame frame = new Frame("这里测试CardLayout");
        //2.创建一个String数组，存储不同卡片的名字
        String[] names = {"第一张","第二张","第三张","第四张","第五张"};
        //3.创建一个Panel容器p1，并设置其布局管理器为CardLayout,用来存放多张卡片
        CardLayout cardLayout = new CardLayout();
        Panel p1 = new Panel();
        p1.setLayout(cardLayout);
        //4.往p1中存储5个Button按钮，名字从String数组中取
        for (int i = 0; i < 5; i++) {
            p1.add(names[i],new Button(names[i]));
        }
        //5.创建一个Panel容器p2,用来存储5个按钮，完成卡片的切换
        Panel p2 = new Panel();
        //6.创建5个按钮，并给按钮设置监听器
        ActionListener listener = new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String command = e.getActionCommand();
                switch (command){
                    case "上一张":
                        cardLayout.previous(p1);
                        break;
                    case "下一张":
                        cardLayout.next(p1);
                        break;
                    case "第一张":
                        cardLayout.first(p1);
                        break;
                    case "最后一张":
                        cardLayout.last(p1);
                        break;
                    case "第三张":
                        cardLayout.show(p1,"第三张");
                        break;
                }
            }
        };
        Button b1 = new Button("上一张");
        Button b2 = new Button("下一张");
        Button b3 = new Button("第一张");
        Button b4 = new Button("最后一张");
        Button b5 = new Button("第三张");
        b1.addActionListener(listener);
        b2.addActionListener(listener);
        b3.addActionListener(listener);
        b4.addActionListener(listener);
        b5.addActionListener(listener);
        //7.把5个按钮添加到p2中
        p2.add(b1);
        p2.add(b2);
        p2.add(b3);
        p2.add(b4);
        p2.add(b5);
        //8.把p1添加到frame的中间区域
        frame.add(p1);
        //9.把p2添加到frame的底部区域
        frame.add(p2,BorderLayout.SOUTH);
        //10设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
}

BoxLayout

为了简化开发，Swing 引入了 一个新的布局管理器 : BoxLayout 。 BoxLayout 可以在垂直和 水平两个方向上摆放 GUI 组件， BoxLayout 提供了如下一个简单的构造器:

案例1：
使用Frame和BoxLayout完成下图效果：

演示代码1：

import javax.swing.*;
import java.awt.*;
public class BoxLayoutDemo1 {
    public static void main(String[] args) {
        //1.创建Frame对象
        Frame frame = new Frame("这里测试BoxLayout");
        //2.创建BoxLayout布局管理器，并指定容器为上面的frame对象，指定组件排列方向为纵向
        BoxLayout boxLayout = new BoxLayout(frame, BoxLayout.Y_AXIS);
        frame.setLayout(boxLayout);
        //3.往frame对象中添加两个按钮
        frame.add(new Button("按钮1"));
        frame.add(new Button("按钮2"));
        //4.设置frame最佳大小，并可见
        frame.pack();
        frame.setVisible(true);
    }
}

在java.swing包中，提供了一个新的容器**Box**，该容器的默认布局管理器就是BoxLayout,大多数情况下，使用Box容器去容纳多个GUI组件，然后再把Box容器作为一个组件，添加到其他的容器中，从而形成整体窗口布局。

案例2：
使用Frame和Box，完成下图效果：

import javax.swing.*;
import java.awt.*;
public class BoxLayoutDemo2 {
    public static void main(String[] args) {
        //1.创建Frame对象
        Frame frame = new Frame("这里测试BoxLayout");
        //2.创建一个横向的Box,并添加两个按钮
        Box hBox = Box.createHorizontalBox();
        hBox.add(new Button("水平按钮一"));
        hBox.add(new Button("水平按钮二"));
        //3.创建一个纵向的Box，并添加两个按钮
        Box vBox = Box.createVerticalBox();
        vBox.add(new Button("垂直按钮一"));
        vBox.add(new Button("垂直按钮二"));
        //4.把box容器添加到frame容器中
        frame.add(hBox,BorderLayout.NORTH);
        frame.add(vBox);
        //5.设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
}

通过之前的两个BoxLayout演示，我们会发现，被它管理的容器中的组件之间是没有间隔的，不是特别的美观，但之前学习的几种布局，组件之间都会有一些间距，那使用BoxLayout如何给组件设置间距呢？
其实很简单，我们只需要在原有的组件需要间隔的地方，添加间隔即可，而每个间隔可以是一个组件，只不过该组件没有内容，仅仅起到一种分隔的作用。

Box类中，提供了5个方便的静态方法来生成这些间隔组件：

案例3：
使用Frame和Box，完成下图效果：

演示代码3：

import javax.swing.*;
import java.awt.*;
public class BoxLayoutDemo3 {
    public static void main(String[] args) {
        //1.创建Frame对象
        Frame frame = new Frame("这里测试BoxLayout");
        //2.创建一个横向的Box,并添加两个按钮
        Box hBox = Box.createHorizontalBox();
        hBox.add(new Button("水平按钮一"));
        hBox.add(Box.createHorizontalGlue());//两个方向都可以拉伸的间隔
        hBox.add(new Button("水平按钮二"));
        hBox.add(Box.createHorizontalStrut(10));//水平间隔固定，垂直间方向可以拉伸
        hBox.add(new Button("水平按钮3"));
        //3.创建一个纵向的Box，并添加两个按钮
        Box vBox = Box.createVerticalBox();
        vBox.add(new Button("垂直按钮一"));
        vBox.add(Box.createVerticalGlue());//两个方向都可以拉伸的间隔
        vBox.add(new Button("垂直按钮二"));
        vBox.add(Box.createVerticalStrut(10));//垂直间隔固定，水平方向可以拉伸
        vBox.add(new Button("垂直按钮三"));
        //4.把box容器添加到frame容器中
        frame.add(hBox, BorderLayout.NORTH);
        frame.add(vBox);
        //5.设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
}

AWT中常用组件

基本组件

这些 AWT 组件的用法比较简单，可以查阅 API 文档来获取它们各自的构方法、成员方法等详细信息。
案例：
实现下图效果：

演示代码：

import javax.swing.*;
import java.awt.*;
public class BasicComponentDemo {
    Frame frame = new Frame("这里测试基本组件");
    //定义一个按钮
    Button ok = new Button("确认");
    //定义一个复选框组
    CheckboxGroup cbg = new CheckboxGroup();
    //定义一个单选框，初始处于被选中状态,并添加到cbg组中
    Checkbox male = new Checkbox("男", cbg, true);
    //定义一个单选框，初始处于未被选中状态,并添加到cbg组中
    Checkbox female = new Checkbox("女", cbg, false);
    //定义一个复选框，初始处于未被选中状态
    Checkbox married = new Checkbox("是否已婚？", false);
    //定义一个下拉选择框
    Choice colorChooser = new Choice();
    //定义一个列表选择框
    List colorList = new List(6, true);
    //定义一个5行，20列的多行文本域
    TextArea ta = new TextArea(5, 20);
    //定义一个50列的单行文本域
    TextField tf = new TextField(50);
    public void init() {
        //往下拉选择框中添加内容
        colorChooser.add("红色");
        colorChooser.add("绿色");
        colorChooser.add("蓝色");
        //往列表选择框中添加内容
        colorList.add("红色");
        colorList.add("绿色");
        colorList.add("蓝色");
        //创建一个装载按钮和文本框的Panel容器
        Panel bottom = new Panel();
        bottom.add(tf);
        bottom.add(ok);
        //把bottom添加到Frame的底部
        frame.add(bottom,BorderLayout.SOUTH);
        //创建一个Panel容器，装载下拉选择框，单选框和复选框
        Panel checkPanel = new Panel();
        checkPanel.add(colorChooser);
        checkPanel.add(male);
        checkPanel.add(female);
        checkPanel.add(married);
        //创建一个垂直排列的Box容器，装载 多行文本域和checkPanel
        Box topLeft = Box.createVerticalBox();
        topLeft.add(ta);
        topLeft.add(checkPanel);
        //创建一个水平排列的Box容器，装载topLeft和列表选择框
        Box top = Box.createHorizontalBox();
        top.add(topLeft);
        top.add(colorList);
        //将top添加到frame的中间区域
        frame.add(top);
        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
    public static void main(String[] args) {
        new BasicComponentDemo().init();
    }
}

对话框Dialog

Dialog

Dialog 是 Window类的子类，是 一个容器类，属于特殊组件 。 对话框是可以独立存在的顶级窗口， 因此用法与普通窗口的用法几乎完全一样，但是使用对话框需要注意下面两点：

• 对话框通常依赖于其他窗口，就是通常需要有一个父窗口；
• 对话框有非模式(non-modal)和模式(modal)两种，当某个模式对话框被打开后，该模式对话框总是位于它的父窗口之上，在模式对话框被关闭之前，父窗口无法获得焦点。 | 方法名称 | 方法功能 | | —- | —- | | Dialog(Frame owner, String title, boolean modal) | 创建一个对话框对象：owner:当前对话框的父窗口title:当前对话框的标题modal：当前对话框是否是模式对话框，true/false |

案例1：
通过Frame、Button、Dialog实现下图效果:

演示代码1：

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class DialogDemo1 {
    public static void main(String[] args) {
        Frame frame = new Frame("这里测试Dialog");
        Dialog d1 = new Dialog(frame, "模式对话框", true);
        Dialog d2 = new Dialog(frame, "非模式对话框", false);
        Button b1 = new Button("打开模式对话框");
        Button b2 = new Button("打开非模式对话框");
        //设置对话框的大小和位置
        d1.setBounds(20,30,300,400);
        d2.setBounds(20,30,300,400);
        //给b1和b2绑定监听事件
        b1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                d1.setVisible(true);
            }
        });
        b2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                d2.setVisible(true);
            }
        });
        //把按钮添加到frame中
        frame.add(b1);
        frame.add(b2,BorderLayout.SOUTH);
        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
}

在Dialog对话框中，可以根据需求，自定义内容
案例：
点击按钮，弹出一个模式对话框，其内容如下:

演示代码：

public class DialogDemo2 {
    public static void main(String[] args) {
        Frame frame = new Frame("这里测试Dialog");
        Dialog d1 = new Dialog(frame, "模式对话框", true);
        //往对话框中添加内容
        Box vBox = Box.createVerticalBox();
        vBox.add(new TextField(15));
        vBox.add(new JButton("确认"));
        d1.add(vBox);
        Button b1 = new Button("打开模式对话框");
        //设置对话框的大小和位置
        d1.setBounds(20,30,200,100);
        //给b1绑定监听事件
        b1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                d1.setVisible(true);
            }
        });
        //把按钮添加到frame中
        frame.add(b1);
        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
}

FileDialog

Dialog 类还有 一个子类 : FileDialog ，它代表一个文件对话框，用于打开或者保存 文件,需要注意的是FileDialog无法指定模态或者非模态，这是因为 FileDialog 依赖于运行平台的实现，如果运行平台的文件对话框是模态的，那么 FileDialog 也是模态的;否则就是非模态的 。

案例2：
使用 Frame、Button和FileDialog完成下图效果：

演示代码2：

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class FileDialogTest {
    public static void main(String[] args) {
        Frame frame = new Frame("这里测试FileDialog");
        FileDialog d1 = new FileDialog(frame, "选择需要加载的文件", FileDialog.LOAD);
        FileDialog d2 = new FileDialog(frame, "选择需要保存的文件", FileDialog.SAVE);
        Button b1 = new Button("打开文件");
        Button b2 = new Button("保存文件");
        //给按钮添加事件
        b1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                d1.setVisible(true);
                //打印用户选择的文件路径和名称
                System.out.println("用户选择的文件路径:"+d1.getDirectory());
                System.out.println("用户选择的文件名称:"+d1.getFile());
            }
        });
        System.out.println("-------------------------------");
        b2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                d2.setVisible(true);
                //打印用户选择的文件路径和名称
                System.out.println("用户选择的文件路径:"+d2.getDirectory());
                System.out.println("用户选择的文件名称:"+d2.getFile());
            }
        });
        //添加按钮到frame中
        frame.add(b1);
        frame.add(b2,BorderLayout.SOUTH);
        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
}

事件处理

前面介绍了如何放置各种组件，从而得到了丰富多彩的图形界面，但这些界面还不能响应用户的任何操作。比如单击前面所有窗口右上角的“X”按钮，但窗口依然不会关闭。因为在 AWT 编程中 ，所有用户的操作，都必须都需要经过一套事件处理机制来完成，而 Frame 和组件本身并没有事件处理能力 。

GUI事件处理机制

定义：
当在某个组件上发生某些操作的时候，会自动的触发一段代码的执行。

在GUI事件处理机制中涉及到4个重要的概念需要理解：
事件源(Event Source)：操作发生的场所，通常指某个组件，例如按钮、窗口等；
事件（Event）：在事件源上发生的操作可以叫做事件，GUI会把事件都封装到一个**Event对象**中，如果需要知道该事件的详细信息，就可以通过Event对象来获取。
事件监听器(Event Listener):当在某个事件源上发生了某个事件，事件监听器就可以对这个事件进行处理。
注册监听：把某个事件监听器(A)通过某个事件(B)绑定到某个事件源(C)上，当在事件源C上发生了事件B之后，那么事件监听器A的代码就会自动执行。

使用步骤：
1.创建事件源组件对象；
2.自定义类，实现XxxListener接口，重写方法；
3.创建事件监听器对象(自定义类对象)
4.调用事件源组件对象的addXxxListener方法完成注册监听

实现监听事件常用的五种方式

https://blog.csdn.net/jasonCSH/article/details/108730324
实例中是给Button设置一个点击事件，所以通过.setOnClickListener( )方法来进行设置，在设置之前我们要先创建事件，实现监听事件方法有很多，主要有以下五种：

1.通过内部类实现：

找到声明控件，再编写一个内部类OnClick实现View.OnClickListener接口，为了提高代码的复用性，在该类中添加一个switch判断语句，通过view.getId( )方法获取到控件的id，根据id执行相应控件的监听事件，在监听事件中使用Toast弹出提示信息，创建好事件后，需要新建一个事件对象，再通过.setOnClickListener( )方法给Button添加该事件，如下：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button mButton = findViewById(R.id.btn);
        OnClick onClick = new OnClick();
        mButton.setOnClickListener(onClick);
    }
    class OnClick implements View.OnClickListener {
        @Override
        public void onClick(View view) {
            switch (view.getId()) {
                case R.id.btn:
                    Toast.makeText(MainActivity.this, "通过内部类实现", Toast.LENGTH_SHORT).show();
                    break;
            }
        }
    }
}

2.通过匿名内部类实现

匿名内部类实现监听事件时这几种方法中最简单，代码量最少的实现方式，该类方法也是通过.setOnClickListener( )方法设置，在该方法中直接创建一个系统提供的View.OnClickListener( )对象，在该对象中编写监听事件，代码如下：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button mButton = findViewById(R.id.btn);
        mButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Toast.makeText(MainActivity.this, "匿名内部类实现", Toast.LENGTH_SHORT).show();
            }
        });
    }
}

3.外部类实现

创建一个类，实现View.OnClickListener接口，在该类中定义一个Activity类型的实例mActivity(因为这是一个公共类，所以可能在不同的Activity中被调用，使用mActivity接收调用的Activity，在监听事件中的Toast语句中传入Activity)，在构造方法中传入，再重写onClick( )方法，在该方法中添加switch提高方法的复用性，在监听事件中使用Toast语句弹出提示信息。代码如下：

public class MyClick implements View.OnClickListener {
    private Activity mActivity;
//创建一个构造方法，传入参数Activity
    public MyClick(Activity activity) {
        this.mActivity = activity;
    }
    @Override
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.btn:
                Toast.makeText(mActivity, "外部类实现", Toast.LENGTH_LONG).show();
                break;
        }
    }
}

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button mButton = findViewById(R.id.btn);
        mButton.setOnClickListener(new MyClick(MainActivity.this));
    }
}

4.通过事件源所在类实现

这个实例中，我们是给Button设置点击事件，所以事件源就为Button，而Button所在类为MainActivity，所以通过事件源所在类实现，只需要给MainActivity实现View.OnClickListener接口，在MainActivity中重写View.OnClickListener的onClick( )方法，如下：

public class MainActivity extends AppCompatActivity implements View.OnClickListener{
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button mButton = findViewById(R.id.btn);
        mButton.setOnClickListener(MainActivity.this);
    }
    @Override
    public void onClick(View view) {
        switch (view.getId()){
            case R.id.btn:
                Toast.makeText(this, "事件所在类实现", Toast.LENGTH_SHORT).show();
                break;
        }
    }
}

5.通过onClick属性实现

在Button控件中有一个”onClick”属性，是用于给Button控件设置监听事件，创建一个监听事件作为属性值传入，代码如下：

    <Button
        android:id="@+id/btn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Click Me"
        android:onClick="show"
        android:textAllCaps="false"/>

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    public void show(View view){
        switch (view.getId()){
            case R.id.btn:
            Toast.makeText(this, "onClick属性实现", Toast.LENGTH_SHORT).show();
        }
    }
}

案例：
完成下图效果，点击确定按钮，在单行文本域内显示 hello world:

演示代码：

public class EventDemo1 {
    Frame  frame = new Frame("这里测试事件处理");
    //事件源
    Button button = new Button("确定");
    TextField tf = new TextField(30);
    public void init(){
        //注册监听
        button.addActionListener(new MyActionListener());
        //添加组件到frame中
        frame.add(tf);
        frame.add(button,BorderLayout.SOUTH);
        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
    //自定义事件监听器类
    private  class MyActionListener implements ActionListener{
        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println("用户点击了确定按钮");
            tf.setText("hello world");
        }
    }
    public static void main(String[] args) {
        new EventDemo1().init();
    }
}

GUI中常见事件和事件监听器

事件监听器必须实现事件监听器接口， AWT 提供了大量的事件监听器接口用于实现不同类型的事件监听器，用于监听不同类型的事件 。 AWT 中提供了丰富的事件类，用于封装不同组件上所发生的特定操作， AWT 的事件类都是 AWTEvent 类的子类 ， AWTEvent是 EventObject 的子类。

事件

AWT把事件分为了两大类：
1.低级事件：这类事件是基于某个特定动作的事件。比如进入、点击、拖放等动作的鼠标事件，再比如得到焦点和失去焦点等焦点事件。

2.高级事件：这类事件并不会基于某个特定动作，而是根据功能含义定义的事件。

事件监听器

不同的事件需要使用不同的监听器监听，不同的监听器需要实现不同的监听器接口， 当指定事件发生后 ， 事件监听器就会调用所包含的事件处理器(实例方法)来处理事件 。

案例

案例一：
通过ContainerListener监听Frame容器添加组件；
通过TextListener监听TextFiled内容变化；
通过ItemListener监听Choice条目选中状态变化；

演示代码一:

import java.awt.*;
import java.awt.event.ContainerAdapter;
import java.awt.event.ContainerEvent;
import java.awt.event.TextEvent;
import java.awt.event.TextListener;
public class ListenerDemo1 {
    public static void main(String[] args) {
        Frame frame = new Frame("这里测试监听器");
        //创建一个单行文本域
        TextField tf = new TextField(30);
        //给文本域添加TextListener，监听内容的变化
        tf.addTextListener(new TextListener() {
            @Override
            public void textValueChanged(TextEvent e) {
                System.out.println("当前内容："+tf.getText());;
            }
        });
        //给frame注册ContainerListener监听器，监听容器中组件的添加
        frame.addContainerListener(new ContainerAdapter() {
            @Override
            public void componentAdded(ContainerEvent e) {
                Component child = e.getChild();
                System.out.println("容器中添加了新组件："+child);
            }
        });
        //添加tf到frame
        frame.add(tf);
        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
}

案例2：
给Frame设置WindowListner，监听用户点击 X 的动作，如果用户点击X，则关闭当前窗口
演示代码2：

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class ListenerDemo2 {
    public static void main(String[] args) {
        Frame frame = new Frame("这里测试WindowListener");
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        frame.setBounds(200,200,500,300);
        frame.setVisible(true);
    }
}

菜单组件

前面讲解了如果构建GUI界面，其实就是把一些GUI的组件，按照一定的布局放入到容器中展示就可以了。在实际开发中，除了主界面，还有一类比较重要的内容就是菜单相关组件，可以通过菜单相关组件很方便的使用特定的功能，在AWT中，菜单相关组件的使用和之前学习的组件是一模一样的，只需要把菜单条、菜单、菜单项组合到一起，按照一定的布局，放入到容器中即可。

下表中给出常见的菜单相关组件：

下图是常见菜单相关组件集成体系图：

菜单相关组件使用：
1.准备菜单项组件，这些组件可以是MenuItem及其子类对象
2.准备菜单组件Menu或者PopupMenu(右击弹出子菜单)，把第一步中准备好的菜单项组件添加进来；
3.准备菜单条组件MenuBar，把第二步中准备好的菜单组件Menu添加进来；
4.把第三步中准备好的菜单条组件添加到窗口对象中显示。
小技巧：
1.如果要在某个菜单的菜单项之间添加分割线，那么只需要调用Menu的add（new MenuItem(-)）即可。
2.如果要给某个菜单项关联快捷键功能，那么只需要在创建菜单项对象时设置即可，例如给菜单项关联 ctrl+shif+/ 快捷键，只需要：new MenuItem(“菜单项名字”,new MenuShortcut(KeyEvent.VK_Q,true);
案例1：
使用awt中常用菜单组件，完成下图效果

演示代码1：

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class SimpleMenu {
    //创建窗口
    private Frame frame = new Frame("这里测试菜单相关组件");
    //创建菜单条组件
    private MenuBar menuBar = new MenuBar();
    //创建文件菜单组件
    private Menu fileMenu = new Menu("文件");
    //创建编辑菜单组件
    private Menu editMenu = new Menu("编辑");
    //创建新建菜单项
    private MenuItem newItem = new MenuItem("新建");
    //创建保存菜单项
    private MenuItem saveItem = new MenuItem("保存");
    //创建退出菜单项
    private MenuItem exitItem = new MenuItem("退出");
    //创建自动换行选择框菜单项
    private CheckboxMenuItem autoWrap = new CheckboxMenuItem("自动换行");
    //创建复制菜单项
    private MenuItem copyItem = new MenuItem("复制");
    //创建粘贴菜单项
    private MenuItem pasteItem = new MenuItem("粘贴");
    //创建格式菜单
    private Menu formatMenu = new Menu("格式");
    //创建注释菜单项
    private MenuItem commentItem = new MenuItem("注释");
    //创建取消注释菜单项
    private MenuItem cancelItem = new MenuItem("取消注释");
    //创建一个文本域
    private TextArea ta = new TextArea(6, 40);
    public void init(){
        //定义菜单事件监听器
        ActionListener listener = new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String command = e.getActionCommand();
                ta.append("单击“"+command+"”菜单\n");
                if (command.equals("退出")){
                    System.exit(0);
                }
            }
        };
        //为注释菜单项和退出菜单项注册监听器
        commentItem.addActionListener(listener);
        exitItem.addActionListener(listener);
        //为文件菜单fileMenu添加菜单项
        fileMenu.add(newItem);
        fileMenu.add(saveItem);
        fileMenu.add(exitItem);
        //为编辑菜单editMenu添加菜单项
        editMenu.add(autoWrap);
        editMenu.add(copyItem);
        editMenu.add(pasteItem);
        //为格式化菜单formatMenu添加菜单项
        formatMenu.add(commentItem);
        formatMenu.add(cancelItem);
        //将格式化菜单添加到编辑菜单中，作为二级菜单
        editMenu.add(new MenuItem("-"));
        editMenu.add(formatMenu);
        //将文件菜单和编辑菜单添加到菜单条中
        menuBar.add(fileMenu);
        menuBar.add(editMenu);
        //把菜单条设置到frame窗口上
        frame.setMenuBar(menuBar);
        //把文本域添加到frame中
        frame.add(ta);
        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
    public static void main(String[] args) {
        new SimpleMenu().init();
    }
}

案例2：
通过PopupMenu实现下图效果：

实现思路：
1.创建PopubMenu菜单组件；
2.创建多个MenuItem菜单项，并添加到PopupMenu中；
3.将PopupMenu添加到目标组件中；
4.为需要右击出现PopubMenu菜单的组件，注册鼠标监听事件，当监听到用户释放右键时，弹出菜单。
演示代码2：

import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
public class PopupMenuTest {
    private Frame frame = new Frame("这里测试PopupMenu");
    //创建PopubMenu菜单
    private PopupMenu popupMenu = new PopupMenu();
    //创建菜单条
    private MenuItem commentItem = new MenuItem("注释");
    private MenuItem cancelItem = new MenuItem("取消注释");
    private MenuItem copyItem = new MenuItem("复制");
    private MenuItem pasteItem = new MenuItem("保存");
    //创建一个文本域
    private TextArea ta = new TextArea("我爱中华！！！", 6, 40);
    //创建一个Panel
    private  Panel panel = new Panel();
    public void init(){
        //把菜单项添加到PopupMenu中
        popupMenu.add(commentItem);
        popupMenu.add(cancelItem);
        popupMenu.add(copyItem);
        popupMenu.add(pasteItem);
        //设置panel大小
        panel.setPreferredSize(new Dimension(300,100));
        //把PopupMenu添加到panel中
        panel.add(popupMenu);
        //为panel注册鼠标事件
        panel.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseReleased(MouseEvent e) {
                boolean flag = e.isPopupTrigger();
                //判断当前鼠标操作是不是触发PopupMenu的操作
                if (flag){
                    //让PopupMenu显示在panel上，并且跟随鼠标事件发生的地方显示
                    popupMenu.show(panel,e.getX(),e.getY());
                }
            }
        });
        //把ta添加到frame中间区域中
        frame.add(ta);
        //把panel添加到frame底部
        frame.add(panel,BorderLayout.SOUTH);
        //设置frame最佳大小，并可视；
        frame.pack();
        frame.setVisible(true);
    }
    public static void main(String[] args) {
        new PopupMenuTest().init();
    }
}