GUI

注：一些代码截图虽然没有了，但是不影响食用！
核心技术：AWT+Swing,

需要jre环境

AWT只有画笔，Swing能画图

AWT

Frame

awt包下

1.Frame类可以定义一个在内存中基础的图形化界面，所以无法在电脑界面显示，需要类中的方法来设置可见性（setVisible（true）），类的构造方法表示图形化界面左上方的名字。

2.可以望文生义，比如需要设置颜色，位置，那么就在Frame类中以set开头的方法中寻找。

3.基本界面设置代码：

import java.awt.*;

public class Gui_01 {
    public static void main(String[] args) {
        //看文档或者源码学习类
        Frame frame=new Frame("邹飞鸣的第一个GUI程序");

        //设置可见性
        frame.setVisible(true);

        //设置窗口大小
        frame.setSize(500,500);

        //设置坐标
        frame.setLocation(500,500);

        //坐标和窗口大小可以用一个方法直接设置,x坐标，y坐标，w宽，h高
		frame.setBounds(x,y,w,h)

        //设置背景颜色
        frame.setBackground(Color.white);

        //设置窗口大小固定
        frame.setResizable(false);
    }
}

如果想设置多个界面，可以继承Frame类，然后构造方法写界面的参数。

import java.awt.*;

public class Gui_02 {
    public static void main(String[] args) {
        new MyFrame(100,100,100,100);
        new MyFrame(200,100,100,100);
        new MyFrame(100,300,100,100);
        new MyFrame(300,300,100,100);
    }
}
class MyFrame extends Frame{
    private static  int id=1 ;

    public MyFrame(){}
    public MyFrame(int x,int y,int w,int h){

        //子类调用父类构造方法，
        super("这是我的第"+(id++)+"个图像界面");

        //调用方法设置坐标和宽高
        super.setBounds(x,y,w,h);

        //设置可见性
        setVisible(true);

        //设置背景颜色
        setBackground(Color.white);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VoWwuYlY-1598874922239)(file:///C:\Users\邹飞鸣\AppData\Roaming\Tencent\Users\1160653906\QQ\WinTemp\RichOle\X0MLM@@DOU5HX0LIY2NQ`DH.png)]

Panel（面板）

1.不能单独存在，

2.和界面一样可以设置大小，位置（相对界面的位置），背景颜色等等，

3.参数设置开始需要设置布局：frame.setLayout（null）（默认为空），完成后需要放入界面中：frame.add（panel）

4.如何设置关闭程序的监听器

代码：

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

public class Gui_03 {
    public static void main(String[] args) {
        Frame frame=new Frame("添加面板");
        frame.setBackground(Color.white);
        frame.setBounds(200,200,700,700);
        Panel panel=new Panel();

        //设置布局，布局为空，如果少了这行代码，画布无论多大，都将会覆盖整个界面
        frame.setLayout(null);
        panel.setBackground(Color.blue);
        panel.setBounds(20,20,500,500);

        //将画布添加进界面中
        frame.add(panel);

        //可见性
        frame.setVisible(true);

        //监听事件，监听窗口关闭事件 System.exit(0)
        //如果使用addWindowListener类，就需要实现类中所有方法，太多了不需要，这时就可以使用这个类的子类WindowAdapter来重写实现一部分功能，这就叫适配器模式
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {

                //窗口关闭需要做的事情
                System.exit(0);
            }
        });
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CrLg0eEI-1598874922242)(AZP%7D_VH%7DIM9SV%608J%5D%5BNQ%5B00.jpg)]

布局

流式布局

1.从左到右布局

代码：

import java.awt.*;

public class G04 {
    public static void main(String[] args) {
        Frame frame=new Frame();
        
        //定义按钮
        Button button=new Button("1");
        Button button2=new Button("2");
        Button button3=new Button("3");
        
        //定义流式布局，参数中还可指定是左右上下中：frame.setLayout(new FlowLayout(FlowLayout.CENTER));默认是置顶中间，一行排满后会在第二行继续排
        frame.setLayout(new FlowLayout());
        frame.setSize(500,500);
        
        //添加按钮进界面
        frame.add(button);
        frame.add(button2);
        frame.add(button3);
        frame.setVisible(true);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1sd7htgT-1598874922245)(%7DRO1G9ZMT66%60J%5DX%7DE8S%5B834.png)]

东西南北中布局

代码：

import java.awt.*;

public class G04 {
    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");
        Button center1=new Button("Center1");

        
        //可以在添加进界面时定义布局及位置：BorderLayout.EAST
        //此布局只能有五个东西，多出来的会被替换掉，按照东西南北中顺序摆放
        //布局中可以嵌套布局
        frame.add(east,BorderLayout.EAST);
        frame.add(west,BorderLayout.WEST);
        frame.add(south,BorderLayout.SOUTH);
        //frame.add(center1,BorderLayout.WEST);
        frame.add(north,BorderLayout.NORTH);
        frame.add(center,BorderLayout.CENTER);

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

    }
}

![img](file:///C:\Users\邹飞鸣\AppData\Roaming\Tencent\Users\1160653906\QQ\WinTemp\RichOle\ESNZIS5NZ$J6}2(KYS)FT.png)

列表布局

1.自动填充全部位置，GridLayout有四个参数，分别是，行，列，表格间宽距，高距。

import java.awt.*;

public class G04 {
    public static void main(String[] args) {
        Frame frame=new Frame();
        Button button=new Button("1");
        Button button2=new Button("2");
        Button button3=new Button("3");

	    //设置布局
        frame.setLayout(new GridLayout(2,2));

        frame.add(button);
        frame.add(button2);
        frame.add(button3);

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

    }
}

练习：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FF82vE11-1598874922248)(A%60965P%254GPWYV4O$7%7B_MK.png)]

import java.awt.*;
  
思路：先整体分为上下，用列表，其次上面整体用东南西北中布局，中间嵌套列表布局，整体下面和上面方法相似
public class G04 {
    public static void main(String[] args) {
        Frame frame=new Frame();

        //设置整体的上下两块
        frame.setBackground(Color.white);
        frame.setSize(500,500);
        frame.setVisible(true);
        frame.setLayout(new GridLayout(2,0));

        Panel panel1=new Panel(new  BorderLayout());
        Panel panel2=new Panel(new BorderLayout());
        Panel panel3=new Panel(new GridLayout(2,1));
        Panel panel4=new Panel(new GridLayout(2,2));

        //设置上面，中间的两行
        panel3.add(new Button("1"));
        panel3.add(new Button("2"));

        //设置整个上面的布局
        panel1.add(new Button("3"),BorderLayout.WEST);
        panel1.add(new Button("4"),BorderLayout.EAST);
        panel1.add(panel3,BorderLayout.CENTER);

        //设置下面中间的
        panel4.add(new Button("5"));
        panel4.add(new Button("6"));
        panel4.add(new Button("7"));
        panel4.add(new Button("8"));

        //设置下面整体
        panel2.add(new Button("9"),BorderLayout.WEST);
        panel2.add(new Button("10"),BorderLayout.EAST);
        panel2.add(panel4,BorderLayout.CENTER);

        //将上下两个画布添加进界面
        frame.add(panel1);
        frame.add(panel2);
    }
}

事件监听器

新知：
1.addActionListener（）方法获得这个东西的名字（如：按钮的名字）

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

public class G05 {
    public static void main(String[] args) {
        Frame frame=new Frame("事件监听器");
        frame.setVisible(true);
        frame.setSize(500,500);

        Button button1=new Button("b1");
        Button button2=new Button("b2");
        frame.add(button1,BorderLayout.SOUTH);
        frame.add(button2,BorderLayout.NORTH);
        MyaddActionListener My=new MyaddActionListener();


        //对按钮的监听，是一个接口，需要实现类，在实现方法中写按钮点击后的操作
        button1.addActionListener(My);
        button2.addActionListener(My);
    }
}
class MyaddActionListener implements ActionListener{
    @Override
    public void actionPerformed(ActionEvent e) {

        //getActionCommand方法是得到按钮的名称：b1/b2
        Frame frame1=new Frame("事件监听器1");
        frame1.setVisible(true);
        frame1.setSize(200,200);
        frame1.add(new Button(e.getActionCommand()));
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sPTQUzDo-1598874922250)(_$U3G3DWX0QLUAQ2UBSD722.png)]

文本框监听

新知：

1.让界面居中 ，获取系统桌面宽和高setLocation(((Toolkit.getDefaultToolkit().getScreenSize().width)/2)-250((Toolkit.getDefaultToolkit().getScreenSize().height)/2)-250);

2.创建文本框
TextField textField=new TextField();

3.将文本框中输入的文字替换成指定文字，但后台获取的内容不变,参数是char类型
textField.setEchoChar(‘邹’);

4.获取一些资源，返回一个对象，返回的对象是调用addActionListener方法的对象
TextField textField1= (TextField)e.getSource();

5.获取文本框内容
textField1.getText();

6.清空文本框
textField1.setText("");//不能填null，null是对象，不是内容

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

public class G06 {
    public static void main(String[] args) {
        new MyFrame1();
    }
}
class MyFrame1 extends Frame{
    public MyFrame1(){
        setSize(500,500);

        //让界面居中
        setLocation(((Toolkit.getDefaultToolkit().getScreenSize().width)/2)-250,((Toolkit.getDefaultToolkit().getScreenSize().height)/2)-250);
        setVisible(true);

        //创建文本框
        TextField textField=new TextField();
        add(textField);

        //将文本框中输入的文字替换成指定文字，但后台获取的内容不变,参数是char类型
        textField.setEchoChar('邹');

        //设置监听事件
        MyActionListener my=new MyActionListener();
        textField.addActionListener(my);
    }
}
class MyActionListener implements ActionListener{

    @Override
    public void actionPerformed(ActionEvent e) {
        //获取一些资源，返回一个对象
      TextField textField1=  (TextField)e.getSource();

      //获取文本框内容
      System.out.println(textField1.getText());


      //清空文本框
        textField1.setText("");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oozcmOwJ-1598874922251)(1.png)]

简易计算器

新知：

1.class MyFrame4 extends Frame implements ActionListener
    可以继承且实现接口
2.JButton
    这个可以用汉字命名按钮，且是最新的按钮类
3.for(Button button:arrayList){
            button.addActionListener(this);
        }
	用集合存储按钮后，可以用增强for来达到对所以按钮监听的目的，接收用对应类型的值Button button，就可以调用对应特有的方法（组合？）
4.字符串的切割及判断对应的分隔符是什么

​

opp原则：组合大于继承

继承：
    class A extends B
组合：
    class A{
        public B b;
    }

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.Collections;

/*设计一个按钮式计算器
----------------
----------------
1   2   3   +  |
4   5   6   -  |
7   8   9   x  |
清除 0   =   ÷  |
 */
public class G07_1 {
    public static void main(String[] args) {
        new MyFrame4();
    }
}

/*第一步，设计计算器的界面，先定义界面的初始参数，然后将界面通过列表布局，分为5行一列
   第一行：先写装按钮的容器：画布，（如果不写画布那么默认五行，一行一个按钮）文本框，显示输入的数值及最后的结果
   第二行：画布，数值1,2,3,+这四个按钮
   第三行：以此类推，和第二行差不多
   注：这些按钮，文本框，画布的定义只能在构造方法外面，因为我们要使文本框作用域包含整个类，这样才能在本类的实现
   ActionListener接口的方法中使用文本框,所以将监听器的实现方法直接写在类中，则类即为此接口的实现类，也可使用
   内部类方法，这样做完全是因为我们要使用的文本框其作用域只能有这么大，只能被迫将接口的实现写在同一个类中
    */
class MyFrame4 extends Frame implements ActionListener {
//第1.1步,创建每行的组件。
    //文本框
    TextField textField = new TextField();

    //创建第二行的组件容器画布，用列表布局。
    Panel panel1 = new Panel(new GridLayout(1, 4));
    Button button1 = new Button("1");
    Button button2 = new Button("2");
    Button button3 = new Button("3");
    Button buttonplus = new Button("+");

    //创建第3行的组件容器画布，用列表布局。
    Panel panel2 = new Panel(new GridLayout(1, 4));
    Button button4 = new Button("4");
    Button button5 = new Button("5");
    Button button6 = new Button("6");
    Button buttonreduce = new Button("-");

    //创建第4行的组件容器画布，用列表布局.
    Panel panel3 = new Panel(new GridLayout(1, 4));
    Button button7 = new Button("7");
    Button button8 = new Button("8");
    Button button9 = new Button("9");
    Button buttonride = new Button("x");

    //创建第5行的组件容器画布，用列表布局。
    Panel panel4 = new Panel(new GridLayout(1, 4));
    JButton button_eliminate = new JButton("清屏");
    Button button0 = new Button("0");
    Button button_equal = new Button("=");
    Button button_except = new Button("÷");

    public  MyFrame4(){
//第1.2步定义界面初始参数,写在构造方法内
        //界面居中
        setBounds(((Toolkit.getDefaultToolkit().getScreenSize().width) / 2) - 250, ((Toolkit.getDefaultToolkit().getScreenSize().height) / 2) - 250, 500, 500);

        //界面五行一列布局
        setLayout(new GridLayout(5, 1));

        //界面可见性
        setVisible(true);

//第1.3步，将所有组件添加到对应的界面或者画布中
        //文本框写入
        add(textField);

        //第二行写入
        panel1.add(button1);
        panel1.add(button2);
        panel1.add(button3);
        panel1.add(buttonplus);
        add(panel1);

        //第三行写入
        panel2.add(button4);
        panel2.add(button5);
        panel2.add(button6);
        panel2.add(buttonreduce);
        add(panel2);

        //第四行写入
        panel3.add(button7);
        panel3.add(button8);
        panel3.add(button9);
        panel3.add(buttonride);
        add(panel3);

        //第五行写入
        panel4.add(button_eliminate);
        panel4.add(button0);
        panel4.add(button_equal);
        panel4.add(button_except);
        add(panel4);

//第1.4步，将所有的按钮设置监听器
        /*监听前可以将所有按钮存储在集合中，这样可以减少重复代码,集合类型直接用Button，

         */

        ArrayList<Button> arrayList=new ArrayList<>();
        //用工具类来一次性填写多个参数,注：button_eliminate，类型不是Button而是JButton所以，单独拿出来监听
        Collections.addAll(arrayList,button0,button1,button2,button4,button5,button6,button7,button8,button9,button_equal,button_except,buttonplus,button3,buttonreduce,buttonride);

        //遍历集合并定于监听器，且先行写出button_eliminate的监听器,参数因为是在本类中实现类，所以直接填this
        button_eliminate.addActionListener(this);
        for(Button button:arrayList){
            button.addActionListener(this);
        }
        //附加结束程序进程的功能，可忽略
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {

                //窗口关闭需要做的事情
                System.exit(0);
            }
        });

    }
/*第二步，对所有的按钮和文本框进行联系，点击按钮，按钮代表的名字将在文本框显示，
    且当点击“=”时，将自动计算对应的值并在文本框中只显示结果，如，依次点“1” “+”
    “1” “=”，文本框最终会显示”2“    ,这一切都要在实现方法中写即actionPerformed方法中
    */
    String str1="";//用来存储所有按下的按钮值
    @Override
    public void actionPerformed(ActionEvent e) {

        //获取按钮名字
        String str = e.getActionCommand();

        /*
        因为具有特殊功能的按钮只有“=”和“清屏”所以我们可以用if语句将其分为三类，
        普通的按钮：只是在框中显示自身的值
        “=”按钮：计算对应的值
        "清屏"按钮：清除文本框中的内容，以重新计算
         */
        if(str.equals("=")){
            /*
            按下=号后，我们能够得到的只是文本框中的一串字符串，而且里面还有+，-，x，÷四个不能进行常规转换
            的字符，所以就可以使用字符串切割方法：split()，如果分隔符“+，-，x，÷”分割成功，返回的数组中
            会有两个参数，如果没有成功，则只有一个参数，所以依据这个特性，可以判断分隔符是哪个，也就是说，
            可以知道是进行什么运算，那我们可以将数组中的两个字符串元素用Integer类，转换成int类型进行计算
            ，然后又转换回来进行输出
             */
            String text=textField.getText();//获取文本框内容
            String[] text1;//分割后存储的数组
            int c;//运算后的结果
            if ((text1 = text.split("\\+")).length == 2) {
                c = Integer.parseInt(text1[0]) + Integer.parseInt(text1[1]);
                textField.setText(String.valueOf(c));

            } else if ((text1 = text.split("-")).length == 2) {
                c = Integer.parseInt(text1[0]) - Integer.parseInt(text1[1]);
                textField.setText(String.valueOf(c));

            } else if ((text1 = text.split("x")).length == 2) {
                c = Integer.parseInt(text1[0]) * Integer.parseInt(text1[1]);
                textField.setText(String.valueOf(c));

            } else if ((text1 = text.split("÷")).length == 2) {
                c = Integer.parseInt(text1[0]) / Integer.parseInt(text1[1]);
                textField.setText(String.valueOf(c));

            }
        }else if(str.equals("清屏")){
            /*
            清屏操作除了要将累积存储的值str1重置外，还要将文本框清屏
             */
            str1 = "";
            textField.setText("");
        }else{
            /*当按下普通按钮时，文本框要显示对应的值外，之前按下的普通按钮的值也不能被清除掉
            但是setText（）方法是清屏后再输出括号中的参数，所以我们可以将所有的参数累积存储，
            保证不会将之前的值给清除掉，所以我们在此方法的外面定义str1用来存储所有按下的按钮值
             */
            //输出所以按下的按钮值
            textField.setText(str1=str1+str);
        }
    }
/*
-----------------------------------------------------------------------------------------
以上是计算器的基本实现，如果想进一步优化如，点击程序右上角的X能够将程序结束，这个功能我们采用适配器模式
addWindowListener(new WindowAdapter() {
    @Override
    public void windowClosing(WindowEvent e) {

        //窗口关闭需要做的事情
        System.exit(0);
    }
});
 */
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SK1Lb10E-1598874922252)(image-20200819010625414.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ChwIotHN-1598874922252)(image-20200819010645705.png)]

画笔（paint）

新知：

1.画笔颜色
        g.setColor(Color.red);
2.画的形状，线，字符串，圆，正方形等等
     //画个字符串
        g.drawString("邹飞鸣",100,100);
        //圆,不是实心
        g.drawOval(100,150,50,50);
        //实心圆
        g.fillOval(100,200,50,50);
        //矩形
        g.fillRect(100,250,50,50);
3.画完后要将画笔颜色还原成黑色，防止下一次使用时颜色出错

import java.awt.*;

public class G08 {
    public static void main(String[] args) {
        new MyPaint();
    }
}
class MyPaint extends Frame{
    public MyPaint(){
        setBounds(500,500,500,500);
        setVisible(true);
    }
        //alt+ins选择重写项，重写paint，取消super调用的构造方法
    @Override
    public void paint(Graphics g) {

        //画笔颜色
        g.setColor(Color.red);

        //画的形状，线，字符串，圆，正方形等等
        //画个字符串
        g.drawString("邹飞鸣",100,100);
        //圆,不是实心
        g.drawOval(100,150,50,50);
        //实心圆
        g.fillOval(100,200,50,50);
        //矩形
        g.fillRect(100,250,50,50);

        //画完后要将画笔颜色还原成黑色，防止下一次使用时颜色出错
        g.setColor(Color.black);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FnkrCgaS-1598874922253)(image-20200819171131423.png)]

鼠标监听

新知：

1.将子类构造方法添加String参数，这个参数可以通过super传递给父类，从而达到下面给程序命名的作用
    
2.以内部类形式实现鼠标监听
            this.addMouseListener(new MyMouseListener());  
  this代表当前类，内部类可以写成：
      private class MyMouseListener 
          
3.使用适配器模式，将接口变成继承，继承自java中已经实现了此接口的类，用以只重写需要的方法
        private class MyMouseListener extends MouseAdapter  
            
4.重写监听鼠标按下事件的方法，鼠标的监听方法有，按下，按住不放，弹起
            @Override
            public void mouseClicked(MouseEvent e)          
            
5.重绘组件
                frame.repaint();    
		此方法会调用update()（清除当前显示并调用paint()方法）方法，
  有四种重写方法：
  		1.public void repaint()
            
        2.public void repaint(long tm)//指定bai调用update方法之前等待的最大毫秒数tm
            
        3.public void repaint(int x,int y,int width,int height)//重绘组件的指定矩形区域
            
        4.public void repaint(ling tm,int x,int y,int width,int height)
            
   坏处：因为如果用第二种方法，刷新是在一定时间内随机的，所以有可能使画面出现闪烁。

6.复习了迭代器.            

import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.Iterator;

public class G09 {
    public static void main(String[] args) {
        new Mysb("鼠标监听");
    }

    private static class Mysb extends Frame  {
        public Mysb(String string){
            //调用父类构造方法，给程序起名字
            super(string);
            setBounds(500,500,500,500);
            setVisible(true);

            //以内部类形式实现此监听的实现方法
            this.addMouseListener(new MyMouseListener());
        }

        //创建集合，存储鼠标点击的所有点
        ArrayList<Point> arrayList=new ArrayList<>();

        //使用适配器模式，将接口变成继承，继承自java中已经实现了此接口的类
        private class MyMouseListener extends MouseAdapter {

            //重写监听鼠标按下事件的方法，鼠标的监听方法有，按下，按住不放，弹起
            @Override
            public void mouseClicked(MouseEvent e) {

                //获取窗口对象,以及点击的坐标
                Mysb frame=(Mysb)e.getSource();

                //创建java自带的'点'的类的对象，接收两个坐标
                Point point=new Point(e.getX(),e.getY());

                //将点存储进集合中
                arrayList.add(point);

                //每次点击都要刷新一下画笔，通过刷新画笔的方法来画出这些点
                frame.repaint();
            }
        }
        //遍历集合，将点取出并用画笔画出
        @Override
        public void paint(Graphics g) {

            //用迭代器，取出集合中的所有点并画出
            Iterator iterator=arrayList.iterator();
            while (iterator.hasNext()){
                Point point=(Point)iterator.next();
                g.fillOval(point.x,point.y,10,10);
            }
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jq5IgPbK-1598874922254)(image-20200819184934511.png)]

窗口监听事件

新知：

1.监听窗口：两种方法，
    方法一：new一个接口的实现类，然后用的是匿名内部类方法实现接口中所有方法（不推荐）：				                                       this.addWindowListener(new WindowListener()         
    方法二：new一个类，这个类java已经帮我们实现了1，接口中的所有方法，我们只需要重写部分需要的方法即可
          this.addWindowListener(new WindowAdapter() {});
                                                                                                                          
2.关闭窗口的重写方法：
           public void windowClosing(WindowEvent e)
                                                                                                                          
3.激活窗口：
           public void windowActivated(WindowEvent e)                                                                                                           
    

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

public class G10 {
    public static void main(String[] args) {
        new MyWindowFrame();
    }
}
class MyWindowFrame extends Frame {
        MyWindowFrame(){
            setBounds(500,500,500,500);
            setVisible(true);
            

            //this.addWindowListener(new WindowListener()，如果是实现接口，就new这个类
            //也可以用继承自java中已经实现过WindowListener接口的类
            //使用的是匿名内部类
            this.addWindowListener(new WindowAdapter() {
                //关闭窗口
                @Override
                public void windowClosing(WindowEvent e) {
                    System.exit(0);
                }

                //激活窗口
                @Override
                public void windowActivated(WindowEvent e) {
                    ((MyWindowFrame)e.getSource()).setTitle("窗口被激活了");
                }
                
            });
        }

}

键盘监听

新知：

1.键盘监听，用的是匿名内部类，new的是java、已经实现接口后的类，即适配器模式
    this.addKeyListener(new KeyAdapter()
                        
2.键的类型，键入键时调用。 当按下按键时，会发生此事件
            @Override
            public void keyTyped(KeyEvent e)
                        
3.按键，键盘按下
            @Override
            public void keyPressed(KeyEvent e){
                //键盘对应的java中的值：0对应VK_0/0x30 。tatic final int VK_0              = 0x30;
                获取键盘输入的方法：一个返回int一个返回char类型
                    "int："+e.getKeyCode()+"char"+e.getKeyChar()
            }
                        
4.当键已被释放时调用。
            @Override
            public void keyReleased(KeyEvent e)                        

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

public class G11 {
    public static void main(String[] args) {
        new MyKeyListener();
    }
}
class MyKeyListener extends Frame{
    MyKeyListener(){
        setBounds(500,500,500,500);
        setVisible(true);
        this.addKeyListener(new KeyAdapter() {

            //键的类型，键入键时调用。 当按下按键时，会发生此事件
            @Override
            public void keyTyped(KeyEvent e) {

            }

            //按键，键盘按下
            @Override
            public void keyPressed(KeyEvent e) {

                /*获得键盘对应的符号并转换成十进制输出，在java中有两种对应方式，
                一个是e.VK_0,以VK_*代表，*号可写成键盘上的值
                另一个是：用十六进制代表对应键盘上的值：0x30
                但是在java输出的是十进制数，而不是十六进制
                下面是两者对应关系列句：
                public static final int VK_0              = 0x30;
                 */

               System.out.println("int："+e.getKeyCode()+"char"+e.getKeyChar());
            }

            //当键已被释放时调用。
            @Override
            public void keyReleased(KeyEvent e) {

            }
        });
    }
}
结果：
    int：16char
    int：83chars
    int：68chard
    int：67charc
    int：70charf

Swing

JFrame

新知：

1.初始化专用方法名称:init()
    
2.如果想设置背景颜色，并且显示，需要获得一个容器，然后在容器里定义颜色
        Container container=getContentPane();
        container.setBackground(Color.yellow);

3.标签设置
        JLabel jLabel=new JLabel("露从今夜白");

4.标签文本居中,设置水平对齐
        jLabel.setHorizontalAlignment(SwingConstants.CENTER);

5.Swing有帮我们设置好的退出程序的方法
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//直接退出
		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);//释放
        setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);//什么都不做
        setDefaultCloseOperation(WindowConstants.HIDE_ON_CLOSE);//隐藏,程序还在内存，但是打不开了

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

public class G01 {
    public static void main(String[] args) {
        new MyJFrame().init();
    }
}
class MyJFrame extends JFrame{
    //初始化专用方法名称
    public void init(){
        setBounds(500,500,500,500);
        setVisible(true);
        
        //Swing有帮我们设置好的退出程序的方法
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//直接退出
        //setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);//释放
        // setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);//什么都不做
         //setDefaultCloseOperation(WindowConstants.HIDE_ON_CLOSE);//隐藏,程序还在内存，但是打不开了

        //如果想设置背景颜色，并且显示，需要获得一个容器，然后在容器里定义颜色
        Container container=getContentPane();
        container.setBackground(Color.yellow);

        //标签设置
        JLabel jLabel=new JLabel("露从今夜白");

        //添加标签进JFrame中
        this.add(jLabel);//或者用container.add(jLabel);

        //标签文本居中,设置水平对齐
        jLabel.setHorizontalAlignment(SwingConstants.CENTER);

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7JUpRVrs-1598874922254)(image-20200820175457661.png)]

paintComponent（画笔）

@Override
public void paintComponents(Graphics g) {
    super.paintComponents(g);
    
}

弹窗

新知：

1.绝对布局，依照设定的x，y坐标定位布局组件
        container.setLayout(null);

2.弹窗不用自己写关闭窗口事件，类里面已经写好了
    
3.如果用了绝对布局，添加组件时一定要设置组件的位置，不然，会无法显示
    

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

public class G02 {
    public static void main(String[] args) {
        new MyJFrame02();
    }
}
class MyJFrame02 extends JFrame{
    MyJFrame02(){
        setBounds(500,500,500,500);
        setVisible(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//直接退出

        Container container=this.getContentPane();

        //绝对布局，依照设定的x，y坐标定位布局组件
        container.setLayout(null);

        //按钮
        JButton jButton01=new JButton("点击我产生弹窗");
        jButton01.setBounds(50,50,100,50);
        container.add(jButton01);

        jButton01.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                new MyDialogDemo();
            }
        });
    }
}
class MyDialogDemo extends JDialog{
    public MyDialogDemo(){
        this.setVisible(true);
        this.setBounds(500,500,500,500);
        //弹窗不用自己写关闭窗口事件，类里面已经写好了

        Container container=getContentPane();
        container.setLayout(null);

       JLabel jLabel =new JLabel("露从今夜白");
       jLabel.setBounds(50,50,400,400);
        container.add(jLabel);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ABhiYUXS-1598874922255)(image-20200820184137337.png)]

标签

1.lable

2.图标/图片标签（ICON）

新知：

1.获取和此类同级的其他文件,并用地址类型的变量接收
     URL url=MyJFrame03.class.getResource("tx.jpg");

2.将这个url转换成图片
        ImageIcon imageIcon=new ImageIcon(url);

3.将这个图片放进标签中
        jLabel.setIcon(imageIcon);

以图片：

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

public class G03 {
    public static void main(String[] args) {
        new MyJFrame03();
    }
}
class MyJFrame03 extends JFrame {
    MyJFrame03(){
        JLabel jLabel=new JLabel("露从今夜白");
        jLabel.setHorizontalAlignment(SwingConstants.CENTER);

        //获取和此类同级的其他文件,并用地址类型的变量接收
        /*就是你想获得文件，你得从最终生成的.class文件为着手点，
        不要以.java文件的路径为出发点，因为真正使用的就是.class，
        不会拿个.java文件就使用，因为java是编译型语言嘛
         */
        URL url=MyJFrame03.class.getResource("tx.jpg");
        System.out.println(MyJFrame03.class.getResource(""));
        //将这个url转换成图片
        ImageIcon imageIcon=new ImageIcon(url);

        //将这个图片放进标签中
        jLabel.setIcon(imageIcon);
        

        Container container=getContentPane();
        container.add(jLabel);

        setVisible(true);
        setBounds(500,500,500,500);
        
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CEjUuJzY-1598874922256)(image-20200820221342968.png)]

以自己画的：

新知：

1.Icon接口，有三个需要实现的方法，1.画一个图标。2.图标的宽。3.图标的高，需要导入AWT包，因为画是用的AWT中的画笔
    
2.new JLabel("露从今夜白",icon,SwingConstants.CENTER);的第三个参数是让标签居中    

class MyJFrame04 extends JFrame {
    private int width,height;

    //用来设置图标大小
    public MyJFrame04(int width,int height){
        this.width=width;
        this.height=height;
    }
    public void init(){
        setBounds(500,500,500,500);
        setVisible(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        
        //new一个图标类（此类是一个接口），并且实现类接口中的三个方法。
        Icon icon=new Icon() {
            
            //画一个图标的方法
            @Override
            public void paintIcon(Component c, Graphics g, int x, int y) {
                g.fillOval(x,y,width,height);
            }

            //图标的宽
            @Override
            public int getIconWidth() {
                return width;
            }

            //图标的高
            @Override
            public int getIconHeight() {
                return height;
            }
        };

        //第三个参数是设置标题放在中间
        JLabel label=new JLabel("露从今夜白",icon,SwingConstants.CENTER);
        Container container=getContentPane();
        container.add(label);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cjKCq40Y-1598874922256)(image-20200821171129203.png)]

面板（JPane）

滚动条面板（JScrollPanel）

新知：

1.**组件写入的顺序要正确，**比如文本域要先放在面板中，然后面板再放在容器中，这样文本域才能正确显示，如果先放面板，然后文本域再添加进面板，很有可能，文本域不会被加载出来。

2.可见性一定要在程序最后设置，不然可能容器中的组件无法第一时间正确显示: setVisible(true);

3.文本域：可以换行，文本框：不可以换行,这里使用文本域,构造参数可以是一段文本，或者是规定多少就会换行，或者为空
JTextArea textArea=new JTextArea(20,10);

4.Scroll面板（具有滚动条的面板）
JScrollPane scrollPane=new JScrollPane(textArea);

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

public class G05 {
    public static void main(String[] args) {
        new JScrollP();
    }
}
class JScrollP extends JFrame{
    public JScrollP(){
        Container container=this.getContentPane();

        setBounds(500,500,500,500);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        //文本域：可以换行，文本框：不可以换行,这里使用文本域,构造参数可以是一段文本，或者是规定多少就会换行，或者为空
        JTextArea textArea=new JTextArea(20,10);
        textArea.setText("露从今夜白");


        //Scroll面板
        JScrollPane scrollPane=new JScrollPane(textArea);
        container.add(scrollPane);

        setVisible(true);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xDOWyZ6g-1598874922257)(image-20200821174225838.png)]

按钮（JButton）

图片按钮

新知:

1.按钮上可以添加图片，从按钮的构造方法中添加或者类方法中添加

2.设置鼠标悬停在按钮上时显示的文字
button.setToolTipText(“露从今夜白”);

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

public class G06 extends JFrame {
    G06(){

        //图标按钮
        Container container=this.getContentPane();
        URL url = G06.class.getResource("tx.jpg");
        Icon icon = new ImageIcon(url);

        JButton button=new JButton("图标按钮",icon);

        //设置鼠标悬停在按钮上时显示的文字
        button.setToolTipText("露从今夜白");
        container.add(button);

        setVisible(true);
        setBounds(500,500,500,500);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
        new G06();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b9jidTFh-1598874922258)(image-20200821180117968.png)]

单选按钮(JRadioButton)

新知:

1.单选按钮的类JRadioButton

2.使用一个组（类）将需要被单选的按钮全部放入其中，然后就能达到只能被选择一个的目的，如果不放入，则所有按钮都能同时被选择

组的定义方法： ButtonGroup group=new ButtonGroup();，需要使用add将按钮放入其中并且需要再将按钮放入容器中

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

public class G06 extends JFrame {
    G06(){

        //单选框
        Container container=this.getContentPane();

        JRadioButton radioButton1=new JRadioButton("1");
        JRadioButton radioButton2=new JRadioButton("2");
        JRadioButton radioButton3=new JRadioButton("3");

        //将这三个按钮分为一个组，组里面的按钮只能被选择一个，如果不分组，则三个都可以被选择
        ButtonGroup group=new ButtonGroup();
        group.add(radioButton1);
        group.add(radioButton2);
        group.add(radioButton3);

        container.add(radioButton1,BorderLayout.NORTH);
        container.add(radioButton2,BorderLayout.WEST);
        container.add(radioButton3,BorderLayout.SOUTH);

        setVisible(true);
        setBounds(500,500,500,500);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
        new G06();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AT4XetOc-1598874922259)(image-20200821181315128.png)]

多选框

新知：

1.多选框的类：
JCheckBox checkBox1=new JCheckBox(“checkBox1”);

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

public class G06 extends JFrame {
    G06(){

        //多选框
        Container container=this.getContentPane();

        JCheckBox checkBox1=new JCheckBox("checkBox1");
        JCheckBox checkBox2=new JCheckBox("checkBox2");

        container.add(checkBox1,BorderLayout.SOUTH);
        container.add(checkBox2,BorderLayout.NORTH);

        setVisible(true);
        setBounds(500,500,500,500);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
        new G06();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hROBkhwk-1598874922259)(image-20200821193043067.png)]

列表

下拉框（JComboBox）

新知：

1.下拉框类的设置
JComboBox comboBox=new JComboBox();
comboBox.addItem(“露从今夜白”);

2.对下拉框的监听

方法一：获取下拉框对象（getSource（）），然后调用getSelectedItem（）方法获取被选中的值

comboBox.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                JComboBox comboBox1=(JComboBox) e.getSource();
                System.out.println(comboBox1.getSelectedItem());
            }
        });

方法二：利用addItemListener来监听下拉框，同时调用getItem（）方法获取被改变状态的值，但是改变状态的值会有两个，一个前面的是从选中到未选中，一个是从未选中到选中，所以需要加个判断哪个是选中值然后获取值

JComboBox中选择某个选项时itemStateChanged调用2次的原因在于：

1、在选择一个新的选项之前，原来被选中的选项会改变状态,由被选中（SELECTED）到没被选中（DESELECTED）

2、在选择新选项时，这个选项会改变状态，由没被选中（DESELECTED）到被选中（SELECTED）

comboBox.addItemListener(new ItemListener() {
            @Override
            public void itemStateChanged(ItemEvent e) {

                  //判断是不是被选中
                if (e.getStateChange() == ItemEvent.SELECTED) {
                    // 选择的下拉框选项
                    System.out.println(e.getItem());
                }
            }
        });

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

public class G07 extends JFrame {
    public static void main(String[] args) {
        new G07();
    }
    G07(){
        Container container=this.getContentPane();

        //下拉框
        JComboBox comboBox=new JComboBox();
        comboBox.addItem("露从今夜白");
        comboBox.addItem("潇湘七号");
        comboBox.addItem("小春二");

        container.add(comboBox);

        //可以设置监听器监听选择的是什么
        方法一：
        comboBox.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                JComboBox comboBox1=(JComboBox) e.getSource();
                System.out.println(comboBox1.getSelectedItem());
            }
        });
        
        方法二：
        /*
        
        comboBox.addItemListener(new ItemListener() {
            @Override
            public void itemStateChanged(ItemEvent e) {

                  //判断是不是被选中
                if (e.getStateChange() == ItemEvent.SELECTED) {
                    // 选择的下拉框选项
                    System.out.println(e.getItem());
                }
            }
        });
        */
        setVisible(true);
        setBounds(500,500,500,500);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qo9esxaH-1598874922260)(image-20200821210912414.png)]

列表框（JList）

新知：

1.列表框

​ 生成列表框的内容：
​ String[] str ={“1”,“2”,“3”,“4”,“5”,“6”};

​ 创建列表框并放入数据

​ JList list=new JList(str);

2.对列表框进行监听

事件名称：ListSelectionEvent 列表选择事件
事件监听接口：ListSelectionListener 监听器 需要实现 valueChanged 方法
事件相关方法：addListSelectionListener 添加选择监听器

获取选中项的方法：

1.因为valueChanged()方法总是被执行两次,鼠标点击执行一次,鼠标释放执行一次。所以我们先进行判断让此方法只运行一次：

if(list.getValueIsAdjusting())//判断鼠标点击，鼠标点击时getValueIsAdjusting返回true，释放时会返回false

if里面写如何判断：

//获取JList的模型：即其数据内容
ListModel<String> model = list.getModel();

//保存选中的项的索引（下标）
b = list.getLeadSelectionIndex();
                    
//通过索引来获取选中项的名字并输出
System.out.println(model.getElementAt(b));

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

public class G08  extends JFrame {
    G08(){
        Container container=this.getContentPane();

        //生成列表框的内容
        String[] str ={"1","2","3","4","5","6"};

        //列表框
        JList list=new JList(str);

        container.add(list);
        //列表框的监听事件
        list.addListSelectionListener(new ListSelectionListener() {
            @Override
            public void valueChanged(ListSelectionEvent e) {
                int b;

                //判断鼠标点击，鼠标点击时getValueIsAdjusting返回true，释放时会返回false
                if(list.getValueIsAdjusting()) {

                    //获取JList的模型：即其数据内容
                    ListModel<String> model = list.getModel();

                    //保存选中的项的索引（下标）
                    b = list.getLeadSelectionIndex();
                    
                    //通过索引来获取选中项的名字
                    System.out.println(model.getElementAt(b));
                }
            }
        });

        setVisible(true);
        setBounds(500,500,500,500);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
        new G08();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Dc6DVJTz-1598874922261)(image-20200821220216374.png)]

文本框

文本框，密码框，文本域

新知：

1.文本框
//20是设置在某些布局下，文本框能显示的宽度，与输入字符多少无关

   JTextField textField=new JTextField("文本框",20);

2.密码框,默认为"·"

JPasswordField passwordField=new JPasswordField(10);//10是代表密码框的宽度
         passwordField.setEchoChar('密');//可以设置掩盖的字符，是字符型

3.文本域，可与具有滚动条的面板一起用,20是设置文本域的行数，50是设置文本域的宽

JTextArea textArea=new JTextArea("文本域",2,50);

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

public class G09 extends JFrame {
    G09(){
        Container container=this.getContentPane();
        container.setLayout(new FlowLayout());

        //文本框
        //20是设置在某些布局下，文本框能显示的宽度，与输入字符多少无关
        JTextField textField=new JTextField("文本框",20);


        //密码框,默认为·
        JPasswordField passwordField=new JPasswordField(10);
        passwordField.setEchoChar('密');

        //文本域，可与具有滚动条的面板一起用,20是设置文本域的行数，50是设置文本域的宽
        JTextArea textArea=new JTextArea("文本域",2,20);

        container.add(textField);
        container.add(passwordField);
        container.add(textArea);

        setVisible(true);
        setBounds(500,500,500,500);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
            new G09();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ieUSRBdY-1598874922262)(image-20200821224418723.png)]

定时器（Timer）

1. schedule(TimerTask task, Date time) : 安排在 “指定的时间” 执行 指定的任务。（只执行一次）

2. schedule(TimerTask task, Date firstTime , long period) : 安排指定的任务在 "指定的时间 " 开始进行 “重复” 的固定延迟执行．( )

   3 。schedule(TimerTask task,long delay) : 安排在指定延迟后执行指定的任务．

   4 。schedule(TimerTask task,long delay,long period): 安排指定的任务指定的延迟后开始进行重复的固定延迟执行．

   5。scheduleAtFixedRate(TimerTask task,Date firstTime,long period): 安排指定的任务在指定的时间开始进行重复的固定速率执行．

   6。scheduleAtFixedRate(TimerTask task,long delay,long period): 安排指定的任务在指定的延迟后开始进行重复的固定速率执行．

   Timer.cancal(): 终止此计时器，丢弃所有当前已安排的任务。

   Timer.purge(): 从此计时器的任务队列中移除所有已取消的任务。