1. AWT
1.1 AWT概念
AWT全称“Abstract Window Toolkit”，即：抽象窗口工具集。为java应用程序提供了基本的图形组件。ATW是窗口框架，它从不同的操作平台提取出共同组件，当程序运行时，将这些组件的创建和动作委托程序所在的运行平台。
2. AWT容器
2.1 基本介绍
什么是容器？
任何窗口都可以被分解成一个空的容器，容器内盛装了大量的基本组件，通过设置这些组件的大小，属性，位置等，就可以将该容器和组件组成一个整体的窗口。 容器(Container)是Commponent的子类，因此容器对象本身也是一个组件。Commponent类有如下的方法来设置组件的大小，位置，属性和可见性等： setLocation(int x,int y):设置组件的位置
setSize(int width,int height):设置组件的宽度，高度
setBounds(int x,int y, int width,int height):同时设置组件的位置，大小。 setVisible(Boolean b):设置组件的可见性。
除此之外，容器还具有盛装其他组件的功能，容器类(Container)主要提供了一下几个常用的方法来访问容器内的组件:
Component add(Component comp)向容器中添加其他组件 Component getCommponentAt(int x,int y):返回指定点的组件 Int getComponentCount():返回容器内的组件个数 Component[] getComponents():返回容器里的所有组件 AWT 主要提供了两种类型的容器 Window: 可独立存在的窗口
Panel： 可作为容器容纳其他组件，但不能独立存在，必须被添加到其他容器中。 AWT 容器的继承关系图：
Container Window Panel ScrollPane Frame Dialog Appelt
ScrollPane：增加滚动条
Frame： 常见的窗口 Dialog： 对话框 例子：
import java.awt.Frame; public class TestFrame { public static void main(String[] args) { Frame f=new Frame(\"测试窗口\"); //设置窗口的大小，位置 f.setBounds(50, 100, 400, 300); //设置窗口的可见性，默认是隐藏的 f.setVisible(true); } }
运行上面的程序，显示了一个简单的窗口
2.2 Panel
Panel 容器具有以下几个特点：
可作为容器来盛装其他组件，为放置组件提供空间 不能单独存在，必须依附于其他容器 默认使用FlowLayout作为布局管理器
下面的例子使用Panel作为容器来盛装一个文本框和按钮 例子：
import java.awt.Button; import java.awt.Frame; import java.awt.Panel; import java.awt.TextField; public class TestPanel { public static void main(String[] args) {
} } Frame f=new Frame(); //创建一个Panel容器 Panel p=new Panel(); //给Panel容器中添加组件 p.add(new TextField(20)); p.add(new Button(\"按钮\")); //将Panel添加到Frame窗口中 f.add(p); f.setBounds(50, 100, 300,400); f.setVisible(true);
运行之后我们会看到这么一个窗口：
2.3 ScrollPane
ScrollPane是一个带滚动条的容器，不能独立存在。ScrollPane具有以下特点： 可以作为容器来盛装其他组件，当组件占用空间过大时会自动产生滚动
条。
不能单独存在
默认使用BorderLayout作为布局管理器 我们看一个简单的例子：
import java.awt.Button; import java.awt.Frame; import java.awt.ScrollPane;
import java.awt.TextField; public class TestScrollPane { public static void main(String[] args) { Frame f=new Frame(\"测试窗口\"); //创建一个ScrollPane容器，指定总是显示滚动条 ScrollPane sp=new ScrollPane(ScrollPane.SCROLLBARS_ALWAYS); //为ScrollPane容器添加组件 sp.add(new TextField(20)); sp.add(new Button(\"按钮\")); f.add(sp); f.pack(); f.setVisible(true); } }
运行上面的程序我们会看到如下的结果：
3. 布局管理器
为了使生成的图形用户界面具有良好的与平台无关性，java语言中，提供了布局管理器来管理组件在容器中的布局，而不使用直接设置的位置和大小。
AWT 提供了FlowLayout，BorderLayout，GridLayout，GridBigLayout，CardLayout五个常用的布局管理器。
3.1 FlowLayout布局管理器
在FlowLayout布局管理器中，组件像流水一样向某个方向流动（排列），遇到边界就折回。
FlowLayout有如下三个构造器
FlowLayout();使用默认的排序方式，默认垂直，水平创建FlowLayout布
局管理器
FlowLayout(int align)使用指定的对齐方式。
FlowLayout(int align,int hgap,int vgap)使用指定的对齐方式，指定水平，
垂直，水平间距，创建FlowLayout布局管理器 Hgap,vgap代表水平，垂直间距 我们来看下边的例子：
import java.awt.Button; import java.awt.FlowLayout; import java.awt.Frame; public class TestFlowLayout { public static void main(String[] args) { Frame f=new Frame(\"测试窗口\"); //设置Frame容器使用FlowLayout布局管理器 f.setLayout(new FlowLayout(FlowLayout.LEFT,20,5)); } } //向窗口中添加按钮 for(int i=0;i<20;i++) { f.add(new Button(\"按钮\"+i)); } f.pack(); f.setVisible(true);
运行上边的代码我们会看到如下结果：
3.2 BorderLayout布局管理器
BorderLayout 布局管理器将容器分为WAST，SOUTH，WEST，NORTH，CENTER五个区域。
使用BorderLayout时需要注意两点：
1. 向使用BorderLayout布局管理器的容器中添加组件时，如果没指定哪个区域，则默认为中间
2. 如果向同一区域添加组件时，前边的会被后边的覆盖 BorderLayout布局管理器有如下两个构造器
BorderLayout();使用默认水平，垂直间距来创建布局管理器
BorderLayout(int hagp,int vagp);使用指定的水平，垂直间距来创建布局管理
器。 例子：
import java.awt.BorderLayout; import java.awt.Button;
import java.awt.Frame; import javax.swing.border.Border; public class TestBorderLayout { public static void main(String[] args) { Frame f=new Frame(\"测试窗口\"); f.setLayout(new BorderLayout(30,5)); f.add(new Button(\"北\"),BorderLayout.SOUTH); f.add(new Button(\"西\"),BorderLayout.WEST); f.add(new Button(\"南\"),BorderLayout.NORTH); f.add(new Button(\"东\"),BorderLayout.EAST); f.add(new Button(\"中\")); f.pack(); f.setVisible(true); } }
运行结果：
3.3 GirdLayout 布局管理器
GridLayout布局管理器将容器分割成纵横线分割的网络,每个网格所占的区域大小不同，往使用GirdLayout的容器中添加组件时，默认从左向右，从上往下。 GridLayout有如下两个构造器
GirdLayout(int rows,int cols);采用指定的行数，列数，默认横向间距，纵向间
距将容器分割成多个网络
GridLayout((int rows,int cols,int hagp,int vagp);
我们用 GridLayout和BorderLayout开发一个计算器的界面：
import java.awt.BorderLayout; import java.awt.Button; import java.awt.Frame; import java.awt.GridLayout; import java.awt.Panel; import java.awt.TextField; public class TestGridLayout { public static void main(String[] args) { Frame f = new Frame();
Panel p1 = new Panel(); p1.add(new TextField(30)); f.add(p1, BorderLayout.NORTH); // 设置Panel使用GridLayout布局 Panel p2 = new Panel(); p2.setLayout(new GridLayout(3, 5, 4, 4)); String[] name = { \"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"+\", \"-\", \"*\", \"/\", \".\" }; } } //向Panel2中添加按钮 for(String n:name) { p2.add(new Button(n)); } f.add(p2); f.pack(); f.setVisible(true);
运行后我们看到这么一个简单的计算器界面
3.3 GridBagLayout 布局管理器
GirdBagLayout 布局管理器功能最强大。但也是最复杂的。于GridLayout布局管理器不同的，一个组件可以跨越多个网格。并可以设置网格的大小，从而增加了布局的灵活性
使用GridBagLayout布局管理的步骤如下：
创建GridBagLayout布局管理器，并指定GUI容器使用该布局，代码如下： GridBagLayout gb=new GridBagLayout(); Constainer.setLayout(gb);
创建GridBagLayout对象，并设置该对象的相关属性，代码如下： gbc ,gridx=2;//设置受该对象控制的GUI组件位于网格的横向索引 gbc ,gridy=2;//设置受该对象控制的GUI组件位于网格的纵向索引 gbc ,gridwidth=2;//设置受该对象控制的GUI组件位横跨多少网格
gbc ,gridwidth=2;//设置受该对象控制的GUI组件位纵跨多少网格
调用 GridBagLayout对象的方法来建立GridBagConstainer对象和受控组件
之间的关联，代码如下：
gb .setConstainer(c,gbc);//设置c组件受gbc对象控制 添加组件 Constainer.add(c);
使用GridBagLayout布局管理器的关键在于GridBagConstainer，他才是精确控制某个GUI组件的核心,该类有如下几个方法：
Gridx gridy 设置受该对象控制的GUI组件的左上角所在的横向索引，纵向
索引。
Gridwidth gridheight 设置受该对象控制的GUI组件横向，纵向跨越了多少个
网格
Fill：设置受该对象控制的GUI组件如何占领空白区域。
Ipadx、ipady：设置受该对象控制的GUI组件横向，纵向的内部填充大小，
即在该组件的最小尺寸的基础上还需要增加多大。
Insets：何止受该对象控制的GUI组件的外部填充大小，即组件边界于显示
区域边界之间的距离
Anchor : 设置受该对象GUI组件在其显示区域之中的定位方式。
Weightx，weighty：设置受该对象控制的GUI组件占领多余空间的水平，垂
直增加比例。默认值都是0，即不占用多余空间
3.4 CardLayout
CardLayout布局管理器以时间而非空间来管理组件，他将加入容器的组件看成一叠卡片，每次只有最上边的Commponent才可以显示。CardLayout提供了如下两个构造器：
CardLayout(): 创建默认的CardLayout布局管理器
CardLayout(int hgap,int vgap): 通过指定卡片于容器边界的距离，来创建
CardLayout布局管理器
CardLayout 用于控制组件可见的5个方法：
First(Canstainer target)：显示target容器中的第一张卡片 Last(Canstainer target)：显示target容器中的最后一张卡片 Previous(Canstainer target)：显示target容器中前一张卡片 Next(Canstainer target)：显示target容器中下一张卡片
Show(Canstainer target，String name)：显示target容器中指定卡片的名字 如下的例子程序示范了CardLayout布局管理器的用法：
public class TestCardLayout { Frame f = new Frame(); String[] name = { \"第一张\", \"第二张\", \"第三张\", \"第四张\", \"第五张
\" }; Panel p = new Panel(); CardLayout c = new CardLayout(); public void init() { p.setLayout(c); for (int i = 0; i < name.length; i++) { p.add(name[i], new Button(name[i])); } Panel p2 = new Panel(); // 控制显示上一张的按钮 Button previous = new Button(\"上一张\"); previous.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { c.previous(p);// 显示容器里的钱一张卡片 } }); // 控制显示下一张的按钮 Button next = new Button(\"下一张\"); next.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { c.next(p);// 显示容器里的钱一张卡片 } }); // 控制显示第一张的按钮 Button first = new Button(\"第一张\"); first.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { c.first(p);// 显示容器里的钱一张卡片 } }); // 控制显示最后一张的按钮 Button last = new Button(\"最后一张\"); last.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { c.last(p);// 显示容器里的钱一张卡片 } }); // 控制显示第三章的按钮 Button third = new Button(\"第三张\"); third.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { c.show(p, \"第三张\");// 显示容器里的钱一张卡片 }
} } }); p2.add(previous); p2.add(last); p2.add(first); p2.add(next); p2.add(third); f.add(p); f.add(p2,BorderLayout.SOUTH); f.pack(); f.setVisible(true); public static void main(String[] args) { new TestCardLayout().init(); }
运行结果如下：
绝对定位：
Java可以对GUI组件进行绝对定位，在java中采用绝对定位的步骤如下： 将Container的布局管理器设置车改null：setLayout(null);
往容器中添加组件时，先调用setBounds()或setSize()的方法来设置组件的
大小，位置。或直接创建GUI组件时通过构造器来指定该组件的位置，大小，然后将该组件添加到容器中。
下面的程序示范了如何使用绝对定位来控制窗口中的GUI组件
public class TestNullLayout { Frame f = new Frame(); Button b1 = new Button(\"第一个按钮\"); Button b2 = new Button(\"第二个按钮\"); public void init() { } //将容器的布局管理器设置为null f.setLayout(null); //定义按钮的位置，大小 b1.setBounds(20, 30, 90, 28); f.add(b1); b2.setBounds(50, 45, 120, 35); f.add(b2); f.setBounds(50, 100, 400, 300); f.setVisible(true); } public static void main(String[] args) { new TestNullLayout().init(); }
运行效果如下：
3.5 BoxLayout 布局管理器
GridBagLayout布局管理器功能虽然强大，但是太复杂了。所以Swing引入了一个新的布局管理器。BoxLayout布局管理器可以在水平和垂直位置上放置组件。BoxLayout提供了如下的简单构造器：
BoxLayout(Container target,int axis)：创建基于target容器的布局管理器、该
布局管理器里的组件按照axis方向排列。 我们来写一个简单的例子：
public class TestBoxLayout { Frame f=new Frame(); public void init() { //添加BOxLayout布局管理器到容器中,并指定排列方式：垂直 f.setLayout(new BoxLayout(f, BoxLayout.Y_AXIS)); f.add(new Button(\"按钮一\")); f.add(new Button(\"按钮二\")); f.add(new Button(\"按钮三\"));
} f.pack(); f.setVisible(true); } public static void main(String[] args) { new TestBoxLayout().init(); } 运行结果如下：
BoxLayout通常和Box容器结合使用，Box是一个特殊的容器。他有点像Panel，但该容器默认使用BoxLayout布局管理器。Box提供了如下两个静态方法来床架Box对象
CreateHorizontalBox();创建一个水平排列的Box容器 CreateVeriticalBox();创建一个垂直排列的Box容器 我们写个程序来测试一下Box容器
public class TestBox { Frame f=new Frame(); //定义一个水平放置组件的BOx对象
} Box x=Box.createHorizontalBox(); //定义一个垂直房子组件的Box对象 Box y=Box.createVerticalBox(); public void init() { x.add(new Button(\"按钮一\")); x.add(new Button(\"按钮二\")); y.add(new Button(\"按钮三\")); y.add(new Button(\"按钮四\")); f.add(x,BorderLayout.NORTH); f.add(y); f.pack(); f.setVisible(true); } public static void main(String[] args) { new TestBox().init(); }
运行结果如下：
看到运行结果，我们发现一个问题，所有的按钮紧挨在一起，为了解决这个问题，Box提供了如下的5个静态方法
CreateHorizontalGlue（）；可以在水平同时拉伸的间距 CreateVerticalGlue（）；可以在垂直两个方向同时拉伸。 CreateVerticaStrut（int height）;在水平方向上拉伸 CreateHorizontalStrut（int width）；在垂直方向上拉伸
CreateRigArea（Dimension d）；创建指定宽度，高度。不可拉伸
4. 常用组件
4.1 基本组件
AWT 提供了如下基本组件： Button：按钮，可接受单击操作 Canvas：用于绘制画布
Checkbox：复选框组件，也可以作为单选框
CheckboxGroup：用于将多个CheckBox组合成一组，一组CheckBox中只有
一个可以被选中，即全部变成单选框组件 Choice：下拉式选择框组件 Frame：窗口
Label：标签类，用于放置提示性文本 List：列表组件框，可以添加多个项目。 Panel：不能单独存在的基本容器类
ScrollBar：滑动条组件。如果需要用户输入位于某个范围的值。可以使用滑
动条组件
ScrollPane：带水平，垂直的滚动条容器组件 TextArea：多行文本域 TextField：单行文本域
这些组件的用法都比较简单，可以查阅API文档来获取他们各自的构造器，方法等详细信息。
下面的程序示范了他们的基本用法：
public class CommonComponent { Frame f = new Frame(\"常用组件演示\"); Button ok = new Button(\"确定\"); CheckboxGroup cbg = new CheckboxGroup(); Checkbox male = new Checkbox(\"男\", cbg, true); Checkbox female = new Checkbox(\"女\", cbg, false);
} Checkbox married = new Checkbox(\"是否结婚？\", false); Choice colorChooer = new Choice(); List colorList = new List(6, true); TextArea ta = new TextArea(5, 20); TextField tf = new TextField(50); public void init() { colorChooer.add(\"红色\"); colorChooer.add(\"绿色\"); colorChooer.add(\"黄色\"); colorList.add(\"红色\"); colorList.add(\"绿色\"); colorList.add(\"黄色\"); //创建一个Panel，装载文本框，按钮 Panel bottom=new Panel(); bottom.add(tf); bottom.add(ok); f.add(bottom,BorderLayout.SOUTH); //创建一个装载下拉框，三个Checkbox的Panel Panel checkPanel=new Panel(); checkPanel.add(male); checkPanel.add(female); checkPanel.add(married); //创建一个垂直排列的Box，装载多行文本域，panel Box left=Box.createVerticalBox(); left.add(ta); left.add(checkPanel); //创建一个水平排列的Box，装咋left和colorList Box top=Box.createHorizontalBox(); top.add(left); top.add(colorList); //将top Box添加到窗口中 f.add(top); f.pack(); f.setVisible(true); } public static void main(String[] args) { new CommonComponent().init(); }
运行结果如下：
4.2 对话框
对话框是Window的子类，是一个容器类，属于特殊组件。对话框也是可以存在的顶级窗口，因此于普通窗口的用法几乎一样。但对话框有两点需要注意： 对话框通常依赖于其他窗口
对话框有非模式窗口和模式窗口两种。注意模式窗口于非模式窗口的区别 对话框有多个重载的构造器。他的构造器可能有如下三个参数：
Owner：指定该对话框所依赖的窗口，即可使是窗口，也可以是对话框 Title：指定该对话框的标题
Modal：指定该对话框是否是模式的，值为true或者false； 下面的程序示范了模式对话窗口和非模式对话窗口
public class TestDialog { Frame f = new Frame();
} Button b1 = new Button(\"模式窗口\"); Button b2 = new Button(\"非模式窗口\"); Dialog d1 = new Dialog(f, \"模式窗口\", true); Dialog d2 = new Dialog(f, \"非模式窗口\", false); public void init() { d1.setBounds(20, 30, 300, 150); d2.setBounds(20, 30, 300, 150); b1.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { d1.setVisible(true); } }); b2.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { d2.setVisible(true); } }); f.add(b1); f.add(b2,BorderLayout.SOUTH); f.pack(); f.setVisible(true); } public static void main(String[] args) { new TestDialog().init(); }
Dialog还有一个子类，FileDialog，他代表一个文件对话框。用于打开或者保存文件，FileDialog也提供了几个构造器，分别支持parent，title，mode三个参数。其中parent，title指定文件对话框所属的父窗口和标题。Mode只用窗口用于打开或保存文件。该参数支持如下两个参数值：FileDialog.LOAD，和FileDialog.SAVE.
FileDialog提供了如下两个方法来获取打开/保存文件的路径 GetDirectory():获取被打开/保存文件的绝对路径 GetFile（）：获取打开/保存文件的文件名 下面的程序分别示范了使用FileDialog打开/保存文件
public class TestFileDialog { Frame f = new Frame(); Button b1 = new Button(\"打开\"); Button b2 = new Button(\"保存\"); FileDialog open=new FileDialog(f,\"选择要打开的文件\",FileDialog.LOAD); FileDialog save=new FileDialog(f,\"选择要打开的文件\",FileDialog.LOAD); public void init() { b1.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { open.setVisible(true); System.out.println(open.getDirectory()+open.getFile()); } }); b2.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { save.setVisible(true);
} System.out.println(save.getDirectory()+save.getFile()); } }); f.add(b1); f.add(b2,BorderLayout.SOUTH); f.pack(); f.setVisible(true); } public static void main(String[] args) { new TestFileDialog().init(); }
5. 事件处理
5.1 java事件模型的流程
为了使图形界面能够接收用户的操作，必须给各个组件加上事件处理机制。在事件处理机制中，主要涉及三类对象：
Event Source(事件源)：事件发生的场所，通常就是各个组件，按钮等等 Event(事件)：事件封装了GUI组件上发生的特定事情(通常就是指用户的一
次操作)。如果程序需要获得GUI组件上发生的特定事情，都通过Event对象来获取
Event Listener(事件监听器)：负责监听事件源发生的事件，并对各种事件做
出响应处理。
AWT的事件处理机制是一种委派的方式：普通组件（事件源）将整个事件处理委托个特定的对象（事件监听器）；当事件源发生指定事件时，就通知委托的事件监听器，由事件监听器来处理这个事件。 下图展示了AWT事件处理机制流程图：
事件 外部动作 2.触发事件源上事件 4.触发事件监听器，事件被作为参数传递到事件处理器 3.生成事件对象 事件源 1.将事件监听器注册到事件源 事件监听器 5.调用事件处理器做出响应 事件处理器 事件处理器 … …
下面写一个简单的Hello world程序来示范AWT事件处理器 public class EventQs { Frame f = new Frame(\"测试事件\"); Button ok = new Button(\"确定\"); TextField tf = new TextField(30); public void init() { // 注册事件监听器 ok.addActionListener(new OKListener()); f.add(tf); f.add(ok, BorderLayout.SOUTH); f.pack();
f.setVisible(true); } //定义事件监听器类 class OKListener implements ActionListener { //下面的方法就是事件处理器，用于响应特定事件 public void actionPerformed(ActionEvent e) { System.out.println(\"用户单击了确定按钮\"); tf.setText(\"hello world\"); } } public static void main(String[] args) { new EventQs().init(); } } 运行后结果如下：
从上面的程序可以看出，实现AWT事件处理机制的步骤如下：
实现事件监听器类，该监听器类是一个特殊的java类，必须实现一个
XxxListeren接口。
创建普通组件，创建事件监听器对象。
调用addXxxListener方法，将事件监听器对象注册给普通组件。当事件源上
发生特定事件时，AWT会触发事件监听器，由事件监听器调用相应的方法来处理事件，事件源上发生的事件会作为参数传入事件处理器。
5.2 事件和事件监听
AWT事件机制涉及到三个成员：事件源，事件和事件监听器。其中事件源最容易创建，只要通过new来创建一个AWT组件，该组件就是事件源；事件的产生无须程序员关心。它是由系统自动产生的。所以，实现时间监听器是整个事件处理的核心。
事件监听器必须实现时间监听器接口，AWT提供了大量的事件监听器接口用于实现不同类型的事件监听器，用于监听不同类型的事件。
AWT中提供了丰富的事件类，用于封装不同组件上所发生的特定操作：AWT事件都是AWTEvent类的子类，它是EventObject类的子类。 AWT事件分为两大类：低级事件和高级事件。
低级事件：
低级事件是指基于特定动作的事件。如鼠标进入、点击、拖放等动作的鼠标事件，当组件得到焦点，失去焦点时触发的事件。
ComponentEvent：组件事件，当组件尺寸发生变化时，位置发生移动时，显
示和隐藏状态发生改变时触发事件。
ContainerEvent：容器事件，当容器里发生组件添加，移除时触发该事件 WindowEvent：窗口事件，当窗口状态发生改变时触发 FocusEvent：焦点事件，当组件获得或者失去焦点时触发的事件 KeyEvent：键盘事件，当按下，松开，单击键盘时触发 PaintEvent：组件绘制事件。
高级事件（语意事件）：
高级事件是基于语意的事件，他可以和不特定的动作想关联，而依赖于触发此事件的类，比如：FieldText中按Enter键会触发ActionEvent事件。 ActionEvent：动作事件，当按钮，菜单项被单击。
AdjuestmentEvent: 调节事件，在滑动条上移动滑块以调节数值时触发。 itemEvent：选项事件，当用户选中某项或取消某项时触发
TextEvent：文本事件，当文本框，文本域里的文本发生改变时触发。 AWT中事件继承层次如图：
EventObject ActuinEvebt AWTEvent TextEvent AdjuestmentEvenItemEvent COntainerEvent ComponentEvent FocusEvent PaintEvent WindowEvent InputEvent KeyEvent MouseEvent
不同的事件需要使用不同的事件监听，不同的监听器需要实现不同的事件监听器接口，当指定事件发生后，事件处理器就会调用所包含的事件处理器来处理事件。 下表显示了常用的事件、监听器接口和处理器之间的对应关系。
事件 监听器接口 处理器及触发时机 ActionEvent ActionListeren ActionPreformed：按钮、文本框、菜单项被单击时
触发 ContainerEvent ContainerListeren adjustmentValueChanged：滑块位置发生改变时触发 FocusEvent FocusListeren focusGained:组件得到焦点时触发 focusLost:：组件失去焦点时触发 ComponentEvent ComponentListeren comPonentHidden:组件被隐藏时触发 comPonentMoved:组件被移动时触发 comPonentResize:组件大小改变时触发 comPonentShown:组件被显示时触发 keyPressed:按下某个键
KeyEvent KeyListeren keyReleased:松开某个键 keyTyped:单击某个键 MouseEvent MouseListeren mouseClicked:在某个组件上单击时触发 mouseEntered:鼠标进入鼠标进入某个组件时触发 mouseExited:鼠标离开某个组件时触发 mousePressed:在某个组件上按下鼠标时触发 mouseReleased:在某个组件上松开鼠标时触发 MouseEvent MouseMotionListener mouseDragged:鼠标在某个组件上移动，并且按下时触发 mouseMoved:在某个组件上移动，并没有按下时触
发 TextEvent TextListeren textValueChanged:文本组件里的文本发生改变时触发 ItemEvent ItemListeren itemStateChanged:某项被选中或取消时触发 WindowEvent WindowListeren windowActivated:窗口被激活时触发 windowCloed:窗口调用dispose即将关闭时触发 windowDeacticated:窗口失去焦点时触发 windowDeiconified:窗口被恢复时触发 windosIconified:窗口最小化时触发 windowOpened:窗口首次
打开时触发 windowClosing:用户单击窗口右上角X时触发 下面的程序示范了一个监听器监听多个组件，一个组件被多个监听器监听
public class Test_Event { Frame f=new Frame(\"演示一个监听器监听多个组建，一个组建被多个监听器监听\"); TextArea ta=new TextArea(); Button b1=new Button(\"按钮一\"); Button b2=new Button(\"按钮二\"); public void init() { f.add(ta); Panel p=new Panel(); p.add(b1); p.add(b2); f.add(p,BorderLayout.SOUTH); f.pack(); f.setVisible(true); FirstListener first=new FirstListener(); //一个组建被多个监听器监听 b1.addActionListener(first); b1.addActionListener(new SecondListener()); //一个监听器监听读个组建 b2.addActionListener(first); } class FirstListener implements ActionListener { public void actionPerformed(ActionEvent e) { // TODO Auto-generated method stub ta.append(\"第一个事件监听器被触发，事件源是\"+e.getActionCommand()+\"\\n\"); } } class SecondListener implements ActionListener {
public void actionPerformed(ActionEvent e) { // TODO Auto-generated method stub ta.append(\"第二个事件监听器被触发，事件源是\"+e.getActionCommand()+\"\\n\"); } } public static void main(String[] args) { Test_Event te=new Test_Event(); te.init(); } } 运行效果如下：
下面的程序程序为窗口添加窗口监听器。从而示范了窗口监听器的用法。并允许用户单击X来关闭窗口：
public class Test_WindowListener { Frame f=new Frame(\"监听window窗口事件\"); TextArea ta=new TextArea(6,40); public void init() { f.add(ta);
f.pack(); f.setVisible(true); f.addWindowListener(new MyListener()); } class MyListener implements WindowListener { //激活 public void windowActivated(WindowEvent e) { // TODO Auto-generated method stub ta.append(\"窗口激活\"+\"\\n\"); } //关闭后 public void windowClosed(WindowEvent e) { ta.append(\"已经关闭\"+\"\\n\"); } //关闭时 public void windowClosing(WindowEvent e) { // TODO Auto-generated method stub ta.append(\"正在关闭\"); System.exit(0); } //失去焦点 public void windowDeactivated(WindowEvent e) { // TODO Auto-generated method stub ta.append(\"失去焦点 \\n\"); } //获得焦点 public void windowDeiconified(WindowEvent e) { // TODO Auto-generated method stub ta.append(\"获得焦点\\n\"); } //窗体最小化 public void windowIconified(WindowEvent e) { // TODO Auto-generated method stub ta.append(\"窗体最小化\\n\"); } public void windowOpened(WindowEvent e) { // TODO Auto-generated method stub ta.append(\"窗体第一次打开\\n\"); } } public static void main(String[] args) { Test_WindowListener tw=new Test_WindowListener();
} tw.init(); }
因篇幅问题不能全部显示，请点此查看更多更全内容