组件，容器，布局，监听 GUI

GUI编程

AWT

组件和容器

package gui.lesson01;
​
import java.awt.*;
​
public class TestFrame {
    public static void main(String[] args) {
        Frame frame = new Frame("我的第一个图形化界面！"); //Frame jdk，看源码,标题
        frame.setSize(200,200); //设置窗口大小
        frame.setVisible(true);  //需要设置可见性
        frame.setLocation(300,300);  //弹出的初始位置，左上角坐标为（0,0）
        frame.setBackground(new Color(31, 89, 236));  //设置背景颜色  提示Color类，new Color();直接Ctrl+鼠标左键查看Color类源码。
        frame.setResizable(false);   //设置大小固定
    }
}
​

代码二：

package gui.lesson01;
​
import java.awt.*;
​
public class TestFrame2 {
    public static void main(String[] args) {
        //展示多个窗口，new多个对象，用类封装
        new Frame2(100,100,200,200,Color.BLUE);
        new Frame2(300,100,200,200,Color.yellow);
        new Frame2(100,300,200,200,Color.red);
        new Frame2(300,300,200,200,Color.green);
    }
}
class Frame2 extends Frame{ // 继承Frame类    封装
    static int id = 0; //可能存在多个窗口，需要一个计数器
    public Frame2(int x, int y, int w, int h, Color color){
        super("Frame"+(++id));  //调用父类构造器
        setVisible(true);
        setBounds(x,y,w,h);
        setBackground(color);
    }
}

面板Panel

package gui.lesson01.lesson02;
​
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
​
//Panel面板可以看成一个空间，但不能单独存在，需要放在Frame窗口中。
public class TestPanel {
    public static void main(String[] args) {
        Frame frame = new Frame();
​
        Panel panel = new Panel();  //按住Ctrl键，点Panel，发现Panel类继承了container类，container又继承了component类。所以可以在frame.add()中调用。
​
        frame.setBackground(new Color(105, 226, 29)); //设置frame坐标，背景颜色
        frame.setBounds(300,300,500,500);
        frame.setLayout(null);    //设置布局：流布局设置为null，不设置，就会默认把它置顶，窗口中全是红色
​
        panel.setBackground(new Color(215, 36, 36));  //设置相对于frame的坐标，背景颜色
        panel.setBounds(100,100,300,300);
​
        frame.add(panel);  //把面板添加到frame窗口中
        frame.setVisible(true);   //设置窗口可见性
​
        //监听事件，监听窗口关闭事件， System exit(0);
        //适配器模式
//        frame.addWindowListener(new WindowListener() {   //可以new WindowListener()这个借口，但需要重写这些方法，所以使用适配器                          //一般要写接口的实现类
//            @Override
//            public void windowOpened(WindowEvent e) {
//
//            }
//
//            @Override
//            public void windowClosing(WindowEvent e) {
//
//            }
//
//            @Override
//            public void windowClosed(WindowEvent e) {
//
//            }
//
//            @Override
//            public void windowIconified(WindowEvent e) {
//
//            }
//
//            @Override
//            public void windowDeiconified(WindowEvent e) {
//
//            }
//
//            @Override
//            public void windowActivated(WindowEvent e) {
//
//            }
//
//            @Override
//            public void windowDeactivated(WindowEvent e) {
//
//            }
//        });
        frame.addWindowListener(new WindowAdapter() {  //看addWindowListener()这个方法中，需要什么变量类型，就new一个什么类型，可以new一个子类，这个类包含这个接口的所有方法，采用适配器模式，不用重写这么多方法
            //窗口点击关闭时需要做的事情
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);  //关闭窗口，结束程序
                //super.windowClosing(e);
            }
        });
    }
}

布局方式

1. 流式布局：

   package gui.lesson01.lesson02;
   ​
   import java.awt.*;
   ​
   public class TestFlowLayout {
       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());   //默认是center，居中。
           frame.setLayout(new FlowLayout(FlowLayout.LEFT));  //因为LEFT是静态常量，所以可以在new FlowLayout（）里面加参数FlowLayout.LEFT。
           frame.setBounds(100,100,500,500);
   ​
           frame.add(button1);
           frame.add(button2);
           frame.add(button3);
   ​
           frame.setVisible(true);
   ​
       }
   }

2. 东西南北中：

package gui.lesson01.lesson02;
​
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 north = new Button("North");
        Button south = new Button("South");
        Button center = new Button("Center");
​
        frame.add(east,BorderLayout.EAST);
        frame.add(west,BorderLayout.WEST);
        frame.add(north,BorderLayout.NORTH);
        frame.add(south,BorderLayout.SOUTH);
        frame.add(center,BorderLayout.CENTER);
​
        frame.setSize(200,200);
        frame.setVisible(true);
​
    }
}

3. 表格布局：

package gui.lesson01.lesson02;
​
import java.awt.*;
​
public class TestGridLayout {
    public static void main(String[] args) {
        Frame frame = new Frame();
​
        Button a = new Button("a");
        Button b = new Button("b");
        Button c = new Button("c");
        Button d = new Button("d");
        Button e = new Button("e");
        Button f = new Button("f");
​
        frame.setLayout(new GridLayout(2,3));  //表格布局，行，列，行间距，列间距，Ctrl+鼠标点击类看源码，看填写内容类型
        frame.add(a);
        frame.add(b);
        frame.add(c);
        frame.add(d);
        frame.add(e);
        frame.add(f);
​
        frame.pack(); //自动调整窗口内容
        frame.setSize(300,300);
        frame.setVisible(true);
​
    }
}

小测验

package gui.lesson01.lesson02;
​
import java.awt.*;
​
public class Test {
    public static void main(String[] args) {
        Frame frame = new Frame();
        frame.setLayout(new GridLayout(2,1));
        frame.setSize(300,300);
        frame.setBackground(Color.black);
        frame.setVisible(true);
​
        Panel panel1 = new Panel();
        Panel panel2 = new Panel();
        Panel panel3 = new Panel(new GridLayout(2,1));
        Panel panel4 = new Panel(new GridLayout(2,2));
​
        Button button1 = new Button("button1");
        Button button2 = new Button("button2");
        Button button3 = new Button("button3");
        Button button4 = new Button("button4");
​
        panel1.add(button1,BorderLayout.WEST);
        panel1.add(button2,BorderLayout.EAST);
        panel1.add(panel3,BorderLayout.CENTER);
        panel3.add(button3);
        panel3.add(button4);
​
        panel2.add(new Button("button5"),BorderLayout.WEST);
        panel2.add(new Button("button6"),BorderLayout.EAST);
        panel2.add(panel4,BorderLayout.CENTER);
        for (int i = 0; i < 4; i++) {
            panel4.add(new Button("for"+"i"));
        }
​
        frame.add(panel1);
        frame.add(panel2);
​
    }
}

事件监听

package gui.lesson01.lesson03;
​
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
​
public class TestActionEventTwo {
    public static void main(String[] args) {
        Frame frame = new Frame();
        Button button1 = new Button("haha");
        Button button2 = new Button("hahaha");
        //可以显示的定义触发会返回的命令123，如果不定义，会显示默认值hahaha。
        button2.setActionCommand("123");
        MyMonitor myMonitor = new MyMonitor();
        button1.addActionListener(myMonitor);  //给按钮加上监听方法addActionListener，方法中需要参数类型为ActionListener，所以用MyMonitor类实现ActionListener接口，然后new一个MyMonitor类的对象，就是ActionListener类型的。
        button2.addActionListener(myMonitor);  //Person s2 = new Student();  //父类的引用指向子类的类型
​
        frame.add(button1,BorderLayout.NORTH);
        frame.add(button2,BorderLayout.SOUTH);
        frame.setVisible(true);
​
    }
}
class MyMonitor implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("按钮被点击："+e.getActionCommand());
        if(e.getActionCommand().equals("haha")){
            //用if可以实现多个按钮，只写一个监听类
        }
    }
}

代码二：

package gui.lesson01.lesson03;
​
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
​
public class TestActionEvent {
    public static void main(String[] args) {
        Frame frame = new Frame();
        Button button = new Button();
​
        MyListener myListener = new MyListener();
        button.addActionListener(myListener);  //一般监听器后面的类型是接口，但一般不直接new 接口（直接new也是可以的），一般都是new这个接口的实现类。
​
        frame.add(button);
        frame.setVisible(true);
        frame.pack();
        windowsclosing(frame);  //一般主程序只调用方法，关闭程序都写在方法体中
​
    }
    //关闭窗口的事件
    public static void windowsclosing(Frame frame){
        frame.addWindowListener(new WindowAdapter() {  //new一个这个WindowListener接口的实现类WindowAdapter()
            @Override     //适配器，只重写这一个方法就可以，new接口的话，需要重写接口所有方法
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
}
//事件监听
class MyListener implements ActionListener{
​
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("aaa");
    }
}

输入框事件监听

package gui.lesson01.lesson03;
​
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
​
public class TestText01 {
    public static void main(String[] args) {
        //启动
        new MyFrame();
​
    }
}
class MyFrame extends Frame{
    public MyFrame(){   //写在无参构造中，或者有参构造中
        TextField textField = new TextField();
        add(textField);   //文本框加入到窗口中
        //监听输入框事件（监听文本框输入的文字）
        TextListener textListener = new TextListener();
        //按下enter键会触发这个输入框的事件，输入完毕
        textField.addActionListener(textListener);
        //设置替换编码
        textField.setEchoChar('*');  //前台看不到数字，但后台可以看到数字
        setVisible(true);
        pack();
    }
}
​
class TextListener implements ActionListener{
    @Override
    public void actionPerformed(ActionEvent e) {  //textField.addActionListener(textListener);用户的输入赋给实参textListener，同样会赋值给形参e。
        TextField a = (TextField)e.getSource();  //获得e的一些资源，返回一个对象
        System.out.println(a.getText());  //获得输入框的文本 a.getText()就是获取a数组中的某一个属性（文本）  vdffdgfd
        System.out.println(a);   //java.awt.TextField[textfield0,9,36,611x336,text=vdffdgfd,editable,selection=8-8]
        a.setText("");   //回车后设置a中的文本为空（这个a和形式变量e类似于一个数组，很多属性的集合，像一个对象一样）
    }
}
​

简易计算器

package gui.lesson01.lesson03;
​
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
​
public class TextCal {
    public static void main(String[] args) {
        new MyFrame1();
    }
}
class MyFrame1 extends Frame{
    public MyFrame1() {
        TextField textField01 = new TextField(10);   //文本框长度10个字节
        TextField textField02 = new TextField(10);
        TextField textField03 = new TextField(20);
        Button button = new Button("=");
        Label label = new Label("+");  //new一个标签栏
​
        setVisible(true);
        setLayout(new FlowLayout());  //按流式布局排序
​
        add(textField01);  //按从左到右的顺序加入插件
        add(label);
        add(textField02);
        add(button);
        add(textField03);
        pack();    //自动适应窗口
​
        TextListener01 textListener01 = new TextListener01(textField01,textField02,textField03);  //监听器只需要写一个就可以，可以同时监听输入栏和按钮。
        //textField01.addActionListener(textListener01);   //把每一个插件加入监听器
        //textField02.addActionListener(textListener01);
        //textField03.addActionListener(textListener01);
        button.addActionListener(textListener01);   //只有button需要监听事件，其他的都不需要
    }
}
​
class TextListener01 implements ActionListener{   //监听器方法如下：类名想好不要重复
    private TextField text01,text02,text03;   //定义几个私有化变量，方便把用户输入的值（对象）取到
    public TextListener01(TextField text01,TextField text02,TextField text03){  //用户实际需要输入几个值，形参这边就对应几个同类型的变量。形参这可以获得实参的输入值。
        this.text01 = text01;     //将形参中的值赋给TextListener01类中的局部私有变量，要不TextListener01类不能直接获得和使用用户的输入值。
        this.text02 = text02;
        this.text03 = text03;
    }
    @Override
    public void actionPerformed(ActionEvent e) {
​
        int n1 = Integer.parseInt(text01.getText());  //将text01的值中的文本String类型转换为整形，方便进行运算
        int n2 = Integer.parseInt(text02.getText());
        text03.setText(""+(n1+n2));   //设置text03的值，因为是String类型，所以把int加上""强转。
        text01.setText("");   //设置text01的值为空。
        text02.setText("");   //这些变量都是由private TextField text01,text02,text03;提供。
    }
}

代码二：通过组合，进行代码优化

package gui.lesson01.lesson03;
​
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
​
public class TextCal {
    public static void main(String[] args) {
        new MyFrame1().loadFrame();
    }
}
class MyFrame1 extends Frame{
    //属性
    TextField textField01,textField02,textField03;
    //方法
    public void loadFrame() {
        textField01 = new TextField(10);   //文本框长度10个字节
        textField02 = new TextField(10);
        textField03 = new TextField(20);
        Button button = new Button("=");
        Label label = new Label("+");  //new一个标签栏
​
        button.addActionListener(new TextListener01(this));  //给button加一个监听器
​
        setVisible(true);
        setLayout(new FlowLayout());  //按流式布局排序
​
        add(textField01);  //按从左到右的顺序加入插件
        add(label);
        add(textField02);
        add(button);
        add(textField03);
        pack();    //自动适应窗口
​
        //TextListener01 textListener01 = new TextListener01(this);  //监听器只需要写一个就可以，可以同时监听输入栏和按钮。
//        textField01.addActionListener(textListener01);   //把每一个插件加入监听器
//        textField02.addActionListener(textListener01);
//        textField03.addActionListener(textListener01);
        //button.addActionListener(textListener01);
    }
}
​
class TextListener01 implements ActionListener{   //监听器方法如下：类名想好不要重复
//    private TextField text01,text02,text03;   //定义几个私有化变量，方便把用户输入的值（对象）取到
//    public TextListener01(TextField text01,TextField text02,TextField text03){  //用户实际需要输入几个值，形参这边就对应几个同类型的变量。形参这可以获得实参的输入值。
//        this.text01 = text01;     //将形参中的值赋给TextListener01类中的局部私有变量，要不TextListener01类不能直接获得和使用用户的输入值。
//        this.text02 = text02;
//        this.text03 = text03;
//    }
    //获取计算器这个对象，在一个类中组合另外一个类
    MyFrame1 myFrame1 = null;     //通过这个对象获取用户输入的值
    public TextListener01(MyFrame1 myFrame1){  
        this.myFrame1 = myFrame1;    
    }
    @Override
    public void actionPerformed(ActionEvent e) {
​
        int n1 = Integer.parseInt(myFrame1.textField01.getText());  //将text01的值中的文本String类型转换为整形，方便进行运算
        int n2 = Integer.parseInt(myFrame1.textField02.getText());  //获得这个对象的属性的文本
        myFrame1.textField03.setText(""+(n1+n2));   //设置text03的值，因为是String类型，所以把int加上""强转。
        myFrame1.textField01.setText("");   //设置text01的值为空。
        myFrame1.textField02.setText("");   //这些变量都是由private TextField text01,text02,text03;提供。
    }
}

代码三：完全的面向对象，程序优化，第一个为面向过程。用内部类。

package gui.lesson01.lesson03;
​
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
​
public class TextCal {
    public static void main(String[] args) {
        new MyFrame1().loadFrame();
    }
}
class MyFrame1 extends Frame{
    //属性
    TextField textField01,textField02,textField03;
    //方法
    public void loadFrame() {
        textField01 = new TextField(10);   //文本框长度10个字节
        textField02 = new TextField(10);
        textField03 = new TextField(20);
        Button button = new Button("=");
        Label label = new Label("+");  //new一个标签栏
​
        button.addActionListener(new TextListener01());  //给button加一个监听器
​
        setVisible(true);
        setLayout(new FlowLayout());  //按流式布局排序
​
        add(textField01);  //按从左到右的顺序加入插件
        add(label);
        add(textField02);
        add(button);
        add(textField03);
        pack();    //自动适应窗口
    }
    private class TextListener01 implements ActionListener{   //监听器方法如下：类名想好不要重复
        @Override
        public void actionPerformed(ActionEvent e) {   //作为内部类，可以省去创建新对象获取用户输入值得过程
​
            int n1 = Integer.parseInt(textField01.getText());  //将text01的值中的文本String类型转换为整形，方便进行运算                                 //还可以直接调用外部类的属性
            int n2 = Integer.parseInt(textField02.getText());
            textField03.setText(""+(n1+n2));   //设置text03的值，因为是String类型，所以把int加上""强转。
            textField01.setText("");   //设置text01的值为空。
            textField02.setText("");   //这些变量都是由private TextField text01,text02,text03;提供。
        }
    }
}