GUI编程——AWT编程，各种方法函数的使用练习笔记。

GUI

1、AWT

1.1窗口

frame关键字为gui生成窗口的具体实现方法，使用格式：

Frame 定义窗体名 = new Frame(窗口标题)

窗口相关方法：

frame.setBounds()			//输入四个参数，分别设置设置窗体相对显示屏显示坐标及窗体大小
frame.setBackground()		//背景颜色
frame.setVisiable()			//设置窗口可现实（true）
......

1.2面板

import java.awt.*;

public class TextGui01 {
    public static void main(String[] args) {
        Frame frame = new Frame();
       Panel panel = new Panel();

       frame.setLayout(null);       //设置流式布局，否则面板不显示

       frame.setBounds(50,50,400,400);      //窗口大小
       frame.setVisible(true);      //窗口可显示
       frame.setBackground(new Color(26, 163, 198));     //窗口背景颜色

       panel.setBounds(50,50,300,300);      //面板相对窗口坐标及显示大小
       panel.setBackground(new Color(21, 236, 21));     //面板背景颜色
        panel.setVisible(true);

       frame.add(panel);        //将面板添加置窗口上
    }
}

最终显示效果：

AWT添加窗口关闭没有像SWing一样有提供的设置窗口可关闭的方法，需手动添加关闭监听事件，来达到关闭效果。

 /*
        * 添加窗口的关闭监听事件，
        * 由于WindowListener是一个接口，使用它需要重写其中的九种方法，所以我们
        * 实现WindowListener的子类WindowAdapter()，
        * 来重写windowlistener其中的windowclosing方法实现窗口关闭。
        * 适配器模式
         * */
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);		//0为正常关闭，1为异常关闭
            }
        });

SWing实现窗口关闭：

 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);   //设置游戏关闭

1.3布局管理器

• 流式布局FlowLayOut

  FlowLayout默认排序为从左到右，从上到下

  public class FlowLayOuttext {
      public static void main(String[] args) {
          Frame frame = new Frame();
  
          Button button1 = new Button("1");
          Button button2 = new Button("2");
          Button button3 = new Button("3");
        // frame.setLayout(new FlowLayout());	//默认排列
        // frame.setLayout(new FlowLayout(FlowLayout.LEFT)); //左对齐
        // frame.setLayout(new FlowLayout(FlowLayout.LEFT)); //右对齐
          frame.add(button1);
          frame.add(button2);
          frame.add(button3);
          frame.setVisible(true);
      }
  

  默认居中排列效果图：

• 边界布局管理器BorderLayout

  public class BorderLayoutText {
      public static void main(String[] args) {
          Frame frame = new Frame();
          frame.setVisible(true);
  		//东西南北中布局
          Button north = new Button("north");
          Button south = new Button("south");
          Button west = new Button("west");
          Button east = new Button("east");
          Button center = new Button("center");
  
          frame.add(north,BorderLayout.NORTH);
          frame.add(south,BorderLayout.SOUTH);
          frame.add(west,BorderLayout.WEST);
          frame.add(east,BorderLayout.EAST);
          frame.add(center,BorderLayout.CENTER);
      }
  }
  

  效果图：

• 表格布局GridLayout

public class GridLayoutText {
    public static void main(String[] args) {
        Frame frame = new Frame();
        frame.setVisible(true);

        frame.setLayout(new GridLayout(3,2));	//设置排列为三行两列
        Button btn1 = new Button("1");
        Button btn2 = new Button("2");
        Button btn3 = new Button("3");
        Button btn4 = new Button("4");
        Button btn5 = new Button("5");
        Button btn6 = new Button("6");

        frame.add(btn1);
        frame.add(btn2);
        frame.add(btn3);
        frame.add(btn4);
        frame.add(btn5);
        frame.add(btn6);

        frame.pack();   //java函数，设置按钮自适应窗口
    }
}

表格布局效果图(与flowlayout类似，默认从左到右，自上而下的排列)：

• 布局任务练习，做到下面效果图

public class Layout01 {
    public static void main(String[] args) {
        Frame frame = new Frame("窗口的按钮布局练习");
        frame.setVisible(true);
        frame.setBounds(50,50,400,400);

        //设置面板相关
        Panel panel01 = new Panel();
        Panel panel02 = new Panel();
        Panel panel11 = new Panel();
        Panel panel12 = new Panel();
        panel01.setSize(200,200);
        panel02.setSize(200,200);
        panel01.setVisible(true);
        panel11.setVisible(true);
        panel12.setVisible(true);
        panel02.setVisible(true);

        //new所有的按钮
        Button button01 = new Button("1");
        Button button02 = new Button("2");
        Button button03 = new Button("3");
        Button button04 = new Button("4");
        Button button05 = new Button("5");
        Button button06 = new Button("6");
        Button button07 = new Button("7");
        Button button08 = new Button("8");
        Button button09 = new Button("9");
        Button button10 = new Button("10");

        //设置窗口布局
        frame.setLayout(new GridLayout(2,1));
        frame.add(panel01);
        frame.add(panel02);

        //第一个主面板
        panel01.setLayout(new BorderLayout());
        panel01.add(button01,BorderLayout.WEST);
        panel01.add(panel11,BorderLayout.CENTER);
        panel01.add(button02,BorderLayout.EAST);

        //第一个次面板
        panel11.setLayout(new GridLayout(2,1));
        panel11.add(button03);
        panel11.add(button04);

        //第二个主面板
        panel02.setLayout(new BorderLayout());
        panel02.add(button05,BorderLayout.WEST);
        panel02.add(panel12,BorderLayout.CENTER);
        panel02.add(button06,BorderLayout.EAST);

        //第二个次面板
        panel12.setLayout(new GridLayout(2,2));
        panel12.add(button07);
        panel12.add(button08);
        panel12.add(button09);
        panel12.add(button10);

    }
}

/*
或可使用局部内部类和for循环来实现生成button和添加到面板中
*/

实际效果：

1.4事件监听

package com.GUI.kuang;
import java.awt.*;
import javax.swing.*;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class TextActionEvent {
    public static void main(String[] args) {
        Frame frame = new Frame();
        Button button = new Button();
        frame.setVisible(true);
        frame.add(button);
        
        WindowClose(frame);	//实现窗体关闭方法
        
        MyListener myListener = new MyListener();
        //因为addActionListener需要一个ActionListener，所以我们需要构造一个ActionListener
        button.addActionListener(myListener);

    }

//窗体关闭事件,把窗体关闭独立成一个方法,可以共用
    public static void  WindowClose( Frame frame){
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
}

//构造一个自己的ActionListener,监听事件
class MyListener implements ActionListener{

    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("aaa");
    }
}

下面是两个按钮调用同一个监听器类，实现不同的功能：

public class ActionEvent2 {
    public static void main(String[] args) {
            //实现两个按钮按下，实现开始-结束
        Frame frame = new Frame("开始-结束");
        Button button1 = new Button("star");
        Button button2 = new Button("stop");

        //可以多个按钮只写一个监听器类
        button2.setActionCommand("stop-stop");      //给button2设置些额外信息

        frame.setVisible(true);
        frame.add(button1,BorderLayout.NORTH);
        frame.add(button2,BorderLayout.SOUTH);

        MyListener2 myListener = new MyListener2();

        button1.addActionListener(myListener);
        button2.addActionListener(myListener);
    }
}

class MyListener2 implements ActionListener{

    //e.getActionCommand()可以额外捕捉到信息，如果没有额外设置，捕捉到的即是标题
    /*
    * 所以可以通过if判断e.getActionCommand()获得的信息，来进行不同的操作
    * 实现多个对象调用同一个监听器类
    * */
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("当前执行结果："+e.getActionCommand());
    }
}

1.5输入框事件

​ 输入框事件，即在窗口设置一个可输入文本框，然后通过监听事件获得文本框输入的数据。

public class TestText01 {
    public static void main(String[] args) {
        //正常写代码，main方法内只写一个启动，其余的都独立成其他的方法类，来实现具体功能
        MyFrame myFrame = new MyFrame();
    }
}
//窗口类
class MyFrame extends Frame{
    public MyFrame(){
        TextField textField = new TextField();  //设置一个可输入的单行文本框
        add(textField);
        //监听此文本框获得的输入，且每次按enter键，就会触发输入框的输入，即把数据显示在运行栏上
        TextListener textListener = new TextListener();
        textField.addActionListener(textListener);

        textField.setEchoChar('*'); //设置替代文本，即在文本栏上不显示具体输入内容，达到保密效果

        setVisible(true);
    }
}

class TextListener implements ActionListener{

    @Override
    public void actionPerformed(ActionEvent e) {
        //e.getSource();该方法可获得资源
        TextField field = (TextField) e.getSource();    //强制类型转换，向下转型
        System.out.println(field.getText());    //获得输入框的文本
        field.setText("");  //设置为空，即每次回车后清空输入框
    }
}

达到的效果，输入框的显示：

获得的结果：

1.6简易计算器

• 普通的，以及组合+内部类多种写法

写项目，最好还是把每一个类都独立出来写，不要一个类里面写多个类

//一个简易的加法计算器
public class MyCalcu {
    public static void main(String[] args) {
        MyFrame01 myFrame01 = new MyFrame01();
    }
}
class MyFrame01 extends Frame{
    public MyFrame01(){

        TextField textField1= new TextField(10);    //设置框内的可输入字符长度
        TextField textField2= new TextField(10);
        TextField textField3= new TextField(20);

        Button button = new Button("=");
        button.addActionListener(new CalaListener(textField1,textField2,textField3));   //通过传参的方式来实现计算
       //生成标签，+ 号
        Label label = new Label("+");

        setLayout(new FlowLayout());
        add(textField1);
        add(label);
        add(textField2);
        add(button);
        add(textField3);

        pack();
        setVisible(true);
    }
}
class CalaListener implements ActionListener{
    private TextField num1,num2,num3;
    //构造方法来实现获取文本框值
    public CalaListener(TextField num1,TextField num2,TextField num3){
        this.num1=num1;
        this.num2=num2;
        this.num3=num3;
    }
    @Override
    public void actionPerformed(ActionEvent e) {
        //获得加数与被加数
        int i1 = Integer.parseInt(num1.getText());  //数据类型转换
        int i2 = Integer.parseInt(num2.getText());
        //求值
        num3.setText(""+(i1+i2));	//拼接方式输出
        //前两个框清零
        num1.setText("");
        num2.setText("");
    }
}

实现效果：

改造为面向对象写法：

public class MyCalcu {
    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("=");
        button.addActionListener(new CalaListener(this));   //把自己传过去
       //生成标签，+ 号
        Label label = new Label("+");

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

        pack();
        setVisible(true);
    }
}
class CalaListener implements ActionListener{
    //获取计算器这个对象,在一个类中组合另一个类
    Calculator calculator=null;
    public CalaListener(Calculator calculator){
        this.calculator=calculator;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //获得加数与被加数
        int i1 = Integer.parseInt(calculator.num1.getText());  //数据类型转换
        int i2 = Integer.parseInt(calculator.num2.getText());
        //求值
        calculator.num3.setText(""+(i1+i2));
        //前两个框清零
        calculator.num1.setText("");
        calculator.num2.setText("");
    }
}

内部类：

• 更好的包装

  public class MyCalcu {
      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("=");
          button.addActionListener(new CalaListener());   //把自己传过去
         //生成标签，+ 号
          Label label = new Label("+");
  
          //布局
          setLayout(new FlowLayout());
          add(num1);
          add(label);
          add(num2);
          add(button);
          add(num3);
  
          pack();
          setVisible(true);
      }
      //内部类，最大的好处可以畅通无阻地访问外部类的属性和方法
     private class CalaListener implements ActionListener{
          @Override
          public void actionPerformed(ActionEvent e) {
              //获得加数与被加数
              int i1 = Integer.parseInt(num1.getText());  //数据类型转换
              int i2 = Integer.parseInt(num2.getText());
              //求值
              num3.setText(""+(i1+i2));
              //前两个框清零
              num1.setText("");
              num2.setText("");
          }
      }
  }
  

1.7画笔

public class PaintText {
    public static void main(String[] args) {
        new MyPaint().LoadPaint();
    }
}
class MyPaint extends Frame{
    public void LoadPaint(){
        setBounds(100,100,500,500);
        setVisible(true);
    }
    //画笔，frame类中的方法paint方法，是系统自动调用的
    @Override
    public void paint(Graphics g) {
        g.setColor(Color.YELLOW);   //设置具体颜色
        g.fillOval(50,50,100,100);  //.fill..画实心的
        g.setColor(Color.BLACK);
        g.drawOval(100,150,50,50);  //.draw..画空心的
        //记住画完之后要把颜色调成最初的
    }
}

1.8鼠标监听

public class MouseEvent {
    public static void main(String[] args) {
        new MousePaint("画图");
    }
}
class MousePaint extends Frame{
    ArrayList points;   //定义一个集合来存储鼠标点的坐标

    public MousePaint(String title){
        super(title);
        setBounds(100,100,500,500);

        //存放鼠标点击的点
        points = new ArrayList<>();
        //鼠标监听器正对此窗口
        this.addMouseListener(new MyMouseListener());

        setVisible(true);
    }

    @Override
    public void paint(Graphics g) {
        //迭代器来迭代集合中的坐标，从而将其画出来
        Iterator iterator =  points.iterator();
        while (iterator.hasNext()){
            Point point = (Point) iterator.next();
            g.setColor(Color.BLUE);
            g.fillOval(point.x,point.y,10,10);
        }
    }
    //把监听器所获得的鼠标坐标添加到集合中
    public void addPoint(Point point){
        points.add(point);
    }
}
//适配器模式。来重写MouseListener其中的一个方法
    class MyMouseListener extends MouseAdapter {
    //e就是代表当前的鼠标
     @Override
     public void mousePressed(java.awt.event.MouseEvent e) {
        //拿到窗口，好对其操作
        MousePaint mousePaint= (MousePaint) e.getSource();
        //获取当前的鼠标坐标，并添加至窗口上
        mousePaint.addPoint(new Point(e.getX(),e.getY()));
        //每次点击刷新界面
        mousePaint.repaint();
    }
}

实际画图效果：

1.9窗口监听

public class WindowEvent {
    public static void main(String[] args) {
        new MyWindowFrame();
    }
}
class MyWindowFrame extends Frame{
    public MyWindowFrame(){
        setBounds(100,100,400,400);
        setVisible(true);
        //匿名内部类的方式添加窗口监听
        this.addWindowListener(new WindowAdapter() {
            //关闭窗口
            @Override
            public void windowClosing(java.awt.event.WindowEvent e) {
                System.out.println("windowClosing");
                System.exit(0);
            }
            //激活窗口
            @Override
            public void windowActivated(java.awt.event.WindowEvent e) {
                MyWindowFrame source = (MyWindowFrame) e.getSource();
                //设置窗口激活后窗口标题
                source.setTitle("激活");
                System.out.println("windowActivated");
            }
        });
    }
}

激活窗口的显示：

控制台显示：

1.10键盘监听

public class MyKeyEvent {
    public static void main(String[] args) {
        new MyKeyFrame();
    }
}
class MyKeyFrame extends Frame {
    public MyKeyFrame()  {
        setBounds(100,100,400,400);
        setVisible(true);
        //匿名内部类方式添加键盘监听
        this.addKeyListener(new KeyAdapter() {
            //键盘按下
            @Override
            public void keyPressed(KeyEvent e) {
                int keyCode = e.getKeyCode();
                if (keyCode == KeyEvent.VK_UP){
                    System.out.println("this is VK_UP");
                }
            }
        });
    }
}

按下↑键后，控制台结果：