标签：管理器 int 备份 public 窗体 void new 图形化

GUI图形用户界面

import java.awt.Frame;

public class Example01 {
    public static void main(String[] args) {
        //建立新窗体对象
        Frame f = new Frame("我的窗体");
        //设置窗体的宽和高
        f.setSize(400,300);
        //设置窗体在屏幕中所处的位置(参数是左上角坐标)
        f.setLocation(400,400);
        //设置窗体可见
        f.setVisible(true);
    }
}

布局管理器

组件不能单独存在，必须放置于容器当中，而组件在容器中的位置和尺寸是由布局管理器来决定的。在java.awt包中提供了五种布局管理器，分别是FlowLayout（流式布局管理器），BorderLayout(边界布局管理器)、GridLayout(网格布局管理器)、GridBagLayout(网格包布局管理器)和CardLayout(卡片布局管理器)。每个容器在创建时都会使用一种默认的布局管理器，在程序中可以通过调用容器对象的setLayout()方法设置布局管理器。

通过布局管理器来自动进行组件的布局管理。

流式布局管理器

FlowLayout是最简单的布局管理器，在这种布局下，容器会将组件按照添加顺序从左至右放置。当达到容器的边界时，会自动将组件放到下一行的开始位置。这些组件可以左对齐、居中对齐(默认方式)或右对齐的方式排列。FlowLayout对象有三个构造方法。

方法声明	功能描述
FlowLayout()	组件默认居中对齐，水平，垂直间距默认为5个单位
FlowLayout(int align)	指定组件相对于容器的对其方式，水平、垂直间距默认为5个单位
FlowLayout(int align,int hgap,int vgap)	指定组件的对其方式和水平、垂直间距

表中，列出了FlowLayout的三个构造方法，其中参数align决定组件在每行中相对于容器边界的对齐方式，可以使用该类中提供的常量作为参数传递给构造方法，其中FlowLayout.LEFT用于表示左对齐、FlowLayout.RIGHT用于表示右对齐、FlowLayout.CENTER用于表示居中对齐。参数hgap和参数vgap分别设定组件之间的水平和垂直间隙，可以任意填入一个数值。

Button 中文乱码

Button是在java.awt.中的类，具有平台的局限性，在不同的操作系统

中显示是不同的

JButton是在java.awt.中的类，不具有平台的局限性，在Linux和Windows系统中显示相同

尽量使用JButton

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

public class Example02 {
    public static void main(String[] args) {
        //创建一个名为FlowLayout的窗体
        Frame f = new Frame("FlowLayout");
        //设置窗体的布局管理器,所有的组件左对齐，水平间距为20，垂直间距为30
        f.setLayout(new FlowLayout(FlowLayout.LEFT,20,30));
        //设置窗体大小
        f.setSize(200,400);
        //设置窗体显示的位置
        f.setLocation(400,400);
        //把按钮添加到f窗口中
        f.add(new JButton("第一个按钮"));
        f.add(new JButton("第二个按钮"));
        f.add(new JButton("第三个按钮"));
        f.add(new JButton("第四个按钮"));
        f.add(new JButton("第五个按钮"));
        f.add(new JButton("第六个按钮"));

        //设置窗体可见
        f.setVisible(true);
    }
}

边界布局管理器

BorderLayout,是一种较为复杂的布局方式，它将容器划分为五个区域，分别是东(EAST)、南(SOUTH)、西(WEST)、北(NORTH)、中(CENTER)。组件可以被放置在这五个区域中的任意一个。

在改变容器时NORTH和SOUTH区域高度不变长度调整，WEST和EAST区域宽度不变，高度调整，CENTER会相应进行调整。

import java.awt.*;

public class Example03 {
    public static void main(String[] args) {
        Frame f = new Frame("BorderLayout");//创建一个名为BorderLayout的窗体
        f.setLayout(new BorderLayout()); //设置窗体的布局管理器BorderLayout
        f.setSize(300,300); //设置窗体大小
        f.setLocation(300,200); //设置窗体显示的位置
        f.setVisible(true); // 设置窗体可见
        //下面代码创建5个按钮，分别用于填充BorderLayout的5个区域
        Button b1 = new Button("东部");
        Button b2 = new Button("西部");
        Button b3 = new Button("南部");
        Button b4 = new Button("北部");
        Button b5 = new Button("中部");
        //将创建好的的按钮添加到窗体中，并设置按钮所在的区域。
        f.add(b1,BorderLayout.EAST);
        f.add(b2,BorderLayout.WEST);
        f.add(b3,BorderLayout.SOUTH);
        f.add(b4,BorderLayout.NORTH);
        f.add(b5,BorderLayout.CENTER);


    }
}

网格布局管理器

GridLayout(网格布局管理器)使用纵横线将容器分成n行m列大小相等的网格，每个网格中放置一个小组件。添加到容器中的组件首先放置在第1行第一列(左上角的)网格中，然后在第1行的网格中从左向右一次放置其他组件，行满后，继续在下一行中从左到右放置组件。与FlowLayout不同的是，放置在GridLayout布局管理器中的组件将自动占据网格的整个区域。

列从左向右填充第一列--->第二列--->第三列

方法声明	功能描述
GridLayout()	默认只有一行，每个组件占一列
GridLayout(int rows,int cols)	指定容器的行数和列数
GridLayout(int rows,int cols,int hgap,int vgap)	指定容器的行数和列数以及组件之间的水平，垂直间距。

表中，列出了GridLayout的三个构造方法，其中，参数rows代表行数，cols代表列数，hgap和vgap规定水平和垂直方向的间隙。水平间隙指的是网格之间的水平距离，垂直间隙指的是网格之间的垂直距离。

import java.awt.*;

public class Example04 {
    public static void main(String[] args) {
        //创建一个名为GridLayout的窗体
        Frame f = new Frame("GridLayout");
        //设置该窗体为一个3*3的网格 设置布局管理器
        f.setLayout(new GridLayout(3,3));
        //设置窗体大小
        f.setSize(300,300);
        //设置显示位置
        f.setLocation(400,300);
        //for 循环 添加9个按钮到GridLayout中
        for (int i = 1; i <= 9 ; i++) {
            Button btn = new Button("btn" + i);
            f.add(btn); //像窗体中添加按钮
        }
        f.setVisible(true);

    }
}

卡片布局管理器

在操作程序时，经常会遇到通过选项卡按钮来切换应用程序中的界面，这些界面就相当于一张张卡片，而管理这些卡片的布局管理器就是卡片布局管理器(CardLayout)。卡片布局管理器将界面看作是一系列卡片，在任何时候只有一张卡片是可见的，这张卡片占据容器的整个区域。

方法	功能描述
void first(Container parent)	显示parent容器的第一张卡片
void last(Container parent)	显示parent容器的最后一张卡片
void previous(Container parent)	显示parent容器的前一张卡片
void next(Container parent)	显示parent容器的下一张卡片
void show(Container parent,String name)	显示parent容器中名称为name的组件，如果不存在，则不会发生任何操作

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

class Layout extends Frame implements ActionListener{
    CardLayout cardLayout = new CardLayout();//定义卡片布局管理器
    Panel cardPanel = new Panel();  //定义面板放置卡片
    Panel controlPanel = new Panel();//定义面板来放置按钮
    Button preButton; //声明切换到上一张卡片的一个按钮
    Button nextButton; //声明切换到下一张卡片的按钮
    public Layout(){
        this.setSize(300,300);//设置窗体

        cardPanel.setLayout(cardLayout); //设置布局为卡片布局管理器
        // 在cardPanel中添加3个文本标签
        cardPanel.add(new Label("第一个界面",Label.CENTER));
        cardPanel.add(new Label("第二个界面",Label.CENTER));
        cardPanel.add(new Label("第三个界面",Label.CENTER));

        //创建两个按钮
        nextButton = new Button("下一张卡片");
        preButton = new Button("上一张卡片");
        //将按钮添加到controlPanel
        controlPanel.add(nextButton);
        controlPanel.add(preButton);

        // 把面板添加到窗体中显示
        this.add(cardPanel,BorderLayout.CENTER);
        this.add(controlPanel,BorderLayout.SOUTH);
        this.setVisible(true);//设置窗体显示
    }
    @Override
    public void actionPerformed(ActionEvent e) {
        //如果用户点击nextButton，执行操作切换
        if (e.getSource()==nextButton){
            //切换卡片面板当前的卡片，向后切换一张
            cardLayout.next(cardPanel);
        }
        if (e.getSource()==preButton){
            //切换卡片面板当前的卡片，向上切换一张
            cardLayout.previous(cardPanel);
        }
    }
}
public class Example05 {
    public static void main(String[] args) {
        Layout layout = new Layout();
    }
}

不使用布局管理器

当一个容器被创建了，他们都会一个默认的布局管理器。Windows、Frame和Dialog的默认布局管理器是BorderLayout、Panel的默认布局管理器是FlowLayout。如果不希望通过布局管理器来对容器进行管理，也可以调用容器的setLayout(null)方法，将布局管理器取消。在这种情况下，程序必须调用容器中每个组件的setSize()和setLocation()方法或者是setBounds()方法，（这个方法分别接收四个参数，分别是左上角的x，y坐标和组件的长宽）来为这些组件在容器中定位。

import java.awt.*;

public class Exercise06 {
    public static void main(String[] args) {
        Frame f = new Frame("我的窗体");
        //取消frame的布局管理器
        f.setLayout(null);
        //设置窗体大小
        f.setSize(300,150);
        Button btn1 = new Button("go");
        Button btn2 = new Button("re");
        //设置按钮显示的位置和大小
        btn1.setBounds(40,60,100,30);
        btn2.setBounds(140,60,100,30);
        //添加按钮到窗体
        f.add(btn1);
        f.add(btn2);
        //显示窗口
        f.setVisible(true);
    }
}

AWT时间处理

事件处理机制，前面实现的图形化窗口，单击窗口右上角的关闭按钮会发现窗口无法关闭，说明该按钮的单机功能没有实现。没有实现是因为Frame的设计者无法确定用户关闭Frame窗口的方式，例如是直接关闭窗口还是需要弹出对话框询问用户是否关闭。如果想要关闭窗口，就需要通过事件处理机制对窗口进行监听。

事件处理机制专门用于响应用户的操作，比如，想要响应用户的单机鼠标，按下键盘等操作，就需要使AWT的事件处理机制。

事件对象(Event)：封装了GUI组件上发生的特定事件(通常就是用户的一次操作)。
事件源(组件)：事件发生的场所，通常就是产生事件的组件。
监听器(Listener)：负责监听事件源上发生的事件，并对各种事件做出相应处理的对象(对象中包含事件处理器)。
事件处理器：监听对象对接收的事件对象进行相应处理的方法。

在程序中，如果想实现事件的监听机制，首先需要定义一个实现了事件监听器接口的类，例如Windows类型的窗口需要实现WindowsListener。接着通过addWindowListener()方法为事件源注册事件监听器对象，当事件源上发生事件时，便会触发事件监听器对象，由事件监听器调用相应的方法来处理相应的事件。

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

public class Exercise07 {
    public static void main(String[] args) {
        //创建新的窗体
        Frame f = new Frame("我的窗体");
        f.setSize(400,300);//设置窗口大小
        f.setLocation(300,200);//设置窗口的显示位置
        f.setVisible(true);
        //为窗口组件注册监听器
        f.addWindowListener(new MyWindowsListener());
    }
}
class MyWindowsListener  implements WindowListener{

    public MyWindowsListener() {
        super();
    }

    @Override
    public void windowOpened(WindowEvent e) {

    }

    @Override
    public void windowClosing(WindowEvent e) {
        // 监听器监听事件对象进行处理
        Window window = e.getWindow();
        window.setVisible(false);
        //释放窗口
        window.dispose();
    }

    @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) {

    }
}

上面的MyWindowListener类实现WindowListener接口后，需要实现接口中定义的几个方法，然而在程序中需要用到的只有windowClosing()一个方法，其余几个方法都是空实现，没有发挥任何作用，这样代码的编写明显是一种多余但又必需的工作。针对这样的问题，JDK提供了一些适配器，它们是监听器接口的默认实现类，这些实现类中实现接口的所有方法，但方法中没有任何代码，程序可以通过继承适配器来达到实现监听器接口的目的。

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

public class Example09 {
    public static void main(String[] args) {
        //创建窗体
        Frame f = new Frame("我的窗体");
        //设置窗体的大小
        f.setSize(300,200);
        //设置窗体的显示
        f.setLocation(300,500);
        //设置窗体可见
        f.setVisible(true);
        // 为窗口组件注册监听器
        f.addWindowListener(new MyWindowListener());
    }
}
// 继承WindowAdapter  适配器类 重写windowClosing重写
class MyWindowListener extends WindowAdapter{
    @Override
    public void windowClosing(WindowEvent e) {
        Window window = (Window) e.getComponent();
        window.dispose();


    }
}

常用事件分类

swing

GUI提供的接口分为AWT和Swing。相对于AWT来说，Swing包中提供了更加丰富、便捷、强大的GUI组件，而且组件都是Java语言编写的，Swing并不依赖于本地平台，可以真正做到跨平台运行。通常来讲，把依赖于本地平台的AWT组件称为重量级组件，而把不依赖本地平台的Swing组件称为轻量级组件。

大部分的Swing组件都是JComponent类的直接或间接子类，而JComponent类是AWT中java.awt.Container的子类。

说明Swing组件和AWT组件在继承树上形成了一定的关系。

在Swing组件中，最常见的就是JFrame，它和Frame一样是一个独立存在的顶级窗口，不能放置在其他容器之中，JFrame支持通用窗口所有的基本功能，例如窗口的最小化，设定窗口大小等。

import javax.swing.JFrame;
import javax.swing.JButton;
import java.awt.FlowLayout;

public class Example10 extends JFrame {
    public Example10() {
        this.setTitle("JFrameTest");
        this.setSize(250, 300);
        //定义一个按钮
        JButton bt = new JButton("按钮");
        //设置布局管理器
        this.setLayout(new FlowLayout());
        //添加按钮
        this.add(bt);
        //设置点击关闭关闭按钮时的默认操作
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //显示窗体
        this.setVisible(true);
    }

    public static void main(String[] args) {
        new Example10();
    }
}

很多GUI程序都需要在组件上绘制图形，比如实现五子棋小游戏，就需要在组件上绘制棋盘和棋子。在java.awt包中专门提供了一个Graphics类，它相当于一个抽象的画笔，其中提供了各种绘制图形的方法，使用Graphics类的方法就可以完成在组件上绘制图形。。

setColor(color c)    将文字，边框或要填充的区域为指定颜色

Font f=new Font(String name , int type , int size)
setFont(Font f)
Font()方法的三个参数分别表示：字体名称(如："宋体" )，
字体样式(如：Font.PLAINT，Font.ITALIC，Font.BOLD)，字体大小
setFont()方法用于接收一个Font类型的参数

drawRect(int x , int y , int width , int height)
drawRect()方法用于绘制矩形边框；其中：x表示矩形左边缘的位置；
y表示矩形上边缘的位置；width表示矩形的宽，height表示矩形的高 

drawOval(int x , int y , int width , int height) 
drawOval()方法用于绘制一个圆或椭圆；其大小为参数为x,y,width,height指定的矩形的外接圆或椭圆

fillRect(int x , int y , int width , int height)
用预先指定的颜色填充矩形 

fillOval(int x , int y , int width , int height) 
用预先指定的颜色填充圆或椭圆  

drawString(String str , int x , int y) 
用预先设置好的颜色和字体来绘制文本str，文本左下角的坐标为(x,y)

import java.awt.*;
import java.util.Random;

public class Example11 {
    public static void main(String[] args) {
        Frame frame = new Frame("验证码");
        Panel panel = new MyPanel();
        frame.add(panel);
        frame.setSize(200,100);
        //将当前窗口居中
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
}
class MyPanel extends Panel{
    @Override
    public void paint(Graphics g) {
        int width = 160;//定义验证码图片的宽度
        int height = 40;//定义验证码图片的高度
        g.setColor(Color.LIGHT_GRAY); //设置画笔的颜色
        g.fillRect(0,0,width-1,height-1);//绘制验证码的背景
        g.setColor(Color.black);//设置画笔的颜色
        g.drawRect(0,0,width,height);//绘制验证码边框
        //绘制干扰点
        Random random = new Random();
        for (int i = 0; i < 100; i++) {
            int x = random.nextInt(width) -2;
            int y = random.nextInt(height) -2;
            g.drawOval(x,y,2,2);
        }
        //设置验证码的字体
        g.setFont(new Font("黑体",Font.BOLD,30));
        //设置一下当前验证码文字的颜色
        g.setColor(Color.blue);
        //产生随机验证码
        char[] chars = "0123456789abcdefghigklmnopqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ".toCharArray();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 4; i++) {
            int pos = random.nextInt(chars.length);
            char c = chars[pos];
            sb.append(c + " ");
        }
        //绘制文字
        g.drawString(sb.toString(),20,30);
    }
}

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

public class Example12 {
    /**
     * 用匿名内部类实现事件处理
     */
    public static void main(String[] args) {
       Frame f = new Frame("我的窗体");
       f.setSize(400,300);
       f.setLocation(300,200);
       f.setVisible(true);
       Button btn = new Button("EXIT");//创建一个按钮
       f.add(btn);

       //用内部类的方式为按钮注册监听器
        btn.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                System.exit(0);
            }
        });
    }
}

窗口事件

大部分GUI应用程序都需要使用Window窗体对象作为最外层的容器，可以说窗体对象是所有GUI应用程序的基础，应用程序中通常都是将其他组件直接或间接地置于窗体中。

当对于窗体进行操作时，比如窗体的打开、关闭、激活、停用等，这些动作都属于窗体事件，JDK中提供了一个类WindowEvent用于表示这些窗体事件，在应用程序中，当对窗体事件进行处理时，首先需要定义一个实现了WindowListener接口的类的作为窗体监听器，然后通过addWindowListener()方法将窗体对象与窗体监听器进行绑定。

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

public class Example13 {
    public static void main(String[] args) {
        Frame f = new Frame("WindowEvent");
        f.setSize(400,300);
        f.setLocation(300,200);
        f.setVisible(true);
        //使用内部类创建WindowListener对象，监听窗口事件
        f.addWindowListener(new WindowListener() {
            @Override
            public void windowOpened(WindowEvent e) {
                System.out.println("windowOpened ---窗体打开事件");
            }

            @Override
            public void windowClosing(WindowEvent e) {
                System.out.println("windowClosing --- 窗口正在 关闭的事件");
            }

            @Override
            public void windowClosed(WindowEvent e) {
                System.out.println("windowClosed --- 窗口关闭的事件");
            }

            @Override
            public void windowIconified(WindowEvent e) {
                System.out.println("windowIconified --- 窗口图标化事件");
            }

            @Override
            public void windowDeiconified(WindowEvent e) {
                System.out.println("windowDeiconified --- 窗口取消图标化事件");
            }

            @Override
            public void windowActivated(WindowEvent e) {
                System.out.println("windowActivated --- 窗口激活的事件");
            }

            @Override
            public void windowDeactivated(WindowEvent e) {
                System.out.println("windowDeactivated --- 窗口停用事件");
            }
        });

    }
}

动作事件

动作事件与前面的三种事件有所不同，它不代表某个具体的动作，只是表示一个动作发生了，例如在关闭一个文件时，可以通过键盘关闭，也可以通过鼠标关闭，在这里不用关心使用哪种方式对文件进行关闭，只要是对关闭按钮进行操作，及触发了动作事件。

在Java中，动作时间用ActionEvent类表示，处理ActionEvent

标签：管理器,int,备份,public,窗体,void,new,图形化
From： https://www.cnblogs.com/hekang520/p/18387219

图形化(备份)