java第十八章Swing程序设计

最新推荐文章于 2023-12-12 09:54:00 发布

y3068664188

最新推荐文章于 2023-12-12 09:54:00 发布

阅读量168

点赞数

文章标签： java python 开发语言

本文链接：https://blog.csdn.net/y3068664188/article/details/134324486

版权

概述

Swing是用于开发桌面窗口程序主要用来开发GUI程序GUI是应用程序提供给用户操作的图形界面，包括窗口，菜单，按钮等图形界面元素。我们经常使用的QQ等都是GUI程序Swing组件是完全由JAVA语言编写的组件，因为JAVA语言不依赖于本地平台及操作系统，所以swing组件可以被应用于任何平台在Swing包的层次结构和基层关系中，比较重要的类是Component类(组件类)，Container类(容器类)和JComponent类(Swing组件父类)

继承关系如下：

Swing的特点

AWT 风格统一依赖操作系统

Swing 风格不统一不依赖操作系统
java.awt

Swing常用组件

组件类名   组件名称   重要组件
JButton   普通按钮   ——
JCheckBox   复选框、复选按钮   ——
JColorChooser   颜色选择器
JComboBox   下拉列表框   ——
JDesktopPane 桌面面板

JInternalFrame 桌面面板内部的窗体

JDialog   对话框窗体
JEditorPane   可编辑的富文本面板
JFileChooser   文件选择器、文件选择对话框
JFrame   窗体   ——
JLabel   标签   ——
JList   列表框
JMenuBar 菜单栏

JMenu    菜单

JMenuItem     菜单项

JOptionPane   小型弹出式对话框   ——
JPanel   面板   ——
JPasswordField   密码输入框   ——
JPopupMenu   鼠标菜单
JProgressBar   进度条
JRadioButton   单选按钮
JScrollPane   滚动面板   ——
JSlider   滑动条
JSpinner   微调输入框
JSplitPane   分割面板
JTabbedPane   选项卡面板
JTable   表格
JTextArea   文本域   ——
JTextField   文本输入框   ——
JToggleButton   可显示选中状态的按钮
JToolBar   工具栏
JTree   树状菜单
JWindow   无边框窗体
SystemTray   系统托盘
Swing 常用窗体
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

java语言提供了多种窗体的关闭方式，常用的有四种,如下表所示

窗体关闭方式   实现功能
DO_NOTHING_ON_CLOSE   关闭窗体时，不触发任何操作
DISPOSE_ON_CLOSE   关闭窗体时，释放窗体资源窗体会消失但程序不停止
HIDE_ON_CLOSE   关闭窗体时，仅隐藏窗体，不释放资源
EXIT_ON_CLOSE   关闭窗体时，释放窗体资源并关闭程序

例题18.1
package LX;

import java.awt.Container;

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

public class JFreamTest18_1 {

   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);                               //让窗体展现出来
   }

}

结果：

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 LX;

import java.awt.Container;
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;

public class MyJDialog18_2 extends JDialog{//自定义对话框类，继承JDialog类
   public MyJDialog18_2(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) {//单击事件触发的方法
                   MyJDialog18_2 dialog=new MyJDialog18_2(MyFrame.this);//创建MyJDialog对话框
                   dialog.setVisible(true);//使对话框可见
               }
           });
           container.add(bl);//将按钮添加到容器中
           setSize(200,200);//窗体的宽高
           setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//关闭窗体则停止程序
           setVisible(true);//使窗体可见

       }

}

结果：

JOptionPane小型对话框

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

提供了四种创建对话框的方法:

方法   描述
showConfirmDialog()   确认框，询问一个确认问题，如yes/no/cancel
showInputDialog()   输入框，可以让用户向程序输入某些值
showMessageDialog()   通知框，告知用户某事已发生
showOptionDialog()   自定义对话框，集合了上述3种对话框的全部功能

例题18.3
package LX;

import javax.swing.JButton;
import javax.swing.JOptionPane;
import javax.swing.Icon;
import javax.swing.ImageIcon;

public class Demo18_3 {

   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);
   }

}

结果：

确认框

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

例题18.4
package LX;
import javax.swing.JOptionPane;
public class Demo18_4 {

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

   }

}

结果：

如果只想弹出是或否两个按钮，可以使用JOptionPane.YES_NO_OPTION 类型

输入框

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

例题18.5
package LX;
import javax.swing.JOptionPane;

public class Demo18_5 {

   public static void main(String[] args) {
       String name=JOptionPane.showInputDialog(null,"请输入您的姓名");

   }

}

结果：

通知框

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

例题18.6
package LX;

import javax.swing.JOptionPane;

public class Demo18_6 {

   public static void main(String[] args) {
       JOptionPane.showInputDialog(null,
               "您与服务器断开了链接","发生错误",
               JOptionPane.ERROR_MESSAGE);

   }

}

结果：

常用布局管理器

开发Swing程序时，在容器中使用布局管理器能够设置窗体的布局，进而控制Swing组件的位置和大小。常用布局管理器为绝对布局管理器; 流布局管理器; 边界布局管理器; 和网络布局管理器

null绝对布局

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

例题18.7
package LX;
   import java.awt.Container;
   import javax.swing.JButton;
   import javax.swing.JFrame;
   import javax.swing.WindowConstants;

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

}

结果：

FlowLayout流布局管理器

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

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

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

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

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

public FlowLayout()

public FlowLayout(int alignment)

public FlowLayout(int alignment ，int horizGap，int vertGap)

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

例题18.8
package LX;

import java.awt.Container;
import java.awt.FlowLayout;

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

public class FLP extends JFrame{
   public FLP() {
       setTitle("本窗体使用流布局管理器");//设置窗体标题
       Container c=getContentPane();

           //窗体使用流布局组件右对齐组件之间的水平间隔为十像素垂直间隔为十像素

       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 FLP();


   }

}

结果：

BorderLayout边界布局管理器

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

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

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

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

public void add(Component comp,Object constraints)

comp:被添加的组件

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

例题18.9
package LX;

import java.awt.BorderLayout;
import java.awt.Container;

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

public class BLP18_9 extends JFrame{
   public BLP18_9() {
       setTitle("这个窗口使用边界布局管理器");
       Container c=getContentPane();//获取主容器

       setLayout(new BorderLayout());//容器使用边界布局
       JButton Z=new JButton("中");
       JButton B=new JButton("北");
       JButton X=new JButton("西");
       JButton N=new JButton("南");
       JButton D=new JButton("东");
       c.add(Z,BorderLayout.CENTER);//中部添加按钮
       c.add(D,BorderLayout.NORTH);//东部添加按钮
       c.add(X,BorderLayout.SOUTH);//西部添加按钮
       c.add(N,BorderLayout.WEST);//南部添加按钮
       c.add(B,BorderLayout.EAST);//北部添加按钮
       setSize(350,200);//设置窗体大小
       setVisible(true);//设置窗体可见
       setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);//关闭窗体则停止程序

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

   }

}

结果：

GridLayout 网格布局管理器

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

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

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

public GridLayout(int rows， int columns)

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

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

例题18.10
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();

   }

}

结果;

常用面板

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

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

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

例题18.11
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面板添加到滚动面板

例题18.12
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);

   }

}

结果：

文字标签组件与图标

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

JLabrl标签

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

例题18.13
package LX;

import java.awt.Container;

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

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

   }
}

结果：

图标的使用

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

例题18.14
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();

   }

}

结果：

按钮组件

在Swing程序设计中，按钮是较为常见的组件，被用于触发特定的动作提供了多种按钮，组件按钮，单选按钮，复选框等

JButto按钮

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

创建JButto对象后如果要JButto对象进行设置，那么可以使用JButto提供的方法，提供的方法如下表所示：

例题18.15
package LX;
   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 JT18_15 extends JFrame{
       public JT18_15(){
           Icon icon=new ImageIcon("");//获取图片文件
           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(JT18_15.this,"点击按钮");//弹出确认对话框
               }
           });
           setTitle("创建不同样式的按钮");
           setBounds(100,100,400,200);//设置窗体大小
           setVisible(true);//设置窗体可见
           setDefaultCloseOperation(EXIT_ON_CLOSE);//关闭窗体则停止程序
       }

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

结果：

JRadioButton单选按钮

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

单选按钮

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

按钮组

Swing按钮组由ButtonGroup对象表示，多个单选按钮被添加到按钮组后能够实现“选项有多个，但只能选中一个的效果”

对象被创建后可以使用add方法把多个单选按钮添加到对象中

例题18.16
package LX;

import javax.swing.*;
public class RBT18_16 extends JFrame{
       public RBT18_16() {
           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) {
       RBT18_16 frame = new RBT18_16();//创建窗体对象
           frame.setVisible(true);//使窗体可见

   }

}

结果：

JCheckBox复选框

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

例题18.17
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类的常用构造方法如下:

例题18.18
package LX;

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 JBT18_18 extends JFrame {
   public JBT18_18() {
       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);
       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);
       JButton btnNewButton= new JButton("确定");
       btnNewButton.setBounds(200,10,67,23);
       getContentPane().add(btnNewButton);
       btnNewButton.addActionListener(new ActionListener() {   //为按钮添加监听事件

           @Override
           public void actionPerformed(ActionEvent e) {
               // TODO Auto-generated method stub
               lblNewLabel.setText("你的选择的是:"+ comboBox.getSelectedItem());
           }

       });

   }

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       JBT18_18 frame = new JBT18_18();   //创建窗体对象
       frame.setVisible(true);//使窗体可见
   }

}

结果：

JList列表框

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

例题18.19
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<String> 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<String> 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常用构造方法如下:

例题18.20
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();
   }

}

结果：

JPasswordFoeld密码框

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

JTrxtArea文本域

文本域组件由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):

JTrxtArea类提供了一个setLineWrap（boolean wrap）方法，这个方法被用于设置文本域中的文本内容，是否可以自动换行。如果参数为true，那么会自动换行，否则不会自动换行
此外，还提供了一个append(String str)方法，这个方法被用于向文本域中添加文本内容

例题18.21
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，存储表格列明的一维数组

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

例题18.22
package LX;

import java.awt.BorderLayout;

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

public class JD18_22 extends JFrame {
   public static void main(String args[]) {
       JD18_22 frame = new JD18_22();
       frame.setVisible(true);
   }
   public JD18_22() {
       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接口定义了一个表格模型，AbstractDefaultTableModel抽象类实现了TableModel接口的大部分方法只有以下三个抽象方法没有实现：

为了实现使用表格模型，创建表格的功能swing提供了表格模型类，DefaultTableModel，DefaultTableModel常用构造方法如下：

例题18.23
package LX;
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 ST18_23 extends JFrame{
   private static final long serialversionUID=1L;
   public static void main(String[] args) {
       ST18_23 frame=new ST18_23();
       frame.setVisible(true);

   }
   public ST18_23() {
       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方法从表格中删除指定行等

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

例题18.24
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动作事件
是Swing中比较常用的事件监听器，很多组件都会使用它

动作事件监听器
事件名 ActionEvent
事件源 JButto、JList、JTextField等组件
JButto、JList、JTextField等组件监听接口 ActionListener
添加监听方法 addActionListener（）
删除监听方法 removeActionListener()

例题18.25

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.WindowConstants;

public class SE18_25 extends JFrame {
private JButton jb=new JButton("我是按钮，点击我");
public SE18_25() {
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 SE18_25();

}

}

结果：

KeyEvent键盘事件

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

KeyListener接口共有三个抽象方法

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

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

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

上述方法传入了 KeyEvent类的对象,KeyEvent类如下：

方法简介

getSource()   用来获得触发此次事件的组件对象，返回值为Object类
getKeyChar()     用来获得与此事件中的键相关联的字符
getKeyCode()     用来获得与此事件中的键相关联的整数ketCode
getKeyText(int keyCode)    用来获得描述的标签keyCode，如A，F1和HOME等
isActionKey()   用来查看此事件中的键是否为动作键
isControlDown()   用来查看Ctrl键在此次事件中是否被按下当返回true时，表示被按下
isAltDown()     用来查看Alt键在此次事件中是否被按下当返回true时，表示被按下
isShiftDewn()    用来查看Shift键在此次事件中是否被按下当返回true时，表示被按下
在KeyEvent类中，以“VK_”开头的静态常量代表各个按键的Code,可以通过这些静态常量可以判断事件中的按键，获得按键的标签

例题18.26

package LX;
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 a18_26 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对象，用来表示释放键的颜色
   Color red=Color.RED;

   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 {
                   a18_26 frame = new a18_26(); // 创建KeyBoard对象
                   frame.setVisible(true); // 使frame可视
                   frame.addButtons();// 初始化存储所有按键的集合
               } catch (Exception e) {
                   e.printStackTrace();
               }
           }
       });
   }

   /**
   * 创建JFrame窗体
   */
   public a18_26() { // 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(red);// 将指定按键颜色设置为白色
                   }
               }
           }
       });
       panel.add(textField, BorderLayout.CENTER);
       textField.setColumns(10);
   }
}

结果：

MouseEvent鼠标事件

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

MouseListener接口有5个抽象方法

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类常用的方法

getSource   用来获得触发此次事件的组件对象，返回对象为Object类
getButton     用来获得代表此次按下、释放或单击的按键的int型值
getClickCount     用来获得单击按键的次数

要判断触发此次事件的按键时，可以通过下表判断:

静态常量   常量值   代表的键
BUTTON1    1   左键
BUTTON2   2   滚轮
BUTTON3     3   右键

例题18.27

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

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

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

   public static void main(String args[]) {
       a18_27 frame = new a18_27();
       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 a18_27() {
       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 mousePressed (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("光标移出组件");
           }
       });
       getContentPane().add(label, BorderLayout.CENTER);
   }

}