第十八章 Swing 概述

18.1.概述

Swing是用于开发桌面窗口程序的

          主要用来开发GUI程序

GUI是应用程序提供给用户操作的图形界面，包括窗口，菜单，按钮等图形界面元素。我们经常使

用的QQ等都是GUI程序

Swing组件是完全由JAVA语言编写的组件，

因为JAVA语言不依赖于本地平台及操作系统，所以swing组件可以被应用于任何平台

在Swing包的层次结构和基层关系中，比较重要的类是Component类(组件类)，Container类(容器类)和JComponent类(Swing组件父类)

继承关系如下：

常用的 Swing 组件：

18.2 Swing 常用窗体  

18.2.1 JFrame 窗体

开发Swing程序的流程可以被简单的概括为：

• 通过继承javax.swing.JFrame类创建一个窗体
• 然后向这个窗体中添加组件
• 最后为添加的组件设置监听事件

JFrame类的常用构造方法包括以下两种类型：

public JFrame:创建一个初始不可见，没有标题的窗体

public JFeame(String title):创建一个不可见具有标题的窗体

创建窗体后，要对窗体进行设置，如设置窗体的位置大小是否可见。这JFrame类提供了相应的方法：

SetBounds (int x, int y ,int width, int leight):设置窗体左上角在屏幕中的坐标为(x,y),窗体的宽度为width窗体的高度为height

SetLocation(int x,int y):设置窗体左上角在屏幕中的坐标为(x,y)

SetSize(int width, int leight）：设置窗体的宽度为width，高度为height

setVisibale(booleam b):设置窗体是否可见。为true时表示可见;b为false时表示不可见

SetDefaultCloseOperation(int operation):设置窗体的关闭方式，默认值为DISPOSE_ON_CLOSE

例题18.1：

package 十八;

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

public class JFreamTest {
    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);        //设置宽高
        jf.setLocation(320,240);        //设置窗体在主屏的位置
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);     //关闭窗体则停止运行
        jf.setVisible(true);            //让窗体显示
    }
}

 

18.2.2 JDialog 对话框 

JDialog对话框继承了JAVA.awt.Dialog类，其功能，是从一个窗体中弹出另一个窗体

 常用构造方法如下：

Public JDialog():创建一个没有标题和父窗口的对话框

Public JDialog(Frame f):创建一个没有标题，但指定父窗口的对话框

Public JDialog(Frame f , booleam model):创建一个没有标题，但指定父窗体和模式的对话框，如果model为true，那么弹出对话框后，用户无法操作父窗体

Public JDialog(Frame f , String title):创建一个指定标题和父窗体的对话框

Public JDialog(Frame f, String title , boolean model):创建一个指定标题，父窗体和模式的对话框

例题18.2 ：

package 十八;

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

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);			//设置对话框窗体在桌面显示的坐标和大小
    }
}

class MyFrame extends JFrame{				//自定义窗体类，继承 JDialog
    public MyFrame(){
        Container container = getContentPane();
        container.setLayout(null);			//容器使用绝对布局
        JButton bl = new JButton("弹出对话框");		//创建一个按钮
        bl.setBounds(10,10,100,21);
        bl.addActionListener(new ActionListener() {		//为按钮添加单击事件
            @Override	
            public void actionPerformed(ActionEvent e) {		//单击事件触发的方法
                MyJDialog dialog = new MyJDialog(MyFrame.this);		//创建 MyJDialo 对话框
                dialog.setVisible(true);					//使对话框可见
            }
        });
        container.add(bl);			//将按钮添加到容器中
        setSize(200,200);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setVisible(true);
    }

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

18.2.3 JOptionPane小型对话框

Java API中的Javax.swing.JOPtionPane类是一个非常简便的小型对话框, 用于创建对话框的方法都是静态方法，无需创建对象即可弹出

1.自定义对话框

这个对话框可以说是一块白板，开发者可以自定义对话框显示内容，方法：

public static int showOptionDialog(Component parentCponent,
    Object message,
    String title,
    int optionType,
    int messageType,
    Icon icon,
    Object[] options,
    Object initialValue)

参数说明如下：

        parentComponent：指明对话框在哪个窗体上显示，如果传入具体的窗体对象，对话框会在该窗体居中位置显示，如果传入null则在屏幕中间弹出对话框。
        message：提示的信息。
        title：对话框的标题。
        optionType：指定可用于对话框的选项的整数：DEFAULT_OPTION、YES NO_OPTION.YES NO_CANCEL_OPTION 或 OK_CANCEL_OPTION。
        messageType：指定消息种类的整数，主要用于确定来自可插入外观的图标ERRORMESSAGE、INFORMATION_MESSAGE、WARNING_MESSAGE、QUESTION_MESSAGE 或 PLAIN_MESSAGE。
        icon：在对话框中显示的图标。
        options：指示用户可能选择的对象组成的数组。如果对象是组件，则可以正确呈现，非String对象使用其toString方法呈现；如果此参数为null，则由外观确定选项。
        initialValue：表示对话框的默认选择的对象，只有在使用options 时才有意义，可以为null。

例题18.3 ：

package 十八;

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

 

2.确认框 

• 调出带有选项 Yes、No 和Cancel的对话框；标题为 Select an Option。

static int showConfirmDialog(Component parentComponent, Object message)

• 调出一个由optionType参数确定其中选项数的对话框。

static int showConfirmDialog(Component parentComponent, Object message, String title, int optionType)

• 调用一个由optionType参数确定其中选项数的对话框，messageType参数确定要显示的图标。

static int showConfirmDialog(Component parentComponent,

        Object message,

        String title,

        int optionType,

        int messageType)

• 调出一个带有指定图标的对话框，其中的选项数由optionType 参数确定。

static int showConfirmDialog(Component parentComponent,

        Object message,

        String title,

        int optionType,

        int messageType,

        Icon icon)

例题：18.4

package 十八;

import javax.swing.JOptionPane;

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

3.输入框 

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

• 显示请求用户输入内容的问题消息对话框，它以parentComponent为父级。

static String showlnputDialog(Component parentComponent, Object message)

• 显示请求用户输入内容的问题消息对话框，它以parentComponent为父级。

static String showlnputDialog(Component parentComponent, Object message, Object initialSelectionValue)

• 显示请求用户输入内容的对话框，它以parentComponent为父级，该对话框的标题为title，消息类型为messageType。

static String showlnputDialog(Component parentComponent, Object message, String title, int messageType)

• 提示用户在可以指定初始选择、可能选择及其他所有选项的模块化的对话框中输入内容。

static Object showInputDialog(Component parentComponent,

    Object message,

    String title,

    int messageType,

    Icon icon,

    Objectü selectionValues,

    Object initialSelectionValue)

• 显示请求用户输入的问题消息对话框。

static String showInputDialog(Object message)

• 显示请求用户输入的问题消息对话框，它带有已初始化为initialSelectionValue的输入值。

static String showInputDialog(Object message, Object initialSelectionValue)

例题18.5：

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

4.通知框 

创建通知框方法有以下几种重载形式：

• 调出标题为Message的信息消息对话框。

static void showMessageDialog(Component parentComponent, Object message)

• 调出对话框，它显示使用由messageType 参数确定的默认图标的message。

static void showMessageDialog(Component parentComponent,

    Object message,

    String title,

    int messageType)

• 调出一个显示信息的对话框，为其指定了所有参数。

static void showMessageDialog(Component parentComponent,

    Object message,

    String title,

    int messageType,

    Icon icon)

例题18.6：

package 十八;

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

 18.3 常用布局管理器

开发Swing程序时，在容器中使用布局管理器能够设置窗体的布局，进而控制Swing组件的位置和大小。

常用布局管理器为绝对布局管理器; 流布局管理器; 边界布局管理器; 和网络布局管理器

18.3.1 null绝对布局

绝对布局，也叫null布局，其特点是硬性指定组件在容器中的位置和大小; 组件的位置通过绝对坐标的方法来指定

例题18.7：

package 十八;

import java.awt.Container;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.WindowConstants;
 
public class AbsoultePosition extends JFrame{
	public AbsoultePosition() {
		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 AbsoultePosition();
	}
}

18.3.2  FlowLayout流布局管理器

FlowLayout流布局管理器是Swing中最基本的布局管理器，

使用流布局管理器摆放组件时，组件被从左到右摆放，

当组件占据了当前行的所有空间时，溢出的组件会被移动到当前行的下一行

默认情况下，行组件的排列方式被指定为居中对齐，但是通过设置可以更改一行组件的排列方式

FlowLayout类具有以下常用的构造方法

1. public FlowLayout()
2. public FlowLayout(int alignment)
3. public FlowLayout(int alignment ，int horizGap，int vertGap)

 构造方法中的alignment参数表示，使用流布局管理器时，每一行组件的排列方式如下表：

18.8 例题： 

package 十八;

import java.awt.*;
import javax.swing.*;
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++){		//在容器中循环添加10个按钮
			c.add(new JButton("button" + i));
		}
			setSize(300,200);			//设置窗体大小
			setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); //关闭窗体则停止程序
			setVisible(true);			//设置窗体可见
	}
	public static void main(String[] args){
		new FlowLayoutPosition();
	}
}

18.3.3 BorderLayout 边界布局管理器 

使用Swing创建窗体后，容器默认的布局管理器是边界布局管理器，边界布局管理器，把容器划分为东南西北中五个区域

BorderLayout类中的成员变量及其说明如下表所示

如果使用了边界布局管理器，在向容器中添加组件时，如果不指定要把组件添加到哪个区域，那么当前组件会被默认添加到CENTER区域，如果向同一区域中添加多个组件，那么后放入的组件会覆盖先放入的组件见 

 add（）方法被用于实现向容器中添加组件的功能，它可以设置组件的摆放位置，常用语法格式如下：

public void add(Component comp,Object constraints)

• comp:被添加的组件
• constraints：被添加组件的布局约束对象

例题18.9 

package 十八;

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

public class BorderLayoutPosition extends JFrame {
    public BorderLayoutPosition(){
        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 BorderLayoutPosition();
    }
}

 

18.3.4 GridLayout 网格布局管理器

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

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

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

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

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

例题18.10 ：

package 十八;

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

public class GridLayoutPosition extends JFrame {
    public GridLayoutPosition(){
        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 GridLayoutPosition();
    }
}

 

18.4 常用面板 

在Swing程序设计中，面板是一个容器，被用于容纳其他组件，但面板必须被添加到其他容器中。Swing中常用的面板包括JPanel面板和JScrollpane面板

18.4.1 JPanel 面板

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

例题18.11

package 十八;

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

public class JPanelTest extends JFrame {
    public JPanelTest(){
        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());
        //初始化一个面板，此面板使用 1 行 2 列的网格布局，组件水平间隔 10 像素，垂直间隔 10 像素
        JPanel p3 = new JPanel(new GridLayout(1,2,10,10));
        //初始化一个面板，此面板使用 2 行 1 列的网格布局，组件水平间隔 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"));
        //
        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.CENTER);
        //
        p3.add(new JButton("b3"));
        p3.add(new JButton("b3"));
        //
        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) {
        JPanelTest test = new JPanelTest();
        test.setVisible(true);
    }
}

18.4.2 JScrollPane滚动面板

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

例题18.12

package 十八;

import java.awt.Container;
 
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.WindowConstants;
 
public class JScrollPaneTest extends JFrame {
	public JScrollPaneTest() {
		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) {
		JScrollPaneTest test = new JScrollPaneTest();
		test.setVisible(true);
 
	}
}

18.5 文字标签组件与图标

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

 18.5.1 JLabrl标签

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

• public JLabel0：创建一个不带图标或文本的标签。
• public JLabel(Icon icon)：创建一个带图标的标签。
• public JLabel(Icon icon, int aligment)：创建一个带图标的标签，并设置图标的水平对齐方式。
• public JLabel(String text, int aligment)：创建一个带文本的标签，并设置文本的水平对齐方式。
• public JLabel(String text, Icon icon, int aligment)：创建一个带文本和图标的JLabel对象，并设置文本和图标的水平对齐方式。

例题18.13 

package 十八;

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 jI= new JLabel("这是一个 JFrame 窗体");					//创建标签
		container.add(jI);											//将标签添加到容器中
		setSize(200, 100);											//设置窗体大小
		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);	//设置窗体关闭模式
		setVisible(true);											//使窗体可见
	}
public static void main(String args[]){
	new JLabelTest();
	}
}

18.5.2 图标的使用 

在Swing 程序设计中，图标经常被添加到标签、按钮等组件，使用javax.swing.Imagelcon类可以依据现有的图片创建图标。ImageIcon类实现了Icon接口，它有多个构造方法，常用的如下：

• public ImagelconO：创建一个 Imagelcon 对象，创建 ImageIcon对象后，使用其调用 setImage(Image image）方法设置图片。
• public Imagelcon(Image image)：依据现有的图片创建图标。
• public ImageIcon(URL url)：依据现有图片的路径创建图标。

例题18.14 

package 十八;

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

public class Mylmagelcon extends JFrame {
    public Mylmagelcon(){
        Container container = getContentPane();
        JLabel jl = new JLabel("这是一个 JFrame 窗体");
        URL url = Mylmagelcon.class.getResource("pic.png");
        Icon icon = new ImageIcon(url);
        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 Mylmagelcon();
    }
}

18.6 按钮组件

18.6.1 JButton 按钮

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

• public JButtonO：创建一个不带文本或图标的按钮。
• public JButton(String text)：创建一个带文本的按钮。
• public JButton(Icon icon)：创建一个带图标的按钮。
• public JButton(String text, Icon icon)：创建一个带文本和图标的按钮。
• 创建JButon 对象后，如果要对JButton 对象进行设置，那么可以使用JButton类提供的方法。

JButton 类的常用方法及其说明如表18.6所示：

例题18.15 

package 十八;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class JButtonTest extends JFrame {
	public JButtonTest(){
		Icon icon = new ImageIcon("src/pic.jpg");			//获取图片文件
		setLayout(new GridLayout(3, 2, 5, 5));				//设置网格布局管理器
		Container c = getContentPane();						//获取主容器
		JButton btn[]=new JButton[6];						//创建按钮数组
		for (int i= 0; i< btn.length; i++){
			btn[i]= new JButton();							//实例化数组中的对象
			c.add(btn[i]);									//将按钮添加到容器中
		}
		btn[0].setText("不可用");
		btn[0].setEnabled(false);							//设置按钮不可用
		btn[1].setText("有背景色");
		btn[1].setBackground(Color.YELLOW);
		btn[2].setText("无边框");
		btn[2].setBorderPainted(false);						//设置按钮边框不显示
		btn[3].setText("有边框");
		btn[3].setBorder(BorderFactory.createLineBorder(Color.RED));	//添加红色线型边框
		btn[4].setIcon(icon);								//为按钮设置图标
		btn[4].setToolTipText("图片按钮");						//设置鼠标悬停时提示的文字
		btn[5].setText("可点击");
		btn[5].addActionListener(new ActionListener(){		//为按钮添加监听事件
		public void actionPerformed(ActionEvent e){
			JOptionPane.showMessageDialog(JButtonTest.this,"点击按钮");	//出确认对话框
			}
		});
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		setVisible(true);
		setTitle("创建不同样式的按钮");
		setBounds(100, 100, 400,200);
	}
		public static void main(String[] args){
			new JButtonTest();
		}
}

 

18.6.2 JRadinButton 单选按钮 

1.单选按钮

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

• public JRadioButton()：创建一个未被选中、文本未被设定的单选按钮。
• public JRadioButton(Icon icon）：创建一个未被选中、文本未被设定，但具有指定图标的单选按钮。
• public JRadioButton(Icon icon, boolean selected)：创建一个具有指定图标、选择状态，但文本区未被设定的单选按钮。
• public JRadioButton(String text)：创建一个具有指定文本，但未被选中的单选按钮。
• public JRadioButton(String text， Icon icon)：创建一个具有指定文本、指定图标，但未被选中的
• 单选按钮。
• public JRadioButton(String text, Icon icon, boolean selected)：创建一个具有指定的文本、指定图标和选择状态的单选按钮。

根据上述构造方法的相关介绍，不难发现，单选按钮的图标、文本和选择状态等属性能够被同时设定。例如，使用JRadioButton 类的构造方法创建一个文本为“选项 A”的单选按钮，关键代码如下：

JRadioButton rbtn = new JRadioButton("选项 A");

2.按钮组

Swing 按钮组由 ButtonGroup对象表示，多个单选按钮被添加到按钮组后，能够实现“选项有多个,

但只能选中一个”的效果。ButtonGroup 对象被创建后，可以使用addO方法把多个单选按钮添加到

ButtonGroup对象中。例题18.16

package 十八;

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 lblNewLabel = new JLabel("请选择性别");
        lblNewLabel.setBounds(5,5,120,15);
        getContentPane().add(lblNewLabel);
        JRadioButton rbtnNormal = new JRadioButton("男");
        rbtnNormal.setSelected(true);
        rbtnNormal.setBounds(40,30,75,22);
        getContentPane().add(rbtnNormal);
        JRadioButton rbtnPed = new JRadioButton("女");
        rbtnPed.setBounds(120,30,75,22);
        getContentPane().add(rbtnPed);
        ButtonGroup group = new ButtonGroup();
        group.add(rbtnNormal);
        group.add(rbtnPed);
    }

    public static void main(String[] args) {
        RadioButtonTest frame = new RadioButtonTest();
        frame.setVisible(true);
    }
}

18.6.3 JCheckBox 复选框 

JCheckBox的常用构造方法如下:

• public JCheckBox()：创建一个文本、图标未被设定且默认未被选中的复选框。
• public JCheckBox(Icon icon, Boolean checked)：创建一个具有指定图标、指定初始时是否被选中，但文本未被设定的复选框。
• public JCheckBox(String text, Boolean checked)：创建一个具有指定文本、指定初始时是否被选中，但图标未被设定的复选框。

例题18.17

package 十八;

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;
import javax.swing.WindowConstants;
import javax.swing.event.AncestorListener;
 
public class CheckBoxTest extends JFrame{
	public CheckBoxTest() {
		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 CheckBoxTest();
 
	}
 
}

18.7 列表组件 

18.7.1 JComboBox 下拉列表框

JComboBox 类的常用构造方法如下：

• public JComboBox(ComboBoxModeldataModel)：创建一个 JComboBox对象，下拉列表中的列表项使用ComboBoxModel中的列表项，ComboBoxModel 是一个用于组合框的数据模型。
• public JComboBox(Object[]arrayData)：创建一个包含指定数组中的元素的JComboBox对象。
• public JComboBox(Vector vector):创建一个包含指定 Vector 对象中的元素的JComboBox 对象.Voetor对象中的元素可以通过整数索引进行访问，而且 Vector 对象中的元素可以根据需求被添加或者移除。

JComboBox类的常用方法及其说明如表18.7所示。

例题18.18 

import java.awt.event.*;
import javax.swing.*;
public class JComboBoxTest extends JFrame{
	public JComboBoxTest() {
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setTitle("下拉列表框的使用");
		setBounds(100, 100, 317,147);
		getContentPane().setLayout(null);							//设置绝对布局
		JLabel IbINewLabel= new JLabel("请选择证件：");					//设置坐标
		IbINewLabel.setBounds(28, 14, 80, 15);						//为下拉列表中添加项
		getContentPane().add(IbINewLabel);
		JComboBox<String> comboBox = new JComboBox<String>();		//创建一个下拉列表框
		comboBox.setBounds(110, 11, 80,21);
		comboBox.addItem("军人证");
		comboBox.addItem("身份证");
		comboBox.addItem("学生证");
		comboBox.addItem("工作证");
		comboBox.setEditable(true);
		getContentPane().add(comboBox);								//将下拉列表添加到容器中
		JLabel IblResult = new JLabel("");
		IblResult.setBounds(0, 57, 146, 15);
		getContentPane().add(IblResult);
		JButton btnNewButton= new JButton("确定");
		btnNewButton.setBounds(200,10, 67, 23);
		getContentPane().add(btnNewButton);
		btnNewButton.addActionListener(new ActionListener() {		//为按钮添加监听事件
			@Override
			public void actionPerformed(ActionEvent argo){
				//获取下拉列表中的选中项
				IblResult.setText("您选择的是："+comboBox.getSelectedItem());
			}
		});
	}
	public static void main(String[] args){
		JComboBoxTest frame = new JComboBoxTest();					//创建窗体对象
		frame.setVisible(true);										//使窗体可见
	}
}//例题18.18

 

 18.19 JList 列表框 

JList类的常用构造方法如下：

• public void JList()：创建一个空的JList对象。
• public void JList(Object[] listData)：创建一个显示指定数组中的元素的JList对象。
• public void JList(Vector listData)：创建一个显示指定 Vector 中的元素的JList对象。
• public void JList(ListModel dataModel)：创建一个显示指定的非 null模型的元素的JList对象。

例题18.19

package 十八;

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

public class JListTest extends JFrame {
    public JListTest(){
        Container cp = getContentPane();
        cp.setLayout(null);
        //
        String[] contebts = {"列表1","列表2","列表3","列表4","列表5","列表6"};
        JList<String> jl = new JList<>(contebts);
        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 btnNewButton = new JButton("确认");
        btnNewButton.setBounds(120,96,71,23);
        cp.add(btnNewButton);
        btnNewButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //
                java.util.List<String> values = jl.getSelectedValuesList();
                area.setText("");
                for (String value : values){
                    area.append(value + "\n");
                }
            }
        });
        setTitle("在这个窗体中使用了列表框");
        setSize(217,167);
        setVisible(true);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }

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

18.8 文本组件 

18.8.1 JTextField文本框

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

• public JTextFieldO：创建一个文本未被指定的文本框。
• public JTextField(String text)：创建一个指定文本的文本框。
• public JTextField(int fieldwidth)：创建一个指定列宽的文本框。
• public JTextField(String text, int fieldwidth)：创建一个指定文本和列宽的文本框。
• public JTextField(Document docModel, String text, int fieldWidth)：创建一个指定文本模型、本内容和列宽的文本框。

如果要为一个文本未被指定的文本框设置文本内容，那么需要使用 setTextO方法。setText0方法的语法如下：

public void setText(String t)

其中，t表示文本框要显示的文本内容。

例题18.20

package 十八;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
 
public class JTextFieldTest extends JFrame{
	public JTextFieldTest() {
		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 arg0) {
				jt.setText("触发事件");					//设置文本框中的值
			}
		});
		jb.addActionListener(new ActionListener() {		//为按钮添加事件
			public void actionPerformed(ActionEvent arg0) {
				System.out.println(jt.getText());		//输出当前文本框的值
				jt.setText("");							//将文本框置空
				jt.requestFocus();						//焦点回到文本框
			}
		});
		c.add(jt);										//窗体容器添加文本框
		c.add(jb);										//窗体添加按钮
		setBounds(100,100,250,110);
		setVisible(true);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
	}
 
	public static void main(String[] args) {
		new JTextFieldTest();
 
	}
 
}

 18.8.2 JPasswordField 密码框

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

• public JPasswordFieldO：创建一个文本未被指定的密码框。
• public JPasswordFiled(String text)：创建一个指定文本的密码框。
• public JPasswordField(int fieldwidth)：创建一个指定列宽的密码框。
• public JPasswordField(String text, int fieldwidth)：创建一个指定文本和列宽的密码框。
• public JPasswordField(Document docModel, String text, int fieldWidth)：创建一个指定文本模型和列宽的密码框。

JPasswordField 类提供了setEchoCharO方法，这个方法被用于改变密码框的回显字符。setEchoCharO方法的语法如下：

public void setEchoChar(char c)

其中，c表示密码框要显示的回显字符

18.8.3 JTextArea 文本域

文本城组件曲 JTextArea 对象表示，其作用是接受用户的多行文本输入。JTextArea类的常用构造方法如下：

•  patie TextArea0：创建一个文本未被指定的文本域。
• publie NTtextArea(String text)：创建一个指定文本的文本域。
• pabic leatAesfint rows,int columns)：创建一个指定行高和列宽，但文本未被指定的文本域。
• public JTextArea(Document doc)： 创建一个指定文档模型的文本域。
• public JTextArea(Document doc,String Text,int rows,int columns)：创建内容以及行高和列宽的文本域。

例题18.21

package 十八;

import java.awt.*;
import javax.swing.*;
public class JTextAreaTest extends JFrame {
	public JTextAreaTest(){
		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 JTextAreaTest();
	}
}

18.9 表格组件

18.9.1 创建表格

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

构造方法的语法如下：

JTable(Object[][] rowData, Objectl columnNames)

• rowData：存储表格数据的二维数组。
• columnNames：存储表格列名的一维数组。
   

例题18.22 

package 十八;

import java.awt.*;
import javax.swing.*;
public class JTableDemo extends JFrame {
	public static void main(String args[]) {
		JTableDemo frame = new JTableDemo();
		frame.setVisible(true);
	}
	public JTableDemo(){
		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);
	}
}

18.9.2 DefaultTableModel 表格数据模型

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

• public int getRowCountO);
• public int getColumnCountO);
• public Object getValueAt(int rowIndex, int columnIndex);

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

例题18.23

package 十八;

import java.awt.*;
import javax.swing.*;
import javax.swing.table.*;
public class SortingTable extends JFrame {
	private static final long seriaIVersionUID= 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);
	}
}

 

18.9.3 维护表格模型

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

1. 使用getValueAt（）方法获得表格中某一个单元格的值，
2. 使用addRow（）方法向表格中添加新的行
3. 使用setValueAt方法修改表格中某一个单元格的值
4. 使用removeRow方法从表格中删除指定行等

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

例题18.24

package 十八;

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableRowSorter;
import javax.swing.tree.DefaultTreeModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Objects;

public class AddAndDeleteDemo extends JFrame {
    private DefaultTableModel tableModel;
    private JTable table;
    private JTextField aTextField;
    private JTextField bTextField;

    public static void main(String[] args) {
        AddAndDeleteDemo frame = new AddAndDeleteDemo();
        frame.setVisible(true);
    }

    public AddAndDeleteDemo(){
        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_SELECTION);
        //
        table.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                int selectedRow = table.getSelectedRow();
                //
                Object oa = tableModel.getValueAt(selectedRow,0);
                //
                Object ob = tableModel.getValueAt(selectedRow,1);
                aTextField.setText(oa.toString());
                bTextField.setText(ob.toString());
            }
        });
        scrollPane.setViewportView(table);
        JPanel panel = new JPanel();
        getContentPane().add(panel,BorderLayout.SOUTH);
        panel.add(new JLabel("A："));
        aTextField = new JTextField("A4",10);
        panel.add(aTextField);
        panel.add(new JLabel("B："));
        bTextField = new JTextField("B4",10);
        panel.add(bTextField);
        JButton addButton = new JButton("添加");
        addButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String[] rowValuer = {aTextField.getText(),
                        bTextField.getText()};
                tableModel.addRow(rowValuer);//向表格模型中添加一行
                int rowCount = table.getRowCount()+ 1;
                aTextField.setText("A" + rowCount);
                bTextField.setText("B" + rowCount);
            }
        });
        panel.add(addButton);
        JButton updButton = new JButton("修改");
        updButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                int selectedRow = table.getSelectedRow();
                if (selectedRow != -1){
                    //
                    tableModel.setValueAt(aTextField.getText(),selectedRow,0);
                    //
                    tableModel.setValueAt(aTextField.getText(),selectedRow,1);
                }
            }
        });
        panel.add(updButton);
        JButton delButton = new JButton("删除");
        delButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                int selectedRow = table.getSelectedRow();
                if (selectedRow != -1){
                    tableModel.removeRow(selectedRow);
                }
            }
        });
        panel.add(delButton);
    }
}

 18.10 事件监听器 

18.10.1 ActionEvent 动作事件

动作时间（）ActionEvent监听器是Swing中比较常用的事件监听器，很多组件的动作都会使用它监听，例如按钮被单击等。

例题18.25  

package 十八;

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

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(new jbAction());
        setVisible(true);
    }

    class jbAction implements ActionListener{
        public void actionPerformed(ActionEvent arg0){
            jb.setText("我被点击了");
        }
    }

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

18.10.2 KeyEvent 键盘事件 

        当向文本框中输入内容时，将发生键盘事件。KeyEvent类负责捕获键盘事件，可以通过为组件添加实现了KeyListener接口的监听器类来处理相应的键盘事件。
        KeyListener接口共有三个抽象方法，分别在发生击键事件（按下并释放键）、按键被按下（手指按下键但不松开）和按键被释放（手指从按下的键松开）时被触发，具体如下：

public interface KeyListener extends EventListener {

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

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

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

 例题18.26 

package 十八;

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对象，用来表示释放键的颜色1

	ArrayList<JButton> btns = new ArrayList<JButton>();// 定义一个集合，用来存储所有的按键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);
		
	}
}

18.10.3 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.27：

package 十八;

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() {
            @Override
            public void mouseEntered(MouseEvent e) {        //光标移入组件时被触发
                System.out.println("光标移入组件");
            }

            @Override
            public void mousePressed(MouseEvent e) {        //鼠标按键被按下时被触发
                System.out.print("鼠标按键被按下, ");
                mouseOper(e);
            }

            @Override
            public void mouseReleased(MouseEvent e) {       //鼠标按键被释放时被触发
                System.out.print("鼠标按键被释放, ");
                mouseOper(e);
            }

            @Override
            public void mouseClicked(MouseEvent e) {        //单击了鼠标按健时被触发
                System.out.print("单击了鼠标按健, ");
                mouseOper(e);
                int clickCount = e.getClickCount();         //获取鼠标单击次数
                System.out.println("单击次数为" + clickCount + "下");
            }

            @Override
            public void mouseExited(MouseEvent e) {         //光标移出组件时被触发
                System.out.println("光标移出组件");
            }
        });
        getContentPane().add(label, BorderLayout.CENTER);
    }

}