java图形化界面（GUI）

一、AWT编程（抽象窗口工具集）

1.AWT继承体系

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

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

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

2.Container容器

2.1 Container继承体系

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

2.2 常见API

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

方法签名	方法功能
setLocation(int x,int y)	设置组件的位置
setLSize(int width,int height)	设置组件的大小
setBounds(int x,int y,int width,int height)	同时设置组件的位置、大小
setVisible(BOOlean b)	设置组件可见性

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

方法签名	方法功能
Component add(Component comp)	设置组件的位置
Component getComponentAt(int x, int y)	设置组件的大小
int getComponentCount()	同时设置组件的位置、大小
Component[] getComponents()	设置组件可见性

2.3 容器演示

2.3.1 window

import java.awt.*;

public class WindowDemo {
    public static void main(String[] args) {

        //1.创建一个窗口对象
        Frame frame = new Frame("这里测试window窗口");
        //2.指定窗口的位置，大小(单位像素px)
        frame.setLocation(100,100);
        frame.setSize(500,300);
        //3.设置窗口对象可见
        frame.setVisible(true);
    }
}

2.3.2 panel

import java.awt.*;

public class PanelDemo {

    public static void main(String[] args) {
        //1.创建一个window对象，因为，panel以及其他的容器，都不能独立存在，必须依附于window存在
        Frame frame = new Frame("这里演示Panel");
        //2.创建一个Panel对象
        Panel p = new Panel();
        //3.创建一个文本框和一个按钮，并且把他们放入到Panel容器中
        p.add(new TextField("这里是一个测试文本"));
        p.add(new Button("这里是一个测试按钮"));
        //4.把panel放入到window中
        frame.add(p);
        //5.设置window的位置以及大小
        frame.setBounds(100,100,500,300);
        //6.设置window可见
        frame.setVisible(true);
    }

}

2.3.2 ScrollPane

import java.awt.*;

public class ScrollPaneDemo {
    public static void main(String[] args) {
        Frame frame = new Frame("这里演示ScrollPane");

        //1.创建一个ScrollPane对象
        ScrollPane sp = new ScrollPane(ScrollPane.SCROLLBARS_ALWAYS);

        //2.往ScrollPane中添加内容
        sp.add(new TextField("这是测试文本"));//不会显示，因为布局方式
        sp.add(new Button("这是测试按钮"));

        //3.把ScrollPane添加到Frame中
        frame.add(sp);

        frame.setBounds(100,100,500,300);
        frame.setVisible(true);
    }
}

2.4 LayoutManger布局管理器

之前，我们介绍了Component中有一个方法setBounds()可以设置当前容器的位置和大小，但是为我们手动设置位置大小，会造成程序的不通用性，不同操作系统要达到一样效果需要更改像素。
为了解决这个问题，java提供了LayoutManger布局管理器，可以根据运行平台自动调整组件的大小，程序员不用在手动设置组件的大小和位置，只需要选择合适的布局管理器即可。

分别对应网格、流式、卡片、网格包、边框布局。

2.4.1 FlowLayout（流式布局）

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

构造方法	方法功能
FlowLayout()	使用默认的对齐方式及默认的垂直间距、水平间距创建FlowLayout布局管理器
FlowLayout(int align)	使用指定的对齐方式及默认的垂直间距、水平间距创建FlowLayout布局管理器
FlowLayout(int align, int hgap, int vgap)	使用指定的对齐方式及指定的垂直间距、水平间距创建FlowLayout布局管理器
FlowLayout中组件的排列方向（从左到右、从右到左、从中间向两边等），该参数应该使用FlowLayout类的静态常量：FlowLayout.LEFT、FlowLayout.CENTER、FlowLayout.Right，默认是左对齐。

import java.awt.*;

public class FlowLayoutDemo {

    public static void main(String[] args) {
        Frame frame = new Frame("这里测试FlowLayout");

        //1.通过setLayout方法设置容器的布局管理器
       // frame.setLayout(new FlowLayout(FlowLayout.LEFT,20,20));

        //frame.setLayout(new FlowLayout(FlowLayout.CENTER,20,20));

        frame.setLayout(new FlowLayout(FlowLayout.RIGHT,40,20));

        //2.添加多个按钮到frame中
        for (int i = 1; i <= 100; i++) {
            frame.add(new Button("按钮"+i));
        }
        //3.设置最佳大小，pack方法
        frame.pack();

        frame.setVisible(true);
    }

}

2.4.2 BorderLayout（边框布局）

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

当改变使用BorderLayout的容器大小时，NORTH、SOUTH、和CENTER区域水平调整，而EAST、WEST和CENTER区域垂直调整。使用BorderLayout有如下两个注意点：
1.当向使用BorderLayout布局管理器的容器中添加组件时，需要指定要添加到哪个区域中。如果没有指定添加到哪个区域中，则默认添加到中间区域中；
2.如果向同一个区域中添加多个组件时，后放入的组件会覆盖先放入的组件；

构造方法	方法功能
BorderLayout()	使用默认的水平间距、垂直间距创建BorderLayout布局管理器
BorderLayout(int hgap, int vgap)	使用指定的水平间距、垂直间距创建BorderLayout布局管理器

import java.awt.*;

public class BorderLayoutDemo1 {
    public static void main(String[] args) {

        Frame frame = new Frame("这里测试BorderLayout");

        //1.给frame设置BorderLayout布局管理器
        frame.setLayout(new BorderLayout(30,10));

        //2.往frame的指定区域添加组件
        frame.add(new Button("北侧按钮"),BorderLayout.NORTH);
        frame.add(new Button("南侧按钮"),BorderLayout.SOUTH);
        frame.add(new Button("东侧按钮"),BorderLayout.EAST);
        frame.add(new Button("西侧按钮"),BorderLayout.WEST);
        frame.add(new Button("中间按钮"),BorderLayout.CENTER);

        frame.pack();
        frame.setVisible(true);
    }
}

如果不往某个区域放入组件，那么该区域就不会空白出来，而是会被其他区域占用

import java.awt.*;

public class BorderLayoutDemo2 {
    public static void main(String[] args) {

        Frame frame = new Frame("这里测试BorderLayout");

        //1.给frame设置BorderLayout布局管理器
        frame.setLayout(new BorderLayout(30,10));

        //2.往frame的指定区域添加组件
        frame.add(new Button("北侧按钮"),BorderLayout.NORTH);
        frame.add(new Button("南侧按钮"),BorderLayout.SOUTH);
        frame.add(new Button("中间按钮"),BorderLayout.CENTER);

//        frame.add(new TextField("测试文本框"));//默认是中间区域，替代原来的

        //这样就可以都显示出来，嵌套了FlowLayout
        Panel p = new Panel();
        p.add(new Button("中间按钮"));
        p.add(new TextField("测试文本框"));

        frame.add(p);

        frame.pack();
        frame.setVisible(true);
    }
}

2.4.3 GridLayout（网格布局）

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

构造方法	方法功能
GridLayout()	默认为在一行中每个组件一列，以及默认的横向间距、纵向间距将容器分割成多个网格
GridLayout(int rows, int cols, int hgap, int vgap)	采用指定的行数、列数，以及指定的横向间距、纵向间距将容器分割成多个网格
GridLayout(int rows, int cols)	采用指定的行数、列数，以及默认的横向间距、纵向间距将容器分割成多个网格

import java.awt.*;

public class GridLayoutDemo {
    public static void main(String[] args) {
        Frame frame = new Frame("计算器");

        //1.创建一个Panel对象，里面存放一个TextFiled组件
        Panel p = new Panel();
        p.add(new TextField(30));
        //2.把当前这个Panel添加到frame的北边区域
        frame.add(p,BorderLayout.NORTH);
        //3.创建一个Panel对象，并且设置它的布局管理器为GridLayout
        Panel p2 = new Panel();
        p2.setLayout(new GridLayout(3,5,4,4));
        //4.往Panel中添加内容
        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("."));
        //5.把当前Panel添加到frame中
        frame.add(p2);

        frame.pack();
        frame.setVisible(true);
    }
}

2.4.4 GridBagLayout（网格包布局）

• GridBagLayout布局管理器的功能最强大，但也最复杂，与 GridLayout布局管理器不同的是，在 GridBagLayout布局管理器中，一个组件可以跨越一个或多个网格，并可以设置网格的大小互不相同，从而增加了布局的灵活性。当窗口的大小发生变化时， GridBagLayout布局管理器也可以准确地控制窗口各部分的拉伸。
• 由于在 GridBagLayout布局中，每个组件可以占用多个网格，此时，我们往容器中添加组件的时候，就需要具体的控制每个组件占用多少个网格，java提供的 GridBagContainers类，与特定的组件绑定，可以完成具体大小和跨越性位置。

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);
    }
}

2.4.5 CardLayout（卡片布局）

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

方法名称	方法功能
CardLayout()	创建默认的CardLayout布局管理器
CardLayout(int hgap, int vgap)	通过指定卡片与容器左右边界的间距（hgap）、上下边界（vgap）的间距来创建CardLayout布局管理器
first(Container target)	显示target容器中的第一张卡片
last(Container target)	显示target容器中的最后一张卡片
previous(Container target)	显示target容器中的前一张卡片
next(Container target)	显示target容器中的后一张卡片
show(Container target，String name)	显示target容器中指定名字的卡片

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

public class CardLayoutDemo {

    public static void main(String[] args) {
        Frame frame = new Frame("这里测试CardLayout");


        //1.创建一个Panel，用来存储多张卡片
        Panel p1 = new Panel();
        //2.创建CardLayout对象，并且把该对象设置给之前创建的容器
        CardLayout cardLayout = new CardLayout();
        p1.setLayout(cardLayout);
        //3.往panel中存储多个组件
        String[] names = {"第一张","第二张","第三张","第四张","第五张"};

        for (int i = 0; i < names.length; i++) {
            p1.add(names[i],new Button(names[i]));
        }

        //4.把panel放到frame的中间区域
        frame.add(p1);

        //5.创建另外一个panel  p2,用来存储多个按钮组件
        Panel p2 = new Panel();

        //6.创建5个按钮组件
        Button b1 = new Button("上一张");
        Button b2 = new Button("下一张");
        Button b3 = new Button("第一张");
        Button b4 = new Button("最后一张");
        Button b5 = new Button("第三张");

        //7.创建一个事件监听器，监听按钮的点击动作
        ActionListener listener = new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String actionCommand = e.getActionCommand();//这个字符串其实就是按钮上的文字
                switch (actionCommand){
                    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;
                }

            }
        };

        //8.把当前这个时间监听器和多个按钮绑定到一起
        b1.addActionListener(listener);
        b2.addActionListener(listener);
        b3.addActionListener(listener);
        b4.addActionListener(listener);
        b5.addActionListener(listener);
        //9.把按钮添加到容器p2中
        p2.add(b1);
        p2.add(b2);
        p2.add(b3);
        p2.add(b4);
        p2.add(b5);

        //10.把p2放到frame的南边区域
        frame.add(p2,BorderLayout.SOUTH);

        frame.pack();
        frame.setVisible(true);
    }
}

2.4.6 BoxLayout（盒子布局）

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

方法名称	方法功能
BoxLayout(Container target, int axis)	指定创建基于target容器的BoxLayout布局管理器，该布局管理器的组件按axis方向排列。其中axis有BoxLayout.X_AXIS（横向）和BoxLayout.Y_AXIS（纵向）两个方向

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

public class BoxLayoutDemo1 {
    public static void main(String[] args) {
        Frame frame = new Frame("这里测试BoxLayout");

        //1.基于frame容器，创建一个BoxLayout对象，并且，该对象存放组件是垂直存放
        //BoxLayout boxLayout = new BoxLayout(frame, BoxLayout.Y_AXIS);
        //该对象存放组件是水平存放
        BoxLayout boxLayout = new BoxLayout(frame, BoxLayout.X_AXIS);

        //2.把BoxLayout对象设置给Frame
        frame.setLayout(boxLayout);

        //3.往frame中添加两个按钮组件
        frame.add(new Button("按钮1"));
        frame.add(new Button("按钮2"));

        frame.pack();
        frame.setVisible(true);
    }
}

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

方法名称	方法功能
static Box createHorizontalBox()	创建一个水平排列组件的Box容器
static Box createVerticalBox()	创建一个垂直排列组件的Box容器

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

public class BoxLayoutDemo2 {
    public static void main(String[] args) {
        Frame frame = new Frame("这里测试BoxLayout");


        //1.创建一个水平排列组件的Box容器
        Box hBox = Box.createHorizontalBox();
        //2.往当前容器中添加两个按钮
        hBox.add(new Button("水平按钮1"));
        hBox.add(new Button("水平按钮2"));
        //3.创建一个垂直排列组件的Box容器
        Box vBox = Box.createVerticalBox();
        //4.往当前容器中添加两个按钮
        vBox.add(new Button("垂直按钮1"));
        vBox.add(new Button("垂直按钮2"));

        //5.把两个Box容器添加到Frame中展示
        frame.add(hBox,BorderLayout.NORTH);
        frame.add(vBox);

        frame.pack();
        frame.setVisible(true);

    }
}

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

s方法名称	方法功能
static Component createGlue()	创建默认的Glue
static Component createHorizontalGlue()	创建一条水平Glue（可在两个方向上同时拉伸的间距）
static Component createVerticalGlue()	创建一条垂直Glue（可在两个方向上同时拉伸的间距）
static Component createHorizontalStrut(int width)	创建一条指定宽度（宽度固定了，不能拉伸）的水平Struct（可在垂直方向拉伸的间距）
static Component createVerticalStrut(int height)	创建一条指定高度（高度固定了，不能拉伸）的垂直Struct（可在水平方向拉伸的间距）

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

public class BoxLayoutDemo3 {

    public static void main(String[] args) {
        Frame frame = new Frame("这里测试BoxLayout");

        //1.创建水平排列的Box容器 hBox
        Box hBox = Box.createHorizontalBox();
        //2.往hBox容器中添加按钮,还需要在多个按钮之间添加分割
        hBox.add(new Button("水平按钮一"));
        hBox.add(Box.createHorizontalGlue());//该分割在两个方向上都可以拉伸
        hBox.add(new Button("水平按钮二"));
        hBox.add(Box.createHorizontalStrut(30));
        hBox.add(new Button("水平按钮三"));
        //3.创建垂直排列的Box容器 vBox
        Box vBox = Box.createVerticalBox();
        //4.往vBox容器中添加按钮,还需要在多个按钮之间添加分割
        vBox.add(new Button("垂直按钮一"));
        vBox.add(Box.createVerticalGlue());//该分割在两个方向上都可以拉伸
        vBox.add(new Button("垂直按钮二"));
        vBox.add(Box.createVerticalStrut(30));
        vBox.add(new Button("垂直按钮三"));
        vBox.add(Box.createGlue());//两个方向都可以拉伸
        //5.把box容器添加到frame中
        frame.add(hBox,BorderLayout.NORTH);//加到北边垂直不能拉伸，所以测试时加到中心测试
      //frame.add(hBox);
        frame.add(vBox);

        frame.pack();
        frame.setVisible(true);
    }
}

2.5 AWT中常用组件

2.5.1 基本组件

组件名	功能
Button	按钮
Canvas	用于绘图的画布
Checkbox	复选框组件（也可以当作单选框组件使用）
CheckboxGroup	用于将多个Checkbox组件组合成一组，一组Checkbox组价将只有一个可以被选中，即全部变成单选框组件
Choice	下拉选择框
Frame	窗口，在GUI程序里通过该类创建窗口
Label	标签类，用于放置提示性文本
List	列表框组件，可以添加多项条目
Panel	不能单独存在基本容器类，必须放在其他容器中
Scrollbar	滑动条组件。如果需要用户输入位于某个范围的值，就可以使用滑动条组件，比如调色板中设置RGB的上值所用的滑动条。当创建 一个滑动条时，必须指定它的方向、初始值、滑块的大小，最小值和最大值
Scrollpane	带水平及垂直滚动条的容器组件
TextArea	多行文本域
TextField	单行文本框

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

public class BasicComponentDemo {
    Frame frame = new Frame("这里测试基本组件");

    TextArea ta = new TextArea(5,20);//文本域

    Choice colorChooser = new Choice();//下拉选择框

    CheckboxGroup cbg = new CheckboxGroup();
    Checkbox male = new Checkbox("男",cbg,true);
    Checkbox female = new Checkbox("女",cbg,false);

    Checkbox isMarried = new Checkbox("是否已婚？");

    TextField tf = new TextField(50);
    Button ok = new Button("确认");

    List colorList = new List(6,true);

    public void init(){
        //组装界面

        //组装底部
        Box bBox = Box.createHorizontalBox();
        bBox.add(tf);
        bBox.add(ok);

        frame.add(bBox,BorderLayout.SOUTH);

        //组装 选择部分
        colorChooser.add("红色");
        colorChooser.add("蓝色");
        colorChooser.add("绿色");

        Box cBox = Box.createHorizontalBox();
        cBox.add(colorChooser);
        cBox.add(male);
        cBox.add(female);
        cBox.add(isMarried);

        //组装文本域和选择部分
        Box topLeft = Box.createVerticalBox();
        topLeft.add(ta);
        topLeft.add(cBox);

        //组装顶部左边和列表框
        colorList.add("红色");
        colorList.add("绿色");
        colorList.add("蓝色");

        Box top = Box.createHorizontalBox();
        top.add(topLeft);
        top.add(colorList);

        frame.add(top);

        //设置frame为最佳大小，并且可见
        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        new BasicComponentDemo().init();

    }
}

2.5.2 对话框Dialog

2.5.2.1 Dialog

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

• 对话框通常依赖于其他窗口，就是通常需要有一个父窗口；
• 对话框有非模式（non-modal）和模式（modal）两种，当某个模式对话框被打开后，该模式对话框总是位于它的父窗口上，在模式对话框被关闭之前，父窗口无法获取焦点。

方法名称	方法功能
Dialog(Frame owner,String title,boolean modal)	创建一个对话框的对象： owner：当前对话框的父窗口 title:当前对话框的标题 modal:当前对话框是否是模式对话框，true/false

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


public class DialogDemo1 {
    public static void main(String[] args) {

        Frame frame = new Frame("这里测试Dialog");

        //1.创建两个对话框Dialog对象，一个模式的，一个非模式的
        Dialog d1 = new Dialog(frame, "模式对话框", true);
        Dialog d2 = new Dialog(frame, "非模式对话框", false);

        //2.通过setBounds方法设置Dialog的位置以及大小
        d1.setBounds(20,30,300,200);
        d2.setBounds(20,30,300,200);

        //3.创建两个按钮
        Button b1 = new Button("打开模式对话框");
        Button b2 = new Button("打开非模式对话框");

        //4.给这两个按钮添加点击后的行为
        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);
            }
        });


        //5.把按钮添加到frame中

        frame.add(b1,BorderLayout.NORTH);
        frame.add(b2);

        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);

    }
}

在Dialog对话框中，可以根据需求，自定义内容

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


public class DialogDemo2 {
    public static void main(String[] args) {

        Frame frame = new Frame("这里测试Dialog");

        //1.创建两个对话框Dialog对象，一个模式的，一个非模式的
        Dialog d1 = new Dialog(frame, "模式对话框", true);

        //创建一个垂直的Box容器，把一个文本框和一个按钮添加到Box容器中
        Box vBox = Box.createVerticalBox();
        vBox.add(new TextField(20));
        vBox.add(new Button("确认"));

        //把Box容器添加到Dialog中
        d1.add(vBox);

        //2.通过setBounds方法设置Dialog的位置以及大小
        d1.setBounds(20,30,300,200);

        //3.创建两个按钮
        Button b1 = new Button("打开模式对话框");

        //4.给这两个按钮添加点击后的行为
        b1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                d1.setVisible(true);
            }
        });


        //5.把按钮添加到frame中

        frame.add(b1,BorderLayout.NORTH);

        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);

    }
}

2.5.2.1 Dialog

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

方法名称	方法功能
FileDialog(Frame parent, String title, int mode)	创建一个文件对话框的对象： parent：当前对话框的父窗口 title:当前对话框的标题 mode:文件对话框类型，如果指定为FileDialog.LOAD，用于打开文件，如果指定为FileDialog.SAVE ，用于保存文件
String getDirectory()	获取被打开或保存文件的绝对路径
String getFile()	获取被打开或保存文件的文件名

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");

        //1.创建两个FileDialog对象
        FileDialog f1 = new FileDialog(frame,"选择要打开的文件",FileDialog.LOAD);
        FileDialog f2 = new FileDialog(frame,"选择要保存的路径",FileDialog.SAVE);

        //2.创建两个按钮
        Button b1 = new Button("打开文件");
        Button b2 = new Button("保存文件");

        //3.给这两个按钮设置点击后的行为：获取打开或者保存的路劲文件名
        b1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                f1.setVisible(true);//代码会阻塞到这里

                //获取选择的路径及文件
                String directory = f1.getDirectory();
                String file = f1.getFile();
                System.out.println("打开的文件路径为："+directory);
                System.out.println("打开的文件名称为："+file);
            }
        });

        b2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                f2.setVisible(true);

                //获取选择的路径及文件
                String directory = f2.getDirectory();
                String file = f2.getFile();
                System.out.println("保存的文件路径为："+directory);
                System.out.println("保存的文件名称为："+file);

            }
        });


        //4.把按钮添加到Frame中
        frame.add(b1,BorderLayout.NORTH);
        frame.add(b2);


        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
}

2.6 事件处理

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

2.6.1 GUI事件处理机制

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

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

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

public class EventDemo1 {
    Frame  frame = new Frame("这里测试事件处理");

    TextField tf = new TextField(30);
    //事件源
    Button ok = new Button("确定");

    public void init(){
        //组装视图
        //监听器
        //MyListener myListener = new MyListener();

        //注册监听
        ok.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("ok按钮被点击了...");
                tf.setText("Hello World");
            }
        });

       //把tf和ok放入到Frame中
       frame.add(tf,BorderLayout.NORTH);
       frame.add(ok);

       frame.pack();
       frame.setVisible(true);

    }
    /*private class MyListener implements ActionListener{

        @Override
        public void actionPerformed(ActionEvent e) {
            tf.setText("Hello World");
        }
    }*/

    public static void main(String[] args) {
        new EventDemo1().init();
    }
}

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

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

2.6.2.1 事件

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

事件	触发时机
CompoentEvent	组件事件，当组件尺寸发生变化、位置发生移动、显示/隐藏状态发生改变时触发该事件
ContainerEvent	容器事件，当容器里发生添加组件、删除组件时触发该事件
WindowEvent	窗口事件，当窗口状态发生改变（如：打开、关闭、最大化、最小化时触发该事件）
FocusEvent	焦点事件，当组件得到焦点或失去焦点时触发该事件
KeyEvent	键盘事件，当按键被按下、松开、单击时触发该事件
MouseEvent	鼠标事件，当进行单击、按下、松开、移动鼠标等动作时触发该事件
PaintEvent	组件绘制事件，该事件是一个特殊的事件类型，当GUI组件调用update/paint方法来呈现自身时触发该事件，该事件并非专用于事件处理模型
2.高级事件：这类事件并不会基于某个特定动作，而是根据功能含义定义的事件
事件	触发时机
–	–
ActionEvent	动作事件，当按钮、菜单项被单击，在TextField中按Enter键时触发
AjustmentEvent	调节事件，在滑动条上移动滑块以调节数值时触发该事件
ItemEvent	选项事件，当用户选中某项，或取消选中某项时触发该事件
TextEvent	文本事件，当文本框、文本域里的文本发生改变时触发该事件

2.6.2.2 事件监听器

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

事件类别	描述信息	监听器接口
ActionEvent	激活组件	ActionListener
ItemEvent	选择了某些项目	ItemListener
MouseEvent	鼠标移动	MouseMotionListener
MouseEvent	鼠标点击等	MouseListener
KeyEvent	键盘输入	KeyListener
FocusEvent	组件收到或失去焦点	FocusListener
AjustmentEvent	鼠标移动	MouseMotionListener
CompoentEvent	对象移动缩放显示隐藏等	ComponentListener
WindowEvent	窗口收到窗口级事件	WindowListener
ContainerEvent	容器增加删除了组件	ContainerListener
TextEvent	文本字段或文本区发生改变	TextListener

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

public class ListenerDemo1 {
    public static void main(String[] args) {
        Frame frame = new Frame("这里测试监听器");

        //创建组件（事件源）
        TextField tf = new TextField(30);
        Choice names = new Choice();
        names.add("柳岩");
        names.add("舒淇");
        names.add("闫妮");

        //给文本域添加TextListener，监听内容的变化
        tf.addTextListener(new TextListener() {
            @Override
            public void textValueChanged(TextEvent e) {
                String text = tf.getText();
                System.out.println("当前文本框中的内容为："+text);
            }
        });


        //给下拉选择框添加ItemListener，监听条目选项的变化
        names.addItemListener(new ItemListener() {
            @Override
            public void itemStateChanged(ItemEvent e) {
                Object item = e.getItem();
                System.out.println("当前选中的条目为："+item);
            }
        });


        //给frame注册ContainerListener监听器，监听容器中组件的添加
        frame.addContainerListener(new ContainerListener() {
            @Override
            public void componentAdded(ContainerEvent e) {
                Component child = e.getChild();
                System.out.println("frame中添加了："+child);
            }

            @Override
            public void componentRemoved(ContainerEvent e) {

            }
        });


        //添加到frame中
        Box hBox = Box.createHorizontalBox();
        hBox.add(names);
        hBox.add(tf);
        frame.add(hBox);

        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
}

WindowListener的适配器模式

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.setBounds(200,200,500,300);

        //设置WindowListener，监听用户点击X的动作，如果点击X，则关闭窗口
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                //停止当前程序
                System.exit(0);
            }
        });


        frame.setVisible(true);
    }
}

2.7 菜单组件

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

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

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;

public class SimpleMenu {
    //创建窗口
    private Frame frame = new Frame("这里测试菜单相关组件");

    //创建菜单条
    MenuBar menuBar = new MenuBar();

    //创建菜单组件
    Menu fileMenu = new Menu("文件");
    Menu editMenu = new Menu("编辑");
    Menu formatMenu = new Menu("格式");

    //菜单项组件
    MenuItem auto = new MenuItem("自动换行");
    MenuItem copy = new MenuItem("复制");
    MenuItem paste = new MenuItem("粘贴");

    MenuItem comment = new MenuItem("注释",new MenuShortcut(KeyEvent.VK_Q,true));//关联快捷键  ctrl+shift+Q
    MenuItem cancelComment = new MenuItem("取消注释");

    TextArea ta = new TextArea(6,40);

    public void init(){
        //组装视图
        comment.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                ta.append("您点击了菜单项： "+e.getActionCommand()+"\n");
            }
        });
        //comment.addActionListener(e -> ta.append("您点击了菜单项： "+e.getActionCommand()+"\n"));

        formatMenu.add(comment);
        formatMenu.add(cancelComment);

        //组装编辑菜单
        editMenu.add(auto);
        editMenu.add(copy);
        editMenu.add(paste);
        editMenu.add(formatMenu);

        //组装菜单条
        menuBar.add(fileMenu);
        menuBar.add(editMenu);

        //把菜单条放入到Frame中
        frame.setMenuBar(menuBar);

        frame.add(ta);

        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }


    public static void main(String[] args) {
        new SimpleMenu().init();
    }
}

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

public class PopupMenuTest {

    private Frame frame = new Frame("这里测试PopupMenu");

    //创建文本域
    TextArea ta = new TextArea("我爱中华",6,40);

    //创建Panel容器
    Panel p = new Panel();

    //创建PopupMenu
    PopupMenu popupMenu = new PopupMenu();

    //创建菜单项
    MenuItem comment = new MenuItem("注释");
    MenuItem cancelComment = new MenuItem("取消注释");
    MenuItem copy = new MenuItem("复制");
    MenuItem save = new MenuItem("保存");

    public void init(){
        //组装视图
        ActionListener listener = new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String actionCommand = e.getActionCommand();
                ta.append("您点击了： "+actionCommand+"\n");
            }
        };

        comment.addActionListener(listener);
        cancelComment.addActionListener(listener);
        copy.addActionListener(listener);
        save.addActionListener(listener);


        popupMenu.add(comment);
        popupMenu.add(cancelComment);
        popupMenu.add(copy);
        popupMenu.add(save);

        p.add(popupMenu);

        //设置Panel的大小
        p.setPreferredSize(new Dimension(400,300));

        //给Panel注册鼠标事件，监听用户释放鼠标的动作，展示菜单
        p.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseReleased(MouseEvent e) {
                boolean flag = e.isPopupTrigger();
                if (flag){//右击，左击为false
                    //显示PopupMenu
                    popupMenu.show(p,e.getX(),e.getY());
                }
            }
        });

        //放置ta和p
        frame.add(ta);
        frame.add(p,BorderLayout.SOUTH);

        //设置frame最佳大小，并可视；
        frame.pack();
        frame.setVisible(true);

    }

    public static void main(String[] args) {
        new PopupMenuTest().init();
    }

}

2.8 绘图

很多程序例如游戏开发都需要在窗口绘制各种图形，除此之外，即使在开发javaEE项目时，有时候也必须“动态”地向客户端生成各种图形、图表，比如图形验证码、统计图等等，这都需要利用AWT的绘图功能。

2.8.1 组件绘图原理

之前我们已经学习很多组件，例如Button、Frame、Checkbox等等，不同的组件，展示出来的图形都不一样，其实这些组件暂时出来的图形，其本质就是用AWT的绘图来完成的。
在AWT中，真正提供绘图功能的是Graphics对象，那么Component组件和Graphics对象存在什么关系，才能让Component绘制自身图形？在Component类中，提供了下列三个方法来完成组件图形的绘制与刷新：

方法名称	功能
void paint(Graphics g)	绘制组件的外观
void update(Graphics g)	内部调用paint方法，刷新组件外观
void repaint()	调用update()方法，刷新组件外观

一般情况下，update和paint方法是由AWT系统负责调用，如果程序希望重新绘制组件，可以调用repaint方法完成。

2.8.2 Graphics类的使用

程序中绘图一样，也需要画布、画笔、颜料等等。AWt提供了Canvas类充当画布，提供了Graphics类来充当画笔，通过Graphics对象的setColor()方法可以给画笔设置颜色。
画图步骤：
1.自定义类，继承Canvas类，重写paint(Graphics g)方法完成画图；
2.在paint方法内部，真正开始画图字之前调用Graphics对象的setColor()、setFont()等方法设置画笔的颜色、字体等属性；
3.调用Graphics画笔的drawXxx(）方法开始画图。

• 下表中列出了Graphics类中的常用的一些方法：

方法名称	方法功能
setColor(Color c)	设置颜色
setFont(Font font)	设置字体
drawLine(int x1, int y1, int x2, int y2)	绘制直线
drawRect(int x, int y, int width, int height)	绘制矩形
drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)	绘制圆角矩形
drawOval(int x, int y, int width, int height)	绘制椭圆形
drawPolygon(int[] xPoints, int[] yPoints, int nPoints)	绘制多边形
drawArc(int x, int y, int width, int height, int startAngle, int arcAngle)	绘制圆弧
drawPolyline(int[] xPoints, int[] yPoints, int nPoints)	绘制折线
fillRect(int x, int y, int width, int height)	填充矩形区域
fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)	填充圆角矩形区域
fillOval(int x, int y, int width, int height)	填充椭圆区域
fillPolygon(int[] xPoints, int[] yPoints, int nPoints)	填充多边形区域
fillArc(int x, int y, int width, int height, int startAngle, int arcAngle)	填充圆弧对应的扇形区域
drawImage(Image img, int x, int y, Color bgcolor, ImageObserver observer)	绘制位图

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


public class SimpleDraw {

    private final String RECT_SHAPE="rect";
    private final String OVAL_SHAPE="oval";

    private Frame frame = new Frame("这里测试绘图");

    Button btnRect = new Button("绘制矩形");
    Button btnOval = new Button("绘制椭圆");

    //定义一个变量，记录当前要绘制椭圆还是矩形
    private String shape = "";

    //自定义类，继承Canvas类，重写paint(Graphics g)方法完成画图；
    private class MyCanvas extends Canvas{
        @Override
        public void paint(Graphics g) {
            //绘制不同的图形

            if (shape.equals(RECT_SHAPE)){
                //绘制矩形
                g.setColor(Color.BLACK);//设置当前画笔的颜色为黑色
                g.drawRect(100,100,150,100);

            }else if(shape.equals(OVAL_SHAPE)){
                //绘制椭圆
                g.setColor(Color.RED);
                g.drawOval(100,100,150,100);
            }

        }
    }

    //创建自定义的画布对象
    MyCanvas drawArea = new MyCanvas();


    public void init(){
        //组装视图
        btnRect.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //修改标记的值为rect
                shape = RECT_SHAPE;
                drawArea.repaint();
            }
        });

        btnOval.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //修改标记的值为oval
                shape = OVAL_SHAPE;
                drawArea.repaint();
            }
        });

        //创建Panel，承载按钮
        Panel p = new Panel();
        p.add(btnRect);
        p.add(btnOval);

        frame.add(p,BorderLayout.SOUTH);

        //drawArea的大小需要设置
        drawArea.setPreferredSize(new Dimension(300,300));
        frame.add(drawArea);

        frame.pack();
        frame.setVisible(true);

    }

    public static void main(String[] args) {
        new SimpleDraw().init();
    }

}

java也可用于开发一些动画。所谓动画，就是间隔一定的时间（通常销毁0.1秒）重新绘制的画像，两次绘制的图像之间差异较小，肉眼看起来就成了动画。
为了实现间隔一定时间就重新调用组件的repaint（）方法，可以借助于Swing提供的Timer类，Timer类是一个定时器，他有一下构造器：
Timer(int delay,ActionListener listener);每间隔delay毫秒，系统自动触发ActionListener监听器里的事件处理器方法，在方法内部我们就可以调用组件的repaint()方法，完成组件重绘。

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

public class PinBall {
    //创建窗口对象
    private Frame frame = new Frame("弹球游戏");

    //桌面宽度
    private final int TABLE_WIDTH = 300;
    //桌面高度
    private final int TABLE_HEIGHT = 400;


    //球拍的高度和宽度
    private final int RACKET_WIDTH = 60;
    private final int RACKET_HEIGHT = 20;

    //小球的大小
    private final int BALL_SIZE = 16;

    //定义变量，记录小球的坐标
    private int ballX = 120;
    private int ballY = 20;

    //定义变量，记录小球在x和y方向上分别移动的速度
    private int speedY = 10;
    private int speedX = 5;

    //定义变量，记录球拍的坐标
    private int racketX = 120;
    private final int racketY = 340;

    //定义变量，标识当前游戏是否已结束
    private boolean isOver = false;

    //声明一个定时器
    private Timer timer;

    //自定义一个类，继承canvas，充当画布
    private class MyCanvas extends Canvas{
        @Override
        public void paint(Graphics g) {
            //TODO 在这里绘制内容

            if (isOver){
                //游戏结束
                g.setColor(Color.BLUE);

               // g.setFont(new Font("Times",Font.BOLD,30));
                g.setFont(new Font("Times",Font.ITALIC,30));

                g.drawString("游戏结束！",50,200);

            }else{
                //游戏中

                //绘制小球
                g.setColor(Color.RED);
                g.fillOval(ballX,ballY,BALL_SIZE,BALL_SIZE);

                //绘制球拍
                g.setColor(Color.PINK);
                g.fillRect(racketX,racketY,RACKET_WIDTH,RACKET_HEIGHT);
            }

        }
    }

    //创建绘画区域
    MyCanvas drawArea = new MyCanvas();

    public void init(){
        //组装视图，游戏逻辑的控制

        //完成球拍坐标的变化
        KeyListener listener = new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                //获取当前按下的键
                int keyCode = e.getKeyCode();

                if (keyCode == KeyEvent.VK_LEFT){
                    //<-  应该向左移动
                    if (racketX>0){
                        racketX -=10;
                    }
                }

                if (keyCode == KeyEvent.VK_RIGHT){
                    //->  应该向右移动
                    if (racketX < (TABLE_WIDTH-RACKET_WIDTH)){
                        racketX+=10;
                    }
                }
            }
        };


        //给Frame和drawArea注册监听器
        frame.addKeyListener(listener);
        drawArea.addKeyListener(listener);

        //小球坐标的控制
        ActionListener task = new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {


                //根据边界范围，修正速度
                if (ballX<=0 || ballX >=(TABLE_WIDTH-BALL_SIZE)){
                    speedX = -speedX;
                }

                if( ballY <=0 || ( ballY > racketY-BALL_SIZE && ballX > racketX && ballX < racketX+RACKET_WIDTH)){
                    speedY = -speedY;
                }

                if (ballY > racketY-BALL_SIZE && ( ballX < racketX || ballX > racketX+RACKET_WIDTH)){
                    //当前小球超出了球拍的范围，游戏结束

                    //停止定时器
                    timer.stop();
                    //修改游戏是否结束的标记
                    isOver = true;
                    //重绘界面
                    drawArea.repaint();
                }

                //更新小球的坐标，重绘界面
                ballX+=speedX;
                ballY+=speedY;
                //重绘界面
                drawArea.repaint();
            }
        };
        timer = new Timer(100,task);
        timer.start();


        drawArea.setPreferredSize(new Dimension(TABLE_WIDTH,TABLE_HEIGHT));
        frame.add(drawArea);

        //设置frame最佳大小，并可视
        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        new PinBall().init();
    }
}

2.8.3 处理位图

如果仅仅绘制一些简单的几何图形，程序的图形效果依然比较单调。AWT也允许在组件上绘制位图。Graphics提供了drawImage(Image image)方法用于绘制位图，该方法需要一个Image参数——代表位图，通过该方法就可以绘制出指定的图。
位图使用步骤：
1.创建Image的子类对象BufferedImage(int width, int height, int imageType)，创建时需要指定位图的宽高及类型属性；此时相当于在内存中生成了一张图片；
2.调用BufferedImage对象的getGraphics()方法获取画笔，此时就可以往内存中的这张图片上绘图了，绘图的方法和之前学习的一模一样；
3.调用组件paint方法中提供的Graphics对象的drawImage()方法，一次性的内存中的图片BufferedImage绘制到特定的组件上。
使用位图绘制组件的好处：
使用位图来绘制组件，相当于实现了图的缓冲区，此时绘图时没有直接把图形绘制到组件上，而是先绘制到内存中的BufferedImage上，等全部绘制完毕，再一次性的图像显示到组件上即可，这样用户体验更好。

import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;

public class HandDraw {
    //定义窗口对象
    private Frame frame = new Frame("简单手绘程序");

    //定义画图区的宽高
    private final int AREA_WIDTH = 500;
    private final int AREA_HEIGHT = 400;

    //定义一个右键菜单，用于设置画笔的颜色
    private PopupMenu colorMenu = new PopupMenu();
    private MenuItem redItem = new MenuItem("红色");
    private MenuItem greenItem = new MenuItem("绿色");
    private MenuItem blueItem = new MenuItem("蓝色");

    //定义一个变量，记录当前画笔的颜色
    private Color forceColor = Color.BLACK;

    //创建一个BufferedImage位图对象
    BufferedImage image = new BufferedImage(AREA_WIDTH, AREA_HEIGHT, BufferedImage.TYPE_INT_RGB);

    //通过位图，获取关联的Graphics对象
    Graphics g = image.getGraphics();

    //自定义一个类，继承Canvas
    private class MyCanvas extends Canvas {
        @Override
        public void paint(Graphics g) {
            g.drawImage(image, 0, 0, null);
        }
    }

    MyCanvas drawArea = new MyCanvas();


    //定义变量，记录鼠标拖动过程中，上一次所处的坐标
    private int preX = -1;
    private int preY = -1;

    public void init() {
        //组装视图，逻辑控制

        ActionListener listener = new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String actionCommand = e.getActionCommand();
                switch (actionCommand) {
                    case "红色":
                        forceColor = Color.RED;
                        break;
                    case "绿色":
                        forceColor = Color.GREEN;
                        break;
                    case "蓝色":
                        forceColor = Color.BLUE;
                        break;
                }
            }
        };

        redItem.addActionListener(listener);
        greenItem.addActionListener(listener);
        blueItem.addActionListener(listener);

        colorMenu.add(redItem);
        colorMenu.add(greenItem);
        colorMenu.add(blueItem);

        //把colorMenu设置给绘图区域
        drawArea.add(colorMenu);

        drawArea.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseReleased(MouseEvent e) {//当鼠标键抬起时被调用
                boolean popupTrigger = e.isPopupTrigger();
                if (popupTrigger) {
                    colorMenu.show(drawArea, e.getX(), e.getY());
                }

                //重置preX和preY
                preX = -1;
                preY = -1;
            }
        });

        //设置位图的背景为白色
        g.setColor(Color.white);
        g.fillRect(0, 0, AREA_WIDTH, AREA_HEIGHT);

        //通过监听鼠标的移动，完成线条绘制
        drawArea.addMouseMotionListener(new MouseMotionAdapter() {
            //该方法，当鼠标左键按下，并进行拖动时，会被调用
            @Override
            public void mouseDragged(MouseEvent e) {
                if (preX > 0 && preY > 0) {
                    g.setColor(forceColor);
                    //画线条  需要两组坐标，分别代表线条的起点和终点  e.getX(),e.getY()可以获取坐标()
                    g.drawLine(preX, preY, e.getX(), e.getY());
                }

                //修正preX和preY的值
                preX = e.getX();
                preY = e.getY();

                //重绘组件
                drawArea.repaint();
            }
        });

        drawArea.setPreferredSize(new Dimension(AREA_WIDTH,AREA_HEIGHT));
        frame.add(drawArea);
        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        new HandDraw().init();
    }
}

2.8.4 ImageIO的使用

在实际生活中，很多软件都支持打开本地磁盘已经存在的图片，然后进行编辑，编辑完毕后，再重新保存在本地磁盘，如果使用AWT要完成这样的功能，那么需要使用到ImageIO这个类，可以操作本地磁盘的图片文件。

方法名称	方法功能
static BufferedImage read(File input)	获取本地磁盘图片文件
static BufferedImage read(InputStream input)	读取本地磁盘图片文件
static boolean write(RenderedImage im, String formatName, File output)	往本地磁盘中输出图片文件

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;


public class ReadAndSaveImage {

    private Frame frame = new Frame("图片查看器");

    MenuBar menuBar = new MenuBar();
    Menu menu = new Menu("文件");
    MenuItem open = new MenuItem("打开");
    MenuItem save = new MenuItem("另存为");

    //声明BufferedImage对象，记录本地存取到内存中的图片
    BufferedImage image;
    private class MyCanvas extends Canvas{
        @Override
        public void paint(Graphics g) {
            g.drawImage(image,0,0,null);
        }
    }
    MyCanvas drawArea = new MyCanvas();

    public void init() throws Exception{
        //组装视图

        open.addActionListener(e->{
            //打开一个文件对话框
            FileDialog fileDialog = new FileDialog(frame,"打开图片",FileDialog.LOAD);
            fileDialog.setVisible(true);

            //获取用户选择的图片路径以及名称
            String dir = fileDialog.getDirectory();
            String fileName = fileDialog.getFile();

            try {
                image = ImageIO.read(new File(dir,fileName));
                drawArea.repaint();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        });

        save.addActionListener(e->{
            //展示一个文件对话框
            FileDialog fileDialog = new FileDialog(frame,"保存图片",FileDialog.SAVE);
            fileDialog.setVisible(true);

            //获取用户设置的保存路径以及文件名称
            String dir = fileDialog.getDirectory();
            String fileName = fileDialog.getFile();

            try {
                ImageIO.write(image,"JPEG",new File(dir,fileName));
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        });

        menu.add(open);
        menu.add(save);

        menuBar.add(menu);

        //把菜单条放入到窗口中
        frame.setMenuBar(menuBar);
        frame.add(drawArea);

        frame.setBounds(200,200,740,508);

        frame.setVisible(true);

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



    public static void main(String[] args) throws Exception {
        new ReadAndSaveImage().init();
    }
}

2.8.5 五子棋

import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.io.File;

public class Gobang {
    //定义五子棋游戏窗口
    private JFrame f = new JFrame("五子棋游戏");

    //声明四个BufferedImage对象，分别记录四张图片
    BufferedImage table;
    BufferedImage black;
    BufferedImage white;
    BufferedImage selected;


    //声明棋盘的宽和高
    final int TABLE_WIDTH = 535;
    final int TABLE_HEIGHT = 536;

    //声明棋盘横向和纵向分别可以下多少子，他们的值都为15
    final int BOARD_SIZE = 15;

    //声明每个棋子占用棋盘的比率
    final int RATE = TABLE_WIDTH / BOARD_SIZE;

    //声明变量，记录棋子对于x方向和y方向的偏移量
    final int X_OFFSET = 5;
    final int Y_OFFSET = 6;

    //声明一个二维数组，记录棋子, 如果索引[i][j]处的值为  0-没有棋子  1-白棋  2-黑棋
    int[][] board = new int[BOARD_SIZE][BOARD_SIZE];

    //声明红色选择框的坐标  该坐标其实就是二维数组board中的索引
    int selected_X = -1;
    int selected_Y = -1;

    //自定义类，继承Canvas
    private class ChessBoard extends JPanel {
        @Override
        public void paint(Graphics g) {
            //绘图

            //绘制棋盘
            g.drawImage(table,0,0,null);

            //绘制选择框
            if (selected_X>0 && selected_Y>0){
                g.drawImage(selected,selected_X*RATE+X_OFFSET,selected_Y*RATE+Y_OFFSET,null);
            }

            //绘制棋子
            for (int i = 0; i < BOARD_SIZE; i++) {
                for (int j = 0; j < BOARD_SIZE; j++) {

                    //绘制黑棋
                    if (board[i][j] == 2){
                        g.drawImage(black,i*RATE+X_OFFSET,j*RATE+Y_OFFSET,null);
                    }
                    //绘制白棋
                    if (board[i][j] == 1){
                        g.drawImage(white,i*RATE+X_OFFSET,j*RATE+Y_OFFSET,null);
                    }
                }
            }
        }
    }

    ChessBoard chessBoard = new ChessBoard();


    //声明变量，记录当前下棋的颜色
    int board_type = 2;

    //声明底部需要用到的组件
    Panel p = new Panel();
    Button whiteBtn = new Button("白棋");
    Button blackBtn = new Button("黑棋");
    Button deleteBtn = new Button("删除");

    public void refreshBtnColor(Color whiteBtnColor,Color blackBtnColor,Color deleteBtnColor){
        whiteBtn.setBackground(whiteBtnColor);
        blackBtn.setBackground(blackBtnColor);
        deleteBtn.setBackground(deleteBtnColor);
    }

    public void init() throws Exception {
        //组装视图，编写逻辑
       whiteBtn.addActionListener(e->{
           // 修改当前要下的棋子的标志为1
           board_type = 1;
           // 刷新按钮的颜色
            refreshBtnColor(Color.GREEN,Color.GRAY,Color.GRAY);
       });

        blackBtn.addActionListener(e->{
            // 修改当前要下的棋子的标志为2
            board_type = 2;
            // 刷新按钮的颜色
            refreshBtnColor(Color.GRAY,Color.GREEN,Color.GRAY);
        });

        deleteBtn.addActionListener(e->{
            // 修改当前要下的棋子的标志为0
            board_type = 0;
            // 刷新按钮的颜色
            refreshBtnColor(Color.GRAY,Color.GRAY,Color.GREEN);
        });

        p.add(whiteBtn);
        p.add(blackBtn);
        p.add(deleteBtn);

        f.add(p,BorderLayout.SOUTH);

        //组装棋盘

        //初始化图片
        table = ImageIO.read(new File("awt-app\\img\\board.jpg"));
        white = ImageIO.read(new File("awt-app\\img\\white.gif"));
        black = ImageIO.read(new File("awt-app\\img\\black.gif"));
        selected = ImageIO.read(new File("awt-app\\img\\selected.gif"));

        //处理鼠标移动
        chessBoard.addMouseMotionListener(new MouseMotionAdapter() {
            //当鼠标移动时会调用该方法
            @Override
            public void mouseMoved(MouseEvent e) {

                selected_X = (e.getX()-X_OFFSET)/RATE;
                selected_Y = (e.getY()-Y_OFFSET)/RATE;

                chessBoard.repaint();
            }
        });

        //处理鼠标点击
        chessBoard.addMouseListener(new MouseAdapter() {
            //当鼠标被点击后 会调用这个方法
            @Override
            public void mouseClicked(MouseEvent e) {
                int xPos = (e.getX()-X_OFFSET)/RATE;
                int yPos = (e.getY()-Y_OFFSET)/RATE;

                board[xPos][yPos] = board_type;
                chessBoard.repaint();
            }

            @Override
            public void mouseExited(MouseEvent e) {
                selected_X=-1;
                selected_Y=-1;

                chessBoard.repaint();
            }
        });

        chessBoard.setPreferredSize(new Dimension(TABLE_WIDTH,TABLE_HEIGHT));
        f.add(chessBoard);

        //设置frame最佳大小并可见
        f.pack();
        f.setVisible(true);

    }

    public static void main(String[] args) throws Exception {
        new Gobang().init();
    }

}

二、Swing编程

Swing编程