随笔转载自：此去经年ぢ

地址：http://www.cnblogs.com/FLFL/p/5369756.html

1.     GUI编程引言

以前的学习当中，我们都使用的是命令交互方式：

　　例如:在DOS命令行中通过javac java命令启动程序.

软件的交互的方式：

　　  1. 命令交互方式

　　　　   图书管理系统

　　2. 图形交互方式

　　　　ava提供了专业的API用于开发图形用户界面

　　　　　　GUI--> Graphic  User   Interface

　　  将要了解GUI API的框架结构,以及GUI组件以及组件之间的关系,容器和布局管理器,颜色,字体等.

2.     GUI的分类

2.1. AWT

　　Java1.0版本的图形用户界面库，设计目标是帮助程序员编写在所有平台上都能良好表现的GUI程序。为了实现这个目标Java1.0提供了抽象窗口工具集（AWT），但是这个目标并没有达到。AWT在所有的系统上表现都不好。因为：最初版本的AWT是在一个月内构思，设计和实现的（Think in Java ）。

　　Abstract  Window  Toolkit   抽象窗口工具集

　　Java将图形用户界面相关的类捆绑在了一起,放在了一个称之为抽象窗口工具集的库中.AWT适合开发简单的图形用户界面,并不适合开发复杂的GUI项目.

　　位于: java.awt.* 中,定义了很多的组件类，开发者可以直接创建对象加以使用

　　缺点: 所有的图形界面都依赖于底层的操作系统,容易发生于特定平台相关的故障.

　　AWT调用本地系统资源生成图形化界面, 依赖本地平台. 1.0

2.2. Swing

SUN公司对AWT进行了升级，基于AWT，推出了一种更稳定,更通用和更灵活的库.称之为Swing组件库(Swing component)。

既然都是用于GUI设计的组件库,那么为了区分Swing组件类和对应的AWT组件类,Swing组件类都已字母J为前缀.位于:javax.swing.* 中,提供了和AWT中等同的所有的组件类，但是类名的前面多加了一个J.

SWING可以跨平台. 1.2

我们主要学习Swing GUI组件.

3.     Java GUI API

GUI API包含的类分为三个部分:组件类(component class) 容器类(container class),和辅助类(helper class)

  1. 组件类是用来创建用户图形界面的,例如JButton,JLabel,JTextField.
  2. 容器类是用来包含其他组件的,例如JFrame,JPanel
  3. 辅助类是用来支持GUI组件的,例如Color,Font

3.1. 组件类

在图形用户界面程序中当我们想要创建按钮、复选框和滚动条等这些可以显示在屏幕上的对象，该如何创建。其实这些都属于一类叫做组件类。

AWT中的组件根类

  1. 类 Component
  2. java.lang.Object
  3.             java.awt.Component

Swing中的组件根类

 
  1. javax.swing
  2. 类 JComponent
  3. java.lang.Object
  4.            java.awt.Component
  5.                     java.awt.Container
  6.                             javax.swing.JComponent
 

组件类的实例可以显示在屏幕上.Component类是包括容器类的所有用户界面类的根类是java.awt中的类,对应的Swing中的是Jcomponent.了解了Component和JComponent都是抽象类.所以不能使用new关键字创建对象.所以需要使用它们的具体的实现类来创建对象.

在AWT中典型图形用户界面中的按钮(Button)、复选框(Checkbox)和滚动条(Scrollbar)都是组件类,都是Component类的子类.

在Swing中的GUI组件,有对应的JButton,JCheckBox,JscrollBar

继承关系图(AWT)

3.2. 容器类

　　容器(Container)，是一个特殊的组件，该组件可以通过add()添加其他组件。

　　容器类适用于盛装其他GUI组件的GUI组件.例如 Panel Frame Dialog都是AWT组件的容器类.

对应的Swing组件的容器类是JPanel JFrame JDialog

3.3. GUI辅助类

用来描述GUI组件的属性,例如图像的颜色,字体等. 注意:辅助类是在java.awt中的

3.4. GUI运行原理

在JDK的bin目录中有javaw.exe .javaw.exe是java在window中专门用于执行GUI程序.

4.     体验GUI

 
  1. import javax.swing.JFrame;
  2. import javax.swing.JOptionPane;
  3.  
  4. public class Demo {
  5.     public static void main(String[] args) {
  6.         // 创建JFrame
  7.         JFrame frame = new JFrame("hello,world");
  8.         // 设置尺寸
  9.         frame.setSize(200, 100);
  10.         // JFrame在屏幕居中
  11.         frame.setLocationRelativeTo(null);
  12.         // JFrame关闭时的操作
  13.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  14.         // 显示JFrame
  15.         frame.setVisible(true);
  16.  
  17.     }
  18. }
 

5.     Jframe框架

JFrame(框架)是一个容器

创建一个用户界面需要创建一个JFrame来存放用户界面组件.例如存放按钮，文本框。

 
  1. javax.swing
  2. 类 JFrame
  3. java.lang.Object
  4.   java.awt.Component
  5.       java.awt.Container
  6.           java.awt.Window
  7.               java.awt.Frame
  8.                   javax.swing.JFrame
 

5.1. 创建一个框架

 
  1. public class Demo1 {
  2.     public static void main(String[] args) {
  3.         // 创建JFrame
  4.         JFrame frame = new JFrame("我的frame");
  5.         // 显示JFrame
  6.         frame.setVisible(true);
  7.  
  8.     }
  9. }
 

注意:需要调用setVisible(true)方法后才会显示框架

　　运行程序会在窗口的左上角显示一个窗口,但是只能显示标题栏,而且关闭JFrame时,程序程序没有停止.

所以需要完成如下需求:

　　1: 设置Jframe的宽度和高度

　　2: 让Jframe显示在屏幕中间

　　3: 关闭Jframe时,程序会停止

5.1.1.  设置JFrame的宽度和高度

  1. java.awt.Window.setSize(int width, int height)

查找API文档,查看 setSize方法,可以指定框架的宽度和高度.参数类型是int,注意是以像素为单位,普通的笔记本的屏幕分辨率为1280*800或者1366*768.注意:分辨率表示每平方英寸的像素数.屏幕分辨率越高,屏幕的像素越多.所以分辨率越高看到的细节就越多.

setSize方法被定义在java.awt.Component类中,被Component  的子类java.awt.Window 重写.而Jframe以继承了Windiws类所以也具备该方法.

5.1.2.  JFrame显示在屏幕中间

setLocationRelativeTo()方法

  1. java.awt.Window.setLocationRelativeTo(Component c)
  2. 设置窗口相对于指定组件的位置。
  3. 如果 c 为 null，则此窗口将置于屏幕的中央。

setLocationRelativeTo(null)方法可以在屏幕上居中显示框架.

如果不想要设置在中间,可以使用

  1. setLocation(200, 100);

5.1.3.  关闭JFrame程序停止

setDefaultCloseOperation(int operation)方法

  1. javax.swing.JFrame.setDefaultCloseOperation(int operation)

该方法告诉程序,当框架关闭时结束程序.方法的参数是JFrame 的常量EXIT_ON_CLOSE

添加完毕

 
  1. public class Demo1 {
  2.     public static void main(String[] args) {
  3.         // 创建JFrame
  4.         JFrame frame = new JFrame("我的frame");
  5.         // 设置尺寸
  6.         frame.setSize(200, 100);
  7.         // JFrame在屏幕居中
  8.         frame.setLocationRelativeTo(null);
  9.         // JFrame关闭时的操作
  10.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  11.         // 显示JFrame
  12.         frame.setVisible(true);
  13.  
  14.     }
  15. }
 

5.2. 框架中添加组件

上述案例中的框架是空的.可以通过add方法在框架中添加组件

  1. java.awt.Container.add(Component comp)

代码:

 
  1. public static void main(String[] args) {
  2.         // 创建JFrame
  3.         JFrame frame = new JFrame("我的frame");
  4.  
  5.         // 创建按钮
  6.         JButton button = new JButton("OK");
  7.         // 向frame中添加一个按钮
  8.         frame.add(button);
  9.  
  10.         // 设置尺寸
  11.         frame.setSize(200, 100);
  12.         // JFrame在屏幕居中
  13.         frame.setLocationRelativeTo(null);
  14.         // JFrame关闭时的操作
  15.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  16.         // 显示JFrame
  17.         frame.setVisible(true);
  18.  
  19.     }
 

运行程序,会显示上图所示窗口.调整窗口的大小,按钮都是显示在窗口的中央,并且占满整个框架.

这是因为组件(本例就是按钮)是被布局管理器放到框架中的.默认布局管理器就是将按钮放到中央.

备注: 可以通过f.setVisible(false);  隐藏窗体f.dispose();关闭窗口

设置图片:

setIconImage(Toolkit.getDefaultToolkit().createImage("png-0015.png"));

6.     JoptionPane对话框

显示一个带有OK 按钮的模态对话框。

下面是几个使用showMessageDialog 的例子：

Java代码  

  1. JOptionPane.showMessageDialog(null, "错误信息提示", "标题", JOptionPane.INFORMATION_MESSAGE);

效果如下：

Java代码  

  1. JOptionPane.showMessageDialog(jPanel, "提示消息", "标题",JOptionPane.WARNING_MESSAGE);

Java代码  

  1.  JOptionPane.showMessageDialog(null, "提示消息.", "标题",JOptionPane.ERROR_MESSAGE);

Java代码

  1.  JOptionPane.showMessageDialog(null, "提示消息.", "标题",JOptionPane.PLAIN_MESSAGE);

1.2 showOptionDialog

这个函数可以改变显示在按钮上的文字。你还可以执行更多的个性化操作。

常规的消息框：

Java代码  

  1. int n = JOptionPane.showConfirmDialog(null, "你高兴吗?", "标题",JOptionPane.YES_NO_OPTION);//i=0/1

输入框 ：

String inputValue = JOptionPane.showInputDialog("请输入你给我金额");

7.     面板(Panel)

面板也是一个容器的组件，可以在上面添加

注意：面板不能单独使用，必须在顶层窗口中使用。

8.     常见组件

一些常用的组件例如:

JLabel,

JButton ,

JTextField

JPassworldField

JRadioButton

JCheckBox

JTextArea

JList

JMenuBar

JMenu

JMenultem

8.1. Button按钮

Java中的Swing提供了常规按钮,单选按钮,复选按钮和菜单按钮

8.1.1.  JButtion普通按钮

按钮Button是点击时触发动作事件的组件.

8.1.2.  JRadioButton单选按钮

单选按钮,可以让用户从一组选项中选择一个单一条目.例如性别.

使用单选按钮时注意将,单选按钮放在一组,需要使用java.swing.ButtonGroup. 的add方法,添加到一个组中,位于同一个组的单选按钮就是互斥的. 如果没有将单选按钮放在一个组中,就是独立的..我们让然需要把按钮添加在容器中.因为ButtonGroup添加到容器中..

8.1.3.  JCheckBox复选框

多选

8.2. JLabel标签

8.3. JTextField文本域

8.4. JTextArea文本区域

8.5. JComboBox组合框

8.6. JList 列表框

例如: String[] data = { "one", "two", "three" };

JList list = new JList(data);

p1.add(list);

8.7. JmenuBar菜单条

JMenu菜单

JMenultem菜单项

菜单条(MenuBar)中包含菜单(Menu),菜单中中包含菜单项(MenuItem)

注意添加的顺序。例如：记事本的菜单条中包含文件、编辑、格式、查看、帮助菜单。其中文件菜单中包含新建、打开、保存、另存为等菜单项

案例综合。

 
  1. public class CommonComponent extends JFrame {
  2.     public CommonComponent() {
  3.  
  4.         // 面板
  5.         JPanel p1 = new JPanel();
  6.         add(p1);
  7.  
  8.         // 标签
  9.         JLabel name = new JLabel("用户名:");
  10.         p1.add(name);
  11.  
  12.         // 文本域
  13.         JTextField field = new JTextField(8);
  14.         p1.add(field);
  15.  
  16.         // 标签
  17.         JLabel passwd = new JLabel("密码");
  18.         p1.add(passwd);
  19.         // 密码域
  20.         JPasswordField pass = new JPasswordField(8);
  21.         p1.add(pass);
  22.  
  23.         // 单选按钮
  24.         JLabel gender = new JLabel("性别");
  25.         p1.add(gender);
  26.         JRadioButton male = new JRadioButton("男");
  27.         JRadioButton female = new JRadioButton("女");
  28.         // 单选按钮组,同一个单选按钮组的互斥.
  29.         ButtonGroup group = new ButtonGroup();
  30.         group.add(male);
  31.         group.add(female);
  32.         // 注意,单选按钮组不能添加进容器
  33.         p1.add(male);
  34.         p1.add(female);
  35.  
  36.         // 复选框
  37.         JLabel like = new JLabel("爱好:");
  38.         p1.add(like);
  39.         JCheckBox eat = new JCheckBox("吃饭");
  40.         JCheckBox movie = new JCheckBox("看电影");
  41.         JCheckBox sleep = new JCheckBox("睡觉");
  42.         p1.add(eat);
  43.         p1.add(movie);
  44.         p1.add(sleep);
  45.  
  46.         // 文本域
  47.         JLabel info = new JLabel("个人简介");
  48.         p1.add(info);
  49.         JTextArea area = new JTextArea(20, 20);
  50.         p1.add(area);
  51.  
  52.         // 列表
  53.         String[] data = { "one", "two", "three" };
  54.         JList list = new JList(data);
  55.         p1.add(list);
  56.  
  57.         // 普通按钮
  58.         JButton button = new JButton("注册");
  59.         p1.add(button);
  60.  
  61.         // 菜单条
  62.         JMenuBar bar = new JMenuBar();
  63.         // 菜单
  64.         JMenu menu = new JMenu("文件");
  65.         // 菜单选项
  66.         JMenuItem myNew = new JMenuItem("新建");
  67.         JMenuItem myOpen = new JMenuItem("打开");
  68.         bar.add(menu);
  69.         menu.add(myNew);
  70.         menu.add(myOpen);
  71.         add(bar, BorderLayout.NORTH);
  72.  
  73.     }
  74.  
  75.     public static void main(String[] args) {
  76.         CommonComponent frame = new CommonComponent();
  77.         frame.setTitle("常用组件");
  78.         frame.setSize(400, 400);
  79.         frame.setLocationRelativeTo(null);
  80.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  81.         // 自适应
  82.         frame.pack();
  83.         frame.setVisible(true);
  84.     }
  85. }
 

因为面板默认是流式布局.

9.     布局管理器

Java的GUI组件都放置在容器中,他们的位置是由容器的布局管理器来管理的.在前面的程序中,并没有指定将OK按钮放置在框架的什么位置,但是,Java知道应该把它放置在哪里,因为在后台工作的布局管理器能够将组件放到正确的位置.布局管理器是使用布局管理器类创建的.

我们可以使用setLayout() 方法在容器中设置布局管理器.

我们将要了解FlowLayout GridLayout BorderLayout

9.1. FlowLayout流式布局

FlowLayout(流式布局)是最简单布局管理器. Jpanel容器默认的布局管理器

流式布局,按照组件添加的顺序,从左到到右将组件排列在容器中.当放满一行,就开始新的一行.在FlowLayout有3个常量FlowLayout可以指定组件的对齐方式.

LEFT   每一行组件都应该是左对齐的

RIGHT  每一行组件都应该是右对齐的

CENTER  每一行组件都应该是居中的

还可以指定组件之间的以像素为单位的间隔.

 
  1. int getHgap()
  2.           获取组件之间以及组件与 Container 的边之间的水平间隙。
  3. int getVgap()
  4.           获取组件之间以及组件与 Container 的边之间的垂直间隙。
  5. void setHgap(int hgap)
  6.           设置组件之间以及组件与 Container 的边之间的水平间隙。
  7. void setVgap(int vgap)
  8.           设置组件之间以及组件与 Container 的边之间的垂直间隙。
 

这个布局管理器的对其方式默认值是CENTER

这个布局管理器的水平间隔默认值是 5个像素

这个布局管理器的垂直间隔默认是是5个像素

创建该布局管理器

 
  1. FlowLayout()
  2.           构造一个新的 FlowLayout，它是居中对齐的，默认的水平和垂直间隙是 5 个单位。
  3. FlowLayout(int align)
  4.           构造一个新的 FlowLayout，它具有指定的对齐方式，默认的水平和垂直间隙是 5 个单位。
  5. FlowLayout(int align, int hgap, int vgap)
  6.           创建一个新的流布局管理器，它具有指定的对齐方式以及指定的水平和垂直间隙。
 

案例:创建框架,使用流失布局管理器.向该框架添加三个标签和文本域.

 
  1. public class ShowFlowLayout extends JFrame {
  2.  
  3.     public ShowFlowLayout() {
  4.         super.setLayout(new FlowLayout(FlowLayout.LEFT, 10, 20));
  5.  
  6.         add(new JLabel("姓名:"));
  7.         add(new JTextField(8));
  8.         add(new JLabel("邮箱:"));
  9.         add(new JTextField(8));
  10.         add(new JLabel("电话:"));
  11.         add(new JTextField(8));
  12.  
  13.     }
  14.  
  15.     public static void main(String[] args) {
  16.         ShowFlowLayout frame = new ShowFlowLayout();
  17.         frame.setTitle("FlowLayout");
  18.         frame.setSize(500, 200);
  19.         frame.setLocationRelativeTo(null);
  20.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  21.         frame.setVisible(true);
  22.     }
  23. }
 

该案例在本类main方法中创建了一个本类对象. 该类的构造函数中创建并且添加组件.

该案例使用了FlowLayout管理器在框架放置组件.如果改变框架的大小.组建会自动的重新排列,以适应框架.

如果将同一个按钮在框架中添加10次,那么该框架只会出现一次,将一个按钮向容器中添加多以和一次是一样的.

9.2. GridLayout网格布局

GridLyaout是以网格形式管理组件的.组件按照他们添加的顺序从左到右排列,显示第一行,接着是第二行,一次类推.

Gridlayout可以指定网格中的行数和列数

规则如下:

行数和列数可以是0但是不能两者都为0.

如果一个为0另外一个不为0,那么不为0的行或列的大小就是固定的,为0的行或者列有布局管理器动态决定.

例如:如果指定一个网格有0行3列10个组件,GirdLayout会创建3个固定的列和行,最后一行只有一个组件.如果指定一个网格有3行0列10个组件,GridLayout就会创建3行4列,最后一行包含2个组件.

如果行数和列数都不为0,那么以行数为依据.所以行数是固定的,布局管理器会动态的计算列数.例如,如果指定一个网格有3行3列10个组件,GridLayout会创建3个固定的行和4列,最后一行包含2个组件.

构造方法

 
  1. GridLayout()
  2.           创建具有默认值的网格布局，即每个组件占据一行一列。
  3. GridLayout(int rows, int cols)
  4.           创建具有指定行数和列数的网格布局。
  5. GridLayout(int rows, int cols, int hgap, int vgap)
  6.           创建具有指定行数和列数,水平间隔,垂直间隔的网格布局。
 

方法:

 
  1. int getRows()
  2.           获取此布局中的行数。 默认值是1
  3. int getColumns()
  4.           获取此布局中的列数。 默认值是1
  5.  int getHgap()
  6.           获取组件之间的水平间距。 默认值是0
  7. int getVgap()
  8.           获取组件之间的垂直间距。默认值是0
  9.  
  10. 设置
  11. void setRows(int rows)
  12.           将此布局中的行数设置为指定值。默认值是1
  13. void setColumns(int cols)
  14.           将此布局中的列数设置为指定值。  默认值是1
  15.  void setHgap(int hgap)
  16.           将组件之间的水平间距设置为指定值。  默认值是0
  17.  void setVgap(int vgap)
  18.           将组件之间的垂直间距设置为指定值。默认值是0
 

案例:该案例依然添加3个标签和3个文本域,只不过布局管理器是GrigLayout

 
  1. public class ShowGridLayout extends JFrame {
  2.     public ShowGridLayout() {
  3.         setLayout(new GridLayout(3, 2, 5, 5));
  4.  
  5.         add(new JLabel("姓名:"));
  6.         add(new JTextField(8));
  7.         add(new JLabel("邮箱:"));
  8.         add(new JTextField(8));
  9.         add(new JLabel("电话:"));
  10.         add(new JTextField(8));
  11.     }
  12.  
  13.     public static void main(String[] args) {
  14.         ShowGridLayout frame = new ShowGridLayout();
  15.         frame.setTitle("GridLayout");
  16.         frame.setSize(200, 125);
  17.         frame.setLocationRelativeTo(null);
  18.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  19.         frame.setVisible(true);
  20.     }
  21. }
 

如果使用setLayout(new GridLayout(3,10))替换setlayout语句,还是会得到3行2列,因为行的参数非零,所以列的参数会被忽略.列的实际参数是由布局管理器计算出来的.

9.3.BorderLayout边框布局

边框布局,JFrame 容器默认的布局管理器是边框布局.该管理器将容器非为东西南北中5个区域.

我们使用add(Component,index)方法可以将组件添加进到BorderLayout中,index是一个常量,有5个值

 
  1. EAST
  2.           东区域的布局约束（容器右边）。
  3. WEST
  4.           西区域的布局约束（容器左边）。
  5. SOUTH
  6.           南区域的布局约束（容器底部）。
  7. NORTH
  8.           北区域的布局约束（容器顶部）。
  9. CENTER
  10.           中间区域的布局约束（容器中央）。
 

构造函数

  1. BorderLayout()
  2.           构造一个组件之间没有间距的新边框布局。
  3. BorderLayout(int hgap, int vgap)
  4.           构造一个具有指定组件间距的边框布局。

方法:

 
  1. int getHgap()
  2.           返回组件之间的水平间距。
  3. int getVgap()
  4.           返回组件之间的垂直间距。
  5. void setHgap(int hgap)
  6.           设置组件之间的水平间距。 默认值是0
  7.  void setVgap(int vgap)
  8.           设置组件之间的垂直间距。默认值是0
 

组件会根据他们最合适的尺寸和在容器中的位置来放置,南北组件可以水平拉伸,东西组件可以垂直拉伸,中央组件既可以水平拉伸也可以垂直拉伸.

案例:演示边框布局管理器

 
  1. public class ShowBorderLayout extends JFrame {
  2.     public ShowBorderLayout() {
  3.         setLayout(new BorderLayout(5, 10));
  4.  
  5.         add(new JButton("东"), BorderLayout.WEST);
  6.         add(new JButton("西"), BorderLayout.EAST);
  7.         add(new JButton("南"), BorderLayout.SOUTH);
  8.         add(new JButton("北"), BorderLayout.NORTH);
  9.         add(new JButton("中"), BorderLayout.CENTER);
  10.     }
  11.  
  12.     public static void main(String[] args) {
  13.         ShowBorderLayout frame = new ShowBorderLayout();
  14.         frame.setTitle("BorderLayout");
  15.         frame.setSize(300, 200);
  16.         frame.setLocationRelativeTo(null);
  17.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  18.         frame.setVisible(true);
  19.     }
  20. }
 

注意: 如果布局管理器为Border管理器,调用add方法,没有说明组件的位置(东西南北中)默认是center.

所以

add(new JButton("ok"))和add(new JButton("ok"), BorderLayout.CENTER )

效果是一样的.

如果在Border容器中添加2个组件,都没有指定位置,那么只会显示最后一个组件

add(new JButton("ok1"))和add(new JButton("ok2")) 只会显示ok2

使用布局管理器

代码:

 
  1. public class CommonComponent extends JFrame {
  2.     public CommonComponent() {
  3.         // 菜单条
  4.         JMenuBar bar = new JMenuBar();
  5.         // 菜单
  6.         JMenu menu = new JMenu("文件");
  7.         // 菜单选项
  8.         JMenuItem myNew = new JMenuItem("新建");
  9.         JMenuItem myOpen = new JMenuItem("打开");
  10.         bar.add(menu);
  11.         menu.add(myNew);
  12.         menu.add(myOpen);
  13.         add(bar, BorderLayout.NORTH);
  14.  
  15.         // 面板
  16.         JPanel p1 = new JPanel();
  17.         p1.setLayout(new GridLayout(2, 2, 5, 5));
  18.         add(p1);
  19.  
  20.         // 标签
  21.         JLabel name = new JLabel("用户名:");
  22.         p1.add(name);
  23.  
  24.         // 文本域
  25.         JTextField field = new JTextField(8);
  26.         p1.add(field);
  27.  
  28.         // 标签
  29.         JLabel passwd = new JLabel("密码");
  30.         p1.add(passwd);
  31.         // 密码域
  32.         JPasswordField pass = new JPasswordField(8);
  33.         p1.add(pass);
  34.  
  35.         JPanel p2 = new JPanel();
  36.         // 单选按钮
  37.         JLabel gender = new JLabel("性别");
  38.         p2.add(gender);
  39.         JRadioButton male = new JRadioButton("男");
  40.         JRadioButton female = new JRadioButton("女");
  41.         // 单选按钮组,同一个单选按钮组的互斥.
  42.         ButtonGroup group = new ButtonGroup();
  43.         group.add(male);
  44.         group.add(female);
  45.         // 注意,单选按钮组不能添加进容器
  46.         p2.add(male);
  47.         p2.add(female);
  48.  
  49.         JPanel p3 = new JPanel();
  50.         // 复选框
  51.         JLabel like = new JLabel("爱好:");
  52.         p3.add(like);
  53.         JCheckBox eat = new JCheckBox("吃饭");
  54.         JCheckBox movie = new JCheckBox("看电影");
  55.         JCheckBox sleep = new JCheckBox("睡觉");
  56.         p3.add(eat);
  57.         p3.add(movie);
  58.         p3.add(sleep);
  59.  
  60.         JPanel p4 = new JPanel(new GridLayout(1, 0, 5, 5));
  61.         // 文本域
  62.         JLabel info = new JLabel("个人简介:");
  63.         p4.add(info);
  64.         JTextArea area = new JTextArea(50, 10);
  65.         p4.add(area);
  66.  
  67.         JPanel p5 = new JPanel(new BorderLayout());
  68.         // 列表
  69.         String[] data = { "one", "two", "three" };
  70.         JList list = new JList(data);
  71.         p5.add(list, BorderLayout.WEST);
  72.  
  73.         JPanel p6 = new JPanel();
  74.         // 普通按钮
  75.         JButton button = new JButton("注册");
  76.         p6.add(button);
  77.         JButton button2 = new JButton("取消");
  78.         p6.add(button2);
  79.  
  80.         setLayout(new GridLayout(7, 1, 5, 5));
  81.         add(p1);
  82.         add(p2);
  83.         add(p3);
  84.         add(p4);
  85.         add(p5);
  86.         add(p6);
  87.  
  88.     }
  89.  
  90.     public static void main(String[] args) {
  91.         CommonComponent frame = new CommonComponent();
  92.         frame.setTitle("常用组件");
  93.         frame.setSize(400, 600);
  94.         frame.setLocationRelativeTo(null);
  95.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  96.         // 自适应
  97.         // frame.pack();
  98.         frame.setVisible(true);
  99.     }
  100. }
 
 
  1. public class TestPanel extends JFrame {
  2.     public TestPanel() {
  3.         // 创建面板,默认是流式布局
  4.         JPanel p1 = new JPanel();
  5.         // 指定为网格布局,4行3列
  6.         p1.setLayout(new GridLayout(4, 3));
  7.         for (int i = 1; i <=9; i++) {
  8.             p1.add(new JButton("" + i));
  9.         }
  10.         p1.add(new JButton("0"));
  11.         p1.add(new JButton("OK"));
  12.         p1.add(new JButton("EXIT"));
  13.  
  14.         // 创建面板,指定边框布局
  15.         JPanel p2 = new JPanel(new BorderLayout());
  16.         // 面板添加文本域,边框北部
  17.         p2.add(new JTextField("我在这里啊!!!"), BorderLayout.NORTH);
  18.         // 面板添加其他面板,边框中部.
  19.         p2.add(p1, BorderLayout.CENTER);
  20.  
  21.         // 框架添加面板,框架的布局默认就是边框布局,面板指定位于框架西部
  22.         add(p2, BorderLayout.EAST);
  23.         // 框架添加按钮,位于框架总部.
  24.         add(new JButton("哈哈"), BorderLayout.CENTER);
  25.  
  26.     }
  27.  
  28.     public static void main(String[] args) {
  29.         TestPanel frame = new TestPanel();
  30.         frame.setTitle("JPanel");
  31.         frame.setSize(400, 260);
  32.         frame.setLocationRelativeTo(null);
  33.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  34.         frame.setVisible(true);
  35.     }
  36. }
 

注意: 面板容器是一个轻量级的容器，该容器不能单独的使用，必须依赖与外层的顶层容器(JFrame)

10.     Java事件监听机制

在上述的程序中,其中菜单条,菜单 项，按钮等都是对象,当我们单击对象时,应该能够完成一些任务.例如在程序中通过鼠标操作时,单击,双击,鼠标移入,鼠标移出.能够执行一些任务,在 Java中我们可以使用事件监听机制,在Java的事件监听机制中 ,当事件发生时(点击按钮,移动鼠标等，关闭窗口)会被一类对象发现并处理.

10.1. 事件和事件源

在运行java图形用户界面程序时,用户与程序交互,用户执行了某些操作时，会发生一些事情， 那么事件(event)可以定义为程序发生了某些事情的信号.典型用户操作就是用户移动鼠标,点击按钮,敲击键盘等.程序可以选择相应事件或者忽略事件。

能够创建一个事件并触发该事件的组件称为源对象。例如由于按钮能够点击, 那么按钮就是一个源对象,按钮被点击就是一个事件。

一个事件是事件类的实例对象。事件类的根类是java.util.EventObject。

事件对象包含事件相关的属性，可以使用EventObject类中的实例方法getSource获得事件的源对象。

EventObject类的子类可以描述特定类型的事件

用户动作

源对象

触发的事件类型

点击按钮

JButton

ActionEvent

文本域按回车

JTextField

ActionEvent

窗口打开，关闭，最小化，关闭

Window

WindowEvent

单击，双击，移动，鼠标

Component

MouseEvent

点击单选框

JradioButton

ItemEvent ActionEvent

点击复选框

JcheckBox

ItemEvent ActionEvent

10.2. 监听器

当源对象触发了一个事件,谁来处理这个事件？在Java中对此感兴趣的对象会处理它。对此感兴趣的对象称之为监听器（Listener）。

举例来说当我们点击一个按钮，想要按钮执行一些动作，需要一个对象来监控按钮，当点击按钮的事件发生时，该对象就会监听到按钮事件。进而可以执行一些动作。

例如：

Java中,对象表示的每个事件都是由java.util中EventObject类的子类,

例如: MouseEvent: 表示鼠标的动作,例如移动光标,单击,双击

KeyEvent: 表示键盘上的按键.

ActionEvent表示用户采取的用户界面操作,例如点击屏幕上的按钮.

10.3. 事件处理

Java对组件都有对应的事件监听器，和添加事件监听器方法。

例如： 按钮： 源对象，会触发

体验：当用户点击按钮时，按钮上的信息会发生变化

 
  1. import java.awt.event.ActionEvent;
  2. import java.awt.event.ActionListener;
  3. import javax.swing.JButton;
  4. import javax.swing.JFrame;
  5.  
  6. public class ShowButton extends JFrame {
  7.     public ShowButton() {
  8.         JButton button = new JButton("点我");
  9.         add(button);
  10.  
  11.         // 添加鼠标监听事件
  12.         button.addActionListener(new ActionListener() {
  13.  
  14.             @Override
  15.             public void actionPerformed(ActionEvent e) {
  16.                 System.out.println("按钮被点击");
  17.                 Object source = e.getSource();
  18.                 JButton button = (JButton) source;
  19.                 String text = button.getText();
  20.                 if ("按钮被点击".equals(text)) {
  21.                     button.setText("点我");
  22.                 } else {
  23.                     button.setText("按钮被点击");
  24.                 }
  25.             }
  26.         });
  27.     }
  28.  
  29.     public static void main(String[] args) {
  30.         ShowButton frame = new ShowButton();
  31.         frame.setTitle("我的框架");
  32.         frame.setSize(400, 200);
  33.         frame.setLocationRelativeTo(null);
  34.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  35.         frame.setVisible(true);
  36.     }
  37. }
 

10.4. 窗口事件

Window类

 
  1. java.awt
  2. 类 Window
  3. java.lang.Object
  4.       java.awt.Component
  5.              java.awt.Container
  6.                    java.awt.Window
 

Window 对象是一个顶层窗口。窗口（Window）对应的事件叫做窗口事件（WindowEvent），任何窗口（Window）以及窗口的子类都可能触发窗口事件： 打开窗口，正在关闭窗口，激活窗口，变成非活动窗口，最小化窗口和还原窗口。

Window添加窗口事件（WindowEvent）监听器的方法

  1. void addWindowListener(WindowListener l)
  2.           添加指定的窗口侦听器，以从此窗口接收窗口事件

监听Window窗口事件（WindowEvent）的监听器：WindowListener

  1. java.awt.event
  2. 接口 WindowListener
  3. 用于接收窗口事件的侦听器接口。当通过打开、关闭、激活或停用、图标化或取消图标化而改变了窗口状态时，将调用该侦听器对象中的相关方法

WindowListener接口中定义的方法

 
  1. 抽象方法：
  2. void windowActivated(WindowEvent e)
  3.           激活窗口
  4.  void windowClosed(WindowEvent e)
  5.           关闭窗口
  6.  void windowClosing(WindowEvent e)
  7.           正在关闭窗口
  8.  void windowDeactivated(WindowEvent e)
  9.           变为非活动窗口
  10.  void windowDeiconified(WindowEvent e)
  11.           还原窗口
  12.  void windowIconified(WindowEvent e)
  13.           最小化窗口
  14. void windowOpened(WindowEvent e)
  15.            打开窗口
  16.
 

案例： 框架的事件监听处理

 
  1. javax.swing
  2. 类 JFrame
  3. java.lang.Object
  4.        java.awt.Component
  5.               java.awt.Container
  6.                     java.awt.Window
  7.                           java.awt.Frame
  8.                                 javax.swing.JFrame
 

创建JFrame，Jfame是一个框架，属于窗体（Window）体系中的一员，也可以实现窗口的最大化，最小化，关闭，点击窗体，等一系列的操作。那么在用户触发这些事件发生时能够做一些工作，就需要注册事件监听器。

JFrame 是通过addWindowListener 方法就注册窗体事件监听器，该方法需要接受一个监听器（WindowListener）对象。查找API文档，发现WindowListener是一个接口，

我们需要窗口监听器(WindowListener)的实例对象，所以需要实现该接口，重写WindowListener接口的抽象方法。然后创建该实现类对象，作为参数传递给addWindowListener .

例如： 当像激活窗口这样的窗口事件发生时，windowActivated 方法就会触发。

代码如下：

 
  1. import java.awt.event.WindowEvent;
  2. import java.awt.event.WindowListener;
  3. import javax.swing.JFrame;
  4.  
  5. public class WindowEventDemo extends JFrame {
  6.  
  7.     WindowEventDemo() {
  8.         // this对象时JFrame的子类，而JFrame 类是Window体系中的一员所以具备添加窗口事件的方法
  9.         this.addWindowListener(new MyWindow());
  10.     }
  11.  
  12.     public static void main(String[] args) {
  13.         WindowEventDemo frame = new WindowEventDemo();
  14.         frame.setTitle("我的框架");
  15.         frame.setSize(400, 200);
  16.         frame.setLocationRelativeTo(null);
  17.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  18.         frame.setVisible(true);
  19.     }
  20. }
  21.  
  22. // 实现WindowListener
  23. class MyWindow implements WindowListener {
  24.     // 激活窗口
  25.     public void windowActivated(WindowEvent e) {
  26.         System.out.println("激活窗口");
  27.     }
  28.  
  29.     // 关闭窗口
  30.     public void windowClosed(WindowEvent e) {
  31.         System.out.println("关闭窗口");
  32.     }
  33.  
  34.     // 正在关闭窗口
  35.     public void windowClosing(WindowEvent e) {
  36.         System.out.println("正在关闭窗口");
  37.     }
  38.  
  39.     // 变为非活动窗口
  40.     public void windowDeactivated(WindowEvent e) {
  41.         System.out.println("变为非活动窗口");
  42.     }
  43.  
  44.     // 还原窗口
  45.     public void windowDeiconified(WindowEvent e) {
  46.         System.out.println("还原窗口");
  47.     }
  48.  
  49.     // 最小化窗口
  50.     public void windowIconified(WindowEvent e) {
  51.         System.out.println(" 最小化窗口");
  52.     }
  53.  
  54.     // 打开窗口
  55.     public void windowOpened(WindowEvent e) {
  56.         System.out.println("打开窗口");
  57.     }
  58.  
  59. }
 

总结：Window类或者Window类的任何子类都可能会触发WindowEvent。因为JFrame是Window的子类。所以也可以触发WindowEvent。

1.5. 监听器接口适配器

因为WindowListener接口中的方法都是抽象的，所以即使程序中不想关注某些事件，但是还是要实现所以的方法，比较麻烦，为了方便起见，Java提供了一个针对WindowListener接口的实现类，该类中把WindowListener接口中的方法全部实现，只不过方法体都为空。

例如： 加入我们只对激活窗口感兴趣，那么只需要继承该实现类重写激活窗口的方法即可。简化了代码。

 
  1. import java.awt.event.WindowAdapter;
  2. import java.awt.event.WindowEvent;
  3. import javax.swing.JFrame;
  4.  
  5. public class AdapterDemo extends JFrame {
  6.     AdapterDemo() {
  7.         addWindowListener(new MyAdapter());
  8.     }
  9.  
  10.     public static void main(String[] args) {
  11.         AdapterDemo frame = new AdapterDemo();
  12.         frame.setTitle("我的框架");
  13.         frame.setSize(400, 200);
  14.         frame.setLocationRelativeTo(null);
  15.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  16.         frame.setVisible(true);
  17.     }
  18.  
  19.     class MyAdapter extends WindowAdapter {
  20.         public void windowActivated(WindowEvent e) {
  21.             System.out.println("windowActivated....");
  22.         }
  23.     }
  24.  
  25. }
 

那么这个WindowAdapter类就叫做适配器类，是为了简化代码的书写而出现的。

  1. 适配器                            接口
  2. WindowAdapter               WindowListener
  3. MouserAdapter                 MouserListener
  4. KeyAdapter                  KeyListener

10.6. 鼠标键盘事件

当在一个组件上按下，释放，点击，移动，或者拖动鼠标时，就会产生鼠标事件。MouseEvent对象捕获这个事件。

MouseEvent

  1. java.awt.event.MouseEvent

Java对鼠标事件提供了MouseListener 监听器接口，可以监听鼠标的按下，释放，输入，退出和点击动作。

MouseListener

用于接收组件上“感兴趣”的鼠标事件（按下、释放、单击、进入或离开）的侦听器接口

方法：

 
  1. void mouseClicked(MouseEvent e)
  2.           鼠标按键在组件上单击（按下并释放）时调用。
  3.  void mouseEntered(MouseEvent e)
  4.           鼠标进入到组件上时调用。
  5.  void mouseExited(MouseEvent e)
  6.           鼠标离开组件时调用。
  7.  void mousePressed(MouseEvent e)
  8.           鼠标按键在组件上按下时调用。
  9.  void mouseReleased(MouseEvent e)
  10.           鼠标按钮在组件上释放时调用。
 

按键事件可以利用键盘来控制和执行一些动作，如果按下、释放一个键就会触发按键事件。KeyEvent对象可以捕获按键的按下放开和敲击。KeyEvent提供了getkeyChar 来获取按键对应的字符。

  1. java.awt.event.KeyEvent
  2.  
  3. char getKeyChar()
  4.           返回与此事件中的键关联的字符。

Java提供了KeyListener监听器接口来监听按键事件。

KeyListener接口

用于接收键盘事件（击键）的侦听器接口。

 
  1. void keyPressed(KeyEvent e)
  2.           按下某个键时调用此方法。
  3.  void keyReleased(KeyEvent e)
  4.           释放某个键时调用此方法。
  5.  void keyTyped(KeyEvent e)
  6.           键入某个键时调用此方法。
 
 
  1. public class MouseEventDemo extends JFrame {
  2.     MouseEventDemo() {
  3.         JButton button = new JButton("ok");
  4.         JTextArea text = new JTextArea();
  5.         add(button, BorderLayout.NORTH);
  6.         add(text, BorderLayout.CENTER);
  7.  
  8.         button.addMouseListener(new MouseListener() {
  9.  
  10.             // 鼠标按钮在组件上释放时调用。
  11.             public void mouseReleased(MouseEvent e) {
  12.                 System.out.println("鼠标释放");
  13.  
  14.             }
  15.  
  16.             // 鼠标按键在组件上按下时调用。
  17.             public void mousePressed(MouseEvent e) {
  18.                 System.out.println("鼠标按下组件");
  19.  
  20.             }
  21.  
  22.             // 鼠标离开组件时调用。
  23.             public void mouseExited(MouseEvent e) {
  24.                 System.out.println("鼠标离开组件");
  25.  
  26.             }
  27.  
  28.             // 鼠标进入到组件上时调用。
  29.             public void mouseEntered(MouseEvent e) {
  30.                 // 鼠标进入
  31.                 System.out.println("鼠标进入组件");
  32.  
  33.             }
  34.  
  35.             // 鼠标按键在组件上单击（按下并释放）时调用。
  36.             public void mouseClicked(MouseEvent e) {
  37.                 System.out.println("鼠标单击组件");
  38.  
  39.             }
  40.         });
  41.         text.addKeyListener(new KeyListener() {
  42.  
  43.             // 键入某个键时调用此方法。
  44.             public void keyTyped(KeyEvent e) {
  45.                 System.out.println("键入某个键");
  46.                 if (e.getKeyChar() == 'q') {
  47.                     System.exit(0);
  48.                 }
  49.             }
  50.             // 释放某个键时调用此方法。
  51.             public void keyReleased(KeyEvent e) {
  52.                 System.out.println("按键释放");
  53.  
  54.             }
  55.  
  56.             // 按下某个键时调用此方法。
  57.             public void keyPressed(KeyEvent e) {
  58.                 System.out.println("键盘按下");
  59.             }
  60.         });
  61.     }
  62.  
  63.     public static void main(String[] args) {
  64.         MouseEventDemo frame = new MouseEventDemo();
  65.         frame.setTitle("鼠标事件");
  66.         frame.setSize(400, 200);
  67.         frame.setLocationRelativeTo(null);
  68.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  69.         frame.setVisible(true);
  70.     }
  71. }
 

10.7. 事件监听机制小结

一：确定事件源（容器或组件）

二：注册监听器

　　 通过事件源对象的addXXXListener()方法将监听器对象注册到该事件源上。

三：监听器对象

　　 注册监听器时，需要指定监听器对象。

以参数的形式进监听器对象传递给addXXXListener()

监听器对象是XXXListener的子类对象或者XXXAdapter的子类对象。

　　监听器对象一般用匿名内部类来表示。（简化书写）

　　在覆盖方法的时候，方法的参数一般是XXXEvent类型的变量接收。

　　 事件触发后会把事件打包成对象传递给该变量。(其中包括事件源对象。通过getSource()或者getComponent()获取。)

四：常见的事件监听器

WindowListener        主要用于监听窗口

ActionListener          主要用于用监听组件对象的单击动作

MouseListener          鼠标监听器

KeyListener               监听键盘

…….

五：常见的事件适配器

WindowAdapter

MouseAdapter

KeyAdapter

Java Swing 使用总结（转载）的更多相关文章

  1. Java Swing 资料（转载学习）

    Swing图像界面简介:https://blog.csdn.net/xietansheng/article/details/72814531 Swing实用经验总结篇:https://blog.csd ...

  2. 客户端是选择Java Swing还是C# Winform

      登录|注册     mentat的专栏       目录视图 摘要视图 订阅 [专家问答]韦玮:Python基础编程实战专题     [知识库]Swift资源大集合    [公告]博客新皮肤上线啦 ...

  3. atitit.软件开发GUI 布局管理优缺点总结java swing wpf web html c++ qt php asp.net winform

    atitit.软件开发GUI 布局管理优缺点总结java swing wpf web html c++ qt php asp.net winform 1. Absoluti 布局(经常使用) 1 2. ...

  4. Java Swing创建自定义闪屏:在闪屏上添加Swing进度条控件(转)

    本文将讲解如何做一个类似MyEclipse启动画面的闪屏,为Java Swing应用程序增添魅力. 首先看一下效果图吧, 原理很简单,就是创建一个Dialog,Dialog有一个进度条和一个Label ...

  5. atitit.窗体静听esc退出本窗体java swing c# .net php

    atitit.窗体静听esc退出本窗体java swing c# .net php 1. 监听esc  按键 1 1.1. 监听一个组件 1 1.2. 监听加在form上 1 2. 关闭窗体 2 1. ...

  6. atitit.D&D drag&drop拖拽文件到界面功能 html5 web 跟个java swing c#.net c++ 的总结

    atitit.D&D drag&drop拖拽文件到界面功能 html5 web 跟个java swing c#.net c++ 的总结 1. DND的操作流程 1 2. Html5 注 ...

  7. Atitit. 悬浮窗口的实现 java swing c# .net c++ js html 的实现

    Atitit. 悬浮窗口的实现 java swing c# .net c++ js html 的实现 1. 建立悬浮窗口引用代码 1 1.1. 定义悬浮窗口,设置this主窗口引用,是为了在悬浮窗口中 ...

  8. Atitit。D&D drag&drop拖拽功能c#.net java swing的对比与实现总结

    Atitit.D&D drag&drop拖拽功能c#.net java swing的对比与实现总结 1. 实现一个D&D操作一般包括三个步骤: 1 2. .net黑头的拖曳机制 ...

  9. atitit.系统托盘图标的设计java swing c# .net c++ js

    atitit.系统托盘图标的实现java swing c# .net c++ js 1. 系统托盘图标的结构 1 2. Java swing的实现 1 3. .net的实现 1 4. C++的实现 1 ...

随机推荐

  1. Android+clipse导入工程提示:invalid project description

    今天遇到一个奇怪的问题.一个android的工程用eclipse导入的时候,提示错误.错误为:invalid project description . details为xxxx project ov ...

  2. bzoj1560

    首先这种题目肯定是要先排序,以x为第一关键字,y为第二关键字不难想到O(n2)的dp,下面显然要优化不难发现,由于两点的耗费是坐标差的平方的和,不带根号,因此,不难发现一个很有用的性质,如果从A点能到 ...

  3. apple ID的重要性

    当手机丢失时,您可以将对应的产品码提供给运营商,提高找回丢失手机的可能性.         2.去App store下载“查找我的iPhone(Find My iPhone)”,立刻安上,用你的app ...

  4. 身为java程序员你需要知道的网站(包含书籍,面试题,架构...)

    推荐几本书<高级java程序员值得拥有的10本书>,     首页 所有文章 资讯 Web 架构 基础技术 书籍 教程 我要投稿 更多频道 » - 导航条 - 首页 所有文章 资讯 Web ...

  5. APP界面设计之页面布局的22条基本原则

    移动 APP 页面布局(Layout)是我们设计 app 界面的时候,最主要的设计任务.一个 app 的好与不好,很大部分取决于移动 APP 页面布局的合理性. 下图为 APP 最原始的布局模型. 页 ...

  6. ZOJ- 3640 Help Me Escape

    Help Me Escape Time Limit: 2 Seconds      Memory Limit: 32768 KB Background     If thou doest well, ...

  7. ANT的下载和安装

    下载 下载页面:http://ant.apache.org/bindownload.cgi 安装 撰写本文的时候,最新的ANT版本是1.9.7,它是绿色软件,解压缩得到apache-ant-1.9.7 ...

  8. 佛山Uber优步司机奖励政策（1月18日~1月24日）

    滴快车单单2.5倍,注册地址:http://www.udache.com/ 如何注册Uber司机(全国版最新最详细注册流程)/月入2万/不用抢单:http://www.cnblogs.com/mfry ...

  9. 来看看Github上流行的编码规范

      Popular Coding Convention on Github是一个有趣的网站,它根据Github的代码提交情况分析了几种语言流行的代码规范,目前支持对JavaScript,Java,Py ...

  10. MySQL (DCL)

    DCL语句 :数据库系统管理员使用,也就是数据库管理员 root 可以添加用户.删除用户.授予和限制用户权限,这些用户的信息可以在数据库的mysql数据库中查询到 1.查看用户信息     1.用ro ...