Swing 主要用来开发GUI(Graphical User Interface)程序,GUI是应用程序提供给用户操作的图形界面,包括窗口、菜单、按钮等图形界面元素,我们经常使用的 QQ 软件、360 安全卫士等均为 GUT程序。Java语言为 Swing程序的开发提供了丰富的类库,这些类分别被存储在java.awt和javax.swing包中。Swing提供了丰富的组件,在开发 Swing 程序时,这些组件被广泛地应用。
Swing 组件是完全由 Java 语言编写的组件。因为Java 语言不依赖于本地平台(即“操作系统”).所以Swing 组件可以被应用于任何平台。基于“跨平台”这一特性,Swing 组件被称作“轻量级组件”反之,依赖于本地平台的组件被称作“重量级组件”,
在Swing 包的层次结构和继承关系中,比较重要的类是Component 类(组件类)Container 类(容
感类)和JComponent 类(Swing 组件父类)。Swing 包的层次结构和承关系如图18.1所示。
图18.1包含了一些Swing 组件,常用的Swing组件如表18.1所示
Swing常用窗体
JFrame窗体
开发 Swing程序的流程可以被简单地概括为首先通过继承javaxswingJFrame类创建一个窗体,然后向这个窗体中添加组件,最后为添加的组件设置监听事件。下面将详细讲解Frame 窗体的使用方法。JFrame类的常用构造方法包括以下两种形式:
public JFrame0:创建一个初始不可见、没有标题的窗体。
publicJFrame(String title):创建一个不可见、具有标题的窗体。
例如,创建一个不可见、具有标题的窗体,关键代码如下:
JFrame jf=new JFrame("登录系统”);
Container container = jf.getContentPane();
在创建窗体后,先调用getContentPane0方法将窗体转换为容器,再调用add0方法或者remove0方法向容器中添加组件或者删除容器中的组件。向容器中添加按钮,关键代码如下:
JButton okBtn = new JButton("确定")
container.add(okBtn);
删除容器中的按钮,关键代码如下:
container.remove(okBtn);
创建窗体后,要对窗体进行设置,如设置窗体的位置、大小、是否可见等。JFrame 类提供的相应方法可实现上述设置操作,具体如下:
setBounds(int x,inty,int width,int leight):设置窗体左上角在屏幕中的坐标为(xy),窗体的宽V度为width,窗体的高度为height。
setLocation(intx,inty):设置窗体左上角在屏幕中的坐标为(x,y)。
setSize(int width,int height):设置窗体的宽度为 width,高度为 height。
setVisibale(boolean b): 设置窗体是否可见。b为true 时,表示可见;b为false 时,表示不可见
setDefaultCloseOperation(int operation):设置窗体的关闭方式,默认值为DISPOSE_ON _CLOSE。
代码案例:
import java.awt.*; //导入AWT包
import javax.swing.*; //导入Swing包
public class Test {
public static void main(String[] args) { //主方法
JFrame jf=new JFrame(); //创建窗体对象
jf.setTitle("创建一个JFrame窗体"); //设置窗体标题
Container container=jf.getContentPane(); //获取主容器
JLabel jl=new JLabel("这是一个JFrame窗体"); //一个文本标签
jl.setHorizontalAlignment(SwingConstants.CENTER); //使标签上的文字居中
container.add(jl); //将标签添加到主容器中
jf.setSize(300,150); //设置窗体宽高
jl.setLocation(320,240); //设置窗体在屏幕中出现的位置
jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); //关闭窗体则停止程序
jf.setVisible(true); //让窗体展示出来
}
}
运行结果:
JDialog 对话框
JDialog 对话框继承了java.awt.Dialog 类,其功能是从一个窗体中弹出另一个窗体,如使用IE 浏览器时弹出的确定对话框。JDialog对话框与JFrame 窗体类似,被使用时也需要先调getContentPane()方法把JDialog 对话框转换为容器再对JDialog对话框进行设置。JDialog 类常用的构造方法如下:
代码案例:
package eighteenth;
import java.awt.Container;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.WindowConstants;
class MyJDialog extends JDialog{//自定义对话框类,继承 JDialog
public MyJDialog (MyFrame frame) {
//调用父类构造方法,第一个参数是父窗体,第二个参数是窗体标题,第三个参数表示堵塞父窗体
super(frame,"第一个 JDialog 窗体",true);
Container container=getContentPane();//获取主容器
container.add(new JLabel("这是一个对话框"));//在容器中添加标题
setBounds(120,120,100,100);//设置对话框窗体在桌面显示的坐标和大小
}
public static void main(String[] args) {
new MyFrame ();
}
}
class MyFrame extends JFrame {//自定义窗体,继承 JFrame
public MyFrame() {//窗体的构造方法
Container container=getContentPane();//获得窗体主容器
container.setLayout(null);//容器使用绝对布局
JButton bl=new JButton("弹出对话框");//创建一个按钮
bl.setBounds(10,10,100,21);//定义按钮在容器中的坐标和大小
bl.addActionListener(new ActionListener() {//为按钮添加单击事件
public void actionPerformed(ActionEvent e) {//单击事件触发的方法
MyJDialog dialog =new MyJDialog(MyFrame.this);//创建 MyJDialog对话框
dialog .setVisible(true);//是对话框可见
}
});
container.add(bl);//将按钮添加到容器中
setSize(200,200);//窗体的宽高
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//关闭窗体则停止程序
setVisible(true);//使窗体可见
}
}
JOptionPane小型对话框
JavaAPI中的javaxswingJOptionPane类是一个非常简便的小型对话框类,该类用于创建对话框的方法都是静态方法,无须创建对象即可弹出。在日常开发中经常使用该类弹出提示、确认用户需求、调试程序等。JOptionPane 提供了4种创建对话框的方法,如表 18.3 所示。
1,自定义对话框
首先介绍一个自定义的对话框,这个对话框可以说是一块白板,开发者可以自行定义对话框中显示的元素。创建自定义对话框的方法如下:
public static int showOptionDialog(Component parentComponent,
Object message,
String title,
int optionType,
int messageType,
Icon icon,
Object[] options,
Object initialValue)
参数说明如下;
代码案例:
package eighteenth;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JOptionPane;
public class Demo {
public static void main(String[] args) {
Object O[]= {new JButton("是的"),new JButton("再想想")};//按钮对象的 Object 数组
Icon icon=new ImageIcon("src/注意.png");//获取图标对象
JOptionPane.showOptionDialog(null, "你做好准备了吗", "注意了!",
JOptionPane.DEFAULT_OPTION,JOptionPane.DEFAULT_OPTION,icon,O, null);
}
}
运行结果:
2.确认框
确认框已经封装好了一套外观样式,弹出后要求用户做选择操作,用户选择具体选项后,确认框可以返回用户的选择结果,结果以int方式返回。创建确认对话框的方法有以下几种重载形式:
代码案例:
package eighteenth;
import javax.swing.JOptionPane;
public class Demo {
public static void main(String[] args) {
int answer=JOptionPane.showConfirmDialog(null,"确定离开吗?","标题",
JOptionPane.YES_NO_CANCEL_OPTION);
}
}
运行结果:
3.输入框
输入框已经封装好了一套外观样式,弹出后要求用户在文本框中输入文本,用户完成输入操作后输入框可以返回用户输入的结果。创建输入框的方法有以下几种重载形式:
案例代码:
package eighteenth;
import javax.swing.JOptionPane;
public class Demo {
public static void main(String[] args) {
String name=JOptionPane.showInputDialog(null,"请输入您的姓名");
}
}
运行结果:
4,通知框
通知框是最简单的一个对话框,仅弹出提示,不会返回任何值。创建通知框方法有以下几种重载形式:
代码案例:
package eighteenth;
import javax.swing.JOptionPane;
public class Demo {
public static void main(String[] args) {
JOptionPane.showMessageDialog(null,"您与服务器断开了连接","发生错误",JOptionPane.ERROR_MESSAGE);
}
}
常用布局管理器
null 绝对布局
绝对布局也叫 null 布局,其特点是硬性指定组件在容器中的位置大小,组件的位置通过绝对坐标的方式来指定。使用绝对布局首先使用 Container.seLayout(null)方法取消容器的布局管理器,然后再使用 Component.setBounds(int x,int y,int width,int height)方法设置每个组件在容器中的位置和大小。
package eighteenth;
import java.awt.Container;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.WindowConstants;
public class AbsolutePosition extends JFrame{
public AbsolutePosition() {
setTitle("本窗体使用绝对布局");//窗体标题
setLayout(null);//使用 null 布局
setBounds(0,0,300,150);//设置窗体的坐标与宽高
Container c=getContentPane();//获取主容器
JButton b1=new JButton("按钮1");//创建按钮
JButton b2=new JButton("按钮2");
b1.setBounds(10,30,80,30);//设置按钮的位置与大小
b2.setBounds(60,70,100,20);
c.add(b1);//将按钮添加到容器
c.add(b2);
setVisible(true);//使窗体可见
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//关闭窗体则停止程序
}
public static void main(String[] args) {
new AbsolutePosition();
}
}
运行结果:
FlowLayout 流布局管理器
流布局(FlowLayout)管理器是 Swing 中最基本的布局管理器。使用流布局管理器摆放组件时,组件被从左到右摆放。当组件占据了当前的所有空间时,溢出的组件会被移动到当前的下一行。默认情况下,行组件的排列方式会被指定为居中对齐,但是通过设置可以更改每一行组件的排序方式。
package eighteenth;
import java.awt.Container;
import java.awt.FlowLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.WindowConstants;
public class FlowLayoutPosition extends JFrame{
public FlowLayoutPosition(){
setTitle("本窗体使用流布局管理器");//设置窗体标题
Container c=getContentPane();//获取窗体主容器
//窗体使用流布局,组件右对齐,组件之间的组件之间的水平间隔为10像素,垂直间隔10像素
setLayout(new FlowLayout(FlowLayout.RIGHT,10,10));
for(int i=0;i<10;i++) {
c.add(new JButton("button"+i));
}
setSize(300,200);//设置窗体大小
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);//关闭窗体则停止程序
setVisible(true);//设置窗体可见
}
public static void main(String[] args) {
new FlowLayoutPosition();
}
}
运行结果:
BorderLayout 边界布局管理器
使用 Swing 创建窗体后,容器默认的布局管理器是边界布局(BorderLayout )管理器 ,边界布局把容量划分为东、南、西、北、中5个区域,但组件被添加到设置为边界布局管理器的容器时,需要使用 BorderLayout 类中成员变量指定被添加的组件在边界布局管理器中的区域。
package eighteenth;
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.FlowLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.WindowConstants;
public class FlowLayoutPosition extends JFrame{
public FlowLayoutPosition() {
setTitle("本窗体使用边界布局管理器");//设置窗体标题
Container c=getContentPane();//获取窗体主容器
setLayout(new BorderLayout());//容器使用边界布局
JButton centerBtn=new JButton("中");
JButton northBtn=new JButton("北");
JButton southBtn=new JButton("南");
JButton westBtn=new JButton("西");
JButton eastBtn=new JButton("东");
c.add(centerBtn,BorderLayout.CENTER);
c.add(northBtn,BorderLayout.NORTH);
c.add(southBtn,BorderLayout.SOUTH);
c.add(westBtn,BorderLayout.WEST);
c.add(eastBtn,BorderLayout.EAST);
setSize(350,200);//设置窗体大小
setVisible(true);//设置窗体可见
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);//关闭窗体则停止程序
}
public static void main(String[] args) {
new FlowLayoutPosition();
}
}
运行结果:
GridLayout 网格布局管理器
GridLayout 网格布局管理器能够把容器划分为网格,组件可以按行列进行排列。
在网格布局管理器中,网格的个数由行数和列数决定,且每个网格的大小都相同。从网格的左上角开始,按照从左到右,从上到下的顺序被添加到网格中,且每个组件都会填满整个网格。改变窗口大小的同时,组件的大小也会随之改变
网格布局管理器主要有以下两个常用的构造方法:
public GridLayout(int rows, int columns)
public GridLayout(int rows, int columns ,int hortizGap,int vertGap)
rows和columns这两个参数只允许有一个参数可以为零,被用于表示一行或一列可以排列任意多个组件
package LX;
import java.awt.Container;
import java.awt.GridLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.WindowConstants;
public class GP18_10 extends JFrame {
public GP18_10(){
Container c=getContentPane();
//设置容器使用网格布局管理器设置7行3列的网格组件间,水平间距为5像素,垂直间距为5像素
setLayout(new GridLayout(7,3,5,5));
for(int i=0;i<20;i++) {
c.add(new JButton("button"+i));//循环添加按钮
}
setSize(300,300);
setTitle("这是一个使用网格布局管理器的窗体");
setVisible(true);
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
public static void main(String[] args) {
new GP18_10();
}
}
运行结果:
常用面板
JPanel面板
在Swing程序设计中,面板是一个容器,被用于容纳其他组件,
但面板必须被添加到其他容器中。Swing中常用的面板包括JPanel面板和JScrollpane面板
JPanel面板继承Java.awt.Container类,JPanel面板必须在窗体容器中使用,无法脱离窗体显示
package LX;
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.GridLayout;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.WindowConstants;
public class JT18_11 extends JFrame{
public JT18_11(){
Container c=getContentPane();//获取窗体主容器
//将整个容器设置为2行2列的网格布局,组件水平间隔10像素,垂直间隔10像素
c.setLayout(new GridLayout(2,2,10,10));
//初始化一个面板,此面板使用1行4列的网格布局,组件水平间隔10像素,垂直间隔10像素
JPanel p1=new JPanel(new GridLayout(1,4,10,10));
//初始化一个面板,此面板使用边界布局
JPanel p2=new JPanel(new BorderLayout());
JPanel p3=new JPanel(new GridLayout(1,2,10,10));
JPanel p4=new JPanel(new GridLayout(2,1,10,10));
//给每个面板都添加边框和标题,使用 BorderFactory 工厂类生成带标题的边框对象
p1.setBorder(BorderFactory.createTitledBorder("面板1"));
p2.setBorder(BorderFactory.createTitledBorder("面板2"));
p3.setBorder(BorderFactory.createTitledBorder("面板3"));
p4.setBorder(BorderFactory.createTitledBorder("面板4"));
//向面板1中添加按钮
p1.add(new JButton("b1"));
p1.add(new JButton("b1"));
p1.add(new JButton("b1"));
p1.add(new JButton("b1"));
//向面板2中添加按钮
p2.add(new JButton("b2"),BorderLayout.WEST);
p2.add(new JButton("b2"),BorderLayout.EAST);
p2.add(new JButton("b2"),BorderLayout.NORTH);
p2.add(new JButton("b2"),BorderLayout.SOUTH);
p2.add(new JButton("b2"),BorderLayout.CENTER);
//向面板3中添加按钮
p3.add(new JButton("b3"));
p3.add(new JButton("b3"));
//向面板4中添加按钮
p4.add(new JButton("b4"));
p4.add(new JButton("b4"));
//向容器中添加面板
c.add(p1);
c.add(p2);
c.add(p3);
c.add(p4);
setTitle("这个窗体中使用了面板");
setSize(500,300);//窗体宽高
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);//关闭动作
}
public static void main(String[] args) {
JT18_11 test=new JT18_11();
test.setVisible(true);
}
}
运行结果:
JScrollPane滚动面板
JScrollPane面板,是带滚动条的面板,被用于在较小的窗体中显示较大篇幅的内容,要注意的是,不能使用布局管理器,只能容纳一个组件,如果添加多个组件,那么需要先将多个组件添加到JPanel面板,再将JPanel面板添加到滚动面板
package LX;
import java.awt.Container;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.WindowConstants;
public class JPT18_12 extends JFrame {
public JPT18_12() {
Container c = getContentPane();//获取主容器
//创建文本区域组件,文本域默认大小为 20 行、50 列
JTextArea ta = new JTextArea(20,50);
//创建 JScrollPane 滚动面板,并将文本域放到滚动面板中
JScrollPane sp = new JScrollPane(ta);
c.add(sp);//将该面板添加到主容器中
setTitle("带滚动条的文字编译器");
setSize(400,200);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
}
public static void main(String[] args) {
JPT18_12 test = new JPT18_12();
test.setVisible(true);
}
}
运行结果:
文字标签组件与图标
标签被用于显示文本,图标等内容。用户能够通过标签上的文本图标等内容获取相应的提示信息。
JLabel标签
JLabrl标签的父类是JComponent类,标签不能被添加监听器,但是标签显示的文本,图标等内容可以指定对齐方式,通过JLabrl类的构造方法可以创建多种标签,常用的构造方法如下
:
import java.awt.Container;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.WindowConstants;
public class JLabelTest extends JFrame{
public JLabelTest (){
Container container=getContentPane();//获取主容器
JLabel jl=new JLabel("这是一个 JFrame 窗体");//创建标签
container.add(jl);
setSize(200,100);//设置窗体大小
setVisible(true);//设置窗体可见
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//关闭窗体则停止程序
}
public static void main(String[] args) {
new JLabelTest();
}
}
运行结果:
图标的使用
在swing程序设计中,图标经常被添加到标签,按钮等组件。它有多个常用方法如下:
package LX;
import java.awt.*;
import java.net.URL;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import javax.swing.WindowConstants;
public class My18_14 extends JFrame {
public My18_14(){
Container container=getContentPane();
JLabel jl=new JLabel("这是一个JFrame窗体");//创建标签
URL url=My18_14.class.getResource("图片3.png");//获取图片所在的URL
Icon icon =new ImageIcon(url);//获取图片的icon对象
jl.setIcon(icon);//为标签设置图片
jl.setHorizontalAlignment(SwingConstants.CENTER);//设置文字放置在标签中间
jl.setOpaque(true);//设置标签为不透明状态
container.add(jl);//将标签添加到容器中
setSize(300,200);//设置窗体大小
setVisible(true);//使窗体可见
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//关闭窗体则停止程序
}
public static void main(String[] args) {
new My18_14();
}
}
运行结果:
按钮组件
JButton按钮
Swing 按钮由JButton 对象表示,JButton 常用的构造方法如下:
publicJButton():创建一个不带文本或图标的按钮。
publicJButton(String text):创建一个带文本的按钮。
publicJButton(Icon icon): 创建一个带图标的按钮。
public JButton(String text,Icon icon):创建一个带文本和图标的按钮。
创建JButton 对象后,如果要对 JButton 对象进行设置,那么可以使用 JButton 类提供的方法JButton 类的常用方法及其说明如表18.6所示:
package eighteenth;
import java.awt.Color;
import java.awt.Container;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.BorderFactory;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.WindowConstants;
public class JButtonTest extends JFrame{
public JButtonTest(){
Icon icon=new ImageIcon("");//获取图片文件
setLayout(new GridLayout(3,2,5,5));//设置网格布局管理器
Container c=getContentPane();//获取主容器
JButton btn[]=new JButton[6];//创建按钮数组
for(int i=0;i<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,"点击按钮");//弹出确认对话框
}
});
setTitle("创建不同样式的按钮");
setBounds(100,100,400,200);//设置窗体大小
setVisible(true);//设置窗体可见
setDefaultCloseOperation(EXIT_ON_CLOSE);//关闭窗体则停止程序
}
public static void main(String[] args) {
new JButtonTest();
}
}
运行结果:
JRadioButton单选按钮
Swing单选按钮由JRadioButton对象表示,在swing程序设计中,需要把多个单选按钮添加到按钮组,当用户选中某个单选按钮时,按钮组中的其他单选按钮将不能被同时选中。
1、单选按钮
创建JRadioButton对象需要使用JRadioButton类的构造方法,,常用构造方法如下:
2、按钮组
Swing按钮组由ButtonGroup对象表示,多个单选按钮被添加到按钮组后能够实现“选项有多个,但只能选中一个的效果”,对象被创建后可以使用add方法把多个单选按钮添加到对象中
import javax.swing.*;
public class RadioButtonTest extends JFrame{
public RadioButtonTest() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setTitle("单选按钮的使用");
setBounds(100,100,240,120);
getContentPane().setLayout(null);//设置绝对布局
JLabel lbINewLabel = new JLabel("请选择性别:");
//设置绝对布局
lbINewLabel.setBounds(5, 5,120,15);
getContentPane().add(lbINewLabel);
JRadioButton rbtnNormal =new JRadioButton("男");
rbtnNormal.setSelected(true);
rbtnNormal.setBounds(40, 30, 75,22);
getContentPane().add(rbtnNormal);
JRadioButton rbtnPwd = new JRadioButton("女");
rbtnPwd.setBounds(120,30,75,22);
getContentPane().add(rbtnPwd);
ButtonGroup group = new ButtonGroup(); //创建按钮组,把交互面板中的单选按钮添加到按钮组中
group.add(rbtnNormal);
group.add(rbtnPwd);
}
public static void main(String[] args) {
RadioButtonTest frame = new RadioButtonTest();//创建窗体对象
frame.setVisible(true);//使窗体可见
}
}
运行结果:
JCheckBox复选框
复选框组件由JCheckBox对象表示,以单选按钮不同的是,窗体中的复选框可以被选中多个,这是因为每一个复选框都提供了被选中和不被选中两种状态。常用构造方法如下:
package LX;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
public class CBT18_17 extends JFrame {
public CBT18_17() {
setBounds(100,100,170,110);//窗口坐标和大小
setDefaultCloseOperation(EXIT_ON_CLOSE);
Container c=getContentPane();//获取主容器
c.setLayout(new FlowLayout());//容器使用流布局
JCheckBox c1=new JCheckBox("1");//创建复选框
JCheckBox c2=new JCheckBox("2");
JCheckBox c3=new JCheckBox("3");
c.add(c1);//容器添加复选框
c.add(c2);
c.add(c3);
JButton btn=new JButton("打印");//创建打印按钮
btn.addActionListener(new ActionListener(){//打印按钮动作事件
public void actionPerformed(ActionEvent e) {
//在控制台分别输出三个复选框的选中状态
System.out.println(c1.getText()+"按钮选中状态:"+c1.isSelected());
System.out.println(c2.getText()+"按钮选中状态:"+c2.isSelected());
System.out.println(c3.getText()+"按钮选中状态:"+c3.isSelected());
}
});
c.add(btn);//容器添加打印按钮
setVisible(true);
}
public static void main(String[] args) {
new CBT18_17();
}
}
运行结果:
列表组件
Swing中提供两种列表组件,分别为下拉列表框(JComboBox)和列表框(JList),下拉列表框与列表框都是带有一系列列表选项的组件,用户可以从中选择需要的列表项,列表框较下拉列表框更直观,他们将所有的列表项罗列在列表框,但是下拉列表这个表框更为便捷美观,它将所有的列表项隐藏起来,当用户用其中的列表项时才会显示出来。
JComboBox下拉列表框
初次使用下拉列表框时,会感觉swing中的下拉列表框以WINDOWS操作系统中的下拉列表框有一些相似,实质上两者并不完全相同,因为swing中的下拉列表框不仅可以供用户从中选择,列表项也提供编辑列表项的功能JComboBox类的常用构造方法如下:
package eighteenth;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
public class JComboBoxTest extends JFrame {
public JComboBoxTest() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setTitle("下拉列表框的使用");
setBounds(100,100,317,147);
getContentPane().setLayout(null);//设置绝对布局
JLabel lblNewLabel = new JLabel("请选择证件:");
lblNewLabel.setBounds(28,14,80,15);
getContentPane().add(lblNewLabel);
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) {
lblNewLabel.setText("你的选择的是:"+ comboBox.getSelectedItem());
}
});
}
public static void main(String[] args) {
JComboBoxTest frame = new JComboBoxTest(); //创建窗体对象
frame.setVisible(true);//使窗体可见
}
}
运行结果:
JList列表框
列表框组件被添加到窗体中后,就会被指定长和宽。如果列表框的大小不足以容纳列表项的个数,那么需要设置列表框具有滚动效果,即把列表框添加到滚动面板。列表框组件由j list对象表示常用构造方法如下:
package LX;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.WindowConstants;
public class JLT18_19 extends JFrame {
public JLT18_19() {
Container cp=getContentPane();//获取窗体主容器
cp.setLayout(null);//容器使用绝对布局
//创建字符串数组保存列表中的数据
String[]contents= {"列表1","列表2","列表3","列表4","列表5","列表6"};
JList<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常用构造方法如下:
package LX;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextField;
import javax.swing.WindowConstants;
public class JFT18_20 extends JFrame{
public JFT18_20() {
Container c=getContentPane();//获取窗体主容器
c.setLayout(new FlowLayout());
JTextField jt=new JTextField("请点击清除按钮");//设定文本框初始值
jt.setColumns(20);//设置文本框长度
jt.setFont(new Font("宋体",Font.PLAIN,20));//设置字体
JButton jb=new JButton("清除");
jt.addActionListener(new ActionListener() {//为文本框添加回车事件
public void actionPerformed(ActionEvent arf0) {
jt.setText("触发事件");//设置文本框中的值
}
});
jt.addActionListener(new ActionListener() {// 为按钮添加事件
public void actionPerformed(ActionEvent arf0) {
System.out.println(jt.getText());//输出当前文本框的值
jt.setText("");//将文本框置空
jt.requestFocus();// 焦点回到文本框
}
});
c.add(jt);//窗体容器添加文本框
c.add(jb);//窗体添加按钮
setBounds(100,100,250,110);
setVisible(true);
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
public static void main(String[] args) {
new JFT18_20();
}
}
运行结果:
JPasswordField密码框
密码框组件由JPasswordField对象表示,其作用是把用户输入的字符串,以某种符号进行加密
常用构造方法如下:
JTextArea文本框
文本域组件由JTrxtArea对象表示,其作用是接受用户的多行文本输入,常用构造方法如下:
public JTextArea():
public JTextArea(String text):
public JTextArea(int rows,int columns):
public JTextArea(Document doc):
public JTextArea(Document doc ,String Text,int rows,int columns);
package LX;
import java.awt.Container;
import javax.swing.JFrame;
import javax.swing.JTextArea;
import javax.swing.WindowConstants;
public class JT18_21 extends JFrame {
public JT18_21() {
setSize(200,100);
setTitle("定义自动换行的文本域");
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
Container cp = getContentPane(); //获取窗体主容器
//创建一个文本内容为“文本域”、行高和列宽均为 6 的文本域
JTextArea jt = new JTextArea("文本域",6,6);
jt.setLineWrap(true); //可以自动换行
cp.add(jt);
setVisible(true);
}
public static void main(String[] args) {
new JT18_21();
}
}
运行结果:
表格组件
Swing表格由JTable表示其作用是把数据以表格的形式显示给用户
创建表格
JTanle类除了提供了默认的构造方法外,还提供了被用于显示二维数组中的元素的构造方法。这个构造方法的语法如下:
JTanle(Object[][]rowDate,Object[]columnNames)
rowDate存储表格数据的二维数组
columnNames,存储表格列明的一维数组
在使用表格时,要先把表格添加到滚动面板,再把滚动面板添加到窗体的相应位置
package eighteenth;
import java.awt.BorderLayout;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
public class JTextAreaTest extends JFrame {
public static void main(String args[]) {
JTextAreaTest frame = new JTextAreaTest();
frame.setVisible(true);
}
public JTextAreaTest() {
setTitle("创建可以滚动的表格");
setBounds(100,100,240,150);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
String[] columnNames = {"A","B"}; //定义表格列名数
//定义表格数据数组
String[][] tableValues ={{"A1","B1"},{"A2","B2"},{"A3","B3"},
{"A4","B4"},{"A5","B5"}};
//创建指定列名和数据的表格
JTable table = new JTable(tableValues, columnNames);
//创建显示表格的滚动面板
JScrollPane scrollPane = new JScrollPane(table);
//将滚动面板添加到边界布局的中间
getContentPane().add(scrollPane, BorderLayout.CENTER);
}
}
运行结果:
DefaultTableModel 表格数据模型
Swing 使用 TableModel 接口定义了一个表格模型,AbstractTableModel 抽象类实现了 TableModel接口的大部分方法,只有以下3 个抽象方法没有实现:
public int getRowCount();
public int getColumnCount();
public Object getValueAt(int rowIndex, int columnIndex);
为了实现使用表格模型创建表格的功能,Swing 提供了表格模型类,即 DefaultTableModel 类。DefaultTableModel类继承了 AbstractTableModel 抽象类且实现了上述 3 个抽象方法。DefaultTableModel类提供的常用构造方法如表 18.8 所示
import java.awt.BorderLayout;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.WindowConstants;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableRowSorter;
public class SortingTable extends JFrame{
private static final long serialversionUID=1L;
public static void main(String[] args) {
SortingTable frame=new SortingTable();
frame.setVisible(true);
}
public SortingTable() {
setTitle ("表演模型与表格");
setBounds(100,100,240,150);//窗体宽高
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JScrollPane scrollPane=new JScrollPane();
getContentPane().add(scrollPane,BorderLayout.CENTER);
String[] columnNames= {"A","B"};//定义表格列名数组
//定义表格数据数组
String[][] tableValues= {{"A1","B1"},{"A2","B2"},{"A3","B3"}};
//创建指定表格列名和表格数据的表格模型
DefaultTableModel tableModel=new DefaultTableModel(tableValues,columnNames);
JTable table=new JTable(tableModel);//创建指定表格模型的表格
table.setRowSorter(new TableRowSorter<>(tableModel));
scrollPane.setViewportView(table);
}
}
运行结果:
维护表格模型
表格中的数据内容需要用于维护,
使用getValueAt()方法获得表格中某一个单元格的值,
使用addRow方()法向表格中添加新的行
使用setValueAt()方法修改表格中某一个单元格的值
使用removeRow()方法从表格中删除指定行等
当删除表格模型中的指定行时,每删除一行,其后所有行的索引值将相应的减一,所以当连续删除多行时,需要注意对删除行索引的处理。
package LX;
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.ListSelectionModel;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableRowSorter;
public class ADD18_24 extends JFrame{
private DefaultTableModel tableModel;//定义表格模型对象
private JTable table;//定义表格对象
private JTextField aTextFied ;
private JTextField bTextFied ;
public ADD18_24() {
setTitle("维护表格模型");
setBounds(100,100,520,200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
final JScrollPane scrollPane=new JScrollPane();
getContentPane().add(scrollPane,BorderLayout.CENTER);
String[] columnNames= {"A","B"};//定义表格列名数组
//定义表格数据数组
String[][]tableValues= {{"A1","B1"},{"A2","B2"},{"A3","B3"}};
//创建指定表格列名和表格数据的表格模型
tableModel =new DefaultTableModel(tableValues,columnNames);
table=new JTable(tableModel);//创建指定表格模型的表格
table.setRowSorter(new TableRowSorter<>(tableModel));//设置表格的排序器
//设置表格的选择模式为单选
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
//为表格添加鼠标事件监听器
table.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {//发生了单击事件
int selectedRow=table.getSelectedRow();//获得被选中行的索引
//从表格模型中获得指定单元格的值
Object oa=tableModel.getValueAt(selectedRow, 0);
//从表格模型中获得指定单元格的值
Object ob=tableModel.getValueAt(selectedRow, 1);
aTextFied.setText(oa.toString());//将值赋值给文本框
bTextFied.setText(ob.toString());//将值赋值给文本框
}
});
scrollPane.setViewportView(table);
JPanel panel=new JPanel();
getContentPane().add(panel, BorderLayout.SOUTH);
panel.add(new JLabel("A:"));
aTextFied = new JTextField("A4",10);
panel.add(aTextFied);
panel.add(new JLabel("B:"));
bTextFied = new JTextField("B4",10);
panel.add(bTextFied);
JButton addButton = new JButton("添加");
addButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String[] rowValues = {aTextFied.getText(),
bTextFied.getText()};//创建表格行数组
tableModel.addRow(rowValues);//向表格模型中添加一行
int rowCount = table.getRowCount()+ 1;
aTextFied.setText("A" + rowCount);
bTextFied.setText("B" + rowCount);
}
});
panel.add(addButton);
JButton updButton = new JButton("修改");
updButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int selectdRow=table.getSelectedRow();//获得被选中行的索引
if(selectdRow!=1) {//判断是否存在被选中行
//修改表格模型中的指定值
tableModel.setValueAt(aTextFied.getText(),selectdRow, 0);
//修改表格模型中的指定
tableModel.setValueAt(bTextFied.getText(),selectdRow, 1);
}
}
});
panel.add(updButton);
JButton delButton = new JButton("删除");
delButton.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e) {
int selectedRow = table.getSelectedRow();//获得被选中行的索引
if (selectedRow != -1)//判断是否存在被选中行
tableModel.removeRow(selectedRow);//从表格模型中删除指定行
}
});
panel.add(delButton);
}
public static void main(String[] args) {
ADD18_24 frame=new ADD18_24();
frame.setVisible(true);
}
}
运行结果:
事件监听器
ActionEvent 动作事件
动作事件(ActionEvent)监听器是 Swing 中比较常用的事件监听器,很多组件的动作都会使用它监听,如按钮被单击等。表 18.9 描述了动作事件监听器的接口与事件源等。
KeyEvent 键盘事件
当向文本框中输入内容时,将发生键盘事件。KeyEvent 类负责捕获键盘事件,可以通过为组件添加实现了 KeyListener 接口的监听器类来处理相应的键盘事件。
KeyListener 接口共有 3 个抽象方法,分别在发生击键事件(按下并释放键)、按键被按下(手指按下键但不松开)和按键被释放(手指从按下的键上松开)时被触发,具体如下:
public interface KeyListener extends EventListener {
public void keyTyped(KeyEvent e); //发生击键事件时被触发
public void keyPressed(KeyEvent e); //按键被按下时被触发
public void keyReleased(KeyEvent e); //按键被释放时被触发
}
在上述每个抽象方法中,均传入了 KeyEvent 类的对象。KeyEvent 类中比较常用的方法如表18.10所示。
MouseEvent 鼠标事件
所有组件都能发生鼠标事件,MouseEvent 类负责捕获鼠标事件,可以通过为组件添加实现了MouseListener 接口的监听器类来处理相应的鼠标事件。
MouseListener 接口共有 5个抽象方法,分别在光标移入或移出组件、鼠标按键被按下或释放和发生单击事件时被触发。所谓单击事件,就是按键被按下并释放。需要注意的是,如果按键是在移出组件之后才被释放,则不会触发单击事件。MouseListener 接口的具体定义如下:
public interface MouseListener extends EventListener {
public void mouseEntered(MouseEvent e); //光标移入组件时被触发
public void mousePressed(MouseEvent e); //鼠标按键被按下时被触发
public void mouseReleased(MouseEvent e) //鼠标按键被释放时被触发
public void mouseClicked(MouseEvent e); //发生单击事件时被触发
public void mouseExited(MouseEvent e); //光标移出组件时被触发
在上述每个抽象方法中,均传入了MouseEvent 类的对象。MouseEvent 类中比较常用的方法如表18.11所示。
当需要判断触发此次事件的按键时,可以通过表 18.12中的静态常量判断由getButton0方法返回的int型值代表的键。