第十八章 Swing程序设计

Swing概述

Swing 主要用来开发GUI(Graphical User Interface)程序，GUI是应用程序提供给用户操作的图形界面，包括窗口、菜单、按钮等图形界面元素，我们经常使用的 QQ 软件、360 安全卫士等均为 GUT程序。Java语言为 Swing程序的开发提供了丰富的类库，这些类分别被存储在java.awt和javax.swing包中。Swing提供了丰富的组件，在开发 Swing 程序时，这些组件被广泛地应用。

Swing 组件是完全由 Java 语言编写的组件。因为Java 语言不依赖于本地平台(即“操作系统”).所以Swing 组件可以被应用于任何平台。基于“跨平台”这一特性，Swing 组件被称作“轻量级组件”反之，依赖于本地平台的组件被称作“重量级组件”,

在Swing 包的层次结构和继承关系中，比较重要的类是Component 类(组件类)Container 类(容
感类)和JComponent 类(Swing 组件父类)。Swing 包的层次结构和承关系如图18.1所示。

图18.1包含了一些Swing 组件，常用的Swing组件如表18.1所示

Swing常用窗体

JFrame窗体

开发 Swing程序的流程可以被简单地概括为首先通过继承javaxswingJFrame类创建一个窗体，然后向这个窗体中添加组件，最后为添加的组件设置监听事件。下面将详细讲解Frame 窗体的使用方法。JFrame类的常用构造方法包括以下两种形式:

•  public JFrame0:创建一个初始不可见、没有标题的窗体。
•  publicJFrame(String title):创建一个不可见、具有标题的窗体。

例如，创建一个不可见、具有标题的窗体，关键代码如下:

JFrame jf=new JFrame("登录系统”)；

Container container = jf.getContentPane();

在创建窗体后，先调用getContentPane0方法将窗体转换为容器，再调用add0方法或者remove0方法向容器中添加组件或者删除容器中的组件。向容器中添加按钮，关键代码如下:

JButton okBtn = new JButton("确定")

container.add(okBtn);

删除容器中的按钮，关键代码如下:

container.remove(okBtn);

创建窗体后，要对窗体进行设置，如设置窗体的位置、大小、是否可见等。JFrame 类提供的相应方法可实现上述设置操作，具体如下:

• setBounds(int x,inty,int width,int leight):设置窗体左上角在屏幕中的坐标为(xy)，窗体的宽V度为width，窗体的高度为height。
• setLocation(intx,inty):设置窗体左上角在屏幕中的坐标为(x,y)。
• setSize(int width,int height):设置窗体的宽度为 width，高度为 height。
• setVisibale(boolean b): 设置窗体是否可见。b为true 时，表示可见;b为false 时，表示不可见
• setDefaultCloseOperation(int operation):设置窗体的关闭方式，默认值为DISPOSE_ON _CLOSE。

代码案例：

import java.awt.*;	//导入AWT包
import javax.swing.*;	//导入Swing包

public class Test {

	public static void main(String[] args) {	//主方法
		JFrame jf=new JFrame();		//创建窗体对象
		jf.setTitle("创建一个JFrame窗体");	//设置窗体标题
			Container container=jf.getContentPane();	//获取主容器
			JLabel jl=new JLabel("这是一个JFrame窗体");	//一个文本标签
			jl.setHorizontalAlignment(SwingConstants.CENTER);	//使标签上的文字居中
			container.add(jl);		//将标签添加到主容器中
			jf.setSize(300,150);	//设置窗体宽高
			jl.setLocation(320,240);	//设置窗体在屏幕中出现的位置
			jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);	//关闭窗体则停止程序
			jf.setVisible(true);	//让窗体展示出来
	}

}

运行结果：

JDialog 对话框

JDialog 对话框继承了java.awt.Dialog 类，其功能是从一个窗体中弹出另一个窗体，如使用IE 浏览器时弹出的确定对话框。JDialog对话框与JFrame 窗体类似,被使用时也需要先调getContentPane()方法把JDialog 对话框转换为容器再对JDialog对话框进行设置。JDialog 类常用的构造方法如下:

代码案例：

package eighteenth;

import java.awt.Container;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.WindowConstants;
 
class MyJDialog extends JDialog{//自定义对话框类，继承 JDialog
	public MyJDialog (MyFrame frame) {
	//调用父类构造方法，第一个参数是父窗体，第二个参数是窗体标题，第三个参数表示堵塞父窗体
		super(frame,"第一个 JDialog 窗体",true);
		Container container=getContentPane();//获取主容器
		container.add(new JLabel("这是一个对话框"));//在容器中添加标题
		setBounds(120,120,100,100);//设置对话框窗体在桌面显示的坐标和大小
	}	
 
public static void main(String[] args) {
	new MyFrame ();
}
}
 
class MyFrame extends JFrame {//自定义窗体，继承 JFrame
	public MyFrame() {//窗体的构造方法
		Container container=getContentPane();//获得窗体主容器
		container.setLayout(null);//容器使用绝对布局
		JButton bl=new JButton("弹出对话框");//创建一个按钮
		bl.setBounds(10,10,100,21);//定义按钮在容器中的坐标和大小
		bl.addActionListener(new ActionListener() {//为按钮添加单击事件
			public void actionPerformed(ActionEvent e) {//单击事件触发的方法
				MyJDialog dialog =new MyJDialog(MyFrame.this);//创建 MyJDialog对话框 
				dialog .setVisible(true);//是对话框可见
			}
		});
		container.add(bl);//将按钮添加到容器中
		setSize(200,200);//窗体的宽高
		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//关闭窗体则停止程序
		setVisible(true);//使窗体可见
	}
}

运行代码：

JOptionPane小型对话框

JavaAPI中的javaxswingJOptionPane类是一个非常简便的小型对话框类，该类用于创建对话框的方法都是静态方法，无须创建对象即可弹出。在日常开发中经常使用该类弹出提示、确认用户需求、调试程序等。JOptionPane 提供了4种创建对话框的方法，如表 18.3 所示。

1，自定义对话框

首先介绍一个自定义的对话框，这个对话框可以说是一块白板，开发者可以自行定义对话框中显示的元素。创建自定义对话框的方法如下:

public static int showOptionDialog(Component parentComponent，

                Object message,

                String title,

                int optionType,

                int messageType,
                Icon icon,

                Object[] options，

                Object initialValue)

参数说明如下;

代码案例：

package eighteenth;

import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JOptionPane;
 
public class Demo {
	public static void main(String[] args) {
		Object O[]= {new JButton("是的"),new JButton("再想想")};//按钮对象的 Object 数组
		Icon icon=new ImageIcon("src/注意.png");//获取图标对象
		JOptionPane.showOptionDialog(null, "你做好准备了吗", "注意了！",
				JOptionPane.DEFAULT_OPTION,JOptionPane.DEFAULT_OPTION,icon,O, null);
	}
}

运行结果：

2.确认框

确认框已经封装好了一套外观样式，弹出后要求用户做选择操作，用户选择具体选项后，确认框可以返回用户的选择结果，结果以int方式返回。创建确认对话框的方法有以下几种重载形式:

代码案例：

package eighteenth;

import javax.swing.JOptionPane;
 
public class Demo {
	public static void main(String[] args) {
		int answer=JOptionPane.showConfirmDialog(null,"确定离开吗？","标题",
				JOptionPane.YES_NO_CANCEL_OPTION);
	}
}

运行结果：

3.输入框

输入框已经封装好了一套外观样式，弹出后要求用户在文本框中输入文本，用户完成输入操作后输入框可以返回用户输入的结果。创建输入框的方法有以下几种重载形式:

案例代码：

package eighteenth;
 
import javax.swing.JOptionPane;
 
public class Demo {
	public static void main(String[] args) {
		String name=JOptionPane.showInputDialog(null,"请输入您的姓名");
	}
}

运行结果：

4，通知框

通知框是最简单的一个对话框，仅弹出提示，不会返回任何值。创建通知框方法有以下几种重载形式:

代码案例：

package eighteenth;
 
import javax.swing.JOptionPane;
 
public class Demo {
	public static void main(String[] args) {
		JOptionPane.showMessageDialog(null,"您与服务器断开了连接","发生错误",JOptionPane.ERROR_MESSAGE);
	}
}

运行结果：

常用布局管理器

null 绝对布局

绝对布局也叫 null 布局，其特点是硬性指定组件在容器中的位置大小，组件的位置通过绝对坐标的方式来指定。使用绝对布局首先使用 Container.seLayout(null)方法取消容器的布局管理器，然后再使用 Component.setBounds(int x,int y,int width,int height)方法设置每个组件在容器中的位置和大小。

package eighteenth;
 
import java.awt.Container;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.WindowConstants;
 
public class AbsolutePosition extends JFrame{
	public AbsolutePosition() {
		setTitle("本窗体使用绝对布局");//窗体标题
		setLayout(null);//使用 null 布局
		setBounds(0,0,300,150);//设置窗体的坐标与宽高
		Container c=getContentPane();//获取主容器
		JButton b1=new JButton("按钮1");//创建按钮 
		JButton b2=new JButton("按钮2");
		b1.setBounds(10,30,80,30);//设置按钮的位置与大小
		b2.setBounds(60,70,100,20);
		c.add(b1);//将按钮添加到容器
		c.add(b2);
		setVisible(true);//使窗体可见
		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//关闭窗体则停止程序
	}
	public static void main(String[] args) {
		new AbsolutePosition();
	}
}

运行结果：

FlowLayout 流布局管理器

 流布局（FlowLayout）管理器是 Swing 中最基本的布局管理器。使用流布局管理器摆放组件时，组件被从左到右摆放。当组件占据了当前的所有空间时，溢出的组件会被移动到当前的下一行。默认情况下，行组件的排列方式会被指定为居中对齐，但是通过设置可以更改每一行组件的排序方式。       

package eighteenth;
 
import java.awt.Container;
import java.awt.FlowLayout;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.WindowConstants;
 
public class FlowLayoutPosition extends JFrame{
	public  FlowLayoutPosition(){
		setTitle("本窗体使用流布局管理器");//设置窗体标题
		Container c=getContentPane();//获取窗体主容器
		//窗体使用流布局，组件右对齐，组件之间的组件之间的水平间隔为10像素，垂直间隔10像素
		setLayout(new FlowLayout(FlowLayout.RIGHT,10,10));
		for(int i=0;i<10;i++) {
			c.add(new JButton("button"+i));
		}
		setSize(300,200);//设置窗体大小
		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);//关闭窗体则停止程序
		setVisible(true);//设置窗体可见
	}
 
	public static void main(String[] args) {
		new FlowLayoutPosition();
	}
}

运行结果：

BorderLayout 边界布局管理器 

 使用 Swing 创建窗体后，容器默认的布局管理器是边界布局（BorderLayout ）管理器 ，边界布局把容量划分为东、南、西、北、中5个区域，但组件被添加到设置为边界布局管理器的容器时，需要使用 BorderLayout 类中成员变量指定被添加的组件在边界布局管理器中的区域。

package eighteenth;
 
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.FlowLayout;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.WindowConstants;
 
public class FlowLayoutPosition extends JFrame{
	public FlowLayoutPosition() {
		setTitle("本窗体使用边界布局管理器");//设置窗体标题
		Container c=getContentPane();//获取窗体主容器
		setLayout(new BorderLayout());//容器使用边界布局
		JButton centerBtn=new JButton("中");
		JButton northBtn=new JButton("北");
		JButton southBtn=new JButton("南");
		JButton westBtn=new JButton("西");
		JButton eastBtn=new JButton("东");
		c.add(centerBtn,BorderLayout.CENTER);
		c.add(northBtn,BorderLayout.NORTH);
		c.add(southBtn,BorderLayout.SOUTH);
		c.add(westBtn,BorderLayout.WEST);
		c.add(eastBtn,BorderLayout.EAST);
		setSize(350,200);//设置窗体大小
		setVisible(true);//设置窗体可见
		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);//关闭窗体则停止程序
	}
 
	public static void main(String[] args) {
		new FlowLayoutPosition();
	}
}

运行结果：

GridLayout 网格布局管理器

GridLayout 网格布局管理器能够把容器划分为网格，组件可以按行列进行排列。

在网格布局管理器中，网格的个数由行数和列数决定，且每个网格的大小都相同。从网格的左上角开始，按照从左到右，从上到下的顺序被添加到网格中，且每个组件都会填满整个网格。改变窗口大小的同时，组件的大小也会随之改变

网格布局管理器主要有以下两个常用的构造方法：

public GridLayout(int rows， int columns)

public GridLayout(int rows， int columns ，int hortizGap,int vertGap)

rows和columns这两个参数只允许有一个参数可以为零，被用于表示一行或一列可以排列任意多个组件

package LX;
 
import java.awt.Container;
import java.awt.GridLayout;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.WindowConstants;
 
public class GP18_10 extends JFrame {
	public GP18_10(){
		Container c=getContentPane();
		//设置容器使用网格布局管理器设置7行3列的网格组件间，水平间距为5像素，垂直间距为5像素
		setLayout(new GridLayout(7,3,5,5));
		for(int i=0;i<20;i++) {
			c.add(new JButton("button"+i));//循环添加按钮
			
		}
		setSize(300,300);
		setTitle("这是一个使用网格布局管理器的窗体");
		setVisible(true);
		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		
	}
	public static void main(String[] args) {
		new GP18_10();
 
	}
 
}

运行结果：

常用面板

JPanel面板

在Swing程序设计中，面板是一个容器，被用于容纳其他组件，

但面板必须被添加到其他容器中。Swing中常用的面板包括JPanel面板和JScrollpane面板

JPanel面板继承Java.awt.Container类，JPanel面板必须在窗体容器中使用，无法脱离窗体显示

package LX;
 
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.GridLayout;
 
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.WindowConstants;
 
public class JT18_11 extends JFrame{
	public  JT18_11(){
		Container c=getContentPane();//获取窗体主容器
		//将整个容器设置为2行2列的网格布局，组件水平间隔10像素，垂直间隔10像素
		c.setLayout(new GridLayout(2,2,10,10));
		//初始化一个面板，此面板使用1行4列的网格布局，组件水平间隔10像素，垂直间隔10像素
		JPanel p1=new JPanel(new GridLayout(1,4,10,10));
		//初始化一个面板，此面板使用边界布局
		JPanel p2=new JPanel(new BorderLayout());
		JPanel p3=new JPanel(new GridLayout(1,2,10,10));
		JPanel p4=new JPanel(new GridLayout(2,1,10,10));
		//给每个面板都添加边框和标题，使用 BorderFactory 工厂类生成带标题的边框对象
		p1.setBorder(BorderFactory.createTitledBorder("面板1"));
		p2.setBorder(BorderFactory.createTitledBorder("面板2"));
		p3.setBorder(BorderFactory.createTitledBorder("面板3"));
		p4.setBorder(BorderFactory.createTitledBorder("面板4"));
		//向面板1中添加按钮
		p1.add(new JButton("b1"));
		p1.add(new JButton("b1"));
		p1.add(new JButton("b1"));
		p1.add(new JButton("b1"));
		//向面板2中添加按钮
		p2.add(new JButton("b2"),BorderLayout.WEST);
		p2.add(new JButton("b2"),BorderLayout.EAST);
		p2.add(new JButton("b2"),BorderLayout.NORTH);
		p2.add(new JButton("b2"),BorderLayout.SOUTH);
		p2.add(new JButton("b2"),BorderLayout.CENTER);
		//向面板3中添加按钮
		p3.add(new JButton("b3"));
		p3.add(new JButton("b3"));
		//向面板4中添加按钮
		p4.add(new JButton("b4"));
		p4.add(new JButton("b4"));
		//向容器中添加面板
		c.add(p1);
		c.add(p2);
		c.add(p3);
		c.add(p4);
		setTitle("这个窗体中使用了面板");
		setSize(500,300);//窗体宽高
		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);//关闭动作
	}
	public static void main(String[] args) {
		JT18_11 test=new JT18_11();
		test.setVisible(true);
	}
}

运行结果：

JScrollPane滚动面板

JScrollPane面板，是带滚动条的面板，被用于在较小的窗体中显示较大篇幅的内容，要注意的是，不能使用布局管理器，只能容纳一个组件，如果添加多个组件，那么需要先将多个组件添加到JPanel面板，再将JPanel面板添加到滚动面板

package LX;
 
import java.awt.Container;
 
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.WindowConstants;
 
public class JPT18_12 extends JFrame {
	public JPT18_12() {
		Container c = getContentPane();//获取主容器
		//创建文本区域组件，文本域默认大小为 20 行、50 列
		JTextArea ta = new JTextArea(20,50);
		//创建 JScrollPane 滚动面板，并将文本域放到滚动面板中
		JScrollPane sp = new JScrollPane(ta);
		c.add(sp);//将该面板添加到主容器中
		setTitle("带滚动条的文字编译器");
		setSize(400,200);
		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
	}
	public static void main(String[] args) {
		JPT18_12 test = new JPT18_12();
		test.setVisible(true);
 
	}
 
}

运行结果：

文字标签组件与图标

标签被用于显示文本，图标等内容。用户能够通过标签上的文本图标等内容获取相应的提示信息。

JLabel标签

JLabrl标签的父类是JComponent类，标签不能被添加监听器，但是标签显示的文本，图标等内容可以指定对齐方式，通过JLabrl类的构造方法可以创建多种标签，常用的构造方法如下：

import java.awt.Container;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.WindowConstants;

public class JLabelTest extends JFrame{
	public  JLabelTest (){
		Container container=getContentPane();//获取主容器
		JLabel jl=new JLabel("这是一个 JFrame 窗体");//创建标签
		container.add(jl);
		setSize(200,100);//设置窗体大小
		setVisible(true);//设置窗体可见
		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//关闭窗体则停止程序
	}

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

	}
}

运行结果：

图标的使用

在swing程序设计中，图标经常被添加到标签，按钮等组件。它有多个常用方法如下：

package LX;
 
import java.awt.*;
import java.net.URL;
 
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import javax.swing.WindowConstants;
 
public class My18_14 extends JFrame {
	public My18_14(){
	Container container=getContentPane();
	JLabel jl=new JLabel("这是一个JFrame窗体");//创建标签
	URL url=My18_14.class.getResource("图片3.png");//获取图片所在的URL
	Icon icon =new ImageIcon(url);//获取图片的icon对象
	jl.setIcon(icon);//为标签设置图片
	jl.setHorizontalAlignment(SwingConstants.CENTER);//设置文字放置在标签中间
	jl.setOpaque(true);//设置标签为不透明状态
	container.add(jl);//将标签添加到容器中
	setSize(300,200);//设置窗体大小
	setVisible(true);//使窗体可见
	setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//关闭窗体则停止程序
	
	}
	
 
	
	
	public static void main(String[] args) {
		new My18_14();
		
	}
 
}

运行结果：

按钮组件

JButton按钮

Swing 按钮由JButton 对象表示，JButton 常用的构造方法如下:

•  publicJButton():创建一个不带文本或图标的按钮。
• publicJButton(String text):创建一个带文本的按钮。
• publicJButton(Icon icon): 创建一个带图标的按钮。
• public JButton(String text,Icon icon):创建一个带文本和图标的按钮。

创建JButton 对象后，如果要对 JButton 对象进行设置，那么可以使用 JButton 类提供的方法JButton 类的常用方法及其说明如表18.6所示:

package eighteenth;

import java.awt.Color;
import java.awt.Container;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.BorderFactory;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.WindowConstants;

public class JButtonTest extends JFrame{
	public  JButtonTest(){
		Icon icon=new ImageIcon("");//获取图片文件
		setLayout(new GridLayout(3,2,5,5));//设置网格布局管理器
		Container c=getContentPane();//获取主容器
		JButton btn[]=new JButton[6];//创建按钮数组
		for(int i=0;i

运行结果： 

JRadioButton单选按钮

Swing单选按钮由JRadioButton对象表示，在swing程序设计中，需要把多个单选按钮添加到按钮组，当用户选中某个单选按钮时，按钮组中的其他单选按钮将不能被同时选中。

1、单选按钮

创建JRadioButton对象需要使用JRadioButton类的构造方法，，常用构造方法如下：

2、按钮组

Swing按钮组由ButtonGroup对象表示，多个单选按钮被添加到按钮组后能够实现“选项有多个，但只能选中一个的效果”，对象被创建后可以使用add方法把多个单选按钮添加到对象中

import javax.swing.*;
public class RadioButtonTest extends JFrame{
		public RadioButtonTest() {
			setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
			setTitle("单选按钮的使用");
			setBounds(100,100,240,120);
			getContentPane().setLayout(null);//设置绝对布局
			JLabel lbINewLabel = new JLabel("请选择性别:");
			//设置绝对布局
			lbINewLabel.setBounds(5, 5,120,15);
			getContentPane().add(lbINewLabel);
			JRadioButton rbtnNormal =new JRadioButton("男");
			rbtnNormal.setSelected(true);
			rbtnNormal.setBounds(40, 30, 75,22);
			getContentPane().add(rbtnNormal);
			JRadioButton rbtnPwd = new JRadioButton("女");
			rbtnPwd.setBounds(120,30,75,22);
			getContentPane().add(rbtnPwd);
			ButtonGroup group = new ButtonGroup(); //创建按钮组，把交互面板中的单选按钮添加到按钮组中
			group.add(rbtnNormal);
			group.add(rbtnPwd);
		}

	public static void main(String[] args) {
		RadioButtonTest frame = new RadioButtonTest();//创建窗体对象
			frame.setVisible(true);//使窗体可见

	}

}

运行结果：

JCheckBox复选框

复选框组件由JCheckBox对象表示，以单选按钮不同的是，窗体中的复选框可以被选中多个，这是因为每一个复选框都提供了被选中和不被选中两种状态。常用构造方法如下：

package LX;

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;

public class CBT18_17 extends JFrame {
	public CBT18_17() {
		setBounds(100,100,170,110);//窗口坐标和大小
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		Container c=getContentPane();//获取主容器
		c.setLayout(new FlowLayout());//容器使用流布局
		JCheckBox c1=new JCheckBox("1");//创建复选框
		JCheckBox c2=new JCheckBox("2");
		JCheckBox c3=new JCheckBox("3");
		c.add(c1);//容器添加复选框
		c.add(c2);
		c.add(c3);
		JButton btn=new JButton("打印");//创建打印按钮
		btn.addActionListener(new ActionListener(){//打印按钮动作事件
			public void actionPerformed(ActionEvent e) {
				//在控制台分别输出三个复选框的选中状态
				System.out.println(c1.getText()+"按钮选中状态："+c1.isSelected());
				System.out.println(c2.getText()+"按钮选中状态："+c2.isSelected());
				System.out.println(c3.getText()+"按钮选中状态："+c3.isSelected());
				
			}
		});		
		c.add(btn);//容器添加打印按钮
		setVisible(true);
		
	
	}
	public static void main(String[] args) {
		new CBT18_17();

	}

}

运行结果：

列表组件

Swing中提供两种列表组件，分别为下拉列表框（JComboBox)和列表框(JList)，下拉列表框与列表框都是带有一系列列表选项的组件，用户可以从中选择需要的列表项，列表框较下拉列表框更直观，他们将所有的列表项罗列在列表框，但是下拉列表这个表框更为便捷美观，它将所有的列表项隐藏起来，当用户用其中的列表项时才会显示出来。

JComboBox下拉列表框

初次使用下拉列表框时，会感觉swing中的下拉列表框以WINDOWS操作系统中的下拉列表框有一些相似，实质上两者并不完全相同，因为swing中的下拉列表框不仅可以供用户从中选择，列表项也提供编辑列表项的功能JComboBox类的常用构造方法如下:

package eighteenth;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;

public class JComboBoxTest extends JFrame {
	public JComboBoxTest() {
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setTitle("下拉列表框的使用");
		setBounds(100,100,317,147);
		getContentPane().setLayout(null);//设置绝对布局
		JLabel lblNewLabel = new JLabel("请选择证件:");
		lblNewLabel.setBounds(28,14,80,15);
		getContentPane().add(lblNewLabel);
		JComboBoxcomboBox = new JComboBox();//创建一个下拉列表框
		comboBox.setBounds(110,11,80,21);		//设置坐标
		comboBox.addItem("身份证");				//为下拉列表中添加项
		comboBox.addItem("军人证");
		comboBox.addItem("学生证");
		comboBox.addItem("工作证");
		comboBox.setEditable(true);			//将下拉列表添加到容器中
		getContentPane().add(comboBox);
		JButton btnNewButton= new JButton("确定");
		btnNewButton.setBounds(200,10,67,23);
		getContentPane().add(btnNewButton);
		btnNewButton.addActionListener(new ActionListener() {	//为按钮添加监听事件

			@Override
			public void actionPerformed(ActionEvent e) {
				lblNewLabel.setText("你的选择的是:"+ comboBox.getSelectedItem());
			}
			
		});
		
	}

	public static void main(String[] args) {
		JComboBoxTest frame = new JComboBoxTest();	//创建窗体对象
		frame.setVisible(true);//使窗体可见
	}

}

运行结果： 

JList列表框

列表框组件被添加到窗体中后，就会被指定长和宽。如果列表框的大小不足以容纳列表项的个数，那么需要设置列表框具有滚动效果，即把列表框添加到滚动面板。列表框组件由j list对象表示常用构造方法如下：

package LX;
 
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.WindowConstants;
 
public class JLT18_19 extends JFrame {
	public JLT18_19() {
		Container cp=getContentPane();//获取窗体主容器
		
		cp.setLayout(null);//容器使用绝对布局
		//创建字符串数组保存列表中的数据
		String[]contents= {"列表1","列表2","列表3","列表4","列表5","列表6"};
		JList jl=new JList<>(contents);//创建列表框并将字符串数组作为构造参数
		JScrollPane js=new JScrollPane(jl);//将列表框放入滚动面板
		js.setBounds(10, 10, 100, 109);//设定滚动面板的坐标和大小
		cp.add(js);
		JTextArea area=new JTextArea();//创建文本域
		JScrollPane scrollPane=new JScrollPane(area);//将文本域放入滚动面板
		scrollPane.setBounds(118,10,73,80);//设定滚动面板的坐标和大小
		cp.add(scrollPane);
		JButton bthNewButton=new JButton("确认");//创建确定按钮
		bthNewButton.setBounds(120,96,71,23);//设定按钮的坐标和大小
		cp.add(bthNewButton);
		bthNewButton.addActionListener(new ActionListener() {//添加按钮事件
			public void actionPerformed(ActionEvent e) {
				//获取列表中选中的元素返回JAVA.util.list类型
				java.util.List values=jl.getSelectedValuesList();
				area.setText("");//清空文本域
				for(String value : values) {
					area.append(value+"\n");//在文本域循环追加列表框中选中的值
				}
			}
		});
		setTitle("在这个窗口中使用了列表框");
		setSize(300,200);
		setVisible(true);
		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
	}
	public static void main(String[] args) {
		new JLT18_19();
 
	}
 
}

运行结果：

文本组件

文本组件在开发swing程序过程中经常被用到，尤其是文本框组件和密码框组件 

JTextField文本框

文本框组件由JTextField对象表示，JTextField常用构造方法如下：

package LX;
 
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextField;
import javax.swing.WindowConstants;
 
public class JFT18_20 extends JFrame{
	 public JFT18_20() {
		 Container c=getContentPane();//获取窗体主容器
		 
		 
		 
		 
		 
		
		 
		
		 
		 
		 c.setLayout(new FlowLayout());
		 JTextField jt=new JTextField("请点击清除按钮");//设定文本框初始值
		 jt.setColumns(20);//设置文本框长度
		 jt.setFont(new Font("宋体",Font.PLAIN,20));//设置字体
		 JButton jb=new JButton("清除");
		 jt.addActionListener(new ActionListener() {//为文本框添加回车事件
			 public void actionPerformed(ActionEvent arf0) {
				 jt.setText("触发事件");//设置文本框中的值
			 }
		 });
		 jt.addActionListener(new ActionListener() {// 为按钮添加事件
			 public void actionPerformed(ActionEvent arf0) {
				 System.out.println(jt.getText());//输出当前文本框的值
				 jt.setText("");//将文本框置空
				 jt.requestFocus();// 焦点回到文本框
			 }
	 });
		 c.add(jt);//窗体容器添加文本框
		 c.add(jb);//窗体添加按钮
		 setBounds(100,100,250,110);
		 setVisible(true);
		 setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
	 }
	public static void main(String[] args) {
		new JFT18_20();
		
 
	}
 
}

 运行结果：

JPasswordField密码框

密码框组件由JPasswordField对象表示，其作用是把用户输入的字符串，以某种符号进行加密
常用构造方法如下:

JTextArea文本框

文本域组件由JTrxtArea对象表示，其作用是接受用户的多行文本输入，常用构造方法如下:

public JTextArea():

public JTextArea(String text):

public JTextArea(int rows,int columns):

public JTextArea(Document doc):

public JTextArea(Document doc ，String Text,int rows,int columns)；

package LX;
 
 
 
import java.awt.Container;
 
import javax.swing.JFrame;
import javax.swing.JTextArea;
import javax.swing.WindowConstants;
 
public class JT18_21 extends JFrame {
	public   JT18_21() {
		setSize(200,100);
		setTitle("定义自动换行的文本域");
		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
		Container cp = getContentPane();	//获取窗体主容器
		//创建一个文本内容为“文本域”、行高和列宽均为 6 的文本域
		JTextArea jt = new JTextArea("文本域",6,6);
		jt.setLineWrap(true);	//可以自动换行
		cp.add(jt);
		setVisible(true);
}
	public static void main(String[] args) {
			new JT18_21();
	}
}

运行结果：

表格组件

Swing表格由JTable表示其作用是把数据以表格的形式显示给用户

创建表格

JTanle类除了提供了默认的构造方法外，还提供了被用于显示二维数组中的元素的构造方法。这个构造方法的语法如下:

JTanle（Object[][]rowDate，Object[]columnNames）

rowDate存储表格数据的二维数组

columnNames，存储表格列明的一维数组

在使用表格时，要先把表格添加到滚动面板，再把滚动面板添加到窗体的相应位置

package eighteenth;

import java.awt.BorderLayout;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;


public class JTextAreaTest extends JFrame {
	public static void main(String args[]) {
		JTextAreaTest frame = new JTextAreaTest();
		frame.setVisible(true);
	}
	public JTextAreaTest() {
		setTitle("创建可以滚动的表格");
		setBounds(100,100,240,150);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		String[] columnNames = {"A","B"};	//定义表格列名数
		//定义表格数据数组
		String[][] tableValues ={{"A1","B1"},{"A2","B2"},{"A3","B3"},
				{"A4","B4"},{"A5","B5"}};
		//创建指定列名和数据的表格
		JTable table = new JTable(tableValues, columnNames);
		//创建显示表格的滚动面板
		JScrollPane scrollPane = new JScrollPane(table);
		//将滚动面板添加到边界布局的中间
		getContentPane().add(scrollPane, BorderLayout.CENTER);
	}
}

运行结果：

 DefaultTableModel 表格数据模型

Swing 使用 TableModel 接口定义了一个表格模型，AbstractTableModel 抽象类实现了 TableModel接口的大部分方法，只有以下3 个抽象方法没有实现:

• public int getRowCount();
• public int getColumnCount();
• public Object getValueAt(int rowIndex, int columnIndex);

为了实现使用表格模型创建表格的功能，Swing 提供了表格模型类，即 DefaultTableModel 类。DefaultTableModel类继承了 AbstractTableModel 抽象类且实现了上述 3 个抽象方法。DefaultTableModel类提供的常用构造方法如表 18.8 所示

import java.awt.BorderLayout;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.WindowConstants;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableRowSorter;

public class SortingTable extends JFrame{
	private static final long serialversionUID=1L;
	public static void main(String[] args) {
		SortingTable frame=new SortingTable();
		frame.setVisible(true);
		
	}
	public SortingTable() {
		setTitle ("表演模型与表格");
		setBounds(100,100,240,150);//窗体宽高
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		JScrollPane scrollPane=new JScrollPane();
		getContentPane().add(scrollPane,BorderLayout.CENTER);
		String[] columnNames= {"A","B"};//定义表格列名数组
		//定义表格数据数组
		String[][] tableValues= {{"A1","B1"},{"A2","B2"},{"A3","B3"}};
		//创建指定表格列名和表格数据的表格模型
		DefaultTableModel tableModel=new DefaultTableModel(tableValues,columnNames);
		JTable table=new JTable(tableModel);//创建指定表格模型的表格
		table.setRowSorter(new TableRowSorter<>(tableModel));
		scrollPane.setViewportView(table);
	}
	}

运行结果：

维护表格模型

表格中的数据内容需要用于维护，

使用getValueAt()方法获得表格中某一个单元格的值，

使用addRow方()法向表格中添加新的行

使用setValueAt()方法修改表格中某一个单元格的值

使用removeRow()方法从表格中删除指定行等

当删除表格模型中的指定行时，每删除一行，其后所有行的索引值将相应的减一，所以当连续删除多行时，需要注意对删除行索引的处理。

package LX;
 
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.ListSelectionModel;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableRowSorter;
 
public class ADD18_24 extends JFrame{
	private DefaultTableModel tableModel;//定义表格模型对象
	
	private JTable table;//定义表格对象
	
	private JTextField aTextFied ;
	private JTextField bTextFied ;
 
	public ADD18_24() {
		setTitle("维护表格模型");
		setBounds(100,100,520,200);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		final JScrollPane scrollPane=new JScrollPane();
		getContentPane().add(scrollPane,BorderLayout.CENTER);
		String[] columnNames= {"A","B"};//定义表格列名数组
		//定义表格数据数组
		String[][]tableValues= {{"A1","B1"},{"A2","B2"},{"A3","B3"}};
		//创建指定表格列名和表格数据的表格模型
		tableModel =new DefaultTableModel(tableValues,columnNames);
		table=new JTable(tableModel);//创建指定表格模型的表格
		table.setRowSorter(new TableRowSorter<>(tableModel));//设置表格的排序器
		//设置表格的选择模式为单选
		table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
		//为表格添加鼠标事件监听器
		table.addMouseListener(new MouseAdapter() {
			public void mouseClicked(MouseEvent e) {//发生了单击事件
				int selectedRow=table.getSelectedRow();//获得被选中行的索引
				//从表格模型中获得指定单元格的值
				Object oa=tableModel.getValueAt(selectedRow, 0);
				//从表格模型中获得指定单元格的值
				Object ob=tableModel.getValueAt(selectedRow, 1);
				aTextFied.setText(oa.toString());//将值赋值给文本框
				bTextFied.setText(ob.toString());//将值赋值给文本框
			}
		});
		
		scrollPane.setViewportView(table);
		JPanel panel=new JPanel();
		getContentPane().add(panel, BorderLayout.SOUTH);
			panel.add(new JLabel("A:"));
			aTextFied = new JTextField("A4",10);
			
			panel.add(aTextFied);
			panel.add(new JLabel("B:"));
			bTextFied = new JTextField("B4",10);
			panel.add(bTextFied);
			JButton addButton = new JButton("添加");
			addButton.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
			String[] rowValues = {aTextFied.getText(),
					bTextFied.getText()};//创建表格行数组
			tableModel.addRow(rowValues);//向表格模型中添加一行
			int rowCount = table.getRowCount()+ 1;
			aTextFied.setText("A" + rowCount);
			bTextFied.setText("B" + rowCount);
			}
			});
			
			panel.add(addButton);
			JButton updButton = new JButton("修改");
			updButton.addActionListener(new ActionListener() {
				public void actionPerformed(ActionEvent e) {
					int selectdRow=table.getSelectedRow();//获得被选中行的索引
					if(selectdRow!=1) {//判断是否存在被选中行
						//修改表格模型中的指定值
						tableModel.setValueAt(aTextFied.getText(),selectdRow, 0);
						//修改表格模型中的指定
						tableModel.setValueAt(bTextFied.getText(),selectdRow, 1);
						
						
					}
				}
			});
			panel.add(updButton);
			JButton delButton = new JButton("删除");
			delButton.addActionListener(new ActionListener(){
				public void actionPerformed(ActionEvent e) {
					int selectedRow = table.getSelectedRow();//获得被选中行的索引
					if (selectedRow != -1)//判断是否存在被选中行
						
						
						tableModel.removeRow(selectedRow);//从表格模型中删除指定行
				}
			});
			
			panel.add(delButton);
			
		
	}
	public static void main(String[] args) {
		ADD18_24 frame=new ADD18_24();
		frame.setVisible(true);
		
 
	}
 
}

运行结果： 

事件监听器

ActionEvent 动作事件

动作事件(ActionEvent)监听器是 Swing 中比较常用的事件监听器，很多组件的动作都会使用它监听，如按钮被单击等。表 18.9 描述了动作事件监听器的接口与事件源等。

package shiba;

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

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.WindowConstants;

public class SimpleEvent extends JFrame {
	private JButton jb = new JButton("我是按钮，点击我");
	
	public SimpleEvent() {
		setLayout(null);
		setSize(200,100);
		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
		Container cp = getContentPane();
		cp.add(jb);
		jb.setBounds(10,10,150,30);
		jb.addActionListener((ActionListener) new jbAction());
		setVisible(true);
		
	}
	class jbAction implements ActionListener{
		public void actionPerformed(ActionEvent arg0) {
			jb.setText("我被点击了");
		}
	}

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

}

运行结果：

KeyEvent 键盘事件

当向文本框中输入内容时，将发生键盘事件。KeyEvent 类负责捕获键盘事件，可以通过为组件添加实现了 KeyListener 接口的监听器类来处理相应的键盘事件。

KeyListener 接口共有 3 个抽象方法，分别在发生击键事件(按下并释放键)、按键被按下(手指按下键但不松开)和按键被释放(手指从按下的键上松开)时被触发，具体如下:

public interface KeyListener extends EventListener {

        public void keyTyped(KeyEvent e);                //发生击键事件时被触发

        public void keyPressed(KeyEvent e);                //按键被按下时被触发

        public void keyReleased(KeyEvent e);                //按键被释放时被触发

}

在上述每个抽象方法中，均传入了 KeyEvent 类的对象。KeyEvent 类中比较常用的方法如表18.10所示。

package shiba;

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import java.awt.Color;
import java.awt.Component;

import javax.swing.JButton;
import java.awt.Font;
import javax.swing.SwingConstants;
import javax.swing.border.TitledBorder;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.ArrayList;

import javax.swing.JTextField;

/**
 * 虚拟键盘(键盘的按下与释放)
 */
public class KeyBoard extends JFrame { // 创建“键盘”类继承JFrame
	// 声明窗体中的成员组件
	private JPanel contentPane;
	private JTextField textField;
	private JButton btnQ;
	private JButton btnW;
	private JButton btnE;
	private JButton btnR;
	private JButton btnT;
	private JButton btnY;
	private JButton btnU;
	private JButton btnI;
	private JButton btnO;
	private JButton btnP;
	private JButton btnA;
	private JButton btnS;
	private JButton btnD;
	private JButton btnF;
	private JButton btnG;
	private JButton btnH;
	private JButton btnJ;
	private JButton btnK;
	private JButton btnL;
	private JButton btnZ;
	private JButton btnX;
	private JButton btnC;
	private JButton btnV;
	private JButton btnB;
	private JButton btnN;
	private JButton btnM;
	Color green = Color.GREEN;// 定义Color对象，用来表示按下键的颜色
	Color white = Color.WHITE;// 定义Color对象，用来表示释放键的颜色

	ArrayList btns = new ArrayList();// 定义一个集合，用来存储所有的按键ID
	// 自定义一个方法，用来将容器中的所有JButton组件添加到集合中

	private void addButtons() {
		for (Component cmp : contentPane.getComponents()) {// 遍历面板中的所有组件
			if (cmp instanceof JButton) {// 判断组件的类型是否为JButton类型
				btns.add((JButton) cmp);// 将JButton组件添加到集合中
			}
		}
	}

	/**
	 * 主方法
	 */
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() { // 使得Runnable中的的run()方法在the system EventQueue的指派线程中被调用
			public void run() {
				try {
					KeyBoard frame = new KeyBoard(); // 创建KeyBoard对象
					frame.setVisible(true); // 使frame可视
					frame.addButtons();// 初始化存储所有按键的集合
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * 创建JFrame窗体
	 */
	public KeyBoard() { // KeyBoard的构造方法
		setTitle("\u865A\u62DF\u952E\u76D8\uFF08\u6A21\u62DF\u952E\u76D8\u7684\u6309\u4E0B\u4E0E\u91CA\u653E\uFF09"); // 设置窗体题目
		setResizable(false); // 不可改变窗体宽高
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置窗体关闭的方式
		setBounds(100, 100, 560, 280); // 设置窗体的位置和宽高
		/**
		 * 创建JPanel面板contentPane置于JFrame窗体中，并设置面板的背景色、边距和布局
		 */
		contentPane = new JPanel();
		contentPane.setBackground(Color.WHITE);
		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
		setContentPane(contentPane);
		contentPane.setLayout(null);
		/**
		 * 创建按钮button置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnQ = new JButton("Q");
		btnQ.setBackground(white);
		btnQ.setVerticalAlignment(SwingConstants.TOP);
		btnQ.setHorizontalAlignment(SwingConstants.LEADING);
		btnQ.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnQ.setBounds(0, 60, 47, 45);
		contentPane.add(btnQ);
		/**
		 * 创建按钮button_2置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnW = new JButton("W");
		btnW.setBackground(white);
		btnW.setVerticalAlignment(SwingConstants.TOP);
		btnW.setHorizontalAlignment(SwingConstants.LEADING);
		btnW.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnW.setBounds(55, 60, 49, 45);
		contentPane.add(btnW);
		/**
		 * 创建按钮button_3置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnE = new JButton("E");
		btnE.setBackground(white);
		btnE.setVerticalAlignment(SwingConstants.TOP);
		btnE.setHorizontalAlignment(SwingConstants.LEADING);
		btnE.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnE.setBounds(110, 60, 45, 45);
		contentPane.add(btnE);
		/**
		 * 创建按钮button_4置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnR = new JButton("R");
		btnR.setBackground(white);
		btnR.setVerticalAlignment(SwingConstants.TOP);
		btnR.setHorizontalAlignment(SwingConstants.LEADING);
		btnR.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnR.setBounds(165, 60, 45, 45);
		contentPane.add(btnR);
		/**
		 * 创建按钮button_5置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnF = new JButton("F");
		btnF.setBackground(white);
		btnF.setVerticalAlignment(SwingConstants.TOP);
		btnF.setHorizontalAlignment(SwingConstants.LEADING);
		btnF.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnF.setBounds(195, 125, 45, 45);
		contentPane.add(btnF);
		/**
		 * 创建按钮button_6置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnD = new JButton("D");
		btnD.setBackground(white);
		btnD.setVerticalAlignment(SwingConstants.TOP);
		btnD.setHorizontalAlignment(SwingConstants.LEADING);
		btnD.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnD.setBounds(137, 125, 45, 45);
		contentPane.add(btnD);

		btnT = new JButton("T");
		btnT.setVerticalAlignment(SwingConstants.TOP);
		btnT.setHorizontalAlignment(SwingConstants.LEADING);
		btnT.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnT.setBackground(white);
		btnT.setBounds(220, 60, 45, 45);
		contentPane.add(btnT);

		btnY = new JButton("Y");
		btnY.setVerticalAlignment(SwingConstants.TOP);
		btnY.setHorizontalAlignment(SwingConstants.LEADING);
		btnY.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnY.setBackground(white);
		btnY.setBounds(275, 60, 45, 45);
		contentPane.add(btnY);

		btnU = new JButton("U");
		btnU.setVerticalAlignment(SwingConstants.TOP);
		btnU.setHorizontalAlignment(SwingConstants.LEADING);
		btnU.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnU.setBackground(white);
		btnU.setBounds(330, 60, 45, 45);
		contentPane.add(btnU);

		btnI = new JButton("I");
		btnI.setVerticalAlignment(SwingConstants.TOP);
		btnI.setHorizontalAlignment(SwingConstants.LEADING);
		btnI.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnI.setBackground(white);
		btnI.setBounds(385, 60, 45, 45);
		contentPane.add(btnI);

		btnO = new JButton("O");
		btnO.setVerticalAlignment(SwingConstants.TOP);
		btnO.setHorizontalAlignment(SwingConstants.LEADING);
		btnO.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnO.setBackground(white);
		btnO.setBounds(440, 60, 46, 45);
		contentPane.add(btnO);

		btnP = new JButton("P");
		btnP.setVerticalAlignment(SwingConstants.TOP);
		btnP.setHorizontalAlignment(SwingConstants.LEADING);
		btnP.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnP.setBackground(white);
		btnP.setBounds(495, 60, 45, 45);
		contentPane.add(btnP);

		btnA = new JButton("A");
		btnA.setVerticalAlignment(SwingConstants.TOP);
		btnA.setHorizontalAlignment(SwingConstants.LEADING);
		btnA.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnA.setBackground(white);
		btnA.setBounds(23, 125, 45, 45);
		contentPane.add(btnA);

		btnS = new JButton("S");
		btnS.setVerticalAlignment(SwingConstants.TOP);
		btnS.setHorizontalAlignment(SwingConstants.LEADING);
		btnS.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnS.setBackground(white);
		btnS.setBounds(82, 125, 45, 45);
		contentPane.add(btnS);

		btnG = new JButton("G");
		btnG.setVerticalAlignment(SwingConstants.TOP);
		btnG.setHorizontalAlignment(SwingConstants.LEADING);
		btnG.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnG.setBackground(white);
		btnG.setBounds(251, 125, 45, 45);
		contentPane.add(btnG);

		btnH = new JButton("H");
		btnH.setVerticalAlignment(SwingConstants.TOP);
		btnH.setHorizontalAlignment(SwingConstants.LEADING);
		btnH.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnH.setBackground(white);
		btnH.setBounds(306, 125, 45, 45);
		contentPane.add(btnH);

		btnJ = new JButton("J");
		btnJ.setVerticalAlignment(SwingConstants.TOP);
		btnJ.setHorizontalAlignment(SwingConstants.LEADING);
		btnJ.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnJ.setBackground(white);
		btnJ.setBounds(361, 125, 45, 45);
		contentPane.add(btnJ);

		btnK = new JButton("K");
		btnK.setVerticalAlignment(SwingConstants.TOP);
		btnK.setHorizontalAlignment(SwingConstants.LEADING);
		btnK.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnK.setBackground(white);
		btnK.setBounds(416, 125, 47, 45);
		contentPane.add(btnK);

		btnL = new JButton("L");
		btnL.setVerticalAlignment(SwingConstants.TOP);
		btnL.setHorizontalAlignment(SwingConstants.LEADING);
		btnL.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnL.setBackground(white);
		btnL.setBounds(471, 125, 45, 45);
		contentPane.add(btnL);

		btnZ = new JButton("Z");
		btnZ.setVerticalAlignment(SwingConstants.TOP);
		btnZ.setHorizontalAlignment(SwingConstants.LEADING);
		btnZ.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnZ.setBackground(white);
		btnZ.setBounds(39, 190, 45, 45);
		contentPane.add(btnZ);

		btnX = new JButton("X");
		btnX.setVerticalAlignment(SwingConstants.TOP);
		btnX.setHorizontalAlignment(SwingConstants.LEADING);
		btnX.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnX.setBackground(white);
		btnX.setBounds(107, 190, 45, 45);
		contentPane.add(btnX);

		btnC = new JButton("C");
		btnC.setVerticalAlignment(SwingConstants.TOP);
		btnC.setHorizontalAlignment(SwingConstants.LEADING);
		btnC.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnC.setBackground(white);
		btnC.setBounds(178, 190, 45, 45);
		contentPane.add(btnC);

		btnV = new JButton("V");
		btnV.setVerticalAlignment(SwingConstants.TOP);
		btnV.setHorizontalAlignment(SwingConstants.LEADING);
		btnV.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnV.setBackground(white);
		btnV.setBounds(250, 190, 45, 45);
		contentPane.add(btnV);

		btnB = new JButton("B");
		btnB.setVerticalAlignment(SwingConstants.TOP);
		btnB.setHorizontalAlignment(SwingConstants.LEADING);
		btnB.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnB.setBackground(white);
		btnB.setBounds(315, 190, 45, 45);
		contentPane.add(btnB);

		btnN = new JButton("N");
		btnN.setVerticalAlignment(SwingConstants.TOP);
		btnN.setHorizontalAlignment(SwingConstants.LEADING);
		btnN.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnN.setBackground(white);
		btnN.setBounds(382, 190, 47, 45);
		contentPane.add(btnN);

		btnM = new JButton("M");
		btnM.setVerticalAlignment(SwingConstants.TOP);
		btnM.setHorizontalAlignment(SwingConstants.LEADING);
		btnM.setFont(new Font("Times New Roman", Font.PLAIN, 14));
		btnM.setBackground(white);
		btnM.setBounds(449, 190, 48, 45);
		contentPane.add(btnM);
		/**
		 * 创建面板panel置于面板contentPane中，设置面板panel的位置、宽高、TitledBorder、背景色以及布局方式（边界布局）
		 */
		JPanel panel = new JPanel();
		panel.setBorder(new TitledBorder(null, "文本显示区", TitledBorder.LEADING, TitledBorder.TOP, null, null));
		panel.setBackground(Color.WHITE);
		panel.setBounds(0, 0, 540, 45);
		contentPane.add(panel);
		panel.setLayout(new BorderLayout(0, 0));

		/**
		 * 创建文本框textField置于面板panel的中间
		 */
		textField = new JTextField();
		textField.addKeyListener(new KeyAdapter() { // 文本框添加键盘事件的监听
			char word;

			@Override
			public void keyPressed(KeyEvent e) { // 按键被按下时被触发
				word = e.getKeyChar();// 获取按下键表示的字符
				for (int i = 0; i < btns.size(); i++) {// 遍历存储按键ID的ArrayList集合
					// 判断按键是否与遍历到的按键的文本相同
					if (String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())) {
						btns.get(i).setBackground(green);// 将指定按键颜色设置为绿色
					}
				}
			}

			@Override
			public void keyReleased(KeyEvent e) { // 按键被释放时被触发
				word = e.getKeyChar();// 获取释放键表示的字符
				for (int i = 0; i < btns.size(); i++) {// 遍历存储按键ID的ArrayList集合
					// 判断按键是否与遍历到的按键的文本相同
					if (String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())) {
						btns.get(i).setBackground(white);// 将指定按键颜色设置为白色
					}
				}
			}
		});
		panel.add(textField, BorderLayout.CENTER);
		textField.setColumns(10);
	}
}

运行结果：

MouseEvent 鼠标事件

所有组件都能发生鼠标事件，MouseEvent 类负责捕获鼠标事件，可以通过为组件添加实现了MouseListener 接口的监听器类来处理相应的鼠标事件。

MouseListener 接口共有 5个抽象方法，分别在光标移入或移出组件、鼠标按键被按下或释放和发生单击事件时被触发。所谓单击事件，就是按键被按下并释放。需要注意的是，如果按键是在移出组件之后才被释放，则不会触发单击事件。MouseListener 接口的具体定义如下:

public interface MouseListener extends EventListener {
        public void mouseEntered(MouseEvent e);        //光标移入组件时被触发

        public void mousePressed(MouseEvent e);        //鼠标按键被按下时被触发

        public void mouseReleased(MouseEvent e)        //鼠标按键被释放时被触发
        public void mouseClicked(MouseEvent e);        //发生单击事件时被触发

        public void mouseExited(MouseEvent e);             //光标移出组件时被触发

在上述每个抽象方法中，均传入了MouseEvent 类的对象。MouseEvent 类中比较常用的方法如表18.11所示。

当需要判断触发此次事件的按键时，可以通过表 18.12中的静态常量判断由getButton0方法返回的int型值代表的键。

package shiba;

import java.awt.BorderLayout;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

import javax.swing.JFrame;
import javax.swing.JLabel;

public class MouseEventDemo extends JFrame { // 继承窗体类JFrame

	public static void main(String args[]) {
		MouseEventDemo frame = new MouseEventDemo();
		frame.setVisible(true); // 设置窗体可见，默认为不可见
	}

	/**
	 * 判断按下的鼠标键，并输出相应提示
	 * 
	 * @param e 鼠标事件
	 */
	private void mouseOper(MouseEvent e) {
		int i =e.getButton();
		if(i == MouseEvent.BUTTON1)
			System.out.println("按下的是鼠标左键");
		else if(i == MouseEvent.BUTTON2)
			System.out.println("按下的是鼠标滚轮");
		else if(i == MouseEvent.BUTTON3)
		 System.out.println("按下的是鼠标右键");
	}

	public MouseEventDemo() {
		super(); // 继承父类的构造方法
		setTitle("鼠标事件示例"); // 设置窗体的标题
		setBounds(100, 100, 500, 375); // 设置窗体的显示位置及大小
		// 设置窗体关闭按钮的动作为退出
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		final JLabel label = new JLabel();
		label.addMouseListener(new MouseListener() {
				public void mouseEntered(MouseEvent e) {
					System.out.println("光标移入组件");
				}
				public void mousePresser(MouseEvent e) {
					System.out.println("鼠标按键被按下， ");
					mouseOper(e);
				}
				public void mouseReleased(MouseEvent e) {
					System.out.println("鼠标按键被释放， ");
					mouseOper(e);
				}
				public void mouseClicked(MouseEvent e) {
					System.out.println("单击了鼠标按键， ");
					mouseOper(e);
					int clickCount = e.getClickCount();
					System.out.println("单击次数为"+clickCount+"下");
				}
				public void mouseExited(MouseEvent e) {
					System.out.println("光标移出了组件");
				}
				@Override
				public void mousePressed(MouseEvent e) {
					// TODO Auto-generated method stub
					
				}
			
		});
		getContentPane().add(label, BorderLayout.CENTER);
	}

}

运行结果：