java swing

最新推荐文章于 2024-04-20 19:56:52 发布

荔枝1995

最新推荐文章于 2024-04-20 19:56:52 发布

阅读量746

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_41683726/article/details/111057163

版权

一、swing简介

Swing 是新一代的图形界面工具。使用 Swing 来开发图形界面比 AWT 更加优秀，因为 Swing 是一种轻量级组件，它采用纯 Java 实现，不再依赖于本地平台的图形界面，所以可以在所有平台上保持相同的运行效果，对跨平台支持比较出色。除此之外，Swing 提供了比 AWT 更多的图形界面组件，因此可以开发出美观的图形界面程序。

1、swing类库结构

Swing类库组织结构图

2、swing包

包名称	描述
javax.swing	提供一组“轻量级”组件，尽量让这些组件在所有平台上的工作方式都相同
javax.swing.border	提供围绕 Swing 组件绘制特殊边框的类和接口
javax.swing.event	提供 Swing 组件触发的事件
javax.swing.filechooser	提供 JFileChooser 组件使用的类和接口
javax.swing.table	提供用于处理 javax.swing.JTable 的类和接口
javax.swing.text	提供类 HTMLEditorKit 和创建 HTML 文本编辑器的支持类
javax.swing.tree	提供处理 javax.swingJTree 的类和接口

3、swing容器

创建图形用户界面程序的第一步是创建一个容器类以容纳其他组件，常见的窗口就是一种容器。容器本身也是一种组件，它的作用就是用来组织、管理和显示其他组件。

Swing 中容器可以分为两类：顶层容器和中间容器。

顶层容器是进行图形编程的基础，一切图形化的东西都必须包括在顶层容器中。顶层容器是任何图形界面程序都要涉及的主窗口，是显示并承载组件的容器组件。在 Swing 中有三种可以使用的顶层容器，分别是 JFrame、JDialog 和 JApplet。

JFrame：用于框架窗口的类，此窗口带有边框、标题、关闭和最小化窗口的图标。带 GUI 的应用程序至少使用一个框架窗口。
JDialog：用于对话框的类。
JApplet：用于使用 Swing 组件的 Java Applet 类。

中间容器是容器组件的一种，也可以承载其他组件，但中间容器不能独立显示，必须依附于其他的顶层容器。常见的中间容器有 JPanel、JScrollPane、JTabbedPane 和 JToolBar。

JPanel：表示一个普通面板，是最灵活、最常用的中间容器。
JScrollPane：与 JPanel 类似，但它可在大的组件或可扩展组件周围提供滚动条。
JTabbedPane：表示选项卡面板，可以包含多个组件，但一次只显示一个组件，用户可在组件之间方便地切换。
JToolBar：表示工具栏，按行或列排列一组组件（通常是按钮）。

二、swing窗口容器和面板容器

在 Swing 中，任何其他组件都必须位于一个顶层容器中。JFrame 窗口和 JPanel 面板是常用的顶层容器。

1、JFrame窗口

JFrame 用来设计类似于 Windows 系统中窗口形式的界面。JFrame 是 Swing 组件的顶层容器，该类继承了 AWT 的 Frame 类，支持 Swing 体系结构的高级 GUI 属性。

方法名称	概述
getContentPane()	返回此窗体的 contentPane 对象
getDefaultCloseOperation()	返回用户在此窗体上单击“关闭”按钮时执行的操作
setContentPane(Container contentPane)	设置 contentPane 属性
setDefaultCloseOperation(int operation)	设置用户在此窗体上单击“关闭”按钮时默认执行的操作
setDefaultLookAndFeelDecorated (boolean defaultLookAndFeelDecorated)	设置 JFrame 窗口使用的 Windows 外观（如边框、关闭窗口的小部件、标题等）
setIconImage(Image image)	设置要作为此窗口图标显不的图像
setJMenuBar( JMenuBar menubar)	设置此窗体的菜单栏
setLayout(LayoutManager manager)	设置 LayoutManager 属性

import javax.swing.JFrame;
import javax.swing.JLabel;
import java.awt.*;
public class JFrameDemo extends JFrame
{
    public JFrameDemo()
    {
        setTitle("Java 第一个 GUI 程序");    //设置显示窗口标题
        setSize(400,200);    //设置窗口显示尺寸
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);    //置窗口是否可以关闭
        JLabel jl=new JLabel("这是使用JFrame类创建的窗口");    //创建一个标签
        Container c=getContentPane();    //获取当前窗口的内容窗格
        c.add(jl);    //将标签组件添加到内容窗格上
        setVisible(true);    //设置窗口是否可见
    }
    public static void main(String[] agrs)
    {
        new JFrameDemo();    //创建一个实例化对象
    }
}

窗口运行结果

2、JPanel面板

JPanel 是一种中间层容器，它能容纳组件并将组件组合在一起，但它本身必须添加到其他容器中使用。

方法名及返回值类型	说明
Component add(Component comp)	将指定的组件追加到此容器的尾部
void remove(Component comp)	从容器中移除指定的组件
void setFont(Font f)	设置容器的字体
void setLayout(LayoutManager mgr)	设置容器的布局管理器
void setBackground(Color c)	设置组件的背景色

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import java.awt.*;
public class JPanelDemo
{   
    public static void main(String[] agrs)
    {
        JFrame jf=new JFrame("Java第二个GUI程序");    //创建一个JFrame对象
        jf.setBounds(300, 100, 400, 200);    //设置窗口大小和位置
        JPanel jp=new JPanel();    //创建一个JPanel对象
        JLabel jl=new JLabel("这是放在JPanel上的标签");    //创建一个标签
        jp.setBackground(Color.white);    //设置背景色
        jp.add(jl);    //将标签添加到面板
        jf.add(jp);    //将面板添加到窗口
        jf.setVisible(true);    //设置窗口可见
    }
}

面板显示效果

三、swing布局管理器

1、边框布局管理器

BorderLayout（边框布局管理器）是 Window、JFrame 和 JDialog 的默认布局管理器。边框布局管理器将窗口分为 5 个区域：North、South、East、West 和 Center。其中，North 表示北，将占据面板的上方；Soufe 表示南，将占据面板的下方；East表示东，将占据面板的右侧；West 表示西，将占据面板的左侧；中间区域 Center 是在东、南、西、北都填满后剩下的区域，如图 1 所示。

框布局管理器区域划分示意图

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import java.awt.*;
public class BorderLayoutDemo
{
    public static void main(String[] agrs)
    {
        JFrame frame=new JFrame("Java第三个GUI程序");    //创建Frame窗口
        frame.setSize(400,200);
        frame.setLayout(new BorderLayout());    //为Frame窗口设置布局为BorderLayout
        JButton button1=new JButton ("上");
        JButton button2=new JButton("左");
        JButton button3=new JButton("中");
        JButton button4=new JButton("右");
        JButton button5=new JButton("下");
        frame.add(button1,BorderLayout.NORTH);
        frame.add(button2,BorderLayout.WEST);
        frame.add(button3,BorderLayout.CENTER);
        frame.add(button4,BorderLayout.EAST);
        frame.add(button5,BorderLayout.SOUTH);
        frame.setBounds(300,200,600,300);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

填充5个区域的效果

2、流式布局管理器

FlowLayout（流式布局管理器）是 JPanel 和 JApplet 的默认布局管理器。FlowLayout 会将组件按照从上到下、从左到右的放置规律逐行进行定位。与其他布局管理器不同的是，FlowLayout 布局管理器不限制它所管理组件的大小，而是允许它们有自己的最佳大小。

FlowLayout布局按钮结果

3、卡片布局管理器

CardLayout（卡片布局管理器）能够帮助用户实现多个成员共享同一个显不空间，并且一次只显示一个容器组件的内容。

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import java.awt.*;
public class CardLayoutDemo
{   
    public static void main(String[] agrs)
    {
        JFrame frame=new JFrame("Java第五个程序");    //创建Frame窗口
        JPanel p1=new JPanel();    //面板1
        JPanel p2=new JPanel();    //面板2
        JPanel cards=new JPanel(new CardLayout());    //卡片式布局的面板
        p1.add(new JButton("登录按钮"));
        p1.add(new JButton("注册按钮"));
        p1.add(new JButton("找回密码按钮"));
        p2.add(new JTextField("用户名文本框",20));
        p2.add(new JTextField("密码文本框",20));
        p2.add(new JTextField("验证码文本框",20));
        cards.add(p1,"card1");    //向卡片式布局面板中添加面板1
        cards.add(p2,"card2");    //向卡片式布局面板中添加面板2
        CardLayout cl=(CardLayout)(cards.getLayout());
        cl.show(cards,"card1");    //调用show()方法显示面板2
        frame.add(cards);
        frame.setBounds(300,200,400,200);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

显示 p1 面板

显示 p2 面板

4、网格布局管理器

GridLayout（网格布局管理器）为组件的放置位置提供了更大的灵活性。它将区域分割成行数（rows）和列数（columns）的网格状布局，组件按照由左至右、由上而下的次序排列填充到各个单元格中。

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import java.awt.*;
public class GridLayoutDemo
{
    public static void main(String[] args)
    {
        JFrame frame=new JFrame("GridLayou布局计算器");
        JPanel panel=new JPanel();    //创建面板
        //指定面板的布局为GridLayout，4行4列，间隙为5
        panel.setLayout(new GridLayout(4,4,5,5));
        panel.add(new JButton("7"));    //添加按钮
        panel.add(new JButton("8"));
        panel.add(new JButton("9"));
        panel.add(new JButton("/"));
        panel.add(new JButton("4"));
        panel.add(new JButton("5"));
        panel.add(new JButton("6"));
        panel.add(new JButton("*"));
        panel.add(new JButton("1"));
        panel.add(new JButton("2"));
        panel.add(new JButton("3"));
        panel.add(new JButton("-"));
        panel.add(new JButton("0"));
        panel.add(new JButton("."));
        panel.add(new JButton("="));
        panel.add(new JButton("+"));
        frame.add(panel);    //添加面板到容器
        frame.setBounds(300,200,200,150);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

计算器

5、网格包布局管理器

GridBagLayout（网格包布局管理器）是在网格基础上提供复杂的布局，是最灵活、最复杂的布局管理器。GridBagLayout 不需要组件的尺寸一致，允许组件扩展到多行多列。每个 GridBagLayout 对象都维护了一组动态的矩形网格单元，每个组件占一个或多个单元，所占有的网格单元称为组件的显示区域。

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import java.awt.*;
public class GridBagLayoutDemo
{
    //向JFrame中添加JButton按钮
    public static void makeButton(String title,JFrame frame,GridBagLayout gridBagLayout,GridBagConstraints constraints)
    {   
        JButton button=new JButton(title);    //创建Button对象
        gridBagLayout.setConstraints(button,constraints);
        frame.add(button);
    }
    public static void main(String[] agrs)
    {
        JFrame frame=new JFrame("拨号盘");
        GridBagLayout gbaglayout=new GridBagLayout();    //创建GridBagLayout布局管理器
        GridBagConstraints constraints=new GridBagConstraints();
        frame.setLayout(gbaglayout);    //使用GridBagLayout布局管理器
        constraints.fill=GridBagConstraints.BOTH;    //组件填充显示区域
        constraints.weightx=0.0;    //恢复默认值
        constraints.gridwidth = GridBagConstraints.REMAINDER;    //结束行
        JTextField tf=new JTextField("13612345678");
        gbaglayout.setConstraints(tf, constraints);
        frame.add(tf);
        constraints.weightx=0.5;    // 指定组件的分配区域
        constraints.weighty=0.2;
        constraints.gridwidth=1;
        makeButton("7",frame,gbaglayout,constraints);    //调用方法，添加按钮组件
        makeButton("8",frame,gbaglayout,constraints);
        constraints.gridwidth=GridBagConstraints.REMAINDER;    //结束行
        makeButton("9",frame,gbaglayout,constraints);
        constraints.gridwidth=1;    //重新设置gridwidth的值
       
        makeButton("4",frame,gbaglayout,constraints);
        makeButton("5",frame,gbaglayout,constraints);
        constraints.gridwidth=GridBagConstraints.REMAINDER;
        makeButton("6",frame,gbaglayout,constraints);
        constraints.gridwidth=1;
       
        makeButton("1",frame,gbaglayout,constraints);
        makeButton("2",frame,gbaglayout,constraints);
        constraints.gridwidth=GridBagConstraints.REMAINDER;
        makeButton("3",frame,gbaglayout,constraints);
        constraints.gridwidth=1;
       
        makeButton("返回",frame,gbaglayout,constraints);
        constraints.gridwidth=GridBagConstraints.REMAINDER;
        makeButton("拨号",frame,gbaglayout,constraints);
        constraints.gridwidth=1;
        frame.setBounds(400,400,400,400);    //设置容器大小
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

拨号盘运行效果

6、盒布局管理器

import javax.swing.Box;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import java.awt.*;
public class BoxLayoutDemo
{
    public static void main(String[] agrs)
    {
        JFrame frame=new JFrame("Java示例程序");
        Box b1=Box.createHorizontalBox();    //创建横向Box容器
        Box b2=Box.createVerticalBox();    //创建纵向Box容器
        frame.add(b1);    //将外层横向Box添加进窗体
        b1.add(Box.createVerticalStrut(200));    //添加高度为200的垂直框架
        b1.add(new JButton("西"));    //添加按钮1
        b1.add(Box.createHorizontalStrut(140));    //添加长度为140的水平框架 
        b1.add(new JButton("东"));    //添加按钮2
        b1.add(Box.createHorizontalGlue());    //添加水平胶水
        b1.add(b2);    //添加嵌套的纵向Box容器
        //添加宽度为100，高度为20的固定区域  
        b2.add(Box.createRigidArea(new Dimension(100,20))); 
        b2.add(new JButton("北"));    //添加按钮3
        b2.add(Box.createVerticalGlue());    //添加垂直组件
        b2.add(new JButton("南"));    //添加按钮4
        b2.add(Box.createVerticalStrut(40));    //添加长度为40的垂直框架
        //设置窗口的关闭动作、标题、大小位置以及可见性等  
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
        frame.setBounds(100,100,400,200); 
        frame.setVisible(true); 
    }
}

BoxLayout运行结果

四、swing标签组件

方法名称	说明
void setText(Stxing text)	定义 JLabel 将要显示的单行文本
void setIcon(Icon image)	定义 JLabel 将要显示的图标
void setIconTextGap(int iconTextGap)	如果 JLabel 同时显示图标和文本，则此属性定义它们之间的间隔
void setHorizontalTextPosition(int textPosition)	设置 JLabel 的文本相对其图像的水平位置
void setHorizontalAlignment(int alignment)	设置标签内容沿 X 轴的对齐方式
int getText()	返回 JLabel 所显示的文本字符串
Icon getIcon()	返回 JLabel 显示的图形图像
Component getLabelFor()	获得将 JLabel 添加到的组件
int getIconTextGap()	返回此标签中显示的文本和图标之间的间隔量
int getHorizontalTextPosition()	返回 JLabel 的文本相对其图像的水平位置
int getHorizontalAlignment()	返回 JLabel 沿 X 轴的对齐方式

import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
public class JLabelDemo
{
    public static void main(String[] agrs)
    {
        JFrame frame=new JFrame("Java标签组件示例");    //创建Frame窗口
        JPanel jp=new JPanel();    //创建面板
        JLabel label1=new JLabel("普通标签");    //创建标签
        JLabel label2=new JLabel();
        label2.setText("调用setText()方法");
        ImageIcon img=new ImageIcon("D:\\money.png");    //创建一个图标
        //创建既含有文本又含有图标的JLabel对象
        JLabel label3=new JLabel("开始理财",img,JLabel.CENTER);
        jp.add(label1);    //添加标签到面板
        jp.add(label2);
        jp.add(label3);
        frame.add(jp);
        frame.setBounds(300,200,400,100);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

标签显示效果

五、swing按钮

方法名称	说明
addActionListener(ActionListener listener)	为按担组件注册 ActionListener 监听
void setIcon(Icon icon)	设置按钮的默认图标
void setText(String text)	设置按鈕的文本
void setMargin(Insets m)	设置按钮边框和标签之间的空白
void setMnemonic(int nmemonic)	设置按钮的键盘快捷键，所设置的快捷键在实际操作时需要结合 Alt 键进行实现
void setPressedIcon(Icon icon)	设置按下按钮时的图标
void setSelectedIcon(Icon icon)	设置选择按鈕时的图标
void setRolloveiicon(Icon icon)	设置鼠标移动到按扭区域时的图标
void setDisabledIcon(Icon icon)	设置按钮无效状态下的图标
void setVerticalAlignment(int alig)	设置图标和文本的垂直对齐方式
void setHorizontalAlignment(int alig)	设置图标和文本的水平对齐方式
void setEnable(boolean flag)	启用或禁用按扭
void setVerticalTextPosition(int textPosition)	设置文本相对于图标的垂直位置
void setHorizontalTextPosition(int textPosition)	设置文本相对于图标的水平位置

import java.awt.Color;
import java.awt.Dimension;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingConstants;
public class JButtonDemo
{
    public static void main(String[] args)
    {
        JFrame frame=new JFrame("Java按钮组件示例");    //创建Frame窗口
        frame.setSize(400, 200);
        JPanel jp=new JPanel();    //创建JPanel对象
        JButton btn1=new JButton("我是普通按钮");    //创建JButton对象
        JButton btn2=new JButton("我是带背景颜色按钮");
        JButton btn3=new JButton("我是不可用按钮");
        JButton btn4=new JButton("我是底部对齐按钮");
        jp.add(btn1);
        btn2.setBackground(Color.YELLOW);    //设置按钮背景色
        jp.add(btn2);
        btn3.setEnabled(false);    //设置按钮不可用
        jp.add(btn3);
        Dimension preferredSize=new Dimension(160, 60);    //设置尺寸
        btn4.setPreferredSize(preferredSize);    //设置按钮大小
        btn4.setVerticalAlignment(SwingConstants.BOTTOM);    //设置按钮垂直对齐方式
        jp.add(btn4);
        frame.add(jp);
        frame.setBounds(300, 200, 600, 300);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

按钮显示

六、swing单行文本框

方法名称	说明
Dimension getPreferredSize()	获得文本框的首选大小
void scrollRectToVisible(Rectangle r)	向左或向右滚动文本框中的内容
void setColumns(int columns)	设置文本框最多可显示内容的列数
void setFont(Font f)	设置文本框的字体
void setScrollOffset(int scrollOffset)	设置文本框的滚动偏移量（以像素为单位）
void setHorizontalAlignment(int alignment)	设置文本框内容的水平对齐方式

import java.awt.Font;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;
public class JTextFieldDemo
{
    public static void main(String[] agrs)
    {
        JFrame frame=new JFrame("Java文本框组件示例");    //创建Frame窗口
        JPanel jp=new JPanel();    //创建面板
        JTextField txtfield1=new JTextField();    //创建文本框
        txtfield1.setText("普通文本框");    //设置文本框的内容
        JTextField txtfield2=new JTextField(28);
        txtfield2.setFont(new Font("楷体",Font.BOLD,16));    //修改字体样式
        txtfield2.setText("指定长度和字体的文本框");
        JTextField txtfield3=new JTextField(30);
        txtfield3.setText("居中对齐");
        txtfield3.setHorizontalAlignment(JTextField.CENTER);    //居中对齐
        jp.add(txtfield1);
        jp.add(txtfield2);
        jp.add(txtfield3);
        frame.add(jp);
        frame.setBounds(300,200,400,100);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

文本框组件运行效果

七、swing文本域

方法名称	说明
void append(String str)	将字符串 str 添加到文本域的最后位置
void setColumns(int columns)	设置文本域的行数
void setRows(int rows)	设置文本域的列数
int getColumns()	获取文本域的行数
void setLineWrap(boolean wrap)	设置文本域的换行策略
int getRows()	获取文本域的列数
void insert(String str,int position)	插入指定的字符串到文本域的指定位置
void replaceRange(String str,int start,int end)	将指定的开始位 start 与结束位 end 之间的字符串用指定的字符串 str 取代

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
public class JTextAreaDemo
{
    public static void main(String[] agrs)
    {
        JFrame frame=new JFrame("Java文本域组件示例");    //创建Frame窗口
        JPanel jp=new JPanel();    //创建一个JPanel对象
        JTextArea jta=new JTextArea("请输入内容",7,30);
        jta.setLineWrap(true);    //设置文本域中的文本为自动换行
        jta.setForeground(Color.BLACK);    //设置组件的背景色
        jta.setFont(new Font("楷体",Font.BOLD,16));    //修改字体样式
        jta.setBackground(Color.YELLOW);    //设置按钮背景色
        JScrollPane jsp=new JScrollPane(jta);    //将文本域放入滚动窗口
        Dimension size=jta.getPreferredSize();    //获得文本域的首选大小
        jsp.setBounds(110,90,size.width,size.height);
        jp.add(jsp);    //将JScrollPane添加到JPanel容器中
        frame.add(jp);    //将JPanel容器添加到JFrame容器中
        frame.setBackground(Color.LIGHT_GRAY);
        frame.setSize(400,200);    //设置JFrame容器的大小
        frame.setVisible(true);
    }
}

文本域运行效果

八、swing复选框

import java.awt.Font;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
public class JCheckBoxDemo
{
    public static void main(String[] agrs)
    {
        JFrame frame=new JFrame("Java复选组件示例");    //创建Frame窗口
        JPanel jp=new JPanel();    //创建面板
        JLabel label=new JLabel("流行编程语言有：");
        label.setFont(new Font("楷体",Font.BOLD,16));    //修改字体样式
        JCheckBox chkbox1=new JCheckBox("C#", true);    //创建指定文本和状态的复选框
        JCheckBox chkbox2=new JCheckBox("C++");    //创建指定文本的复选框
        JCheckBox chkbox3=new JCheckBox("Java");    //创建指定文本的复选框
        JCheckBox chkbox4=new JCheckBox("Python");    //创建指定文本的复选框
        JCheckBox chkbox5=new JCheckBox("PHP");    //创建指定文本的复选框
        JCheckBox chkbox6=new JCheckBox("Perl");    //创建指定文本的复选框
        jp.add(label);
        jp.add(chkbox1);
        jp.add(chkbox2);
        jp.add(chkbox3);
        jp.add(chkbox4);
        jp.add(chkbox5);
        jp.add(chkbox6);
        frame.add(jp);
        frame.setBounds(300,200,400,100);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

复选框组件文本内容

九、swing单选按钮

import java.awt.Font;
import javax.swing.ButtonGroup;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
public class JRadioButtonDemo 
{
    public static void main(String[] agrs)
    {
        JFrame frame=new JFrame("Java单选组件示例");    //创建Frame窗口
        JPanel panel=new JPanel();    //创建面板
        JLabel label1=new JLabel("现在是哪个季节：");
        JRadioButton rb1=new JRadioButton("春天");    //创建JRadioButton对象
        JRadioButton rb2=new JRadioButton("夏天");    //创建JRadioButton对象
        JRadioButton rb3=new JRadioButton("秋天",true);    //创建JRadioButton对象
        JRadioButton rb4=new JRadioButton("冬天");    //创建JRadioButton对象
        label1.setFont(new Font("楷体",Font.BOLD,16));    //修改字体样式
        ButtonGroup group=new ButtonGroup();
        //添加JRadioButton到ButtonGroup中
        group.add(rb1);
        group.add(rb2);
        panel.add(label1);
        panel.add(rb1);
        panel.add(rb2);
        panel.add(rb3);
        panel.add(rb4);
        frame.add(panel);
        frame.setBounds(300, 200, 400, 100);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

JRadioButton 单选按钮

十、swing下拉列表

下拉列表的特点是将多个选项折叠在一起，只显示最前面的或被选中的一个。

方法名称	说明
void addItem(Object anObject)	将指定的对象作为选项添加到下拉列表框中
void insertItemAt(Object anObject,int index)	在下拉列表框中的指定索引处插入项
void removeltem(0bject anObject)	在下拉列表框中删除指定的对象项
void removeItemAt(int anlndex)	在下拉列表框中删除指定位置的对象项
void removeAllItems()	从下拉列表框中删除所有项
int getItemCount()	返回下拉列表框中的项数
Object getItemAt(int index)	获取指定索引的列表项，索引从 0 开始
int getSelectedIndex()	获取当前选择的索引
Object getSelectedltem()	获取当前选择的项

import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
public class JComboBoxDemo
{
    public static void main(String[] args)
    {
        JFrame frame=new JFrame("Java下拉列表组件示例");
        JPanel jp=new JPanel();    //创建面板
        JLabel label1=new JLabel("证件类型：");    //创建标签
        JComboBox cmb=new JComboBox();    //创建JComboBox
        cmb.addItem("--请选择--");    //向下拉列表中添加一项
        cmb.addItem("身份证");
        cmb.addItem("驾驶证");
        cmb.addItem("军官证");
        jp.add(label1);
        jp.add(cmb);
        frame.add(jp);
        frame.setBounds(300,200,400,100);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

下拉列表运行效果

十一、swing列表框

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
public class JListDemo
{
    public static void main(String[] args)
    {
        JFrame frame=new JFrame("Java列表框组件示例");
        JPanel jp=new JPanel();    //创建面板
        JLabel label1=new JLabel("证件类型：");    //创建标签
        String[] items=new String[]{"身份证","驾驶证","军官证"};
        JList list=new JList(items);    //创建JList
        jp.add(label1);
        jp.add(list);
        frame.add(jp);
        frame.setBounds(300,200,400,100);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

列表框运行效果

import java.awt.BorderLayout;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.ListSelectionModel;
import javax.swing.border.EmptyBorder;
public class JListDemo1 extends JFrame
{
    public JListDemo1()
    {
        setTitle("Java列表框组件示例");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);    //设置窗体退出时操作
        setBounds(100,100,300,200);    //设置窗体位置和大小
        JPanel contentPane=new JPanel();    //创建内容面板
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));    //设置面板的边框
        contentPane.setLayout(new BorderLayout(0, 0));    //设置内容面板为边界布局
        setContentPane(contentPane);    //应用内容面板
        JScrollPane scrollPane=new JScrollPane();    //创建滚动面板
        contentPane.add(scrollPane,BorderLayout.CENTER);    //将面板增加到边界布局中央
        JList list=new JList();
        //限制只能选择一个元素
        list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        scrollPane.setViewportView(list);    //在滚动面板中显示列表
        String[] listData=new String[12];    //创建一个含有12个元素的数组
        for (int i=0;i<listData.length;i++)
        {
            listData[i]="这是列表框的第"+(i+1)+"个元素~";    //为数组中各个元素赋值
        }
        list.setListData(listData);    //为列表填充数据
    }
    public static void main(String[] args)
    {
        JListDemo1 frame=new JListDemo1();
        frame.setVisible(true);
    }
}

限制列表框单选运行效果

十二、swing计算器界面的实现

十三、swing事件监听

事件表示程序和用户之间的交互，例如在文本框中输入，在列表框或组合框中选择，选中复选框和单选框，单击按钮等。事件处理表示程序对事件的响应，对用户的交互或者说对事件的处理是事件处理程序完成的。

1、事件处理模型

若使图形界面能够接收用户的操作，必须给各个组件加上事件处理机制。在事件处理的过程中，主要涉及三类对象。

Event（事件）：用户对组件的一次操作称为一个事件，以类的形式出现。例如，键盘操作对应的事件类是 KeyEvent。
Event Source（事件源）：事件发生的场所，通常就是各个组件，例如按钮 Button。
Event Handler（事件处理者）：接收事件对象并对其进行处理的对象事件处理器，通常就是某个 Java 类中负责处理事件的成员方法。

2、动作事件监听器

动作事件监听器是 Swing 中比较常用的事件监听器，很多组件的动作都会使用它监听，像按钮被里击、列表框中选择一项等。与动作事件监听器有关的信息如下。

事件名称：ActionEvent。
事件监听接口: ActionListener。
事件相关方法：addActionListener() 添加监听，removeActionListener() 删除监听。

涉及事件源：JButton、JList、JTextField 等。

import java.awt.BorderLayout;
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.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
public class ActionListenerDemo extends JFrame
{
    JList list;
    JLabel label;
    JButton button1;
    int clicks=0;
    public ActionListenerDemo()
    {
        setTitle("动作事件监听器示例");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100,100,400,200);
        JPanel contentPane=new JPanel();
        contentPane.setBorder(new EmptyBorder(5,5,5,5));
        contentPane.setLayout(new BorderLayout(0,0));
        setContentPane(contentPane);
        label=new JLabel(" ");
        label.setFont(new Font("楷体",Font.BOLD,16));    //修改字体样式
        contentPane.add(label, BorderLayout.SOUTH);
        button1=new JButton("我是普通按钮");    //创建JButton对象
        button1.setFont(new Font("黑体",Font.BOLD,16));    //修改字体样式
        button1.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                label.setText("按钮被单击了 "+(clicks++)+" 次");
            }
        });
        contentPane.add(button1);
    }
    //处理按钮单击事件的匿名内部类
    class button1ActionListener implements ActionListener
    {
        @Override
        public void actionPerformed(ActionEvent e)
        {
            label.setText("按钮被单击了 "+(clicks++)+" 次");
        }
    }
    public static void main(String[] args)
    {
        ActionListenerDemo frame=new ActionListenerDemo();
        frame.setVisible(true);
    }
}

处理按钮的单击事件

3、焦点事件监听器

除了单击事件外，焦点事件监听器在实际项目中应用也比较广泛，例如将光标离开文本框时弹出对话框，或者将焦点返回给文本框等。

与焦点事件监听器有关的信息如下。

事件名称：FocusEvent。
事件监听接口： FocusListener。
事件相关方法：addFocusListener() 添加监听，removeFocusListener() 删除监听。
涉及事件源：Component 以及派生类。

4、监听列表项选择事件

import java.awt.BorderLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.border.EmptyBorder;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
public class JListDemo2 extends JFrame
{
    JList list;
    JLabel label;
    public JListDemo2()
    {
        setTitle("监听列表项选择事件");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100,100,400,200);
        JPanel contentPane=new JPanel();
        contentPane.setBorder(new EmptyBorder(5,5,5,5));
        contentPane.setLayout(new BorderLayout(0,0));
        setContentPane(contentPane);
        label=new JLabel(" ");
        contentPane.add(label,BorderLayout.SOUTH);
        JScrollPane scrollPane=new JScrollPane();
        contentPane.add(scrollPane,BorderLayout.CENTER);
        list=new JList();
        scrollPane.setViewportView(list);
        String[] listData=new String[7];
        listData[0]="《一点就通学Java》";
        listData[1]="《一点就通学PHP》";
        listData[2]="《一点就通学Visual Basic）》";
        listData[3]="《一点就通学Visual C++）》";
        listData[4]="《Java编程词典》";
        listData[5]="《PHP编程词典》";
        listData[6]="《C++编程词典》";
        list.setListData(listData);
        list.addListSelectionListener(new ListSelectionListener()
        {
            public void valueChanged(ListSelectionEvent e)
            {
                do_list_valueChanged(e);
            }

			protected void do_list_valueChanged(ListSelectionEvent e)
			{
				label.setText("感谢您购买："+list.getSelectedValue());
			}
        });
    }
    public static void main(String[] args)
    {
        JListDemo2 frame=new JListDemo2();
        frame.setVisible(true);
    }
}

十四、swing星座选择器界面的实现

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
public class SampeDemo
{
	private JPanel panel=new JPanel();
	private JComboBox cmb=new JComboBox();    //创建JComboBox
	private JLabel label=new JLabel("添加新星座：");
	private JLabel showInfo=new JLabel();    //用于显示信息
	private JTextField jtf=new JTextField(16);    //用于输入信息
	private JButton buttonAdd=new JButton("新增");
	private JButton buttonDel=new JButton("删除");
	public SampeDemo()
	{
	    JFrame frame=new JFrame("选择你的星座");
	    cmb.addItem("--请选择--");    //向下拉列表中添加一项
	    cmb.addItem("巨蟹座");
	    cmb.addItem("狮子座");
	    cmb.addItem("双鱼座");
	    panel.add(cmb);
	    panel.add(label);
	    panel.add(jtf);
	    panel.add(buttonAdd);
	    panel.add(buttonDel);
	    frame.add(panel);
	    buttonAdd.addActionListener(new MyActionListener());    //“添加”按钮的事件
	    buttonDel.addActionListener(new MyActionListener());    //“删除”按钮的事件
	    cmb.addItemListener(new MyItemListener());    //下拉列表的事件
	    frame.setBounds(300,200,600,200);
	    frame.setVisible(true);
	    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
	// 监听选中事件
	class MyItemListener implements ItemListener
	{
	    @Override
	    public void itemStateChanged(ItemEvent e)
	    {
	        String str=e.getItem().toString();
	        panel.add(showInfo);
	        showInfo.setText("您选择的星座是："+str);
	    }
	}
	// 监听添加和删除按钮事件
	class MyActionListener implements ActionListener
	{
	    @Override
	    public void actionPerformed(ActionEvent e)
	    {
	        String command=e.getActionCommand();
	        //添加按钮处理
	        if(command.equals("新增"))
	        {
	            if(jtf.getText().length()!=0)
	            {
	                cmb.addItem(jtf.getText());    //添加项
	                panel.add(showInfo);
	                showInfo.setText("添加成功，新增了："+jtf.getText());
	            }
	            else
	            {
	                panel.add(showInfo);
	                showInfo.setText("请输入要添加星座");
	            }
	        }
	        //删除按钮处理
	        if(command.equals("删除"))
	        {
	            if(cmb.getSelectedIndex()!=-1)
	            {
	                //先获得要删除的项的值
	                String strDel=cmb.getSelectedItem().toString();
	                cmb.removeItem(strDel);    //删除项
	                panel.add(showInfo);
	                showInfo.setText("删除成功，删除了："+strDel);
	            }
	            else
	            {
	                panel.add(showInfo);
	                showInfo.setText("请选择要删除的星座");
	            }
	        }
	    }
	}

    public static void main(String[] args)
    {
        new SampeDemo();    //调用构造方法
    }
}

添加项

显示选中项

删除项

十五、swing滑块

滑块（JSlider）是一个允许用户在有限区间内通过移动滑块来选择值的组件。

滑块可以显示主刻度标记以及主刻度之间的次刻度标记。刻度标记之间的值的个数由 setMajorTickSpacing() 方法和 setMinorTickSpacing() 方法来控制。刻度标记的绘制由 setPaintTicks() 方法控制。

滑块也可以在固定时间间隔（或在任意位置）沿滑块刻度打印文本标签，标签的绘制由 setLabelTable() 方法和 setPaintLabels() 方法控制。

方法名称	说明
createStandardLabels(int increment)	创建一个数字文本标签的 Hashtable，从滑块最小值处开始增加，并使用指定的增量
getLabelTable()	返回哪些标签在哪些刻度绘制的字典
getMaj orTickSpacing()	返回主刻度标记的间隔
getMaximum()	从 BoundedRangeModel 返回滑块所支持的最大值
getMinimum()	从 BoundedRangeModel 返回滑块所支持的最小值
getMinorTickSpacing()	返回次刻度标记的间隔
getSnapToTicks()	如果滑块（及其所表示的值）解析为最靠近用户放置滑块处的刻度标记的值，则返回为 true
getValue()	从 BoundedRangeModel 返回滑块的当前值
setLabelTable(Dictionary labels)	用于指定将在给定值处绘制哪个标签
setMaj orTickSpacing(int n)	此方法设置主刻度标记的间隔
setMaximum(int maximum)	将滑块的最大值设置为 maximum
setMinimum(int minimum)	将滑块的最小值设置为 minimum
setMinorTickSpacing(int n)	设置次刻度标记的间隔
setOrientation(int orientation)	将滑块的方向设置为 SwingConstants.VERTICAL 或 SwingConstants.HORIZONTAL
setPaintLabels(boolean b)	确定是否在滑块上绘制标签
setPaintTicks(boolean b)	确定是否在滑块上绘制刻度标记
setPaintTrack(boolean b)	确定是否在滑块上绘制滑道
setSnapToTicks(boolean b)	指定为 true，则滑块（及其所表示的值）解析为最靠近用户放置滑块处的刻度标记的值
setValue(int n)	将滑块的当前值设置为 n

import java.awt.Container;
import javax.swing.JFrame;
import javax.swing.JSlider;
public class JSliderDemo
{
    public static void main(String[] agrs)
    {
        JFrame frame=new JFrame("滑块组件示例");
        frame.setSize(100,100);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Container contentPane=frame.getContentPane();
        JSlider slider=new JSlider(0,100);
        slider.setMajorTickSpacing(10);
        slider.setMinorTickSpacing(5);
        slider.setPaintLabels(true);   
        slider.setPaintTicks(true);
        contentPane.add(slider);
        frame.setVisible(true);       
    }
}

具有刻度和标签的滑块

十六、swing进度条

进度条（JProgressBar）是一种以可视化形式显示某些任务进度的组件。JProgressBar 类实现了一个用于为长时间的操作提供可视化指示器的 GUI 进度条。在任务的完成进度中，进度条显示该任务完成的百分比。此百分比通常由一个矩形以可视化形式表示，该矩形开始是空的，随着任务的完成逐渐被填充。此外，进度条可显示此百分比的文本表示形式。

方法名称	说明
getMaximum()	返回进度条的最大值
getMinimum()	返回进度条的最小值
getPercentComplete()	返回进度条的完成百分比
getString()	返回当前进度的 String 表示形式
getValue()	返回进度条的当前 value
setBorderPainted(boolean b)	设置 borderPainted 属性，如果进度条应该绘制其边框，则此属性为 true
setIndeterminate(boolean newValue)	设置进度条的 indeterminate 属性，该属性确定进度条处于确定模式中还是处于不确定模式中
setMaximum(int n)	将进度条的最大值设置为 n
setMinimum(int n)	将进度条的最小值设置为 n
setOrientation(int newOrientation)	将进度条的方向设置为 newOrientation
setString(String s)	设置进度字符串的值
setStringPainted(boolean b)	设置 stringPainted 属性的值，该属性确定进度条是否应该呈现进度字符串
setValue(int n)	将进度条的当前值设置为 n
updateUI()	将 UI 属性重置为当前外观对应的值

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
public class JProgressBarDemo extends JFrame
{
    //static JProgressBarDemo frame;
    public JProgressBarDemo()
    {
        setTitle("使用进度条");
        JLabel label=new JLabel("欢迎使用在线升级功能！");
        //创建一个进度条
        JProgressBar progressBar=new JProgressBar();
        JButton button=new JButton("完成");
        button.setEnabled(false);
        Container container=getContentPane();
        container.setLayout(new GridLayout(3,1));
        JPanel panel1=new JPanel(new FlowLayout(FlowLayout.LEFT));
        JPanel panel2=new JPanel(new FlowLayout(FlowLayout.CENTER));
        JPanel panel3=new JPanel(new FlowLayout(FlowLayout.RIGHT));
        panel1.add(label);    //添加标签
        panel2.add(progressBar);    //添加进度条
        panel3.add(button);    //添加按钮
        container.add(panel1);
        container.add(panel2);
        container.add(panel3);
        progressBar.setStringPainted(true);
        //如果不需要进度上显示“升级进行中...”，可注释此行
        //progressBar.setString("升级进行中...");
        //如果需要使用不确定模式，可使用此行
        //progressBar.setIndeterminate(true);
        //开启一个线程处理进度
        new Progress(progressBar, button).start();
        //单机“完成”按钮结束程序
        button.addActionListener(new ActionListener()
        {
            @Override
            public void actionPerformed(ActionEvent e)
            {
                dispose();
                System.exit(0);
            }
        });
    }
    private class Progress extends Thread
    {
        JProgressBar progressBar;
        JButton button;
        //进度条上的数字
        int[] progressValues={6,18,27,39,51,66,81,100};
        Progress(JProgressBar progressBar,JButton button)
        {
            this.progressBar=progressBar;
            this.button=button;
        }
        public void run()
        {
            for(int i=0;i<progressValues.length;i++)
            {
                try
                {
                    Thread.sleep(3000);
                }
                catch(InterruptedException e)
                {
                    e.printStackTrace();
                }
                //设置进度条的值
                progressBar.setValue(progressValues[i]);
            }
            progressBar.setIndeterminate(false);
            progressBar.setString("升级完成！");
            button.setEnabled(true);
        }
    }
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        JProgressBarDemo frame=new JProgressBarDemo();
        frame.setBounds(300,200,300,150);    //设置容器的大小
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
    }
}

进度条运行效果

数字模式下进度条的运行效果

十七、swing计时器

计时器（Timer）组件可以在指定时间间隔触发一个或多个 ActionEvent。设置计时器的过程包括创建一个 Timer 对象，在该对象上注册一个或多个动作侦听器，以及使用 start() 方法启动该计时器。

创建 Timer 类时要指定一个延迟参数和一个 ActionListener。延迟参数用于设置初始延迟和事件触发之间的延迟（以毫秒为单位）。启动计时器后，它将在向已注册监听器触发第一个 ActionEvent 之前等待初始延迟。第一个事件之后，每次超过事件间延迟时它都继续触发事件，直到被停止。

方法名称	说明
addActionListener(ActionListener 1)	将一个动作监听器添加到 Timer
getDelay()	返回两次触发动作事件间延迟，以毫秒为单位
isCoalesce()	如果 Timer 组合多个挂起的动作事件，则返回 true
isRunning()	如果 Timer 正在运行，则返回 true
restart()	重新启动 Timer，取消所有挂起的触发并使它按初始延迟触发
setCoalesce(boolean flag)	设置 Timer 是否组合多个挂起的 ActionEvent
setDelay(int delay)	设置 Timer 的事件间延迟，两次连续的动作事件之间的毫秒数
setLogTimers(boolean flag)	启用/禁用计时器日志
setRepeats(boolean flag)	如果 flag 为 false，则指示 Timer 只向其监听器发送一次动作事件
start()	启动 Timer，使它开始向其监听器发送动作事件
stop()	停止 Timer，使它停止向其监听器发送动作事件

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.Timer;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
public class JProgressBarDemo1 implements ActionListener,ChangeListener
{
    JFrame frame=null;
    JProgressBar progressbar;
    JLabel label;
    Timer timer;
    JButton b;
    public JProgressBarDemo1()
    {
        frame=new JFrame("软件安装");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Container contentPane=frame.getContentPane();
        label=new JLabel(" ",JLabel.CENTER);    //创建显示进度信息的文本标签
        progressbar=new JProgressBar();    //创建一个进度条
        progressbar.setOrientation(JProgressBar.HORIZONTAL);
        progressbar.setMinimum(0);
        progressbar.setMaximum(100);
        progressbar.setValue(0);
        progressbar.setStringPainted(true);
        progressbar.addChangeListener(this);    //添加事件监听器
        //设置进度条的几何形状
        progressbar.setPreferredSize(new Dimension(300,20));
        progressbar.setBorderPainted(true);
        progressbar.setBackground(Color.pink);
        //添加启动按钮
        JPanel panel=new JPanel();
        b=new JButton("安装");
        b.setForeground(Color.blue);
        //添加事件监听器
        b.addActionListener(this);
        panel.add(b);
        timer=new Timer(100, this);    //创建一个计时器，计时间隔为100毫秒
        //把组件添加到frame中
        contentPane.add(panel,BorderLayout.NORTH);
        contentPane.add(progressbar,BorderLayout.CENTER);
        contentPane.add(label,BorderLayout.SOUTH);
        frame.pack();
        frame.setVisible(true);
    }
  //实现事件监听器接口中的方法
    public void actionPerformed(ActionEvent e)
    {
        if(e.getSource()==b)
            timer.start();
        if(e.getSource()==timer)
        {
            int value=progressbar.getValue();
            if(value<100)
            {
                progressbar.setValue(++value);
            }
            else
            {
                timer.stop();
                frame.dispose();
            }
        }
    }
    public void stateChanged(ChangeEvent e1)    //实现事件监听器接口中的方法
    {
        int value=progressbar.getValue();
        if(e1.getSource()==progressbar)
        {
            label.setText("目前已完成进度："+Integer.toString(value)+" %");
            label.setForeground(Color.blue);
        }
    }
    public static void main(String[] agrs)
    {
        new JProgressBarDemo1();    //创建一个实例化对象
    }
}

初始效果

进度变化效果

十八、swing菜单和弹出式菜单

菜单由 Swing 中的 JMenu 类实现，可以包含多个菜单项和带分隔符的菜单。在菜单中，菜单项由 JMenuItem 类表示，分隔符由 JSeparator 类表示。

1、JMenu类的常用方法

方法名称	说明
add(Action a)	创建连接到指定 Action 对象的新菜单项，并将其追加到此菜单的末尾
add(Component c)	将某个组件追加到此菜单的末尾
add(Component c,int index)	将指定组件添加到此容器的给定位置
add(JMenuItem menultem)	将某个菜单项追加到此菜单的末尾
add(String s)	创建具有指定文本的新菜单项，并将其追加到此菜单的末尾
addSeparator()	将新分隔符追加到菜单的末尾
doCliclc(int pressTime)	以编程方式执行“单击”操作
getDelay()	返回子菜单向上或向下弹出前建议的延迟（以毫秒为单位）
getltem(int pos)	返回指定位置的 JMenuItem
getItemCount()	返回菜单上的项数，包括分隔符
getMenuComponent(int n)	返回位于位置 n 的组件
getMenuComponents()	返回菜单子组件的 Component 数组
getSubElements()	返回由 MenuElement 组成的数组，其中包含此菜单组件的子菜单
insert(JMenuItem mi,int pos)	在给定位置插入指定的 JMenuitem
insert(String s,pos)	在给定位置插入具有指定文本的新菜单项
insertSeparator(int index)	在指定的位置插入分隔符
isMenuComponent(Component c)	如果在子菜单层次结构中存在指定的组件，则返回 true
isPopupMenuVisible()	如果菜单的弹出窗口可见，则返回 rue
isSelected()	如果菜单是当前选择的（即高亮显示的）菜单，则返回 true
isTopLevelMenu()	如果菜单是“顶层菜单”（即菜单栏的直接子级），则返回 true
setDelay(int d)	设置菜单的 PopupMenu 向上或向下弹出前建议的延迟
setMenuLocation(int x,int y)	设置弹出组件的位置
setPopupMenuVisible(boolean b)	设置菜单弹出的可见性
setSelected(boolean b)	设置菜单的选择状态

import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.KeyStroke;
public class JMenuDemo1 extends JMenuBar
{
    public JMenuDemo1()
    {
        add(createFileMenu());    //添加“文件”菜单
        add(createEditMenu());    //添加“编辑”菜单
        setVisible(true);
    }
    public static void main(String[] agrs)
    {
        JFrame frame=new JFrame("菜单栏");
        frame.setSize(300,200);
        frame.setJMenuBar(new JMenuDemo1());
        frame.setVisible(true);
    }
    //定义“文件”菜单
    private JMenu createFileMenu()
    {
        JMenu menu=new JMenu("文件(F)");
        menu.setMnemonic(KeyEvent.VK_F);    //设置快速访问符
        JMenuItem item=new JMenuItem("新建(N)",KeyEvent.VK_N);
        item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N,ActionEvent.CTRL_MASK));
        menu.add(item);
        item=new JMenuItem("打开(O)",KeyEvent.VK_O);
        item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O,ActionEvent.CTRL_MASK));
        menu.add(item);
        item=new JMenuItem("保存(S)",KeyEvent.VK_S);
        item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S,ActionEvent.CTRL_MASK));
        menu.add(item);
        menu.addSeparator();
        item=new JMenuItem("退出(E)",KeyEvent.VK_E);
        item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_E,ActionEvent.CTRL_MASK));
        menu.add(item);
        return menu;
    }
    //定义“编辑”菜单
    private JMenu createEditMenu()
    {
        JMenu menu=new JMenu("编辑(E)");
        menu.setMnemonic(KeyEvent.VK_E);
        JMenuItem item=new JMenuItem("撤销(U)",KeyEvent.VK_U);
        item.setEnabled(false);
        menu.add(item);
        menu.addSeparator();
        item=new JMenuItem("剪贴(T)",KeyEvent.VK_T);
        menu.add(item);
        item=new JMenuItem("复制(C)",KeyEvent.VK_C);
        menu.add(item);
        menu.addSeparator();
        JCheckBoxMenuItem cbMenuItem=new JCheckBoxMenuItem("自动换行");
        menu.add(cbMenuItem);
        return menu;
    }
    }

“文件”菜单

2、弹出式菜单JPopuMenu

弹出式菜单由 JPopupMenu 类实现，它是一个可弹出并显示一系列选项的小窗口。它还用于当用户选择菜单项并激活它时显示的“右拉式(pull-right)”菜单，可以在想让菜单显示的任何其他位置使用。例如，当用户在指定区域中右击时。

方法名称	说明
getInvoker()	返回作为此弹出菜单的“调用者”的组件
setInvoker(Component invoker)	设置弹出菜单的调用者，即弹出菜单在其中显示的组件
addPopupMenuListener(PopupMenuListener1)	添加 PopupMenu 监听器
removePopupMenuListener(PopupMenuListener1)	移除 PopupMenu 监听器
getPopupMenuListeners()	返回利用 addPopupMenuListener()添加到此 JMenuitem 的所有 PopupMenuListener 组成的数组
getLabel()	返回弹出菜单的标签
setLabel(String label)	设置弹出菜单的标签
show(Component invoker,int x,int y)	在调用者的坐标空间中的位置 X、Y 处显示弹出菜单
getComponentIndex(Component c)	返回指定组件的索引

import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.ButtonGroup;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.JRadioButtonMenuItem;
public class JPopupMenuDemo extends JFrame
{
    JMenu fileMenu;
    JPopupMenu jPopupMenuOne;
    JMenuItem openFile,closeFile,exit;
    JRadioButtonMenuItem copyFile,pasteFile;
    ButtonGroup buttonGroupOne;
    public JPopupMenuDemo()
    {
        jPopupMenuOne=new JPopupMenu();    //创建jPopupMenuOne对象
        buttonGroupOne=new ButtonGroup();
        //创建文件菜单及子菜单，并将子菜单添加到文件菜单中
        fileMenu=new JMenu("文件");
        openFile=new JMenuItem("打开");
        closeFile=new JMenuItem("关闭");
        fileMenu.add(openFile);
        fileMenu.add(closeFile);
        //将fileMenu菜单添加到弹出式菜单中
        jPopupMenuOne.add(fileMenu);
        //添加分割符
        jPopupMenuOne.addSeparator();
        //创建单选菜单项，并添加到ButtonGroup对象中
        copyFile=new JRadioButtonMenuItem("复制");
        pasteFile=new JRadioButtonMenuItem("粘贴");
        buttonGroupOne.add(copyFile);
        buttonGroupOne.add(pasteFile);
        //将copyFile添加到jPopupMenuOne中
        jPopupMenuOne.add(copyFile);
        //将pasteFile添加到jPopupMenuOne中
        jPopupMenuOne.add(pasteFile);
        jPopupMenuOne.addSeparator();
        exit=new JMenuItem("退出");
        //将exit添加到jPopupMenuOne中
        jPopupMenuOne.add(exit);
        //创建监听器对象
        MouseListener popupListener=new PopupListener(jPopupMenuOne);
        //向主窗口注册监听器
        this.addMouseListener(popupListener);
        this.setTitle("弹出式菜单");
        this.setBounds(100,100,250,150);
        this.setVisible(true);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
    public static void main(String args[])
    {
        new JPopupMenuDemo();
    }
    //添加内部类，其扩展了MouseAdapter类，用来处理鼠标事件
    class PopupListener extends MouseAdapter
    {
        JPopupMenu popupMenu;
        PopupListener(JPopupMenu popupMenu)
        {
            this.popupMenu=popupMenu;
        }
        public void mousePressed(MouseEvent e)
        {
            showPopupMenu(e);
        }
        public void mouseReleased(MouseEvent e)
        {
            showPopupMenu(e);
        }
        private void showPopupMenu(MouseEvent e)
        {
            if(e.isPopupTrigger())
            {
                //如果当前事件与鼠标事件相关，则弹出菜单
                popupMenu.show(e.getComponent(),e.getX(),e.getY());
            }
        }
    }
}

弹出式菜单

十九、swing工具栏

二十、swing文件选择器和颜色选择器

在开发应用程序时经常需要选择文件和选择颜色的功能。例如，从选择的文件中导入数据，为窗体选择背景颜色等。本节详细介绍 Swing 中文件选择器和颜色选择器的使用。

1、文件选择器

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
public class JFileChooserDemo
{
    private JLabel label=new JLabel("所选文件路径：");
    private JTextField jtf=new JTextField(25);
    private JButton button=new JButton("浏览");
    public JFileChooserDemo()
    {
        JFrame jf=new JFrame("文件选择器");
        JPanel panel=new JPanel();
        panel.add(label);
        panel.add(jtf);
        panel.add(button);
        jf.add(panel);
        jf.pack();    //自动调整大小
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        button.addActionListener(new MyActionListener());    //监听按钮事件
    }
    //Action事件处理
    class MyActionListener implements ActionListener
    {
        @Override
        public void actionPerformed(ActionEvent arg0)
        {
            JFileChooser fc=new JFileChooser("F:\\");
            int val=fc.showOpenDialog(null);    //文件打开对话框
            if(val==fc.APPROVE_OPTION)
            {
                //正常选择文件
                jtf.setText(fc.getSelectedFile().toString());
            }
            else
            {
                //未正常选择文件，如选择取消按钮
                jtf.setText("未选择文件");
            }
        }
    }
    public static void main(String[] args)
    {
        new JFileChooserDemo();
    }
}

文件保存对话框

2、颜色选择器

方法名称	说明
getColor()	获取颜色选取器的当前颜色值
getDragEnabled()	获取dragEnabled 属性的值
setColor(Color color)	将颜色选取器的当前颜色设置为指定颜色
setColor(int c)	将颜色选取器的当前颜色设置为指定颜色
setColor(int r,int g,int b)	将颜色选取器的当前颜色设置为指定的 RGB 颜色
setDragEnabled(boolean b)	设置 dragEnabled 属性，该属性必须为 true 才能启用对此组件的自动拖动处理（拖放操作的第一部分）

import java.awt.Color;
import javax.swing.JColorChooser;
import javax.swing.JFrame;
public class JColorChooserDemo
{
    public static void main(String[] args)
    {
        JFrame frame=new JFrame("颜色选择器");
        JColorChooser cc=new JColorChooser();
        cc.showDialog(frame,"颜色选择器",Color.white);
        //JColorChooser.showDialog(frame,"颜色选择器",Color.white);
        //设置窗口的关闭动作、标题、大小位置以及可见性等
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setBounds(100,100,400,200);
        frame.setVisible(true);
    }
}

颜色选择器

二十一、swing对话框

对话框通常用作从用户处接收附加信息，或者提供发生了某种事件的通知。Java 提供了 JOptionPane 类，用来创建标准对话框，也可以通过扩展 JDialog 类创建自定义的对话框。JOptionPane 类可以用来创建 4 种类型的标准对话框：确认对话框、消息对话框、输入对话框。

1、确认对话框

import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.LayoutManager;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class SwingTester {
   public static void main(String[] args) {
      createWindow();
   }

   private static void createWindow() {    
      JFrame frame = new JFrame("Swing确认对话框示例(yiibai.com)");
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      createUI(frame);
      frame.setSize(560, 200);      
      frame.setLocationRelativeTo(null);  
      frame.setVisible(true);
   }

   private static void createUI(final JFrame frame){  
      JPanel panel = new JPanel();
      LayoutManager layout = new FlowLayout();  
      panel.setLayout(layout);       

      JButton button = new JButton("点击我~");
      final JLabel label = new JLabel();
      button.addActionListener(new ActionListener() {
         @Override
         public void actionPerformed(ActionEvent e) {
            int result = JOptionPane.showConfirmDialog(frame,"确定要退出?", "Swing对话框",
               JOptionPane.YES_NO_CANCEL_OPTION,
               JOptionPane.QUESTION_MESSAGE);
            if(result == JOptionPane.YES_OPTION){
               label.setText("你选择了: 是");
            }else if (result == JOptionPane.NO_OPTION){
               label.setText("你选择了: 否");
            }else if (result == JOptionPane.CANCEL_OPTION){
               label.setText("你选择了: 取消");
            }else {
               label.setText("什么也没有选择！");
            }
         }
      });

      panel.add(button);
      panel.add(label);
      frame.getContentPane().add(panel, BorderLayout.CENTER);    
   }  
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LiCqUZbI-1607740011688)(C:\Users\86134\AppData\Roaming\Typora\typora-user-images\image-20201205152357991.png)]

2、消息对话框

import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.LayoutManager;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class SwingTester2 {
   public static void main(String[] args) {
      createWindow();
   }

   private static void createWindow() {    
      JFrame frame = new JFrame("Swing显示错误消息警告");
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      createUI(frame);
      frame.setSize(560, 200);      
      frame.setLocationRelativeTo(null);  
      frame.setVisible(true);
   }

   private static void createUI(final JFrame frame){  
      JPanel panel = new JPanel();
      LayoutManager layout = new FlowLayout();  
      panel.setLayout(layout);       
      JButton button = new JButton("点击我!");
      button.addActionListener(new ActionListener() {
         @Override
         public void actionPerformed(ActionEvent e) {
            JOptionPane.showMessageDialog(frame, "这是Swing错误警告消息~",
               "Swing显示错误消息警告", JOptionPane.ERROR_MESSAGE);
         }
      });

      panel.add(button);
      frame.getContentPane().add(panel, BorderLayout.CENTER);    
   }  
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-utCrrFuh-1607740011688)(C:\Users\86134\AppData\Roaming\Typora\typora-user-images\image-20201205152947287.png)]

3、输入对话框

import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.LayoutManager;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class SwingTester3 {
   public static void main(String[] args) {
      createWindow();
   }

   private static void createWindow() {    
      JFrame frame = new JFrame("Swing文本输入对话框");
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      createUI(frame);
      frame.setSize(560, 200);      
      frame.setLocationRelativeTo(null);  
      frame.setVisible(true);
   }

   private static void createUI(final JFrame frame){  
      JPanel panel = new JPanel();
      LayoutManager layout = new FlowLayout();  
      panel.setLayout(layout);       

      JButton button = new JButton("点击开始~");
      final JLabel label = new JLabel();
      button.addActionListener(new ActionListener() {
         @Override
         public void actionPerformed(ActionEvent e) {
            String result = (String)JOptionPane.showInputDialog(
               frame,
               "选择一种语言：", 
               "Swing文本输入框(示例)",            
               JOptionPane.PLAIN_MESSAGE,
               null,            
               null, 
               "Java? Python?"
            );
            if(result != null && result.length() > 0){
               label.setText("选择了:" + result);
            }else {
               label.setText("未选择！");
            }
         }
      });

      panel.add(button);
      panel.add(label);
      frame.getContentPane().add(panel, BorderLayout.CENTER);    
   }  
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xTQ4hWt4-1607740011689)(C:\Users\86134\AppData\Roaming\Typora\typora-user-images\image-20201205153246621.png)]

二十二、swing表格

表格是 Swing 新增加的组件，主要功能是把数据以二维表格的形式显示出来，并且允许用户对表格中的数据进行编辑。

方法名称	说明
getColumnCount()	返回列模型中的列数
getColumnN ame(int column)	返回出现在视图中 column 列位置处的列名称
getRowCount()	返回 JTable 中可以显示的行数（给定无限空间）
getRowSorter()	返回负责排序的对象
getSelectedColumn()	返回第一个选定列的索引，如果没有选定的列，则返回 -1
getSelectedRow()	返回第一个选定行的索引，如果没有选定的行，则返回 -1
getValueAt(int row,int column)	返回 row 和 column 位置的单元格值
isEditing()	如果正在编辑单元格，则返回 true
selectAll()	选择表中的所有行、列和单元格
setColumnSelectionInterval(int index0,int index1)	选择从 index0 到 index1之间（包含两端）的列
setRowSelectionInterval(int index0,int index1)	选择从 index0 到 index1 之间（包含两端）的行
setTableHeader(JTableHeader tableHeader)	将此 JTable 所使用的 tableHeader 设置为 newHeader
setUpdateSelectionOnSort(boolean update)	指定排序后是否应该更新选择
setValueAt(Object a Value,int row,int column)	设置表模型中 row 和 column 位置的单元格值

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.ListSelectionModel;
import javax.swing.border.EmptyBorder;
import javax.swing.table.DefaultTableModel;
public class RowDeleteDemo extends JFrame
{
    private JPanel contentPane;
    private JTable table;
    public RowDeleteDemo()
    {
        addWindowListener(new WindowAdapter()
        {
            @Override
            public void windowActivated(WindowEvent e)
            {
                do_this_windowActivated(e);
            }
        });
        setTitle("图书信息表");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100,100,450,200);
        contentPane=new JPanel();
        contentPane.setBorder(new EmptyBorder(5,5,5,5));
        contentPane.setLayout(new BorderLayout(0,0));
        setContentPane(contentPane);
        JPanel panel=new JPanel();
        contentPane.add(panel,BorderLayout.SOUTH);
        JButton button=new JButton("删除");
        button.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                do_button_actionPerformed(e);
            }
        });
        panel.add(button);
        JScrollPane scrollPane=new JScrollPane();
        contentPane.add(scrollPane,BorderLayout.CENTER);
        table=new JTable();
        table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
        scrollPane.setViewportView(table);
    }
    protected void do_this_windowActivated(WindowEvent e)
    {
        DefaultTableModel tableModel=(DefaultTableModel) table.getModel();    //获得表格模型
        tableModel.setRowCount(0);    //清空表格中的数据
        tableModel.setColumnIdentifiers(new Object[]{"书名","出版社","出版时间","丛书类别","定价"});    //设置表头
        tableModel.addRow(new Object[]{"Java从入门到精通（第2版）","清华大学出版社","2010-07-01","软件工程师入门丛书","59.8元"});    //增加列
        tableModel.addRow(new Object[]{"PHP从入门到精通（第2版）","清华大学出版社","2010-07-01","软件工程师入门丛书","69.8元"});
        tableModel.addRow(new Object[]{"Visual Basic从入门到精通（第2版）","清华大学出版社","2010-07-01","软件工程师入门丛书","69.8元"});
        tableModel.addRow(new Object[]{"Visual C++从入门到精通（第2版）","清华大学出版社","2010-07-01","软件工程师入门丛书","69.8元" });
        table.setRowHeight(30);
        table.setModel(tableModel);    //应用表格模型
    }
    protected void do_button_actionPerformed(ActionEvent e)
    {
        DefaultTableModel model=(DefaultTableModel) table.getModel();    //获得表格模型
        int[] selectedRows=table.getSelectedRows();
        for(int i=selectedRows[0];i<selectedRows.length;i++)
        {
            model.removeRow(selectedRows[0]);
        }
        table.setModel(model);
    }
    public static void main(String[] args)
    {
        RowDeleteDemo frame = new RowDeleteDemo();
        frame.setVisible(true);
    }
}

删除前表格数据

删除后表格数据

二十三、swing树

如果要显示一个层次关系分明的一组数据，用树结构是最合适的。树如同 Windows 资源管理器的左半部，可通过单击文件夹展开或者收缩内容。

Swing 使用 JTree 类实现树，它的主要功能是把数据按照树状进行显示，其数据来源于其他对象。JTree 树中最基本的对象叫作节点，表示在给定层次结构中的数据项。树以垂直方式显示数据，每行显示一个节点。树中只有一个根节点，所有其他节点从这里引出。除根节点外，其他节点分为两类：一类是代子节点的分支节点，另一类是不带子节点的叶节点。

构造方法	说明
JTree()	返回带有示例模型的 JTree
JTree(Object[] value)	返回 JTree，指定数组的每个元素作为不被显示的新根节点的子节点
JTree(TreeNode root)	返回 JTree，使用指定的 root 作为其根节点
JTree(TreeNode root,boolean aslcsAllowsChildren)	返回 JTree，使用指定的 root 作为其根节点，asksAllowsChildren 用于确定节点是否为叶节点

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
public class JTreeDemo
{
    public static void main(String[] agrs)
    {
        JFrame frame=new JFrame("教师学历信息");
        frame.setSize(330,300);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().add(new JTreeDemo().createComponent());
        frame.pack();
        frame.setVisible(true);
    }
    private JPanel createComponent()
    {
        JPanel panel=new JPanel();
        DefaultMutableTreeNode root=new DefaultMutableTreeNode("教师学历信息");
        String Teachers[][]=new String[3][];
        Teachers[0]=new String[]{"王鹏","李曼","韩小国","穆保龄","尚凌云","范超峰"};
        Teachers[1]=new String[]{"胡会强","张春辉","宋芳","阳芳","朱山根","张茜","宋媛媛"};
        Teachers[2]=new String[]{"刘丹","张小芳","刘华亮","聂来","吴琼"};
        String gradeNames[]={"硕士学历","博士学历","博士后学历"};
        DefaultMutableTreeNode node=null;
        DefaultMutableTreeNode childNode=null;
        int length=0;
        for(int i=0;i<3;i++)
        {
            length=Teachers[i].length;
            node=new DefaultMutableTreeNode(gradeNames[i]);
            for (int j=0;j<length;j++)
            {
                childNode=new DefaultMutableTreeNode(Teachers[i][j]);
                node.add(childNode);
            }
            root.add(node);
        }
        JTree tree=new JTree(root);
        panel.add(tree);
        panel.setVisible(true);
        return panel;
    }
}

教师学历信息运行效果

二十四、swing选项卡

使用选项卡可以在有限的布局空间内展示更多的内容。

JTabbedPane 类创建的选项卡可以通过单击标题或者图标在选项卡之间进行切换。

import javax.swing.JPanel;
import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
public class TabbedPaneDemo extends JPanel
{
	public TabbedPaneDemo()
	{
	    super(new GridLayout(1,1));
	    JTabbedPane tabbedPane=new JTabbedPane();
	    ImageIcon icon=createImageIcon("tab.jp1g");
	    JComponent panel1=makeTextPanel("计算机名");
	    tabbedPane.addTab("计算机名",icon, panel1,"Does nothing");
	    tabbedPane.setMnemonicAt(0,KeyEvent.VK_1);
	    JComponent panel2=makeTextPanel("硬件");
	    tabbedPane.addTab("硬件",icon,panel2,"Does twice as much nothing");
	    tabbedPane.setMnemonicAt(1,KeyEvent.VK_2);
	    JComponent panel3=makeTextPanel("高级");
	    tabbedPane.addTab("高级",icon,panel3,"Still does nothing");
	    tabbedPane.setMnemonicAt(2,KeyEvent.VK_3);
	    JComponent panel4=makeTextPanel("系统保护");
	    panel4.setPreferredSize(new Dimension(410,50));
	    tabbedPane.addTab("系统保护",icon,panel4,"Does nothing at all");
	    tabbedPane.setMnemonicAt(3,KeyEvent.VK_4);
	    add(tabbedPane);
	}
	protected JComponent makeTextPanel(String text)
	{
	    JPanel panel=new JPanel(false);
	    JLabel filler=new JLabel(text);
	    filler.setHorizontalAlignment(JLabel.CENTER);
	    panel.setLayout(new GridLayout(1,1));
	    panel.add(filler);
	    return panel;
	}
	protected static ImageIcon createImageIcon(String path)
	{
	    java.net.URL imgURL=TabbedPaneDemo.class.getResource(path);
	    if(imgURL!=null)
	    {
	        return new ImageIcon(imgURL);
	    }
	    else
	    {
	        System.err.println("Couldn't find file: "+path);
	        return null;
	    }
	}
    public static void main(String[] args)
    {
        JFrame frame=new JFrame("我的电脑 - 属性");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(new TabbedPaneDemo(),BorderLayout.CENTER);
        frame.pack();
        frame.setVisible(true);
    }
}

文本选项卡面板

二十五、swing文本编辑器的实现

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.JTextArea;
import javax.swing.JToolBar;
import javax.swing.filechooser.FileNameExtensionFilter;
public class TextFileOpener extends JFrame
{
    private static final long serialVersionUID=-9077023825514749548L;
    private JTextArea ta_showText;    //定义显示文件属性的文本域
    private JTextArea ta_showProperty;    //定义显示文件内容的文本域
    public TextFileOpener()
    {
        setTitle("文本编辑器");    //设置窗体标题
        setBounds(100,100,400,250);    //设置窗体位置和大小
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);    //设置窗体默认关闭方式
        final JMenuBar menuBar=new JMenuBar();    //创建菜单栏
        setJMenuBar(menuBar);    //把菜单栏放到窗体上
        final JMenu mn_file=new JMenu();    //创建文件菜单
        mn_file.setText("文件");    //为文件菜单设置标题
        menuBar.add(mn_file);    //把文件菜单添加到菜单栏上
        final JMenuItem mi_open=new JMenuItem();    //创建打开菜单项
        mi_open.addActionListener(new ActionListener()
        {
            //为打开菜单项添加监听器
            public void actionPerformed(final ActionEvent arg0)
            {
                openTextFile();    //调用方法，操作文件
            }
        });
        mi_open.setText("打开");    //设置打开菜单项的标题
        mn_file.add(mi_open);    //把打开菜单项添加到文件菜单
        mn_file.addSeparator();    //添加菜单分隔符
        final JMenuItem mi_exit=new JMenuItem();    //创建退出菜单项
        mi_exit.addActionListener(new ActionListener()
        {
            //为退出菜单项添加监听器
            public void actionPerformed(final ActionEvent arg0)
            {
                System.exit(0);    //退出系统
            }
        });
        mi_exit.setText("退出");    //设置退出菜单项的标题
        mn_file.add(mi_exit);    //把退出菜单项添加到文件菜单
        final JMenu mn_edit=new JMenu();    //创建编辑菜单
        mn_edit.setText("编辑");    //为编辑菜单设置标题
        menuBar.add(mn_edit);    //把编辑菜单添加到菜单栏上
        final JMenuItem mi_copy=new JMenuItem();    //创建复制菜单项
        mi_copy.setText("复制");    //设置复制菜单项的标题
        mn_edit.add(mi_copy);    //把复制菜单项添加到编辑菜单
        final JMenuItem mi_cut=new JMenuItem();    //创建剪切菜单项
        mi_cut.setText("剪切");    //设置剪切菜单项的标题
        mn_edit.add(mi_cut);    //把剪切菜单项添加到编辑菜单
        final JMenuItem mi_paste=new JMenuItem();    //创建粘贴菜单项
        mi_paste.setText("粘贴");    //设置粘贴菜单项的标题
        mn_edit.add(mi_paste);    //把粘贴菜单项添加到编辑菜单
        final JToolBar toolBar=new JToolBar();    //创建工具栏
        getContentPane().add(toolBar,BorderLayout.NORTH);    //把工具栏放到窗体上方
        final JButton btn_open=new JButton();    //创建工具按钮
        btn_open.addActionListener(new ActionListener()
        {
            //添加动作监听器
            public void actionPerformed(final ActionEvent arg0)
            {
                openTextFile();    //调用方法，操作文件
            }
        });
        btn_open.setText("  打  开  ");    //设置工具按钮的标题
        toolBar.add(btn_open);    //把工具按钮添加到工具栏上
        final JButton btn_exit=new JButton();    //创建工具按钮
        btn_exit.addActionListener(new ActionListener()
        {
            //添加动作监听器
            public void actionPerformed(final ActionEvent arg0)
            {
                System.exit(0);    //退出系统
            }
        });
        btn_exit.setText("  退  出  ");    //设置工具按钮的标题
        toolBar.add(btn_exit);    //把工具按钮添加到工具栏上
        final JTabbedPane tabbedPane=new JTabbedPane();    //创建选项卡面板
        getContentPane().add(tabbedPane,BorderLayout.CENTER);    //把选项卡面板放到窗体中央
        final JScrollPane scrollPane1=new JScrollPane();    //创建滚动面板
        //把滚动面板放到选项卡的第一个选项页
        tabbedPane.addTab("文件的属性",null,scrollPane1,null);
        ta_showProperty=new JTextArea();    //创建文本域
        //把文本域添加到滚动面板的视图中
        scrollPane1.setViewportView(ta_showProperty);
        final JScrollPane scrollPane2=new JScrollPane();    //创建滚动面板
        //把滚动面板放到选项卡的第二个选项页
        tabbedPane.addTab("文件的内容",null,scrollPane2,null);
        ta_showText=new JTextArea();    //创建文本域
        //把文本域添加到滚动面板的视图中
        scrollPane2.setViewportView(ta_showText);
    }
  //用于打开文件并获得文件信息的方法
    public void openTextFile()
    {
        JFileChooser fileChooser=new JFileChooser();    //创建文件选择对话框
        fileChooser.setFileFilter(new FileNameExtensionFilter("文本文件","txt"));
        int returnValue=fileChooser.showOpenDialog(getContentPane());    //打开文件选择对话框
        if(returnValue==JFileChooser.APPROVE_OPTION)
        {
            //判断用户是否选择了文件
            File file=fileChooser.getSelectedFile();    //获得文件对象
            //获得文件的绝对路径
            ta_showProperty.append("文件的绝对路径是："+file.getAbsolutePath()+"\n");
            //是否为隐藏文件
            ta_showProperty.append("该文件是隐藏文件吗？"+file.isHidden()+"\n");
            FileReader reader;    //声明字符流
            BufferedReader in;    //声明字符缓冲流
            try
            {
                reader=new FileReader(file);    //创建字符流
                in=new BufferedReader(reader);    //创建字符缓冲流
                String info=in.readLine();    //从文件中读取一行信息
                while(info!=null)
                {
                    //判断是否读到内容
                    ta_showText.append(info+"\n");    //把读到的信息追加到文本域中
                    info=in.readLine();    //继续读下一行信息
                }
                in.close();    //关闭字符缓冲流
                reader.close();    //关闭字符流
            }
            catch(Exception ex)
            {
                ex.printStackTrace();    //输出栈踪迹
            }
        }
    }
    public static void main(String[] args)
    {
        TextFileOpener frame=new TextFileOpener();
        frame.setVisible(true);
    }   
}

查看文件属性

查看文件内容

荔枝1995

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
java swing

一、swing简介Swing 是新一代的图形界面工具。使用 Swing 来开发图形界面比 AWT 更加优秀，因为 Swing 是一种轻量级组件，它采用纯 Java 实现，不再依赖于本地平台的图形界面，所以可以在所有平台上保持相同的运行效果，对跨平台支持比较出色。除此之外，Swing 提供了比 AWT 更多的图形界面组件，因此可以开发出美观的图形界面程序。1、swing类库结构2、swing包包名称描述javax.swing提供一组“轻量级”组件，尽量让这些组件在所有平台上的工
复制链接

扫一扫