AWT

1. AWT(Abstract Window Toolkit)，中文译为抽象窗口工具包，该包提供了一套与本地图形界面进行交互的接口，是Java提供的用来建立和设置Java的图形用户界面的基本工具。
2. 常用组件：如下关系图
   

1.1、Frame

构造方法：

Frame frame = new Frame("New Window");

要生成一个窗口，通常使用Window的子类Frame类进行实例化，而不是直接使用Window 类，框架的外观就像平常Windows系统下的窗口，有标题、边框、菜单和大小等。

案例演示：

package awtdemo;

import java.awt.*;
import java.util.Set;

public class TestFrame {
    public static void main(String[] args) {
        //new一个窗口
        Frame frame = new Frame("我的第一个界面");
        //设置窗口的大小，这个传的参数只能是boolean类型，true为可变，false就是不可变
        frame.setResizable(true);
        //设置窗口的可见性，传的参数也只能是boolean类型
        frame.setVisible(true);
        //设置窗口的背景颜色，这里可以new一个Color类自己RGB颜色，也可以直接传一个Color
       // frame.setBackground(new Color(85,150,86));
        frame.setBackground(Color.BLACK);
        //设置窗口的大小
        frame.setSize(400,600);
        //设置窗口的初始弹出来的位置
        frame.setLocation(500,500);
    }
}

效果展示：

然后发现关闭不了，那是因为我们没有设置关闭时间，现在只能通过IDEA停止java程序来关闭，如上图箭头所示。

1.2、Panel

构造方法：

Panel pnl = new Panel();

面板是一种透明的容器，没有标题和边框。与Frame 不同，Panel不能作为最外层的容器单独存在，它首先必须作为一个组件放置在其他容器（一般为Frame）中，然后把组件添加到它里面。在java.swing中则是JPanel。

案例演示：

package awtdemo;

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class TestPanel {
    public static void main(String[] args) {
        Frame frame = new Frame("我的第二个界面");
        //new一个Panel
        Panel panel = new Panel();
        //设置流式布局
        frame.setLayout(null);
        //设置最外面窗口弹出的坐标位置和背景颜色
        frame.setBounds(300,400,500,600);
        frame.setBackground(Color.BLUE);
        //设置透明画板的弹出位置和背景颜色
        panel.setBounds(50,50,400,500);
        panel.setBackground(Color.LIGHT_GRAY);
        //把panel添加进Frame中
        frame.add(panel);
        //把最外层窗口可见性设置为可见，两个就都可见了
        frame.setVisible(true);
        //设置关闭事件 这个是适配器模式，后面再继续探究，现在先用着
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
}

效果展示：

问题：如果把Panel的坐标设置的没有在Frame 的坐标范围内会怎么样？

出来的效果窗口就只会显示Frame不会显示Panel，因为我第一遍测试的时候试了，只会出现Frame设置的效果，要想让Panel显示只能通过放大Frame去看到他，想去尝试的小伙伴可以去尝试一下。

1.3、布局管理器

1.3.1、流布局管理器(FlowLayout)

FlowLayout是Panel 和 Applet 的默认布局管理器。在该布局管理器中，组件在容器中按照从上到下，从左到右的顺序进行排列，行满后则换行。

构造方法较多，例如：

• FlowLayout();

  默认构造方法，设置居中对齐方式，横向和纵向间隔均为默认5像素

• FlowLayout(FlowLayout.LEFT);

  设置居左对齐，横向和纵向间隔均为默认5像素

• FlowLayout(FlowLayout.RIGHT,20,40);

  设置居右对齐，横向间隔20像素，纵向间隔40像

package awtdemo;

import java.awt.*;

public class TestLayout {
    public static void main(String[] args) {
        Frame frame = new Frame("我的第三个窗口");
        //设置按钮
        Button button1 = new Button("button1");
        Button button2 = new Button("button2");
        Button button3 = new Button("button3");
        //设置流式布局 底下是布局的所有构造方法 可以自己测试 
        frame.setLayout(new FlowLayout(FlowLayout.RIGHT,20,40));
        //frame.setLayout(new FlowLayout(FlowLayout.TRAILING);
        //frame.setLayout(new FlowLayout(FlowLayout.CENTER));
        //frame.setLayout(new FlowLayout(FlowLayout.LEFT));
        //frame.setLayout(new FlowLayout(FlowLayout.LEADING));
        frame.setSize(600,200);
        //把按钮添加到Frame面板中
        frame.add(button1);
        frame.add(button2);
        frame.add(button3);

        frame.setVisible(true);


    }
}

效果展示：

1.3.2、边界布局管理器(BorderLayout)

构造方法：

BorderLayout bl = new BorderLayout();`

BorderLayout是Window、Frame和Dialog的默认布局管理器，其将容器分成North、South、East、West和Center 5个区域，每个区域只能放置一个组件。在使用add()方法添加组件到容器时，必须指定将其放置在哪个区域中。使用BorderLayout时，如果容器大小发生变换，组件的相对位置不变

案例演示：

package awtdemo;

import java.awt.*;

public class TestBorderLayout {
    public static void main(String[] args) {
        Frame frame = new Frame("我的第四个窗口");
        //创建五个按钮
        Button east = new Button("East");
        Button west = new Button("West");
        Button south = new Button("South");
        Button north = new Button("North");
        Button center = new Button("Center");
        //把五个按钮全部添加进面板中
        frame.add(east,BorderLayout.EAST);
        frame.add(west,BorderLayout.WEST);
        frame.add(south,BorderLayout.SOUTH);
        frame.add(north,BorderLayout.NORTH);
        frame.add(center,BorderLayout.CENTER);

        frame.setSize(700,700);
        frame.setVisible(true);
    }
}

效果展示：

1.3.3、网格布局管理器(GridLayout)

构造方法：

GridLayout gl = new GridLayout(3,5); //3行5列

GridLayout 可使容器中的各个组件呈网格状布局，平局占据容器的空间，即使容器的大小发生变化，每个组件还是平均占据容器的空间。和FlowLayout一样，GridLayout也是按照从上到下，从左到右的规律进行排列的。

案例演示：

package awtdemo;

import java.awt.*;

public class TestGridLayout {
    public static void main(String[] args) {
        Frame frame = new Frame("我的第五个窗口");
        frame.setSize(400,500);
        Button button1 = new Button("1");
        Button button2 = new Button("1");
        Button button3 = new Button("1");
        Button button4 = new Button("1");
        frame.add(button1);
        frame.add(button2);
        frame.add(button3);
        frame.add(button4);
        //设置为两行两列
        frame.setLayout(new GridLayout(2,2));
        frame.setVisible(true);

    }
}

效果展示：

练习：如何让按钮按照如下图所示布局

过程分析➕案例演示：

package awtdemo;

import java.awt.*;
/*
1.首先我们需要一个顶级的窗口Frame
2.把这个顶级Frame分割成上下两部分，我们就会想到Panel（特性：无法单独显示，必须添加到某个容器中）
3.再把上下两个再分割成两个部分（左右中这个结构），我们我们就需要四个Panel
4.把4个Panel用边界布局管理器排列好完成Panel和Panel之间的嵌套
5.把嵌套好的Panel添加大奥Frame中即可
*/

public class PractiseDemo {
    public static void main(String[] args) {
        //顶级窗口
        Frame frame = new Frame("我的第六个窗口");
        frame.setSize(500,400);
        frame.setLocation(500,500);
        frame.setBackground(Color.BLACK);
        frame.setVisible(true);
        frame.setLayout(new GridLayout(2,1));
        //4个面板
        Panel p1 = new Panel(new BorderLayout());
        Panel p2 = new Panel(new GridLayout(2, 1));
        Panel p3 = new Panel(new BorderLayout());
        Panel p4 = new Panel(new GridLayout(2, 2));
        //第一部分 
        //给面板1增添两个按钮并用边界布局管理器布局到左右两侧
        p1.add(new Button("p1-button"),BorderLayout.WEST);
        p1.add(new Button("p1-button"),BorderLayout.EAST);
        //给面板2增添两个按钮
        p2.add(new Button("p2-button"));
        p2.add(new Button("p2-button"));
        //把2面板用边界布局管理器添加到1面板的中间
        p1.add(p2,BorderLayout.CENTER);

        //第二部分
        //给面板3增添两个按钮并用边界布局管理器布局到左右两侧（跟面板1的操作相同）
        p3.add(new Button("p3-button"),BorderLayout.EAST);
        p3.add(new Button("p3-button"),BorderLayout.WEST);
        //中间四个我们可以用for循环去添加按钮，也可以手动一个个添加都行 这里用for循环
        for (int i = 0; i < 4; i++) {
            p4.add(new Button("p4-button"));
        }
        //把4面板用边界布局管理器添加到3面板的中间
        p3.add(p4,BorderLayout.CENTER);
        //因为上面我们已经把面板2和面板4添加到面板1和面板3上，所以我们只需要要把面板1和面板3添加到顶级窗口上即可显示
        frame.add(p1);
        frame.add(p3);
    }
}

效果展示：

1.4、事件监听

上面我们实现了在面板上面绘制按钮，但是有了按钮，我们如何让按钮按下去有他的功能，这就需要我们给他设置。Button源代码调中用接口方法，而我们的监听处理函数则必须要实现该接口（ActionListener），这样利用多态，使得Button虽调用的为该接口的方法，但运行的则是我们new出来的对象方法。类似于Button提供了这么一个钩子，但是钩子上面是什么东西他自己并不清楚，我们只需要人为地往上面挂上我们需要的东西即可

案例演示：

package awtdemo;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
/*
事假监听的四步：
1.要有时间的源对象:button
2.要发生某种事件（类）：TestActionEvent，封装了事件的信息  
3.要有监听器（接口）：myActionlistener  接到事件后进行处理  
4.要把监听器注册到事件源对象上 button.addActionListener(myActionlistener); 
*/
public class TestActionEvent {
    public static void main(String[] args) {
        Frame frame = new Frame("我的第七个窗口");
        Button button = new Button();
        //因为addActionListener()需要一个 ActionListener，所以我们需要构造一个 ActionListener
        //把我们构造出来的监听事件实例化
        MyActionlistener myActionlistener = new MyActionlistener();
        //添加进去
        button.addActionListener(myActionlistener);
        frame.add(button,BorderLayout.CENTER);
        //自适应
        frame.setVisible(true);
        //关闭窗口事件
        windowClose(frame);
    }
    //关闭窗体的事件 适配器模式
    private static void windowClose(Frame frame){
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
}
//构造一个 ActionListener我们要继承 ActionListener这个接口，继承接口我们就要重写它里面的方法
class MyActionlistener implements ActionListener{
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("我爱你");
    }
}

效果展示：

案例演示：多个按钮，共享一个事件

package awtdemo;

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

public class TestActionEvent2 {
    public static void main(String[] args) {
        Frame frame = new Frame("我的第八个窗口");
        Button button1 = new Button("start");
        Button button2 = new Button("stop");
        //setActionCommand()可以显示的定义出发回返回的命令，不如果不显示定义，会显示默认的值（即按钮的名字）
        //可以多个按钮只写一个监听类
        button2.setActionCommand("button-stop");
        MyMonitor myMonitor = new MyMonitor();
        button1.addActionListener(myMonitor);
        button2.addActionListener(myMonitor);
        frame.add(button1,BorderLayout.NORTH);
        frame.add(button2,BorderLayout.SOUTH);
        frame.pack();
        frame.setVisible(true);
    }
}
class MyMonitor implements ActionListener{
    @Override
    public void actionPerformed(ActionEvent e) {
        //e.getActionCommand()接收定义的命令，并返回
        System.out.println("按钮被点击了："+e.getActionCommand());
    }
}

效果展示：

1.5、输出框TextField监听

package awtdemo;

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

public class TestText1 {
    public static void main(String[] args) {
        new MyFrame();//启动面板
    }
}

class MyFrame extends Frame{
    public MyFrame(){
        TextField textField = new TextField();
         add(textField);//把文本框加入面板
          //监听这个文本框输入的文字
        MyActionlistener2 myActionlistener2 = new MyActionlistener2();
        //按下enter 就会触发这个输入框的事件
        textField.addActionListener(myActionlistener2);
         //设置替换编码
        textField.setEchoChar('*');
        setVisible(true);
        pack();
    }
}
//监听类
class MyActionlistener2 implements ActionListener{

    @Override
    public void actionPerformed(ActionEvent e) {
        TextField field = (TextField) e.getSource();   //获得一些资源,返回的一个对象
        System.out.println(field.getText()); //获得输入框的文本
        field.setText(""); //清除文本框  ""=null
    }
}

效果展示：

1.6、简易加法计算器

package awtdemo;

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

public class TestCalc {
    public static void main(String[] args) {
        new Calclator();
    }
}
class Calclator extends Frame{
    public Calclator(){
        //1.三个文本框
        TextField num1 = new TextField(10);
        TextField num2 = new TextField(10);
        TextField num3 = new TextField(20);
         //一个按钮
        Button button = new Button("=");
        button.addActionListener(new MycalculatorListener(num1,num2,num3));
        //一个标签
        Label label = new Label("+");
        //设置为流式布局
        setLayout(new FlowLayout());
        //按照顺序添加到面板中
        add(num1);
        add(label);
        add(num2);
        add(button);
        add(num3);

        pack();
        setVisible(true);
    }
}
class MycalculatorListener implements ActionListener{
    //获取三个变量
    private  TextField num1,num2,num3;
    //创建三个变量的有参构造
    public MycalculatorListener(TextField num1, TextField num2, TextField num3) {
        this.num1 = num1;
        this.num2 = num2;
        this.num3 = num3;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //1.获得加数和被加数
        //因为getText()方法里面传的是String类型这里我们把它包装成int类型
        int n1 = Integer.parseInt(num1.getText());
        int n2 = Integer.parseInt(num2.getText());
        //2.将这个值加法运算后，放到第三个框
        num3.setText((n1+n2)+"");//自动装箱成String类型
        //3.清除前两个框
        num1.setText("");
        num2.setText("");

    }
}

效果展示：

改进：采用面向对象写法

package awtdemo;


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

//简易计算器
public class TestCalc {
    public static void main(String[] args) {
        new Calculator().loadFrame();
    }
}

//计算器类
class Calculator extends Frame{

    //属性
    TextField num1,num2,num3;

    //方法
    public void loadFrame(){
        num1 = new TextField(10);//字符数
        num2 = new TextField(10);//字符数
        num3 = new TextField(20);//字符数
        Button button = new Button("=");
        
        Label label = new Label("+");

        button.addActionListener(new MyCalculatorListener(this));

        //布局
        setLayout(new FlowLayout());
        add(num1);
        add(label);
        add(num2);
        add(button);
        add(num3);

        pack();
        setVisible(true);
    }


}

//监听器类
class MyCalculatorListener implements ActionListener{

    //获取计算器这个对象,在一个类中组合另外一个类；
    Calculator calculator = null;

    public MyCalculatorListener(Calculator calculator) {
        this.calculator = calculator;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //1. 获得加数和被加数
        //2. 将这个值 + 法运算后，放到第三个框
        //3. 清除前两个框
        int n1 = Integer.parseInt(calculator.num1.getText());
        int n2 = Integer.parseInt(calculator.num2.getText());
        calculator.num3.setText(""+(n1+n2));
        calculator.num1.setText("");
        calculator.num2.setText("");

    }

}

继续优化：使用内部类(更好的封装)

package com.kuang.lesson02;


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

//简易计算器
public class TestCalc {
    public static void main(String[] args) {
        new Calculator().loadFrame();
    }
}

//计算器类
class Calculator extends Frame {

    //属性
    TextField num1, num2, num3;

    //方法
    public void loadFrame() {
        num1 = new TextField(10);//字符数
        num2 = new TextField(10);//字符数
        num3 = new TextField(20);//字符数
        Button button = new Button("=");

        Label label = new Label("+");

        button.addActionListener(new MyCalculatorListener());

        //布局
        setLayout(new FlowLayout());
        add(num1);
        add(label);
        add(num2);
        add(button);
        add(num3);

        pack();
        setVisible(true);
    }

    
    //监听器类
    //内部类的好处，就是可以畅通无阻的访问外部的属性和方法！
    private class MyCalculatorListener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            //1. 获得加数和被加数
            //2. 将这个值 + 法运算后，放到第三个框
            //3. 清除前两个框
            int n1 = Integer.parseInt(num1.getText());//直接调用外部类的属性
            int n2 = Integer.parseInt(num2.getText());
            num3.setText("" + (n1 + n2));
            num1.setText("");
            num2.setText("");
        }
    }
}

1.7、画笔

案例演示：测试

package awtdemo;

import java.awt.*;

public class TextPaint {
    public static void main(String[] args) {
      new MyPaint().loadFrame();
    }
}
class MyPaint extends Frame{
    public void loadFrame(){
        setBounds(300,300,500,600);
        setVisible(true);
    }

    @Override
    public void paint(Graphics g) {
        //创建画笔的颜色
        g.setColor(Color.red);
        g.drawOval(200,100,100,100);
        g.fillRect(100,100,100,100);
        g.fillOval(200,200,200,200);

    }
}

效果展示：

上述只是电脑在画画，怎么实现鼠标画画，这就需要鼠标监听实现鼠标画画

1.8、鼠标监听实现鼠标画画

原理图：

案例演示：

package awtdemo;

import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Iterator;
//鼠标监听事件
public class TestMouseListener {
    public static void main(String[] args) {
        new MyFrame2("画图");
    }
}
//画板的类
class MyFrame2 extends Frame{
    //画画需要画笔。需要监听鼠标当前的位置，需要集合来存储
    ArrayList points;
    public MyFrame2(String title){
        super(title);
        setBounds(200,200,400,300);
        points = new ArrayList<>();
        setVisible(true);
        //添加鼠标监听事件
        this.addMouseListener(new MyMouseListener());
    }
    
//重写画笔的方法
    @Override
    public void paint(Graphics g) {
        Iterator iterator = points.iterator();
        while (iterator.hasNext()){
            Point point = (Point)iterator.next();
            g.setColor(Color.black);
            g.fillOval(point.x,point.y,10,10);
        }
    }
    //添加一个点到界面上
    public void addPaint(Point point){
        points.add(point);
    }
   //鼠标监听事件(适配器模式)
    private class MyMouseListener extends MouseAdapter{
        //重写鼠标按压的方法
        @Override
        public void mousePressed(MouseEvent e) {
            MyFrame2 frame2 = (MyFrame2)e.getSource();
            //我们点击的时候，就会在界面上产生一个点，这个点就是我们鼠标的点
            frame2.addPaint(new Point(e.getX(),e.getY()));
          //每次点击鼠标都需要重新画一遍
            frame2.repaint();//刷新
        }
    }
}

效果展示：

1.9、键盘监听

案例演示：

package awtdemo;

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class TestWindow {
    public static void main(String[] args) {
        new WindowFrame();
    }
}

class WindowFrame extends Frame{
    public WindowFrame(){
        setBackground(Color.blue);
        setBounds(100,100,200,200);
        setVisible(true);
        this.addWindowListener(
                //匿名内部类
                //适配器模式
                new WindowAdapter() {
                    //关闭窗口
                    @Override
                    public void windowClosing(WindowEvent e) {
                        System.out.println("windowClosing");
                        //退出
                        System.exit(0);
                    }
                    //激活窗口
                    @Override
                    public void windowActivated(WindowEvent e) {
                        WindowFrame source = (WindowFrame) e.getSource();
                        source.setTitle("被激活了");
                        System.out.println("windowActivated");
                    }
                }
        );
    }

}

1.10、键盘监听

package awtdemo;

import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;

public class TestKetListener {
    public static void main(String[] args) {
     new KeyFrame();
    }
}
class KeyFrame extends Frame{
    public KeyFrame(){
        setBounds(100,200,300,400);
        setVisible(true);
        //匿名内部类
        this.addKeyListener(new KeyAdapter() {
            //键盘按下
            @Override
            public void keyPressed(KeyEvent e) {
                int keyCode = e.getKeyCode();
                //打印的是每个键所对应的编码
                System.out.println(keyCode);
                //可以根据按下的不同的操作，产生不同的结果
                if (keyCode == KeyEvent.VK_UP){
                    System.out.println("你按下了上键");
                }
            }
        });
    }
}

效果展示：