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类具有以下常用的构造方法
- public FlowLayout()
- public FlowLayout(int alignment)
- 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 维护表格模型
表格中的数据内容需要用于维护,
- 使用getValueAt()方法获得表格中某一个单元格的值,
- 使用addRow()方法向表格中添加新的行
- 使用setValueAt方法修改表格中某一个单元格的值
- 使用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);
}
}