&显示一个项目列表，指明用户可以执行的各项操作 &
&包含 javax.swing 包的菜单类的类层次结构
JMenuBar 类 2-1
&只要选中 JMenuItem，就会产生通过重写 actionPerformed()方法进行处理的 ActionEvent
JMenuBar 类 2-2
JMenu 类 2-1
&JMenu 组件有两个用途
&当它添加至 JMenuBar 时，将显示为文本字符串
&当用户单击此菜单项时，则显示一个弹出式菜单&&
JMenu 类 2-2
JMenuItem 类 2-2
mnuFormat.setText(&格式");
mnuNew.setText(&新建");
mnuOpen.setText(&打开...");
mnuSave.setText(&保存");
mnuSaveAs.setText(&另存为...");
mnuExit.setText(&退出");
mnuHelp.setText(&帮助");
mnuNotepad.add(mnuFile);
mnuNotepad.add(mnuEdit);
mnuNotepad.add(mnuFormat);
mnuNotepad.add(mnuHelp);
mnuFile.add(mnuNew);
mnuFile.add(mnuOpen);
mnuFile.add(mnuSave);
mnuFile.add(mnuSaveAs);
mnuFile.add(mnuExit);
&JPopupMenu 类 2-1
&用于显示展开形式的菜单
&可显示在屏幕的任何地方
&通常是由单击鼠标右键触发的
&激活弹出式菜单项之一所执行的操作总是依赖于上下文
&可供 JPopupMenu 类使用的方法
JPopupMenu 类 2-2
public JMenuItem add(JMenuItem menuItem)
将指定菜单项添加至菜单末尾
public JMenuItem add(Strings)
使用指定文本新建菜单项，并将其添加至菜单末尾
public void show(Component c, int x, int y)
在组件&c&的坐标空间的 (x, y) 位置显示弹出式菜单
public Boolean isPopupTrigger()
确定是否将鼠标事件看作是当前平台的弹出触发器
JCheckBoxMenuItem类
&这个类是 JMenuItem 类的子类
&使用这个类可实现复选框，默认情况下可为其分配选定标记或取消选定标记
JRadioButtonMenuItem类
&在同一时刻只能选择一个菜单项 &
对话框 6-1
&Java 中的对话框是一个容器，它充当父容器的子容器
&JOptionPane 这个类支持的功能有：
&布局标准对话框
&指定对话框的标题和文本
&提供图标和自定义按钮文本
&JOptionPane 可用于显示各种图标，如用于警告消息、问题、错误和信息等的图标
对话框 6-2
&以下是一些可供 JOptionPane 类使用的构造方法：
&JOptionPane()
&JOptionPane(Object&message)
&JOptionPane(Object&message, int&messageType)
&JOptionPane(Object&message, int&messageType, int&optionType)
&JOptionPane(Object&message, int&messageType, int&optionType, Icon icon)
对话框 6-3
&showXxxDialog() 方法的一些重载版本
&JOptionPane 类的 showXxxDialog 方法是显示模式对话框最常用的方法
对话框 6-4
对话框 6-5
&用于验证用户身份和显示相应消息的代码
&验证用户身份的应用程序
&向工程中添加标题为&User_Login&的应用程序
&将 JOptionPane 拖放至该应用程序
&该应用程序将验证用户身份并显示相应消息 &
对话框 6-6
public void btnOk_actionPerformed(ActionEvent e) {
user = txtUserName.getText();
password = txtPassword.getText();
if (user.equals("admin") && password.equals("aptech"))
dlgMessage.showMessageDialog(this,"您是授权用户","经验证的用户",JOptionPane.INFORMATION_MESSAGE);
dlgMessage.showMessageDialog(this,"非法用户名或密码 ","非法用户",JOptionPane.ERROR_MESSAGE);
txtUserName.setText("");
txtPassword.setText("");
txtUserName.setFocusable(true);
菜单的事件处理
JTable 9-1
&以表格方式维护大量数据比以列表方式更加方便
&使用 Swing 中的 JTable 类可以创建表
&JTable 9-2
&创建一个 TableDemo 工程
&单击&File&---》&New&
&选择&Application&，输入 TableDemo 作为应用程序的类名称
&单击&Next&，输入 TableFrame 作为框架的类名称，并输入&欢迎使用 JTable&作为其标题
&单击&Next&，确保已选定&Create Runtime Configuration&选项
&单击&Finish&
&单击&Design&选项卡
&选择组件面板中的&JTable&，并将其拖入框架
&JTable 9-4
JTable 9-5
JTable 9-6
JTable 9-7
&运行该工程
&此时创建的表无表头
&要显示表头，请单击&Design&选项卡
&选定该表，右击其中的表头属性
&单击关联菜单中的&Expose as Class level variable&选项
&此时将显示表头
&运行该工程
&为表头设置属性&
&JTable 9-9
&以下代码将在&Source&选项卡中自动生成 &
import java.awt.BorderL
import java.awt.D
import javax.swing.JF
import javax.swing.JP
import javax.swing.JT
import java.awt.*;
import javax.swing.*;
import javax.swing.table.JTableH
public class TableFrame extends JFrame {
JPanel contentP
Object[ ][ ] cells =
{"Java",new Integer(01),new Integer(400)},
{"Oracle",new Integer(02),new Integer(500)},
{"C#",new Integer(03),new Integer(700)},
String[] colnames={"课程名称","课程编号","学费（元）"};
JTable jTable1 = new JTable(cells, colnames);
JTableHeader jTableHeader1 = jTable1.getTableHeader();
public TableFrame() {
setDefaultCloseOperation(EXIT_ON_CLOSE);
} catch (Exception exception) {
exception.printStackTrace();
*初始化组件.
* @throws java.lang.Exception
contentPane = (JPanel) getContentPane();
contentPane.setLayout(null);
setSize(new Dimension(400, 300));
setTitle("欢迎使用 JTable");
jTable1.setBackground(Color.yellow);
jTable1.setBorder(null);
jTable1.setGridColor(Color.black);
jTable1.setSelectionBackground(Color.orange);
jTable1.setBounds(new Rectangle(11, 29, 251, 161));
jTableHeader1.setBackground(Color.pink);
jTableHeader1.setBounds(new Rectangle(10, 10, 252, 20));
contentPane.add(jTableHeader1);
contentPane.add(jTable1);
import javax.imageio.ImageIO;
import java.awt.image.BufferedI
import java.awt.C
import java.awt. Graphics
BufferedImage image = new BufferedImage(800, 600, BufferedImage.TYPE_INT_RGB);&
gg.dispose();
FileOutputStream fw=new FileOutputStream(new File("cc.JPG"));
ImageIO.write(image, "JPG",fw);
&Swing 菜单由 JMenubar、JMenuItem 和 JMenu 组成
&AbstractButton 是 JMenu 类的父类
&创建 JMenuBar 的实例以创建菜单
&与 JMenuItem 及其与菜单栏关联的子类不同，JPopupMenu 可显示在屏幕的任何地方
&JCheckBoxMenuItem 和 JRadioButtonMenuItem 用于实现菜单栏中的复选框和单选按钮
&JOptionPane 类用于显示对话框
现在贴出代码：
public class AllLookAndFeel {
public static void main(String[] args) {
System.out.println("当前系统可用的所有LAF:");
for (UIManager.LookAndFeelInfo info : UIManager
.getInstalledLookAndFeels()) {
System.out.println(info.getName() + "---&" + info);
public class BindKeyTest {
JFrame jf = new JFrame("测试键盘绑定");
JTextArea jta = new JTextArea(5, 30);
JButton jb = new JButton("发送");
JTextField jtf = new JTextField(15);
public void init() {
jf.add(jta);
JPanel jp = new JPanel();
jp.add(jtf);
jp.add(jb);
jf.add(jp, BorderLayout.SOUTH);
// 发送消息的Action,Action是ActionListener的子接口
Action sendMsg = new AbstractAction() {
public void actionPerformed(ActionEvent e) {
jta.append(jtf.getText() + "\n");
jtf.setText("");
// 添加事件监听器
jb.addActionListener(sendMsg);
// 将Ctrl+Enter键和"send"关联
jtf.getInputMap().put(
KeyStroke.getKeyStroke('\n',
java.awt.event.InputEvent.CTRL_MASK), "send");
// 将"send"和sendMsg Action关联
jtf.getActionMap().put("send", sendMsg);
jf.pack();
jf.setVisible(true);
public static void main(String[] args) {
new BindKeyTest().init();
public class BorderTest {
private JFrame jf = new JFrame("测试边框");
public void init() {
jf.setLayout(new GridLayout(2, 4));
// 使用静态工厂方法创建BevelBorder
Border bb = BorderFactory.createBevelBorder(BevelBorder.RAISED,
Color.RED, Color.GREEN, Color.BLUE, Color.GRAY);
jf.add(getPanelWithBorder(bb, "BevelBorder"));
// 使用静态工厂方法创建LineBorder
Border lb = BorderFactory.createLineBorder(Color.ORANGE, 10);
jf.add(getPanelWithBorder(lb, "LineBorder"));
// 使用静态工厂方法创建EmptyBorder，EmptyBorder就是在组件四周留空
Border eb = BorderFactory.createEmptyBorder(20, 5, 10, 30);
jf.add(getPanelWithBorder(eb, "EmptyBorder"));
// 使用静态工厂方法创建EtchedBorder
Border etb = BorderFactory.createEtchedBorder(EtchedBorder.RAISED,
Color.RED, Color.GREEN);
jf.add(getPanelWithBorder(etb, "EtchedBorder"));
// 直接创建TitledBorder，TitledBorder边框就是为原有的边框增加标题
TitledBorder tb = new TitledBorder(lb, "测试标题", TitledBorder.LEFT,
TitledBorder.BOTTOM, new Font("StSong", Font.BOLD, 18),
Color.BLUE);
jf.add(getPanelWithBorder(tb, "TitledBorder"));
// 直接创建MatteBorder，MatteBorder边框是EmptyBorder的子类，
// 它可以指定留空区域的颜色或背景，此处是指定颜色
MatteBorder mb = new MatteBorder(20, 5, 10, 30, Color.GREEN);
jf.add(getPanelWithBorder(mb, "MatteBorder"));
// 直接创建CompoundBorder，CompoundBorder边框将两个边框组合成新边框
CompoundBorder cb = new CompoundBorder(new LineBorder(Color.RED, 8), tb);
jf.add(getPanelWithBorder(cb, "CompoundBorder"));
jf.pack();
jf.setVisible(true);
public static void main(String[] args) {
new BorderTest().init();
public JPanel getPanelWithBorder(Border b, String BorderName) {
JPanel p = new JPanel();
p.add(new JLabel(BorderName));
// 为Panel组件设置边框
p.setBorder(b);
public class HandDraw {
// 画图区的宽度
private final int AREA_WIDTH = 500;
// 画图区的高度
private final int AREA_HEIGHT = 400;
// 下面的preX、preY保存了上一次鼠标拖动事件的鼠标坐标
private int preX = -1;
private int preY = -1;
// 定义一个右键菜单用于设置画笔颜色
JPopupMenu pop = new JPopupMenu();
JMenuItem chooseColor = new JMenuItem("选择颜色");
// 定义一个BufferedImage对象
BufferedImage image = new BufferedImage(AREA_WIDTH, AREA_HEIGHT,
BufferedImage.TYPE_INT_RGB);
// 获取image对象的Graphics
Graphics g = image.getGraphics();
private JFrame f = new JFrame("简单手绘程序");
private DrawCanvas drawArea = new DrawCanvas();
// 用于保存画笔颜色
private Color foreColor = new Color(255, 0, 0);
public void init()
chooseColor.addActionListener(ae -& {
// 下面代码直接弹出一个模式的颜色选择对话框，并返回用户选择的颜色
// foreColor = JColorChooser.showDialog(f
, "选择画笔颜色" , foreColor);
// 下面代码则弹出一个非模式的颜色选择对话框，
// 并可以分别为&确定&按钮、&取消&按钮指定事件监听器
final JColorChooser colorPane = new JColorChooser(foreColor);
JDialog jd = JColorChooser.createDialog(f , "选择画笔颜色"
, false, colorPane, e -& foreColor = colorPane.getColor(), null);
jd.setVisible(true);
// 将菜单项组合成右键菜单
pop.add(chooseColor);
// 将右键菜单添加到drawArea对象中
drawArea.setComponentPopupMenu(pop);
// 将image对象的背景色填充成白色
g.fillRect(0 , 0 ,AREA_WIDTH , AREA_HEIGHT);
drawArea.setPreferredSize(new Dimension(AREA_WIDTH , AREA_HEIGHT));
// 监听鼠标移动动作
drawArea.addMouseMotionListener(new MouseMotionAdapter()
// 实现按下鼠标键并拖动的事件处理器
public void mouseDragged(MouseEvent e)
// 如果preX和preY大于0
if (preX & 0 && preY & 0)
// 设置当前颜色
g.setColor(foreColor);
// 绘制从上一次鼠标拖动事件点到本次鼠标拖动事件点的线段
g.drawLine(preX , preY , e.getX() , e.getY());
// 将当前鼠标事件点的X、Y坐标保存起来
preX = e.getX();
preY = e.getY();
// 重绘drawArea对象
drawArea.repaint();
// 监听鼠标事件
drawArea.addMouseListener(new MouseAdapter()
// 实现鼠标松开的事件处理器
public void mouseReleased(MouseEvent e)
// 松开鼠标键时，把上一次鼠标拖动事件的X、Y坐标设为-1。
preX = -1;
preY = -1;
f.add(drawArea);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
public static void main(String[] args) {
new HandDraw().init();
// 让画图区域继承JPanel类
class DrawCanvas extends JPanel {
// 重写JPanel的paint方法，实现绘画
public void paint(Graphics g) {
// 将image绘制到该组件上
g.drawImage(image, 0, 0, null);
public class ImageViewer {
// 定义图片预览组件的大小
final int PREVIEW_SIZE = 100;
JFrame jf = new JFrame("简单图片查看器");
JMenuBar menuBar = new JMenuBar();
// 该label用于显示图片
JLabel label = new JLabel();
// 以当前路径创建文件选择器
JFileChooser chooser = new JFileChooser(".");
JLabel accessory = new JLabel();
// 定义文件过滤器
ExtensionFileFilter filter = new ExtensionFileFilter();
public void init()
// --------下面开始初始化JFileChooser的相关属性--------
创建一个FileFilter
filter.addExtension("jpg");
filter.addExtension("jpeg");
filter.addExtension("gif");
filter.addExtension("png");
filter.setDescription("图片文件(*.jpg,*.jpeg,*.gif,*.png)");
chooser.addChoosableFileFilter(filter);
// 禁止&文件类型&下拉列表中显示&所有文件&选项。
chooser.setAcceptAllFileFilterUsed(false);
// 为文件选择器指定自定义的FileView对象
chooser.setFileView(new FileIconView(filter));
// 为文件选择器指定一个预览图片的附件
chooser.setAccessory(accessory);
// 设置预览图片组件的大小和边框
accessory.setPreferredSize(new Dimension(PREVIEW_SIZE, PREVIEW_SIZE));
accessory.setBorder(BorderFactory.createEtchedBorder());
// 用于检测被选择文件的改变事件
chooser.addPropertyChangeListener(event -& {
// JFileChooser的被选文件已经发生了改变
if (event.getPropertyName() ==
JFileChooser.SELECTED_FILE_CHANGED_PROPERTY)
// 获取用户选择的新文件
File f = (File) event.getNewValue();
if (f == null)
accessory.setIcon(null);
// 将所选文件读入ImageIcon对象中
ImageIcon icon = new ImageIcon(f.getPath());
// 如果图像太大，则缩小它
if(icon.getIconWidth() & PREVIEW_SIZE)
icon = new ImageIcon(icon.getImage().getScaledInstance
(PREVIEW_SIZE, -1, Image.SCALE_DEFAULT));
// 改变accessory Label的图标
accessory.setIcon(icon);
// ------下面代码开始为该窗口安装菜单------
JMenu menu = new JMenu("文件");
menuBar.add(menu);
JMenuItem openItem = new JMenuItem("打开");
menu.add(openItem);
// 单击openItem菜单项显示&打开文件&的对话框
openItem.addActionListener(event -& {
// 设置文件对话框的当前路径
// chooser.setCurrentDirectory(new File("."));
// 显示文件对话框
int result = chooser.showDialog(jf , "打开图片文件");
// 如果用户选择了APPROVE（同意）按钮，即打开，保存的等效按钮
if(result == JFileChooser.APPROVE_OPTION)
String name = chooser.getSelectedFile().getPath();
// 显示指定图片
label.setIcon(new ImageIcon(name));
JMenuItem exitItem = new JMenuItem("Exit");
menu.add(exitItem);
// 为退出菜单绑定事件监听器
exitItem.addActionListener(event -& System.exit(0));
jf.setJMenuBar(menuBar);
// 添加用于显示图片的JLabel组件。
jf.add(new JScrollPane(label));
jf.pack();
jf.setVisible(true);
public static void main(String[] args) {
new ImageViewer().init();
// 创建FileFilter的子类，用以实现文件过滤功能
class ExtensionFileFilter extends FileFilter {
private ArrayList&String& extensions = new ArrayList&&();
// 自定义方法，用于添加文件扩展名
public void addExtension(String extension) {
if (!extension.startsWith(".")) {
extension = "." +
extensions.add(extension.toLowerCase());
// 用于设置该文件过滤器的描述文本
public void setDescription(String aDescription) {
description = aD
// 继承FileFilter类必须实现的抽象方法，返回该文件过滤器的描述文本
public String getDescription() {
// 继承FileFilter类必须实现的抽象方法，判断该文件过滤器是否接受该文件
public boolean accept(File f) {
// 如果该文件是路径，接受该文件
if (f.isDirectory())
return true;
// 将文件名转为小写（全部转为小写后比较，用于忽略文件名大小写）
String name = f.getName().toLowerCase();
// 遍历所有可接受的扩展名，如果扩展名相同，该文件就可接受。
for (String extension : extensions) {
if (name.endsWith(extension)) {
return true;
return false;
// 自定义一个FileView类，用于为指定类型的文件或文件夹设置图标
class FileIconView extends FileView {
private FileF
public FileIconView(FileFilter filter) {
this.filter =
// 重写该方法，为文件夹、文件设置图标
public Icon getIcon(File f) {
if (!f.isDirectory() && filter.accept(f)) {
return new ImageIcon("ico/pict.png");
} else if (f.isDirectory()) {
// 获取所有根路径
File[] fList = File.listRoots();
for (File tmp : fList) {
// 如果该路径是根路径
if (tmp.equals(f)) {
return new ImageIcon("ico/dsk.png");
return new ImageIcon("ico/folder.png");
// 使用默认图标
return null;
public class JOptionPaneTest {
JFrame jf = new JFrame("测试JOptionPane");
// 分别定义6个面板用于定义对话框的几种选项
private ButtonPanel messageP
private ButtonPanel messageTypeP
private ButtonPanel msgP
private ButtonPanel confirmP
private ButtonPanel optionsP
private ButtonPanel inputP
private String messageString = "消息区内容";
private Icon messageIcon = new ImageIcon("ico/heart.png");
private Object messageObject = new Date();
private Component messageComponent = new JButton("组件消息");
private JButton msgBn = new JButton("消息对话框");
private JButton confrimBn = new JButton("确认对话框");
private JButton inputBn = new JButton("输入对话框");
private JButton optionBn = new JButton("选项对话框");
public void init() {
JPanel top = new JPanel();
top.setBorder(new TitledBorder(new EtchedBorder(), "对话框的通用选项",
TitledBorder.CENTER, TitledBorder.TOP));
top.setLayout(new GridLayout(1, 2));
// 消息类型Panel，该Panel中的选项决定对话框的图标
messageTypePanel = new ButtonPanel("选择消息的类型", new String[] {
"ERROR_MESSAGE", "INFORMATION_MESSAGE", "WARNING_MESSAGE",
"QUESTION_MESSAGE", "PLAIN_MESSAGE" });
// 消息内容类型的Panel，该Panel中的选项决定对话框的消息区的内容
messagePanel = new ButtonPanel("选择消息内容的类型", new String[] { "字符串消息",
"图标消息", "组件消息", "普通对象消息", "Object[]消息" });
top.add(messageTypePanel);
top.add(messagePanel);
JPanel bottom = new JPanel();
bottom.setBorder(new TitledBorder(new EtchedBorder(), "弹出不同的对话框",
TitledBorder.CENTER, TitledBorder.TOP));
bottom.setLayout(new GridLayout(1, 4));
// 创建用于弹出消息对话框的Panel
msgPanel = new ButtonPanel("消息对话框", null);
msgBn.addActionListener(new ShowAction());
msgPanel.add(msgBn);
// 创建用于弹出确认对话框的Panel
confirmPanel = new ButtonPanel("确认对话框", new String[] {
"DEFAULT_OPTION", "YES_NO_OPTION", "YES_NO_CANCEL_OPTION",
"OK_CANCEL_OPTION" });
confrimBn.addActionListener(new ShowAction());
confirmPanel.add(confrimBn);
// 创建用于弹出输入对话框的Panel
inputPanel = new ButtonPanel("输入对话框",
new String[] { "单行文本框", "下拉列表选择框" });
inputBn.addActionListener(new ShowAction());
inputPanel.add(inputBn);
// 创建用于弹出选项对话框的Panel
optionsPanel = new ButtonPanel("选项对话框", new String[] { "字符串选项", "图标选项",
"对象选项" });
optionBn.addActionListener(new ShowAction());
optionsPanel.add(optionBn);
bottom.add(msgPanel);
bottom.add(confirmPanel);
bottom.add(inputPanel);
bottom.add(optionsPanel);
Box box = new Box(BoxLayout.Y_AXIS);
box.add(top);
box.add(bottom);
jf.add(box);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.pack();
jf.setVisible(true);
// 根据用户选择返回选项类型
private int getOptionType() {
switch (confirmPanel.getSelection()) {
case "DEFAULT_OPTION":
return JOptionPane.DEFAULT_OPTION;
case "YES_NO_OPTION":
return JOptionPane.YES_NO_OPTION;
case "YES_NO_CANCEL_OPTION":
return JOptionPane.YES_NO_CANCEL_OPTION;
return JOptionPane.OK_CANCEL_OPTION;
// 根据用户选择返回消息
private Object getMessage() {
switch (messagePanel.getSelection()) {
case "字符串消息":
return messageS
case "图标消息":
return messageI
case "组件消息":
return messageC
case "普通对象消息":
return messageO
return new Object[] { messageString, messageIcon, messageObject,
messageComponent };
// 根据用户选择返回消息类型（决定图标区的图标）
private int getDialogType() {
switch (messageTypePanel.getSelection()) {
case "ERROR_MESSAGE":
return JOptionPane.ERROR_MESSAGE;
case "INFORMATION_MESSAGE":
return JOptionPane.INFORMATION_MESSAGE;
case "WARNING_MESSAGE":
return JOptionPane.WARNING_MESSAGE;
case "QUESTION_MESSAGE":
return JOptionPane.QUESTION_MESSAGE;
return JOptionPane.PLAIN_MESSAGE;
private Object[] getOptions() {
switch (optionsPanel.getSelection()) {
case "字符串选项":
return new String[] { "a", "b", "c", "d" };
case "图标选项":
return new Icon[] { new ImageIcon("ico/1.gif"),
new ImageIcon("ico/2.gif"), new ImageIcon("ico/3.gif"),
new ImageIcon("ico/4.gif") };
return new Object[] { new Date(), new Date(), new Date() };
// 为各按钮定义事件监听器
private class ShowAction implements ActionListener {
public void actionPerformed(ActionEvent event) {
switch (event.getActionCommand()) {
case "确认对话框":
JOptionPane.showConfirmDialog(jf, getMessage(), "确认对话框",
getOptionType(), getDialogType());
case "输入对话框":
if (inputPanel.getSelection().equals("单行文本框")) {
JOptionPane.showInputDialog(jf, getMessage(), "输入对话框",
getDialogType());
JOptionPane.showInputDialog(jf, getMessage(), "输入对话框",
getDialogType(), null, new String[] {
"轻量级Java EE企业应用实战", "疯狂Java讲义" },
"疯狂Java讲义");
case "消息对话框":
JOptionPane.showMessageDialog(jf, getMessage(), "消息对话框",
getDialogType());
case "选项对话框":
JOptionPane.showOptionDialog(jf, getMessage(), "选项对话框",
getOptionType(), getDialogType(), null, getOptions(),
public static void main(String[] args) {
new JOptionPaneTest().init();
// 定义一个JPanel类扩展类，该类的对象包含多个纵向排列的
// JRadioButton控件,且Panel扩展类可以指定一个字符串作为TitledBorder
class ButtonPanel extends JPanel {
private ButtonG
public ButtonPanel(String title, String[] options) {
setBorder(BorderFactory.createTitledBorder(
BorderFactory.createEtchedBorder(), title));
setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
group = new ButtonGroup();
for (int i = 0; options != null && i & options. i++) {
JRadioButton b = new JRadioButton(options[i]);
b.setActionCommand(options[i]);
group.add(b);
b.setSelected(i == 0);
// 定义一个方法，用于返回用户选择的选项
public String getSelection() {
return group.getSelection().getActionCommand();
public class JToolBarTest {
JFrame jf = new JFrame("测试工具条");
JTextArea jta = new JTextArea(6, 35);
JToolBar jtb = new JToolBar();
JMenuBar jmb = new JMenuBar();
JMenu edit = new JMenu("编辑");
// 获取系统剪贴板
Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
// 创建"粘贴"Action，该Action用于创建菜单项、工具按钮和普通按钮
Action pasteAction = new AbstractAction("粘贴",
new ImageIcon("ico/paste.png")) {
public void actionPerformed(ActionEvent e) {
// 如果剪贴板中包含stringFlavor内容
if (clipboard.isDataFlavorAvailable(DataFlavor.stringFlavor)) {
// 取出剪贴板中stringFlavor内容
String content = (String) clipboard
.getData(DataFlavor.stringFlavor);
// 将选中内容替换成剪贴板中的内容
jta.replaceRange(content, jta.getSelectionStart(),
jta.getSelectionEnd());
} catch (Exception ee) {
ee.printStackTrace();
// 创建"复制"Action
Action copyAction = new AbstractAction("复制", new ImageIcon("ico/copy.png")) {
public void actionPerformed(ActionEvent e) {
StringSelection contents = new StringSelection(
jta.getSelectedText());
// 将StringSelection对象放入剪贴板
clipboard.setContents(contents, null);
// 如果剪贴板中包含stringFlavor内容
if (clipboard.isDataFlavorAvailable(DataFlavor.stringFlavor)) {
// 将pasteAction激活
pasteAction.setEnabled(true);
public void init() {
// pasteAction默认处于不激活状态
pasteAction.setEnabled(false); // ①
jf.add(new JScrollPane(jta));
// 以Action创建按钮，并将该按钮添加到Panel中
JButton copyBn = new JButton(copyAction);
JButton pasteBn = new JButton(pasteAction);
JPanel jp = new JPanel();
jp.add(copyBn);
jp.add(pasteBn);
jf.add(jp, BorderLayout.SOUTH);
// 向工具条中添加Action对象，该对象将会转换成工具按钮
jtb.add(copyAction);
jtb.addSeparator();
jtb.add(pasteAction);
// 向菜单中添加Action对象，该对象将会转换成菜单项
edit.add(copyAction);
edit.add(pasteAction);
// 将edit菜单添加到菜单条中
jmb.add(edit);
jf.setJMenuBar(jmb);
// 设置工具条和工具按钮之间的页边距。
jtb.setMargin(new Insets(20, 10, 5, 30)); // ②
// 向窗口中添加工具条
jf.add(jtb, BorderLayout.NORTH);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.pack();
jf.setVisible(true);
public static void main(String[] args) {
new JToolBarTest().init();
public class SwingComponent {
JFrame f = new JFrame("测试");
// 定义一个按钮,并为之指定图标
Icon okIcon = new ImageIcon("ico/ok.png");
JButton ok = new JButton("确认", okIcon);
// 定义一个单选按钮，初始处于选中状态
JRadioButton male = new JRadioButton("男", true);
// 定义一个单选按钮，初始处于没有选中状态
JRadioButton female = new JRadioButton("女", false);
// 定义一个ButtonGroup，用于将上面两个JRadioButton组合在一起
ButtonGroup bg = new ButtonGroup();
// 定义一个复选框，初始处于没有选中状态。
JCheckBox married = new JCheckBox("是否已婚？", false);
String[] colors = new String[] { "红色", "绿色", "蓝色" };
// 定义一个下拉选择框
JComboBox&String& colorChooser = new JComboBox&&(colors);
// 定义一个列表选择框
JList&String& colorList = new JList&&(colors);
// 定义一个8行、20列的多行文本域
JTextArea ta = new JTextArea(8, 20);
// 定义一个40列的单行文本域
JTextField name = new JTextField(40);
JMenuBar mb = new JMenuBar();
JMenu file = new JMenu("文件");
JMenu edit = new JMenu("编辑");
// 创建&新建&菜单项，并为之指定图标
Icon newIcon = new ImageIcon("ico/new.png");
JMenuItem newItem = new JMenuItem("新建", newIcon);
// 创建&保存&菜单项，并为之指定图标
Icon saveIcon = new ImageIcon("ico/save.png");
JMenuItem saveItem = new JMenuItem("保存", saveIcon);
// 创建&退出&菜单项，并为之指定图标
Icon exitIcon = new ImageIcon("ico/exit.png");
JMenuItem exitItem = new JMenuItem("退出", exitIcon);
JCheckBoxMenuItem autoWrap = new JCheckBoxMenuItem("自动换行");
// 创建&复制&菜单项，并为之指定图标
JMenuItem copyItem = new JMenuItem("复制", new ImageIcon("ico/copy.png"));
// 创建&粘贴&菜单项，并为之指定图标
JMenuItem pasteItem = new JMenuItem("粘贴", new ImageIcon("ico/paste.png"));
JMenu format = new JMenu("格式");
JMenuItem commentItem = new JMenuItem("注释");
JMenuItem cancelItem = new JMenuItem("取消注释");
// 定义一个右键菜单用于设置程序风格
JPopupMenu pop = new JPopupMenu();
// 用于组合三个风格菜单项的ButtonGroup
ButtonGroup flavorGroup = new ButtonGroup();
// 创建五个单选框按钮，用于设定程序的外观风格
JRadioButtonMenuItem metalItem = new JRadioButtonMenuItem("Metal风格", true);
JRadioButtonMenuItem nimbusItem = new JRadioButtonMenuItem("Nimbus风格");
JRadioButtonMenuItem windowsItem = new JRadioButtonMenuItem("Windows风格");
JRadioButtonMenuItem classicItem = new JRadioButtonMenuItem("Windows经典风格");
JRadioButtonMenuItem motifItem = new JRadioButtonMenuItem("Motif风格");
// -----------------用于执行界面初始化的init方法---------------------
public void init()
// 创建一个装载了文本框、按钮的JPanel
JPanel bottom = new JPanel();
bottom.add(name);
bottom.add(ok);
f.add(bottom , BorderLayout.SOUTH);
// 创建一个装载了下拉选择框、三个JCheckBox的JPanel
JPanel checkPanel = new JPanel();
checkPanel.add(colorChooser);
bg.add(male);
bg.add(female);
checkPanel.add(male);
checkPanel.add(female);
checkPanel.add(married);
// 创建一个垂直排列组件的Box，盛装多行文本域JPanel
Box topLeft = Box.createVerticalBox();
// 使用JScrollPane作为普通组件的JViewPort
JScrollPane taJsp = new JScrollPane(ta);
topLeft.add(taJsp);
topLeft.add(checkPanel);
// 创建一个水平排列组件的Box，盛装topLeft、colorList
Box top = Box.createHorizontalBox();
top.add(topLeft);
top.add(colorList);
// 将top Box容器添加到窗口的中间
f.add(top);
// -----------下面开始组合菜单、并为菜单添加监听器----------
// 为newItem设置快捷键，设置快捷键时要使用大写字母
newItem.setAccelerator(KeyStroke.getKeyStroke('N'
, InputEvent.CTRL_MASK));
newItem.addActionListener(e -& ta.append("用户单击了&新建&菜单\n"));
// 为file菜单添加菜单项
file.add(newItem);
file.add(saveItem);
file.add(exitItem);
// 为edit菜单添加菜单项
edit.add(autoWrap);
// 使用addSeparator方法来添加菜单分隔线
edit.addSeparator();
edit.add(copyItem);
edit.add(pasteItem);
// 为commentItem组件添加提示信息
commentItem.setToolTipText("将程序代码注释起来！");
// 为format菜单添加菜单项
format.add(commentItem);
format.add(cancelItem);
// 使用添加new JMenuItem("-")的方式不能添加菜单分隔符
edit.add(new JMenuItem("-"));
// 将format菜单组合到edit菜单中，从而形成二级菜单
edit.add(format);
// 将file、edit菜单添加到mb菜单条中
mb.add(file);
mb.add(edit);
// 为f窗口设置菜单条
f.setJMenuBar(mb);
// -----------下面开始组合右键菜单、并安装右键菜单----------
flavorGroup.add(metalItem);
flavorGroup.add(nimbusItem);
flavorGroup.add(windowsItem);
flavorGroup.add(classicItem);
flavorGroup.add(motifItem);
pop.add(metalItem);
pop.add(nimbusItem);
pop.add(windowsItem);
pop.add(classicItem);
pop.add(motifItem);
// 为5个风格菜单创建事件监听器
ActionListener flavorListener = e -& {
switch(e.getActionCommand())
case "Metal风格":
changeFlavor(1);
case "Nimbus风格":
changeFlavor(2);
case "Windows风格":
changeFlavor(3);
case "Windows经典风格":
changeFlavor(4);
case "Motif风格":
changeFlavor(5);
catch (Exception ee)
ee.printStackTrace();
// 为五个风格菜单项添加事件监听器
metalItem.addActionListener(flavorListener);
nimbusItem.addActionListener(flavorListener);
windowsItem.addActionListener(flavorListener);
classicItem.addActionListener(flavorListener);
motifItem.addActionListener(flavorListener);
// 调用该方法即可设置右键菜单，无须使用事件机制
ta.setComponentPopupMenu(pop);
// 设置关闭窗口时，退出程序
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
// 定义一个方法，用于改变界面风格
private void changeFlavor(int flavor) throws Exception {
switch (flavor) {
// 设置Metal风格
UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
// 设置Nimbus风格
.setLookAndFeel("javax.swing.plaf.nimbus.NimbusLookAndFeel");
// 设置Windows风格
.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
// 设置Windows经典风格
.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsClassicLookAndFeel");
// 设置Motif风格
.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");
// 更新f窗口内顶级容器以及内部所有组件的UI
SwingUtilities.updateComponentTreeUI(f.getContentPane()); // ②
// 更新mb菜单条以及内部所有组件的UI
SwingUtilities.updateComponentTreeUI(mb);
// 更新pop右键菜单以及内部所有组件的UI
SwingUtilities.updateComponentTreeUI(pop);
public static void main(String[] args) {
// 设置Swing窗口使用Java风格
// JFrame.setDefaultLookAndFeelDecorated(true); //③
new SwingComponent().init();
public class InternalDialogTest {
private JFrame jf = new JFrame("测试内部对话框");
private JDesktopPane desktop = new JDesktopPane();
private JButton internalBn = new JButton("内部窗口的对话框");
private JButton deskBn = new JButton("虚拟桌面的对话框");
// 定义一个内部窗口，该窗口可拖动，但不可最大化、最小化、关闭
private JInternalFrame iframe = new JInternalFrame("内部窗口");
public void init()
// 向内部窗口中添加组件
iframe.add(new JScrollPane(new JTextArea(8, 40)));
desktop.setPreferredSize(new Dimension(400, 300));
// 把虚拟桌面添加到JFrame窗口中
jf.add(desktop);
// 设置内部窗口的大小、位置
iframe.reshape(0 , 0 , 300 , 200);
// 显示并选中内部窗口
iframe.show();
desktop.add(iframe);
JPanel jp = new JPanel();
deskBn.addActionListener(event -&
// 弹出内部对话框，以虚拟桌面作为父组件
JOptionPane.showInternalMessageDialog(desktop
, "属于虚拟桌面的对话框"));
internalBn.addActionListener(event -&
// 弹出内部对话框，以内部窗口作为父组件
JOptionPane.showInternalMessageDialog(iframe
, "属于内部窗口的对话框"));
jp.add(deskBn);
jp.add(internalBn);
jf.add(jp , BorderLayout.SOUTH);
jf.pack();
jf.setVisible(true);
public static void main(String[] args) {
new InternalDialogTest().init();
public class JInternalFrameTest {
final int DESKTOP_WIDTH = 480;
final int DESKTOP_HEIGHT = 360;
final int FRAME_DISTANCE = 30;
JFrame jf = new JFrame("MDI界面");
// 定义一个虚拟桌面
private MyJDesktopPane desktop = new MyJDesktopPane();
// 保存下一个内部窗口的坐标点
private int nextFrameX;
private int nextFrameY;
// 定义内部窗口为虚拟桌面的1/2大小
private int width = DESKTOP_WIDTH / 2;
private int height = DESKTOP_HEIGHT / 2;
// 为主窗口定义两个菜单
JMenu fileMenu = new JMenu("文件");
JMenu windowMenu = new JMenu("窗口");
// 定义newAction用于创建菜单和工具按钮
Action newAction = new AbstractAction("新建", new ImageIcon("ico/new.png")) {
public void actionPerformed(ActionEvent event) {
// 创建内部窗口
final JInternalFrame iframe = new JInternalFrame("新文档", true, // 可改变大小
true, // 可关闭
true, // 可最大化
true); // 可最小化
iframe.add(new JScrollPane(new JTextArea(8, 40)));
// 将内部窗口添加到虚拟桌面中
desktop.add(iframe);
// 设置内部窗口的原始位置（内部窗口默认大小是0X0，放在0,0位置）
iframe.reshape(nextFrameX, nextFrameY, width, height);
// 使该窗口可见，并尝试选中它
iframe.show();
// 计算下一个内部窗口的位置
nextFrameX += FRAME_DISTANCE;
nextFrameY += FRAME_DISTANCE;
if (nextFrameX + width & desktop.getWidth())
nextFrameX = 0;
if (nextFrameY + height & desktop.getHeight())
nextFrameY = 0;
// 定义exitAction用于创建菜单和工具按钮
Action exitAction = new AbstractAction("退出", new ImageIcon("ico/exit.png")) {
public void actionPerformed(ActionEvent event) {
System.exit(0);
public void init()
// 为窗口安装菜单条和工具条
JMenuBar menuBar = new JMenuBar();
JToolBar toolBar = new JToolBar();
jf.setJMenuBar(menuBar);
menuBar.add(fileMenu);
fileMenu.add(newAction);
fileMenu.add(exitAction);
toolBar.add(newAction);
toolBar.add(exitAction);
menuBar.add(windowMenu);
JMenuItem nextItem = new JMenuItem("下一个");
nextItem.addActionListener(event -& desktop.selectNextWindow());
windowMenu.add(nextItem);
JMenuItem cascadeItem = new JMenuItem("级联");
cascadeItem.addActionListener(event -&
// 级联显示窗口，内部窗口的大小是外部窗口的0.75
desktop.cascadeWindows(FRAME_DISTANCE , 0.75));
windowMenu.add(cascadeItem);
JMenuItem tileItem = new JMenuItem("平铺");
// 平铺显示所有内部窗口
tileItem.addActionListener(event -& desktop.tileWindows());
windowMenu.add(tileItem);
final JCheckBoxMenuItem dragOutlineItem = new
JCheckBoxMenuItem("仅显示拖动窗口的轮廓");
dragOutlineItem.addActionListener(event -&
// 根据该菜单项是否选择来决定采用哪种拖动模式
desktop.setDragMode(dragOutlineItem.isSelected()
? JDesktopPane.OUTLINE_DRAG_MODE
: JDesktopPane.LIVE_DRAG_MODE));
windowMenu.add(dragOutlineItem);
desktop.setPreferredSize(new Dimension(480, 360));
// 将虚拟桌面添加到顶级JFrame容器中
jf.add(desktop);
jf.add(toolBar , BorderLayout.NORTH);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.pack();
jf.setVisible(true);
public static void main(String[] args) {
new JInternalFrameTest().init();
class MyJDesktopPane extends JDesktopPane {
// 将所有窗口以级联方式显示,
// 其中offset是两个窗口的位移距离, s
// cale是内部窗口与JDesktopPane的大小比例
public void cascadeWindows(int offset, double scale) {
// 定义级联显示窗口时内部窗口的大小
int width = (int) (getWidth() * scale);
int height = (int) (getHeight() * scale);
// 用于保存级联窗口时每个窗口的位置
int x = 0;
int y = 0;
for (JInternalFrame frame : getAllFrames()) {
// 取消内部窗口的最大化,最小化
frame.setMaximum(false);
frame.setIcon(false);
// 把窗口重新放置在指定位置
frame.reshape(x, y, width, height);
// 如果到了虚拟桌面边界
if (x + width & getWidth())
if (y + height & getHeight())
} catch (PropertyVetoException e) {
// 将所有窗口以平铺方式显示
public void tileWindows() {
// 统计所有窗口
int frameCount = 0;
for (JInternalFrame frame : getAllFrames()) {
frameCount++;
// 计算需要多少行、多少列才可以平铺所有窗口
int rows = (int) Math.sqrt(frameCount);
int cols = frameCount /
// 需要额外增加到其他列中的窗口
int extra = frameCount %
// 计算平铺时内部窗口的大小
int width = getWidth() /
int height = getHeight() /
// 用于保存平铺窗口时每个窗口在横向、纵向上的索引
int x = 0;
int y = 0;
for (JInternalFrame frame : getAllFrames()) {
// 取消内部窗口的最大化,最小化
frame.setMaximum(false);
frame.setIcon(false);
// 将窗口放在指定位置
frame.reshape(x * width, y * height, width, height);
// 每排完一列窗口
if (y == rows) {
// 开始排放下一列窗口
// 如果额外多出的窗口与剩下的列数相等，
// 则后面所有列都需要多排列一个窗口
if (extra == cols - x) {
height = getHeight() /
} catch (PropertyVetoException e) {
// 选中下一个非图标窗口
public void selectNextWindow() {
JInternalFrame[] frames = getAllFrames();
for (int i = 0; i & frames. i++) {
if (frames[i].isSelected()) {
// 找出下一个非最小化的窗口，尝试选中它，
// 如果选中失败，则继续尝试选中下一个窗口
int next = (i + 1) % frames.
while (next != i) {
// 如果该窗口不是处于最小化状态
if (!frames[next].isIcon()) {
frames[next].setSelected(true);
frames[next].toFront();
frames[i].toBack();
} catch (PropertyVetoException e) {
next = (next + 1) % frames.
public class JLayeredPaneTest {
JFrame jf = new JFrame("测试JLayeredPane");
JLayeredPane layeredPane = new JLayeredPane();
public void init() {
// 向layeredPane中添加3个组件
layeredPane.add(new ContentPanel(10, 20, "疯狂Java讲义", "ico/java.png"),
JLayeredPane.MODAL_LAYER);
layeredPane.add(new ContentPanel(100, 60, "疯狂Android讲义",
"ico/android.png"), JLayeredPane.DEFAULT_LAYER);
layeredPane.add(new ContentPanel(190, 100, "轻量级Java EE企业应用实战",
"ico/ee.png"), 4);
layeredPane.setPreferredSize(new Dimension(400, 300));
layeredPane.setVisible(true);
jf.add(layeredPane);
jf.pack();
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.setVisible(true);
public static void main(String[] args) {
new JLayeredPaneTest().init();
// 扩展了JPanel类，可以直接创建一个放在指定位置，
// 且有指定标题、放置指定图标的JPanel对象
class ContentPanel extends JPanel {
public ContentPanel(int xPos, int yPos, String title, String ico) {
setBorder(BorderFactory.createTitledBorder(
BorderFactory.createEtchedBorder(), title));
JLabel label = new JLabel(new ImageIcon(ico));
add(label);
setBounds(xPos, yPos, 160, 220); // ①
public class JTabbedPaneTest {
JFrame jf = new JFrame("测试Tab页面");
// 创建一个Tab页面的标签放在左边，采用换行布局策略的JTabbedPane
JTabbedPane tabbedPane = new JTabbedPane(JTabbedPane.LEFT,
JTabbedPane.WRAP_TAB_LAYOUT);
ImageIcon icon = new ImageIcon("ico/close.gif");
String[] layouts = { "换行布局", "滚动条布局" };
String[] positions = { "左边", "顶部", "右边", "底部" };
Map&String, String& books = new LinkedHashMap&&();
public void init()
books.put("疯狂Java讲义" , "java.png");
books.put("轻量级Java EE企业应用实战" , "ee.png");
books.put("疯狂Ajax讲义" , "ajax.png");
books.put("疯狂Android讲义" , "android.png");
books.put("经典Java EE企业应用实战" , "classic.png");
String tip = "可看到本书的封面照片";
// 向JTabbedPane中添加5个标签页面，指定了标题、图标和提示
// 但该标签页面的组件为null
for (String bookName : books.keySet())
tabbedPane.addTab(bookName, icon, null , tip);
jf.add(tabbedPane, BorderLayout.CENTER);
// 为JTabbedPane添加事件监听器
tabbedPane.addChangeListener(event -& {
// 如果被选择的组件依然是空
if (tabbedPane.getSelectedComponent() == null)
// 获取所选标签页
int n = tabbedPane.getSelectedIndex();
// 为指定标前页加载内容
loadTab(n);
// 系统默认选择第一页，加载第一页内容
loadTab(0);
tabbedPane.setPreferredSize(new Dimension(500 , 300));
// 增加控制标签布局、标签位置的单选按钮
JPanel buttonPanel = new JPanel();
ChangeAction action = new ChangeAction();
buttonPanel.add(new ButtonPanel(action
, "选择标签布局策略" , layouts));
buttonPanel.add (new ButtonPanel(action
, "选择标签位置" , positions));
jf.add(buttonPanel, BorderLayout.SOUTH);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.pack();
jf.setVisible(true);
// 为指定标签页加载内容
private void loadTab(int n) {
String title = tabbedPane.getTitleAt(n);
// 根据标签页的标题获取对应图书封面
ImageIcon bookImage = new ImageIcon("ico/" + books.get(title));
tabbedPane.setComponentAt(n, new JLabel(bookImage));
// 改变标签页的图标
tabbedPane.setIconAt(n, new ImageIcon("ico/open.gif"));
// 定义改变标签页的布局策略，放置位置的监听器
class ChangeAction implements ActionListener {
public void actionPerformed(ActionEvent event) {
JRadioButton source = (JRadioButton) event.getSource();
String selection = source.getActionCommand();
// 设置标签页的标题的布局策略
if (selection.equals(layouts[0])) {
tabbedPane.setTabLayoutPolicy(JTabbedPane.WRAP_TAB_LAYOUT);
} else if (selection.equals(layouts[1])) {
tabbedPane.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
// 设置标签页上的标题的放置位置
else if (selection.equals(positions[0])) {
tabbedPane.setTabPlacement(JTabbedPane.LEFT);
} else if (selection.equals(positions[1])) {
tabbedPane.setTabPlacement(JTabbedPane.TOP);
} else if (selection.equals(positions[2])) {
tabbedPane.setTabPlacement(JTabbedPane.RIGHT);
} else if (selection.equals(positions[3])) {
tabbedPane.setTabPlacement(JTabbedPane.BOTTOM);
public static void main(String[] args) {
new JTabbedPaneTest().init();
// 定义一个JPanel类扩展类，该类的对象包含多个纵向排列的JRadioButton控件
// 且JPanel扩展类可以指定一个字符串作为TitledBorder
class ButtonPanel extends JPanel {
private ButtonG
public ButtonPanel(JTabbedPaneTest.ChangeAction action, String title,
String[] labels) {
setBorder(BorderFactory.createTitledBorder(
BorderFactory.createEtchedBorder(), title));
setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
group = new ButtonGroup();
for (int i = 0; labels != null && i & labels. i++) {
JRadioButton b = new JRadioButton(labels[i]);
b.setActionCommand(labels[i]);
// 添加事件监听器
b.addActionListener(action);
group.add(b);
b.setSelected(i == 0);
class Book {
public Book() {
public Book(String name, Icon ico, String desc) {
this.name =
this.ico =
this.desc =
// name的setter和getter方法
public void setName(String name) {
this.name =
public String getName() {
return this.
// ico的setter和getter方法
public void setIco(Icon ico) {
this.ico =
public Icon getIco() {
return this.
// desc的setter和getter方法
public void setDesc(String desc) {
this.desc =
public String getDesc() {
return this.
public String toString() {
public class SplitPaneTest {
Book[] books = new Book[] {
new Book("疯狂Java讲义", new ImageIcon("ico/java.png"),
"国内关于Java编程最全面的图书\n看得懂，学得会"),
new Book("轻量级Java EE企业应用实战", new ImageIcon("ico/ee.png"),
"SSH整合开发的经典图书，值得拥有"),
new Book("疯狂Android讲义", new ImageIcon("ico/android.png"),
"全面介绍Android平台应用程序\n开发的各方面知识") };
JFrame jf = new JFrame("测试JSplitPane");
JList&Book& bookList = new JList&&(books);
JLabel bookCover = new JLabel();
JTextArea bookDesc = new JTextArea();
public void init()
// 为三个组件设置最佳大小
bookList.setPreferredSize(new Dimension(150, 300));
bookCover.setPreferredSize(new Dimension(300, 150));
bookDesc.setPreferredSize(new Dimension(300, 150));
// 为下拉列表添加事件监听器
bookList.addListSelectionListener(event -&{
Book book = (Book)bookList.getSelectedValue();
bookCover.setIcon(book.getIco());
bookDesc.setText(book.getDesc());
// 创建一个垂直的分割面板，
// 将bookCover放在上面，将bookDesc放在下面, 支持连续布局
JSplitPane left = new JSplitPane(JSplitPane.VERTICAL_SPLIT
, true , bookCover, new JScrollPane(bookDesc));
// 打开&一触即展&的特性
left.setOneTouchExpandable(true);
// 下面代码设置分割条的大小。
// left.setDividerSize(50);
// 设置该分割面板根据所包含组件的最佳大小来调整布局
left.resetToPreferredSizes();
// 创建一个水平的分割面板
// 将left组件放在左边，将bookList组件放在右边
JSplitPane content = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT
, left, bookList);
jf.add(content);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.pack();
jf.setVisible(true);
public static void main(String[] args) {
new SplitPaneTest().init();
public class SwingDndSupport {
JFrame jf = new JFrame("Swing的拖放支持");
JTextArea srcTxt = new JTextArea(8, 30);
JTextField jtf = new JTextField(34);
public void init() {
srcTxt.append("Swing的拖放支持.\n");
srcTxt.append("将该文本域的内容拖入其他程序.\n");
// 启动文本域和单行文本框的拖放支持
srcTxt.setDragEnabled(true);
jtf.setDragEnabled(true);
jf.add(new JScrollPane(srcTxt));
jf.add(jtf, BorderLayout.SOUTH);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.pack();
jf.setVisible(true);
public static void main(String[] args) {
new SwingDndSupport().init();
public class TransferHandlerTest {
private JFrame jf = new JFrame("测试TransferHandler");
JColorChooser chooser = new JColorChooser();
JTextArea txt = new JTextArea("测试TransferHandler\n" + "直接将上面颜色拖入以改变文本颜色");
public void init() {
// 启动颜色选择器面板和文本域的拖放功能
chooser.setDragEnabled(true);
txt.setDragEnabled(true);
jf.add(chooser, BorderLayout.SOUTH);
// 允许直接将一个Color对象拖入该JTextArea对象
// 并赋给它的foreground属性
txt.setTransferHandler(new TransferHandler("foreground"));
jf.add(new JScrollPane(txt));
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.pack();
jf.setVisible(true);
public static void main(String[] args) {
new TransferHandlerTest().init();
class FirstLayerUI extends LayerUI&JComponent& {
public void paint(Graphics g, JComponent c) {
super.paint(g, c);
Graphics2D g2 = (Graphics2D) g.create();
// 设置透明效果
g2.setComposite(AlphaComposite
.getInstance(AlphaComposite.SRC_OVER, .5f));
// 使用渐变画笔绘图
g2.setPaint(new GradientPaint(0, 0, Color.RED, 0, c.getHeight(),
Color.BLUE));
// 绘制一个与被装饰组件相同大小的矩形
g2.fillRect(0, 0, c.getWidth(), c.getHeight()); // ①
g2.dispose();
class BlurLayerUI extends LayerUI&JComponent& {
private BufferedImage screenBlurI
private BufferedImageO
public BlurLayerUI() {
float ninth = 1.0f / 9.0f;
// 定义模糊参数
float[] blurKernel = { ninth, ninth, ninth, ninth, ninth, ninth, ninth,
ninth, ninth };
// ConvolveOp代表一个模糊处理，它将原图片的每一个像素与周围
// 像素的颜色进行混合，从而计算出当前像素的颜色值，
operation = new ConvolveOp(new Kernel(3, 3, blurKernel),
ConvolveOp.EDGE_NO_OP, null);
public void paint(Graphics g, JComponent c) {
int w = c.getWidth();
int h = c.getHeight();
// 如果被装饰窗口大小为0X0,直接返回
if (w == 0 || h == 0)
// 如果screenBlurImage没有初始化，或它的尺寸不对。
if (screenBlurImage == null || screenBlurImage.getWidth() != w
|| screenBlurImage.getHeight() != h) {
// 重新创建新的BufferdImage
screenBlurImage = new BufferedImage(w, h,
BufferedImage.TYPE_INT_RGB);
Graphics2D ig2 = screenBlurImage.createGraphics();
// 把被装饰组件的界面绘制到当前screenBlurImage上
ig2.setClip(g.getClip());
super.paint(ig2, c);
ig2.dispose();
Graphics2D g2 = (Graphics2D)
// 对JLayer装饰的组件进行模糊处理
g2.drawImage(screenBlurImage, operation, 0, 0);
class SpotlightLayerUI extends LayerUI&JComponent& {
private boolean
private int cx,
public void installUI(JComponent c) {
super.installUI(c);
JLayer layer = (JLayer)
// 设置JLayer可以响应鼠标、鼠标动作事件
layer.setLayerEventMask(AWTEvent.MOUSE_EVENT_MASK
| AWTEvent.MOUSE_MOTION_EVENT_MASK);
public void uninstallUI(JComponent c) {
JLayer layer = (JLayer)
// 设置JLayer不响应任何事件
layer.setLayerEventMask(0);
super.uninstallUI(c);
public void paint(Graphics g, JComponent c) {
Graphics2D g2 = (Graphics2D) g.create();
super.paint(g2, c);
// 如果处于激活状态
if (active) {
// 定义一个cx、cy位置的点
Point2D center = new Point2D.Float(cx, cy);
float radius = 72;
float[] dist = { 0.0f, 1.0f };
Color[] colors = { Color.YELLOW, Color.BLACK };
// 以center为中心、colors为颜色数组创建环形渐变
RadialGradientPaint p = new RadialGradientPaint(center, radius,
dist, colors);
g2.setPaint(p);
// 设置渐变效果
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
// 绘制矩形
g2.fillRect(0, 0, c.getWidth(), c.getHeight());
g2.dispose();
// 处理鼠标事件的方法
public void processMouseEvent(MouseEvent e, JLayer layer) {
if (e.getID() == MouseEvent.MOUSE_ENTERED)
active = true;
if (e.getID() == MouseEvent.MOUSE_EXITED)
active = false;
layer.repaint();
// 处理鼠标动作事件的方法
public void processMouseMotionEvent(MouseEvent e, JLayer layer) {
Point p = SwingUtilities.convertPoint(e.getComponent(), e.getPoint(),
// 获取鼠标动作事件的发生点的坐标
layer.repaint();
public class JLayerTest {
public void init() {
JFrame f = new JFrame("JLayer测试");
JPanel p = new JPanel();
ButtonGroup group = new ButtonGroup();
JRadioButton radioB
// 创建3个RadioButton，并将它们添加成一组
p.add(radioButton = new JRadioButton("网购购买", true));
group.add(radioButton);
p.add(radioButton = new JRadioButton("书店购买"));
group.add(radioButton);
p.add(radioButton = new JRadioButton("图书馆借阅"));
group.add(radioButton);
// 添加3个JCheckBox
p.add(new JCheckBox("疯狂Java讲义"));
p.add(new JCheckBox("疯狂Android讲义"));
p.add(new JCheckBox("疯狂Ajax讲义"));
p.add(new JCheckBox("轻量级Java EE企业应用"));
JButton orderButton = new JButton("投票");
p.add(orderButton);
// 创建LayerUI对象
LayerUI&JComponent& layerUI = new SpotlightLayerUI(); // ②
// 使用layerUI来装饰指定的JPanel组件
JLayer&JComponent& layer = new JLayer&JComponent&(p, layerUI);
// 将装饰后的JPanel组件添加到容器中
f.add(layer);
f.setSize(300, 170);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
public static void main(String[] args) {
new JLayerTest().init();
public class NonRegularWindow extends JFrame implements ActionListener {
// 定义3个窗口
JFrame transWin = new JFrame("透明窗口");
JFrame gradientWin = new JFrame("渐变透明窗口");
JFrame bgWin = new JFrame("背景图片窗口");
JFrame shapeWin = new JFrame("椭圆窗口");
public NonRegularWindow() {
super("不规则窗口测试");
setLayout(new FlowLayout());
JButton transBn = new JButton("透明窗口");
JButton gradientBn = new JButton("渐变透明窗口");
JButton bgBn = new JButton("背景图片窗口");
JButton shapeBn = new JButton("椭圆窗口");
// 为3个按钮添加事件监听器
transBn.addActionListener(this);
gradientBn.addActionListener(this);
bgBn.addActionListener(this);
shapeBn.addActionListener(this);
add(transBn);
add(gradientBn);
add(bgBn);
add(shapeBn);
// -------设置透明窗口-------
transWin.setLayout(new GridBagLayout());
transWin.setSize(300, 200);
transWin.add(new JButton("透明窗口里的简单按钮"));
// 设置透明度为0.65f，透明度为1时完全不透明。
transWin.setOpacity(0.65f);
// -------设置渐变透明的窗口-------
gradientWin.setBackground(new Color(0, 0, 0, 0));
gradientWin.setSize(new Dimension(300, 200));
// 使用一个JPanel对象作为渐变透明的背景
JPanel panel = new JPanel() {
protected void paintComponent(Graphics g) {
if (g instanceof Graphics2D) {
final int R = 240;
final int G = 240;
final int B = 240;
// 创建一个渐变画笔
Paint p = new GradientPaint(0.0f, 0.0f, new Color(R, G, B,
0), 0.0f, getHeight(), new Color(R, G, B, 255),
Graphics2D g2d = (Graphics2D)
g2d.setPaint(p);
g2d.fillRect(0, 0, getWidth(), getHeight());
// 使用JPanel对象作为JFrame的contentPane
gradientWin.setContentPane(panel);
panel.setLayout(new GridBagLayout());
gradientWin.add(new JButton("渐变透明窗口里的简单按钮"));
// -------设置有背景图片的窗口-------
bgWin.setBackground(new Color(0, 0, 0, 0));
bgWin.setSize(new Dimension(300, 200));
// 使用一个JPanel对象作为背景图片
JPanel bgPanel = new JPanel() {
protected void paintComponent(Graphics g) {
Image bg = ImageIO.read(new File("images/java.png"));
// 绘制一张图片作为背景
g.drawImage(bg, 0, 0, getWidth(), getHeight(), null);
} catch (IOException ex) {
ex.printStackTrace();
// 使用JPanel对象作为JFrame的contentPane
bgWin.setContentPane(bgPanel);
bgPanel.setLayout(new GridBagLayout());
bgWin.add(new JButton("有背景图片窗口里的简单按钮"));
// -------设置椭圆形窗口-------
shapeWin.setLayout(new GridBagLayout());
shapeWin.setUndecorated(true);
shapeWin.setOpacity(0.7f);
// 通过为shapeWin添加监听器来设置窗口的形状。
// 当shapeWin窗口的大小被改变时，程序动态设置该窗口的形状
shapeWin.addComponentListener(new ComponentAdapter() {
// 当窗口大小被改变时，椭圆的大小也会相应地改变
public void componentResized(ComponentEvent e) {
// 设置窗口的形状
shapeWin.setShape(new Ellipse2D.Double(0, 0, shapeWin
.getWidth(), shapeWin.getHeight())); // ①
shapeWin.setSize(300, 200);
shapeWin.add(new JButton("椭圆形窗口里的简单按钮"));
// -------设置主程序的窗口-------
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
public void actionPerformed(ActionEvent event) {
switch (event.getActionCommand()) {
case "透明窗口":
transWin.setVisible(true);
case "渐变透明窗口":
gradientWin.setVisible(true);
case "背景图片窗口":
bgWin.setVisible(true);
case "椭圆窗口":
shapeWin.setVisible(true);
public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
new NonRegularWindow();
class WaitingLayerUI extends LayerUI&JComponent& {
private boolean isR
// 记录转过的角度
private int // ①
public void paint(Graphics g, JComponent c) {
super.paint(g, c);
int w = c.getWidth();
int h = c.getHeight();
// 已经停止运行，直接返回
if (!isRunning)
Graphics2D g2 = (Graphics2D) g.create();
Composite urComposite = g2.getComposite();
g2.setComposite(AlphaComposite
.getInstance(AlphaComposite.SRC_OVER, .5f));
// 填充矩形
g2.fillRect(0, 0, w, h);
g2.setComposite(urComposite);
// -----下面代码开始绘制转动中的&齿轮&----
// 计算得到宽、高中较小值的1/5
int s = Math.min(w, h) / 5;
int cx = w / 2;
int cy = h / 2;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
// 设置笔触
g2.setStroke(new BasicStroke(s / 2, BasicStroke.CAP_ROUND,
BasicStroke.JOIN_ROUND));
g2.setPaint(Color.BLUE);
// 画笔绕被装饰组件的中心转过angle度
g2.rotate(Math.PI * angle / 180, cx, cy);
// 循环绘制12条线条，形成&齿轮&
for (int i = 0; i & 12; i++) {
float scale = (11.0f - (float) i) / 11.0f;
g2.drawLine(cx + s, cy, cx + s * 2, cy);
g2.rotate(-Math.PI / 6, cx, cy);
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
g2.dispose();
// 控制等待（齿轮开始转动）的方法
public void start()
// 如果已经在运行中，直接返回
if (isRunning)
isRunning = true;
// 每隔0.1秒重绘一次
timer = new Timer(100, e -& {
if (isRunning)
// 触发applyPropertyChange()方法，让JLayer重绘。
// 在这行代码中，后面两个参数没有意义。
firePropertyChange("crazyitFlag", 0 , 1);
// 角度加6
angle += 6;
// 到达360后再从0开始
if (angle &= 360)
angle = 0;
timer.start();
// 控制停止等待（齿轮停止转动）的方法
public void stop() {
isRunning = false;
// 最后通知JLayer重绘一次，清除曾经绘制的图形
firePropertyChange("crazyitFlag", 0, 1);
timer.stop();
public void applyPropertyChange(PropertyChangeEvent pce, JLayer layer) {
// 控制JLayer重绘
if (pce.getPropertyName().equals("crazyitFlag")) {
layer.repaint();
public class WaitingJLayerTest {
public void init()
JFrame f = new JFrame("转动的&齿轮&");
JPanel p = new JPanel();
ButtonGroup group = new ButtonGroup();
JRadioButton radioB
// 创建3个RadioButton，并将它们添加成一组
p.add(radioButton = new JRadioButton("网购购买", true));
group.add(radioButton);
p.add(radioButton = new JRadioButton("书店购买"));
group.add(radioButton);
p.add(radioButton = new JRadioButton("图书馆借阅"));
group.add(radioButton);
// 添加3个JCheckBox
p.add(new JCheckBox("疯狂Java讲义"));
p.add(new JCheckBox("疯狂Android讲义"));
p.add(new JCheckBox("疯狂Ajax讲义"));
p.add(new JCheckBox("轻量级Java EE企业应用"));
JButton orderButton = new JButton("投票");
p.add(orderButton);
// 创建LayerUI对象
final WaitingLayerUI layerUI = new WaitingLayerUI();
// 使用layerUI来装饰指定JPanel组件
JLayer&JComponent& layer = new JLayer&JComponent&(p, layerUI);
// 设置4秒之后执行指定动作：调用layerUI的stop()方法
final Timer stopper = new Timer(4000, ae -& layerUI.stop());
// 设置stopper定时器只触发一次。
stopper.setRepeats(false);
// 为orderButton绑定事件监听器：单击该按钮时:调用layerUI的start()方法
orderButton.addActionListener(ae -& {
layerUI.start();
// 如果stopper定时器已停止，启动它
if (!stopper.isRunning())
stopper.start();
// 将装饰后的JPanel组件添加到容器中
f.add(layer);
f.setSize(300, 170);
f.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
f.setVisible (true);
public static void main(String[] args) {
new WaitingJLayerTest().init();
public class JProgressBarTest {
JFrame frame = new JFrame("测试进度条");
// 创建一条垂直进度条
JProgressBar bar = new JProgressBar(JProgressBar.VERTICAL);
JCheckBox indeterminate = new JCheckBox("不确定进度");
JCheckBox noBorder = new JCheckBox("不绘制边框");
public void init()
Box box = new Box(BoxLayout.Y_AXIS);
box.add(indeterminate);
box.add(noBorder);
frame.setLayout(new FlowLayout());
frame.add(box);
// 把进度条添加到JFrame窗口中
frame.add(bar);
// 设置进度条的最大值和最小值
bar.setMinimum(0);
bar.setMaximum(100);
// 设置在进度条中绘制完成百分比
bar.setStringPainted(true);
// 根据该选择框决定是否绘制进度条的边框
noBorder.addActionListener(event -&
bar.setBorderPainted(!noBorder.isSelected()));
indeterminate.addActionListener(event -& {
// 设置该进度条的进度是否确定
bar.setIndeterminate(indeterminate.isSelected());
bar.setStringPainted(!indeterminate.isSelected());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
// 采用循环方式来不断改变进度条的完成进度
for (int i = 0 ; i &= 100 ; i++)
// 改变进度条的完成进度
bar.setValue(i);
// 程序暂停0.1秒
Thread.sleep(100);
catch (Exception e)
e.printStackTrace();
public static void main(String[] args) {
new JProgressBarTest().init();
public class JProgressBarTest2 {
JFrame frame = new JFrame("测试进度条");
// 创建一条垂直进度条
JProgressBar bar = new JProgressBar(JProgressBar.VERTICAL);
JCheckBox indeterminate = new JCheckBox("不确定进度");
JCheckBox noBorder = new JCheckBox("不绘制边框");
public void init()
Box box = new Box(BoxLayout.Y_AXIS);
box.add(indeterminate);
box.add(noBorder);
frame.setLayout(new FlowLayout());
frame.add(box);
// 把进度条添加到JFrame窗口中
frame.add(bar);
// 设置在进度条中绘制完成百分比
bar.setStringPainted(true);
// 根据该选择框决定是否绘制进度条的边框
noBorder.addActionListener(event -&
bar.setBorderPainted(!noBorder.isSelected()));
final SimulatedActivity target = new SimulatedActivity(1000);
// 以启动一条线程的方式来执行一个耗时的任务
new Thread(target).start();
// 设置进度条的最大值和最小值,
bar.setMinimum(0);
// 以总任务量作为进度条的最大值
bar.setMaximum(target.getAmount());
// 以任务的当前完成量设置进度条的value
Timer timer = new Timer(300 , e -& bar.setValue(target.getCurrent()));
timer.start();
indeterminate.addActionListener(event -&
// 设置该进度条的进度是否确定
bar.setIndeterminate(indeterminate.isSelected());
bar.setStringPainted(!indeterminate.isSelected());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
public static void main(String[] args) {
new JProgressBarTest2().init();
// 模拟一个耗时的任务
class SimulatedActivity implements Runnable {
// 任务的当前完成量
private volatile int
// 总任务量
private int
public SimulatedActivity(int amount) {
current = 0;
this.amount =
public int getAmount() {
public int getCurrent() {
// run方法代表不断完成任务的过程
public void run() {
while (current & amount) {
Thread.sleep(50);
} catch (InterruptedException e) {
current++;
public class ProgressMonitorTest {
public void init()
final SimulatedActivity target = new SimulatedActivity(1000);
// 以启动一条线程的方式来执行一个耗时的任务
final Thread targetThread = new Thread(target);
targetThread.start();
final ProgressMonitor dialog = new ProgressMonitor(null
, "等待任务完成" , "已完成：" , 0 , target.getAmount());
timer = new Timer(300 , e -& {
// 以任务的当前完成量设置进度对话框的完成比例
dialog.setProgress(target.getCurrent());
// 如果用户单击了进度对话框的"取消"按钮
if (dialog.isCanceled())
// 停止计时器
timer.stop();
// 中断任务的执行线程
targetThread.interrupt();
// 系统退出
System.exit(0);
timer.start();
public static void main(String[] args) {
new ProgressMonitorTest().init();
public class JSliderTest {
JFrame mainWin = new JFrame("滑动条示范");
Box sliderBox = new Box(BoxLayout.Y_AXIS);
JTextField showVal = new JTextField();
public void init()
// 定义一个监听器，用于监听所有滑动条
listener = event -& {
// 取出滑动条的值，并在文本中显示出来
JSlider source = (JSlider) event.getSource();
showVal.setText("当前滑动条的值为："
+ source.getValue());
// -----------添加一个普通滑动条-----------
JSlider slider = new JSlider();
addSlider(slider, "普通滑动条");
// -----------添加保留区为30的滑动条-----------
slider = new JSlider();
slider.setExtent(30);
addSlider(slider, "保留区为30");
// ---添加带主、次刻度的滑动条,并设置其最大值，最小值---
slider = new JSlider(30 , 200);
// 设置绘制刻度
slider.setPaintTicks(true);
// 设置主、次刻度的间距
slider.setMajorTickSpacing(20);
slider.setMinorTickSpacing(5);
addSlider(slider, "有刻度");
// -----------添加滑块必须停在刻度处滑动条-----------
slider = new JSlider();
// 设置滑块必须停在刻度处
slider.setSnapToTicks(true);
// 设置绘制刻度
slider.setPaintTicks(true);
// 设置主、次刻度的间距
slider.setMajorTickSpacing(20);
slider.setMinorTickSpacing(5);
addSlider(slider, "滑块停在刻度处");
// -----------添加没有滑轨的滑动条-----------
slider = new JSlider();
// 设置绘制刻度
slider.setPaintTicks(true);
// 设置主、次刻度的间距
slider.setMajorTickSpacing(20);
slider.setMinorTickSpacing(5);
// 设置不绘制滑轨
slider.setPaintTrack(false);
addSlider(slider, "无滑轨");
// -----------添加方向反转的滑动条-----------
slider = new JSlider();
// 设置绘制刻度
slider.setPaintTicks(true);
// 设置主、次刻度的间距
slider.setMajorTickSpacing(20);
slider.setMinorTickSpacing(5);
// 设置方向反转
slider.setInverted(true);
addSlider(slider, "方向反转");
// --------添加绘制默认刻度标签的滑动条--------
slider = new JSlider();
// 设置绘制刻度
slider.setPaintTicks(true);
// 设置主、次刻度的间距
slider.setMajorTickSpacing(20);
slider.setMinorTickSpacing(5);
// 设置绘制刻度标签，默认绘制数值刻度标签
slider.setPaintLabels(true);
addSlider(slider, "数值刻度标签");
// ------添加绘制Label类型的刻度标签的滑动条------
slider = new JSlider();
// 设置绘制刻度
slider.setPaintTicks(true);
// 设置主、次刻度的间距
slider.setMajorTickSpacing(20);
slider.setMinorTickSpacing(5);
// 设置绘制刻度标签
slider.setPaintLabels(true);
Dictionary&Integer, Component& labelTable = new Hashtable&&();
labelTable.put(0, new JLabel("A"));
labelTable.put(20, new JLabel("B"));
labelTable.put(40, new JLabel("C"));
labelTable.put(60, new JLabel("D"));
labelTable.put(80, new JLabel("E"));
labelTable.put(100, new JLabel("F"));
// 指定刻度标签，标签是JLabel
slider.setLabelTable(labelTable);
addSlider(slider, "JLable标签");
// ------添加绘制Label类型的刻度标签的滑动条------
slider = new JSlider();
// 设置绘制刻度
slider.setPaintTicks(true);
// 设置主、次刻度的间距
slider.setMajorTickSpacing(20);
slider.setMinorTickSpacing(5);
// 设置绘制刻度标签
slider.setPaintLabels(true);
labelTable = new Hashtable&Integer, Component&();
labelTable.put(0, new JLabel(new ImageIcon("ico/0.GIF")));
labelTable.put(20, new JLabel(new ImageIcon("ico/2.GIF")));
labelTable.put(40, new JLabel(new ImageIcon("ico/4.GIF")));
labelTable.put(60, new JLabel(new ImageIcon("ico/6.GIF")));
labelTable.put(80, new JLabel(new ImageIcon("ico/8.GIF")));
// 指定刻度标签，标签是ImageIcon
slider.setLabelTable(labelTable);
addSlider(slider, "Icon标签");
mainWin.add(sliderBox, BorderLayout.CENTER);
mainWin.add(showVal, BorderLayout.SOUTH);
mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
mainWin.pack();
mainWin.setVisible(true);
// 定义一个方法，用于将滑动条添加到容器中
public void addSlider(JSlider slider, String description) {
slider.addChangeListener(listener);
Box box = new Box(BoxLayout.X_AXIS);
box.add(new JLabel(description + "："));
box.add(slider);
sliderBox.add(box);
public static void main(String[] args) {
new JSliderTest().init();
public class JSpinnerTest {
final int SPINNER_NUM = 6;
JFrame mainWin = new JFrame("微调控制器示范");
Box spinnerBox = new Box(BoxLayout.Y_AXIS);
JSpinner[] spinners = new JSpinner[SPINNER_NUM];
JLabel[] valLabels = new JLabel[SPINNER_NUM];
JButton okBn = new JButton("确定");
public void init()
for (int i = 0 ; i & SPINNER_NUM ; i++ )
valLabels[i] = new JLabel();
// -----------普通JSpinner-----------
spinners[0] = new JSpinner();
addSpinner(spinners[0], "普通" , valLabels[0]);
// -----------指定最小值、最大值、步长的JSpinner-----------
// 创建一个SpinnerNumberModel对象，指定最小值、最大值和步长
SpinnerNumberModel numModel = new SpinnerNumberModel(
3.4 , -1.1 , 4.3 , 0.1);
spinners[1] = new JSpinner(numModel);
addSpinner(spinners[1], "数值范围" , valLabels[1]);
// -----------使用SpinnerListModel的JSpinner------------
String[] books = new String[]
"轻量级Java EE企业应用实战"
, "疯狂Java讲义"
, "疯狂Ajax讲义"
// 使用字符串数组创建SpinnerListModel对象
SpinnerListModel bookModel = new SpinnerListModel(books);
// 使用SpinnerListModel对象创建JSpinner对象
spinners[2] = new JSpinner(bookModel);
addSpinner(spinners[2], "字符串序列值" , valLabels[2]);
// -----------使用序列值是ImageIcon的JSpinner------------
ArrayList&ImageIcon& icons = new ArrayList&&();
icons.add(new ImageIcon("a.gif"));
icons.add(new ImageIcon("b.gif"));
// 使用ImageIcon数组创建SpinnerListModel对象
SpinnerListModel iconModel = new SpinnerListModel(icons);
// 使用SpinnerListModel对象创建JSpinner对象
spinners[3] = new JSpinner(iconModel);
addSpinner(spinners[3], "图标序列值" , valLabels[3]);
// -----------使用SpinnerDateModel的JSpinner------------
// 分别获取起始时间、结束时间、初时时间
Calendar cal = Calendar.getInstance();
Date init = cal.getTime();
cal.add(Calendar.DAY_OF_MONTH , -3);
Date start = cal.getTime();
cal.add(Calendar.DAY_OF_MONTH , 8);
Date end = cal.getTime();
// 创建一个SpinnerDateModel对象，指定最小时间、最大时间和初始时间
SpinnerDateModel dateModel = new SpinnerDateModel(init
, start , end , Calendar.HOUR_OF_DAY);
// 以SpinnerDateModel对象创建JSpinner
spinners[4] = new JSpinner(dateModel);
addSpinner(spinners[4], "时间范围" , valLabels[4]);
// -----------使用DateEditor来格式化JSpinner------------
dateModel = new SpinnerDateModel();
spinners[5] = new JSpinner(dateModel);
// 创建一个JSpinner.DateEditor对象，用于对指定Spinner进行格式化
JSpinner.DateEditor editor = new JSpinner.DateEditor(
spinners[5] , "公元yyyy年MM月dd日 HH时");
// 设置使用JSpinner.DateEditor对象进行格式化
spinners[5].setEditor(editor);
addSpinner(spinners[5], "使用DateEditor" , valLabels[5]);
// 为&确定&按钮添加一个事件监听器
okBn.addActionListener(evt -&
// 取出每个微调控制器的值，并将该值用后面的Label标签显示出来。
for (int i = 0 ; i & SPINNER_NUM ; i++)
// 将微调控制器的值通过指定的JLabel显示出来
valLabels[i].setText(spinners[i].getValue().toString());
JPanel bnPanel = new JPanel();
bnPanel.add(okBn);
mainWin.add(spinnerBox, BorderLayout.CENTER);
mainWin.add(bnPanel, BorderLayout.SOUTH);
mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
mainWin.pack();
mainWin.setVisible(true);
// 定义一个方法，用于将滑动条添加到容器中
public void addSpinner(JSpinner spinner, String description, JLabel valLabel) {
Box box = new Box(BoxLayout.X_AXIS);
JLabel desc = new JLabel(description + "：");
desc.setPreferredSize(new Dimension(100, 30));
box.add(desc);
box.add(spinner);
valLabel.setPreferredSize(new Dimension(180, 30));
box.add(valLabel);
spinnerBox.add(box);
public static void main(String[] args) {
new JSpinnerTest().init();
public class DefaultListModelTest {
private JFrame mainWin = new JFrame("测试DefaultListModel");
// 定义一个JList对象
private JList&String& bookL
// 定义一个DefaultListModel对象
private DefaultListModel&String& bookModel = new DefaultListModel&&();
private JTextField bookName = new JTextField(20);
private JButton removeBn = new JButton("删除选中图书");
private JButton addBn = new JButton("添加指定图书");
public void init()
// 向bookModel中添加元素
bookModel.addElement("疯狂Java讲义");
bookModel.addElement("轻量级Java EE企业应用实战");
bookModel.addElement("疯狂Android讲义");
bookModel.addElement("疯狂Ajax讲义");
bookModel.addElement("经典Java EE企业应用实战");
// 根据DefaultListM}