第9章-GUI-补充案例上课讲义.doc

第9章 GUI_补充案例

精品资料
第九章 GUI
案例9-1 AWT事件处理机制
一、案例描述
1、 考核知识点
编号：00109002
名称：AWT事件处理机制
2、 练习目标
Ø 掌握如何使用AWT事件处理机制
3、 需求分析
事件处理机制专门用于响应用户的操作，比如，想要响应用户的点击鼠标、按下键盘等操作，就需要使用AWT的事件处理机制。为了让初学者熟悉AWT的事件处理机制，本案例将实现关闭一个窗口的功能。
4、 设计思路（实现原理）
1）编写类Example01
2）建立一个窗体，名为“第一个窗体”
3）定义一个类MyWindowListener实现事件监听器的接口WindowListener。
4）通过addWindowListener()方法为事件源注册事件监听器对象。
二、案例实现
import java.awt.*;
import java.awt.event.*;
public class Example01 {
public static void main(String[] args) {
// 建立新窗体
Frame f = new Frame("第一个窗体！");
// 设置窗体的宽和高
f.setSize(300, 300);
// 设置窗体的出现的位置
f.setLocation(300, 200);
// 设置窗体可见
f.setVisible(true);
// 为窗口组件注册监听器
MyWindowListener mw=new MyWindowListener();
f.addWindowListener(mw);
}
}
// 创建MyWindowListener类实现WindowListener接口
class MyWindowListener implements WindowListener {
// 监听器监听事件对象作出处理
public void windowClosing(WindowEvent e) {
Window window = e.getWindow();
window.setVisible(false);
// 释放窗口
window.dispose();
}
public void windowActivated(WindowEvent e) {
}
public void windowClosed(WindowEvent e) {
}
public void windowDeactivated(WindowEvent e) {
}
public void windowDeiconified(WindowEvent e) {
}
public void windowIconified(WindowEvent e) {
}
public void windowOpened(WindowEvent e) {
}
}
运行结果如图9-1所示。

图9-1 第一个窗体
点击窗体右上角的关闭按钮，窗体关闭。
三、案例总结
1、在AWT事件处理机制中几个比较重要的相关概念，具体如下所示：
l 事件对象（Event）：封装了GUI组件上发生的特定事件(通常就是用户的一次操作)。
l 事件源（组件）：事件发生的场所，通常就是产生事件的组件。
l 监听器（Listener）：负责监听事件源上发生的事件，并对各种事件做出响应处理的对象(对象中包含事件处理器)。
l 事件处理器：监听器对象对接收的事件对象进行相应处理的方法。
2、事件对象、事件源、监听器、事件处理器在整个事件处理机制中都起着非常重要的作用，它们彼此之间有着非常紧密的联系，接下来用一个图例来描述事件处理的工作流程，如图9-2所示。

图9-2 事件处理流程图
图9-2中，事件源是一个组件，当用户进行一些操作时，如按下鼠标，或者释放键盘等，这些动作会触发相应的事件。如果事件源注册了事件监听器，则触发的相应事件将会被处理。
案例9-2 使用适配器类改进窗体关闭
一、案例描述
1、 考核知识点
编号：00109003
名称：AWT事件适配器
2、 练习目标
Ø 掌握如何使用AWT事件适配器。
3、 需求分析
JDK提供了一些适配器类，它们是监听器接口的默认实现类，这些实现类中实现了接口的所有方法，但方法中没有任何代码。程序可以通过继承适配器类来达到实现监听器接口的目的。为了让初学者熟悉AWT事件适配器，本案例将使用AWT事件适配器优化窗体关闭代码。
4、 设计思路（实现原理）
1）编写Example02类
2）建立一个窗体，名为“第一个窗体”
3）定义一个MyWindowListener类继承适配器类WindowAdapter。
4）重写适配器类中的windowClosing()方法
二、案例实现
import java.awt.*;
import java.awt.event.*;
public class Example02 {
public static void main(String[] args) {
// 建立新窗体
Frame f = new Frame("第一个窗体！");
// 设置窗体的宽和高
f.setSize(300, 300);
// 设置窗体的出现的位置
f.setLocation(300, 200);
// 设置窗体可见
f.setVisible(true);
// 为窗口组件注册监听器
f.addWindowListener(new MyWindowListener());
}
}
// 继承WindowAdapter类，重写windowClosing()方法
class MyWindowListener extends WindowAdapter {
public void windowClosing(WindowEvent e) {
Window window = (Window) e.getComponent();
window.dispose();
}
}
运行结果如图9-3所示。

图9-3 运行结果
点击窗体右上角的关闭按钮，窗体关闭。
三、案例总结
在本案例中定义的MyWindowListener类继承了适配器类WindowAdapter，同样实现了关闭窗口的功能，却减少了很多代码。需要注意的是，几乎所有的监听器接口都有对应的适配器类，通过继承适配器类来实现监听器接口时，需要处理哪种事件，直接重写该事件对应的方法即可。由于适配器主要是为了减少不必要的代码，所以在方法数不超过3个时候，不需要继承适配器类。
案例9-3 窗体事件
一、案例描述
1、 考核知识点
编号：00109004
名称：窗体事件
2、 练习目标
Ø 掌握窗体事件的处理
3、 需求分析
当对窗体进行操作时，比如窗体的打开、关闭、激活、停用等，这些动作都属于窗体事件，JDK中提供了一个类WindowEvent用于表示这些窗体事件。为了让初学者掌握窗体事件的处理，本案例将实现对窗体事件的监听。
4、 设计思路（实现原理）
1） 编写类Example03，创建一个窗体。
2） 创建WindowListener实例对象。
3） 通过addWindowListener()方法将窗体对象与窗体监听器绑定。
4）运行程序，对生成的窗体操作，观察控制台输出的内容。
二、案例实现
编写Example03类，代码如下所示：
import java.awt.*;
import java.awt.event.*;
public class Example03 {
public static void main(String[] args) {
final Frame f = new Frame("窗体事件");
f.setSize(400,300);
f.setLocation(300,200);
f.setVisible(true);
// 使用内部类创建WindowListener实例对象，监听窗体事件
f.addWindowListener(new WindowListener() {
public void windowOpened(WindowEvent e) {
System.out.println("窗体打开");
}
public void windowActivated(WindowEvent e) {
System.out.println("窗体激活");
}
public void windowIconified(WindowEvent e) {
System.out.println("窗体图标化");
}
public void windowDeiconified(WindowEvent e) {
System.out.println("窗体取消图标化");
}
public void windowDeactivated(WindowEvent e) {
System.out.println("窗体停用");
}
public void windowClosing(WindowEvent e) {
System.out.println("窗体正在关闭");
((Window) e.getComponent()).dispose();
}
public void windowClosed(WindowEvent e) {
System.out.println("窗体关闭");
}
});
}
}
运行结果如图9-4所示。

图9-4 运行结果
从上图可以看出，当对窗口进行操作时，程序监听到了这些窗体事件。
三、案例总结
在本案例中，通过WindowListener对操作窗口的动作事件进行监听，当接收到特定的动作后，就将所触发事件的名称打印出来。了解了窗体事件，在以后的编程中，可以根据实际需求，在监听器中自定义窗体的处理事件器。
案例9-4鼠标事件
一、案例描述
1、 考核知识点
编号：00109005
名称：鼠标事件
2、 练习目标
Ø 掌握鼠标事件的处理
3、 需求分析
在图形用户界面中，用户会经常通过鼠标来进行选择、切换界面等操作，这些操作被定义为鼠标事件，JDK中提供了一个MouseEvent类用于表示鼠标事件。为了让初学者熟悉鼠标事件的处理。本案例将演示如何监听鼠标事件。
4、 设计思路（实现原理）
1） 编写一个类Example04，创建一个窗口。
2） 创建按钮对象，并在窗口添加按钮组件。
3） 为按钮添加鼠标事件监听器。
4） 运行程序生成窗体，用鼠标操作窗口中的按钮，观察控制台的输出。
二、案例实现
import java.awt.*;
import java.awt.event.*;
public class Example04 {
public static void main(String[] args) {
final Frame f = new Frame("鼠标事件");
// 为窗口设置布局
f.setLayout(new FlowLayout());
f.setSize(300, 200);
f.setLocation(300, 200);
f.setVisible(true);
Button but = new Button("按钮"); // 创建按钮对象
f.add(but); // 在窗口添加按钮组件
// 为按钮添加鼠标事件监听器
but.addMouseListener(new MouseListener() {
public void mouseReleased(MouseEvent e) {
System.out.println("鼠标放开");
}
public void mousePressed(MouseEvent e) {
System.out.println("鼠标按下");
}
public void mouseExited(MouseEvent e) {
System.out.println("鼠标移出按钮区域");
}
public void mouseEntered(MouseEvent e) {
System.out.println("鼠标进入按钮区域");
}
public void mouseClicked(MouseEvent e) {
System.out.println("鼠标完成点击");
}
});
}
}
运行程序后生成窗体如图9-5所示。

图9-5 鼠标事件窗体
用鼠标点击按钮，运行结果如图9-6所示。

图9-6 运行结果
三、案例总结
除了本案例中演示的鼠标事件，MouseEvent类中定义了很多常量来标识鼠标动作，具体代码如下。
public void mouseClicked(MouseEvent e) {
if(e.getButton()==e.BUTTON1){
System.out.println("鼠标左击事件");
}
if(e.getButton()==e.BUTTON3){
System.out.println("鼠标右击事件");
}
if(e.getButton()==e.BUTTON2){
System.out.println("鼠标中键点击事件");
}
}
MouseEvent类中针对鼠标的按键都定义了对应的常量，可以通过MouseEvent对象的getButton()方法获取被操作按键的常量键值，从而判断是哪个按键的操作。另外，鼠标的点击次数也可以通过MouseEvent对象的getClickCount()方法获取到。
案例9-5 键盘事件
一、案例描述
1、 考核知识点
编号：00109006
名称：键盘事件
2、 练习目标
Ø 掌握键盘事件的处理
3、 需求分析
键盘操作是常用的用户交互方式，例如键盘按下、释放等，这些操作被定义为键盘事件，JDK中提供了一个KeyEvent类表示键盘事件。为了让初学者掌握键盘事件的处理，本案例将演示如何监听键盘事件。
4、 设计思路（实现原理）
1）编写类Example05，创建一个窗体。
2）在窗体中创建文本框对象。
3）为文本框添加键盘事件监听器
4）运行程序，在窗体的文本框中输入内容，观察控制台的输出情况
二、案例实现
import java.awt.*;
import java.awt.event.*;
public class Example05 {
public static void main(String[] args) {
Frame f = new Frame("键盘事件");
f.setLayout(new FlowLayout());
f.setSize(400, 300);
f.setLocation(300, 200);
TextField tf = new TextField(30); // 创建文本框对象
f.add(tf); // 在窗口中添加文本框组件
f.setVisible(true);
// 为文本框添加键盘事件监听器
tf.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent e) {
int KeyCode = e.getKeyCode(); // 返回所按键对应的整数值
String s = KeyEvent.getKeyText(KeyCode); // 返回按键的字符串描述
System.out.print("输入内容为：" + s + ",");
System.out.println("KeyCode为：" + KeyCode);
}
});
}
}
运行结果如图9-7所示。

图9-7 键盘事件
在文本框中输入“”，控制台输出如图9-8所示。

图9-8 运行结果
三、案例总结
本案例中，当在图9-7中的文件框中键入字符时，便触发了键盘事件。这时，KeyEvent类通过调用getKeyCode()方法将输入内容对应的整数值返回，即keyCode。在KeyEvent类中还有一个静态方法getKeyText(int keyCode)，它可以将按键内容以String形式返回。
案例9-6 FlowLayout布局管理器
一、案例描述
1、 考核知识点
编号：00109008
名称：FlowLayout布局管理器
2、 练习目标
Ø 掌握FlowLayout布局管理器的使用
3、 需求分析
流式布局管理器是最简单的布局管理器，在这种布局下，容器会将组件按照添加顺序从左向右放置。为了让初学者熟悉流式布局管理器，本案例将演示FlowLayout布局管理器的用法。
4、 设计思路（实现原理）
1） 编写类Example06，创建一个名为“流式布局”的窗体。
2） 设置窗体中的布局管理器为FlowLayout。
3） 创建1个按钮，并为按钮添加点击事件，每点击一次按钮就再生成新的按钮。
二、案例实现
import java.awt.*;
import java.awt.event.*;
public class Example06 {
public static void main(String[] args) {
final Frame f = new Frame("流式布局");// 创建一个名为流式布局的窗体
// 设置窗体中的布局管理器为FlowLayout，所有组件左对齐，水平间距为25，垂直间距为25
f.setLayout(new FlowLayout(FlowLayout.LEFT, 25, 25));
f.setSize(200, 300); // 设置窗体大小
f.setLocation(300, 200); // 设置窗体显示的位置
Button but1 = new Button("1");// 创建第1个按钮
f.add(but1); // 把"第1个按钮"添加到f窗口
// 下面的代码是每点击一次“1”就向窗体中添加一个按钮
but1.addActionListener(new ActionListener() { // 动作事件为第1个按钮添加点击事件
private int num = 1; // 定义变量num，记录按钮的个数
public void actionPerformed(ActionEvent e) {
f.add(new Button(++num));// 向窗体中添加新按钮
// f.setVisible(true); // 刷新窗体显示新按钮
}
});
f.setVisible(true); // 设置窗体可见
}
}
运行结果如图3-8所示。

图9-9 运行结果
三、案例总结
1、FlowLayout布局管理器的特点就是可以将所有组件像流水一样依次进行排列，不需要用户明确的设定，但是在灵活性上相对差了点。
2、FlowLayout对象有三个构造方法，如下表所示。
方法声明
功能描述
FlowLayout()
组件默认居中对齐，水平、垂直间距默认为5个单位
FlowLayout(int align)
指定组件相对于容器的对齐方式，水平、垂直间距默认为5个单位
FlowLayout(int align,int hgap,int vgap)
指定组件的对齐方式和水平、垂直间距

案例9-7 BorderLayout布局管理器
一、案例描述
1、 考核知识点
编号：00109009
名称：BorderLayout布局管理器
2、 练习目标
Ø 掌握BorderLayout布局管理器的使用
3、 需求分析
BorderLayout（边界布局管理器）是一种较为复杂的布局方式，它将容器划分为五个区域，分别是东(EAST)、南(SOUTH)、西(WEST)、北(NORTH)、中(CENTER)。为了让初学者熟悉BorderLayout布局，本案例演示一下BorderLayout布局管理器对组件布局的效果。
4、 设计思路（实现原理）
1） 编写类Example07，创建一个名为“边界布局”的窗体
2） 设置窗体中的布局管理器为BorderLayout
3） 创建5个按钮，分别用于填充BorderLayout的5个区域
4） 将创建好的按钮添加到窗体中，并设置按钮所在的区域
二、案例实现
import java.awt.*;
public class Example07 {
public static void main(String[] args) {
final Frame f = new Frame("边界布局");
f.setLayout(new BorderLayout()); // 设置窗体中的布局管理器
f.setSize(300,300);
f.setLocation(300, 200);
f.setVisible(true);
Button but1 = new Button("东"); // 创建新按钮
Button but2 = new Button("西");
Button but3 = new Button("南");
Button but4 = new Button("北");
Button but5 = new Button("中");
f.add(but1,BorderLayout.EAST); // 设置按钮所在区域
f.add(but2,BorderLayout.WEST);
f.add(but3,BorderLayout.SOUTH);
f.add(but4,BorderLayout.NORTH);
f.add(but5,BorderLayout.CENTER);
}
}
运行结果如图9-10所示。

图9-10 运行结果
三、案例总结
1、在BorderLayout布局管理器中，组件组件可以被放置在这五个区域的中任意一个。BorderLayout布局的效果如图9-11所示。

图9-11 BorderLayout效果图
BorderLayout的好处就是可以限定各区域的边界，当用户改变容器窗口大小时，各个组件的相对位置不变。但需要注意的是，向BorderLayout的布局管理器添加组件时，如果不指定添加到哪个区域，则默认添加到CENTER区域，并且每个区域只能放置一个组件，如果向一个区域中添加多个组件时，后放入的组件会覆盖先放入的组件。
案例9-8 GridLayout布局管理器
一、案例描述
1、 考核知识点
编号：00109010
名称：GridLayout布局管理器
2、 练习目标
Ø 掌握GridLayout布局管理器的使用
3、 需求分析
GridLayout（网格布局管理器）使用纵横线将容器分成n行m列大小相等的网格，每个网格中放置一个组件。为了让初学者熟悉GridLayout布局管理器，本案例将演示GridLayout布局的用法。
4、 设计思路（实现原理）
1） 编写类Example08，创建一个名为"网格布局"的窗体。
2） 设置该窗体为4*3的网格。
3） 循环添加12个按钮到GridLayout中
二、案例实现
import java.awt.*;
public class Example08 {
public static void main(String[] args) {
Frame f = new Frame("网格布局");
f.setLayout(new GridLayout(4, 3));// 设置该窗体为4*3的网格
f.setSize(300, 300); // 设置窗体大小
f.setLocation(400, 300);
// 下面的代码是循环添加12个按钮到GridLayout中
for (int i = 1; i <= 12; i++) {
Button btn = new Button("btn" + i);
f.add(btn); // 向窗体中添加按钮
}
f.setVisible(true);
}
}
运行结果如图9-12所示。

图9-12 运行结果
三、案例总结
1、GridLayout中有三个构造方法，如下所示。
方法声明
功能描述
GridLayout()
默认只有一行，每个组件占一列
GridLayout(int rows,int cols)
指定容器的行数和列数
GridLayout(int rows,int cols,int hgap,int vgap)
指定容器的行数和列数以及组件之间的水平、垂直间距
2、GridLayout布局管理器的特点是组件的相对位置不随区域的缩放而改变，但组件的大小会随之改变，组件始终占据网格的整个区域。缺点就是总是忽略组件的最佳大小，所有组件的宽高都相同。

案例9-9 GridBagLayout布局管理器
一、案例描述
1、 考核知识点
编号：00109011
名称：GridBagLayout布局管理器
2、 练习目标
Ø 掌握GridBagLayout布局管理器的使用。
3、 需求分析
GridBagLayout（网格包布局管理器）是最灵活、最复杂的布局管理器。与GridLayout布局管理器类似，不同的是，它允许网格中的组件大小各不相同，而且允许一个组件跨越一个或者多个网格。为了让初学者熟悉 GridBagLayout的布局，本案例将来演示GridBagLayout的用法。
4、 设计思路（实现原理）
1）定义一个类Layout继承自Frame类
2）使用网格包布局管理器
3）创建六个按钮以不同的占位分布
4）编写Example09类，创建Layout类的实例
二、案例实现
编写Example09类，代码如下所示：
import java.awt.*;
class Layout extends Frame {
public Layout(String title) {
GridBagLayout layout = new GridBagLayout();
GridBagConstraints c = new GridBagConstraints();
this.setLayout(layout);
c.fill = GridBagConstraints.BOTH; // 设置组件横向纵向可以拉伸
c.weightx = 1; // 设置横向权重为1
c.weighty = 1; // 设置纵向权重为1
this.addComponent("btn1", layout, c);
this.addComponent("btn2", layout, c);
this.addComponent("btn3", layout, c);
c.gridwidth = GridBagConstraints.REMAINDER; // 添加的组件是本行最后一个组件
this.addComponent("btn4", layout, c);

c.weightx = 0; // 设置横向权重为0
c.weighty = 0; // 设置纵向权重为0
addComponent("btn5", layout, c);
c.gridwidth = 1; // 设置组件跨一个网格(默认值)
this.addComponent("btn6", layout, c);
c.gridwidth = GridBagConstraints.REMAINDER; // 添加的组件是本行最后一个组件
this.addComponent("btn7", layout, c);
c.gridheight = 2; // 设置组件纵向跨两个网格
c.gridwidth = 1; // 设置组件横向跨一个网格
c.weightx = 2; // 设置横向权重为2
c.weighty = 2; // 设置纵向权重为2
this.addComponent("btn8", layout, c);
c.gridwidth = GridBagConstraints.REMAINDER;
c.gridheight = 1;
this.addComponent("btn9", layout, c);
this.addComponent("btn10", layout, c);
this.pack();
this.setVisible(true);
}
// 增加组件的方法
private void addComponent(String name, GridBagLayout layout,
GridBagConstraints c) {
Button bt = new Button(name); // 创建一个名为name的按钮
layout.setConstraints(bt, c); // 设置GridBagConstraints对象和按钮的关联
this.add(bt); // 增加按钮
}
}
public class Example09 {
public static void main(String[] args) {
new Layout("GridBagLayout");
}
}
运行结果如图9-13所示。

图9-13 运行结果
从运行结果可以看到，程序正常执行。
三、案例总结
使用GridBagLayout布局管理器的步骤如下：
1、创建GridbagLayout布局管理器，并使容器采用该布局管理器。
GridBagLayout layout = new GridBagLayout();
container.setLayout(layout);
2、创建GridBagContraints对象(布局约束条件)，并设置该对象的相关属性。
GridBagConstraints constraints = new GridBagConstraints();
constraints.gridx = 1; // 设置网格的左上角横向索引
constraints.gridy = 1; // 设置网格的左上角纵向索引
constraints.gridwidth = 1; // 设置组件横向跨越的网格
constraints.gridheight = 1; // 设置组件纵向跨越的网格
3、调用GridBagLayout对象的setConstraints()方法建立GridBagConstraints对象和受控组件之间的关联。
layout.setConstraints(component,constraints);
4、向容器中添加组件
container.add(conponent);
GridBagConstraints对象可以重复使用，只需要改变它的属性即可。如果要向容器中添加多个组件，则重复2、3、4步骤。
案例9-10 CardLayout布局管理器
一、案例描述
1、 考核知识点
编号：00109012
名称：CardLayout布局管理器
2、 练习目标
Ø 掌握CardLayout布局管理器的使用
3、 需求分析
在操作程序时，我们经常会通过选项卡按钮来切换程序中的界面，这些界面就相当于一张张卡片，而管理这些卡片的布局管理器就是卡片布局管理器(CardLayout)。为了让初学者熟悉CardLayout布局管理器，本案例将演示CardLayout中常用方法的使用。
4、 设计思路（实现原理）
1）定义类Cardlayout继承Frame类，实现ActionListener接口
2）在该类中定义Panel面板放置卡片，再定义一个Panel面板放置按钮
3）定义卡片布局对象，在卡片面板中添加2个文本标签分别为“传智播客”和“黑马程序员”
4）定义一个方法实现按钮的监听触发，并对触发事件做出相应的处理
5）编写类Example10，创建Cardlayout实例
二、案例实现
定义Example10类，代码如下所示：
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
//定义Cardlayout继承Frame类，实现ActionListener接口
class Cardlayout extends Frame implements ActionListener {
Panel cardPanel = new Panel(); // 定义Panel面板放置卡片
Panel controlpaPanel = new Panel(); // 定义Panel面板放置按钮
Button nextbutton, preButton;
CardLayout cardLayout = new CardLayout();// 定义卡片布局对象
public Cardlayout() { // 定义构造方法，设置卡片布局管理器的属性
setSize(300, 200);
setVisible(true);
// 为窗口添加关