Swing程序设计（八）——其他高级组件

最新推荐文章于 2023-02-23 13:26:41 发布

韶关是我家

最新推荐文章于 2023-02-23 13:26:41 发布

阅读量484

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/qq_42188457/article/details/104159920

版权

Java 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

其他高级组件

一、高级组件面板

JSplitPane（分割面板）

常用构造方法	说明
public JSplitPane()	创建一个默认的分割面板。默认情况下为在水平方向上分割，重绘方式为只在调整分隔条位置完成时重绘。
public JSplitPane(int newOrientation)	创建一个按照指定方向分割的分割面板。入口参数newOrientation的可选静态常量有：HORIZAONTAL_SPLIT(在水平方向分割，为默认值)；VERTICAL_SPLIT（在垂直方向上分割）
public JSplitPane(int newOrientation,boolean newContinuousLayout)	创建一个按照指定方向分割，并且按照指定方式重绘的分割面板。如果将入口参数newContinuousLayout设为true，表示在调整分隔条位置的过程中连续重绘，设为false则表示只在调整分隔条位置完成时重绘。

常用方法	说明
public void setOrientation(int orientation)	设置分割面板的分割方向，即水平分割（默认）或垂直分割：JSplitPane.VERTICAL_SPLIT（组件的上/下方向）JSplitPane.HORIZONTAL_SPLIT（组件的左/右方向）
public void setDividerLocation(int location)	设置分隔条的绝对位置，即分隔条左侧（水平分割的宽度）或上方（垂直分割）的高度
public void setDividerLocation(double proportionalLocation)	设置分隔条的位置为 JSplitPane 大小的一个百分比。
public void setDividerSize(int newSize)	设置分隔条的宽度。默认为5像素
public void setLeftComponent(Component comp)	将组件设置到分隔条的左边（或上面）。
public void setRightComponent(Component comp)	将组件设置到分隔条的右边（或者下面）。
public void setTopComponent(Component comp)	将组件设置到分隔条的上面或者左边。
public void setBottomComponent(Component comp)	将组件设置到分隔条的下面或者右边。
public void setOneTouchExpandable(boolean newValue)	设置 oneTouchExpandable 属性的值，此属性为 true，使 JSplitPane 在分隔条上提供一个 UI 小部件来快速展开/折叠分隔条。此属性的默认值为 false。有些外观可能不支持一键展开，它们将忽略此属性。
public void setContinuousLayout(boolean newContinuousLayout)	设置 continuousLayout 属性的值，此值为 true，在用户干预期使子组件连续地重新显示和布局子组件（连续重绘）。此属性的默认值为 false。一些外观可能不支持连续布局；它们将忽略此属性。（即设置调整分隔条位置时面板的重绘方式）

JTabbedPane（选项卡面板）

常用构造方法	说明
public JTabbedPane()	创建一个具有默认的选项卡面板。默认情况下标签位于选项卡的上方，布局方式为限制布局
public JTabbedPane(int tabPlacement)	创建一个指定标签显示位置的空的选项卡面板，入口参数 tabPlacement的可选静态常量是：JTabbedPane.TOP、JTabbedPane.BOTTOM、JTabbedPane.LEFT 或 JTabbedPane.RIGHT
public JTabbedPane(int tabPlacement,int tabLayoutPolicy)	创建一个空的 TabbedPane，使其具有指定的选项卡布局和选项卡布局策略。布局可以是以下几种之一：JTabbedPane.TOP、JTabbedPane.BOTTOM、JTabbedPane.LEFT 或 JTabbedPane.RIGHT。布局策略可以是以下两种之一：JTabbedPane.WRAP_TAB_LAYOUT （限制布局，为默认）或 JTabbedPane.SCROLL_TAB_LAYOUT（滚动布局）。

常用方法	说明
public void addTab(String title,Component component)	添加一个标签为 title且没有图标的以及内容为component的选项卡
public void addTab(String title, Icon icon,Component component)	添加一个标签为title、图标为icon的选项卡
public void addTab(String title, Icon icon,Component component,String tip)	添添加一个标签为title、图标为icon、提示为tip的选项卡
public void insertTab(String title,Icon icon,Component component,String tip，int index)	在索引index位置处插入一个标签为title、图标为icon、提示为tip的选项卡
public void setTabPlacement(int tabPlacement)	设置此选项卡窗格的选项卡布局。（即选项卡标签的显示位置），JTabbedPane.TOP、JTabbedPane.BOTTOM、JTabbedPane.LEFT、JTabbedPane.RIGHT
public void setTabLayoutPolicy(int tabLayoutPolicy)	设置在一次运行中不能放入所有的选项卡时，选项卡窗格使用的对选项卡进行布局安排的策略。（即设置选项卡标签的布局方式）：JTabbedPane.WRAP_TAB_LAYOUT（限制布局，默认）、JTabbedPane.SCROLL_TAB_LAYOUT（滚动布局）
public void setSelectedIndex(int index)	设置索引位置的选项卡被选中
public void setEnabledAt(int index,boolean enabled)	设置是否启用 index 位置的选项卡。如果在该索引位置没有选项卡，则会引发一个内部异常。
public void setDisabledIconAt(int index, Icon disabledIcon)	将 index 位置的禁用图标设置为 icon，它可以为 null。如果在该索引位置没有选项卡，则会引发一个内部异常。（即为指定索引位置的选项卡设置不可用时显示的图标）
public int getTabCount()	返回此 tabbedpane 的选项卡数。
public int getSelectedIndex()	返回当前选择的此选项卡窗格的索引。如果当前没有选择选项卡，则返回 -1。（即获取被选中选项卡的索引值）
public String getTitleAt(int index)	返回 index 位置的选项卡标签。
public void addChangeListener(ChangeListener l)	为选项卡面板添加捕获被选中选项卡发生改变的事件

注意：3个重载的addTab()方法的所有入口参数都可以设置为空null

ChangeListener接口：可用于选项卡选中状态改变的监听
void stateChanged(ChangeEvent e)：当侦听器的目标已更改其状态时调用。

JDesktopPane类（桌面面板）和JInternalFrame类（内部窗体）
内部窗体必须在桌面面板中。JDesktopPane类是一个容器类，用来创建一个虚拟的桌面,JInternalFrame类是一个轻量级对象（即不依赖于系统，不因系统不同而显示差异），用来创建支持拖动、关闭、图标化、调整大小、标题显示和菜单栏的内部窗体，该内部窗体需要显示在由JDesktopPane类创建的桌面面板中。

JDesktopPane类（桌面面板）：

构造方法	说明
public JDesktopPane()	创建一个新的 JDesktopPane 。

常用方法	说明
public void add(Component comp,Object constraints)	将指定的组件添加到此容器的尾部。同时通知布局管理器使用指定的 constraints 对象将组件添加到此容器的布局中。
public JInternalFrame[] getAllFrames()	返回桌面中当前显示的所有 JInternalFrames。返回图标化的窗体和扩展的窗体。
public JInternalFrame getSelectedFrame()	返回此 JDesktopPane 中当前活动的 JInternalFrame，如果当前没有活动的 JInternalFrame，则返回 null。（即返回当前被选中的JInternalFrame）
public void removeAll()	从桌面中移除所有的JInternalFrame
public void remove(int index)	从桌面中移除位于指定索引的JInternalFrame
public void setSelectedFrame(JInternalFrame f)	设置指定的JInternalFrame为当前被选中的窗体
public void setDragMode(int dragMode)	设置窗体的拖动模式（即在拖动窗体时窗体的重绘方式），入口参数的可选静态常量有：LIVE_DRAG_MODE（连续重绘窗体及内容）, OUTLINE_DRAG_MODE（只连续重绘被拖动窗体的边框）

知识拓展：为桌面面板添加背景图片
实现思路是将一个显示背景图片的标签组件添加到桌面所有窗体的最后方，即桌面面板最底层，以保证他总是绘制在桌面所有内容的后面。

final JDesktopPane desktopPane = new JDesktopPane();
		getContentPane().add(desktopPane, BorderLayout.CENTER);
		final JLabel backLabel = new JLabel(); // 创建一个标签组件对象
		// 获得背景图片的路径
		URL resource = this.getClass().getResource("/back.JPG");
		ImageIcon icon = new ImageIcon(resource); // 创建背景图片对象
		backLabel.setIcon(icon); // 令标签组件显示背景图片
		// 设置组件的显示位置及大小
		backLabel.setBounds(0, 0, icon.getIconWidth(), icon
				.getIconHeight());
		// 将标签组件添加到指定索引位置
		desktopPane.add(backLabel, new Integer(Integer.MIN_VALUE));  //这里将用来显示背景图片的标签组件
		添加到桌面面板的最底层，即new Integer(Integer.MIN_VALUE)层

JInternalFrame类（内部窗体）：

构造方法	说明
public JInternalFrame()	创建不可调整大小的、不可关闭的、不可最大化的、不可图标化的、没有标题的 JInternalFrame。
public JInternalFrame(String title)	创建不可调整大小的、不可关闭的、不可最大化的、不可图标化的、具有指定标题的 JInternalFrame。
public JInternalFrame(String title, boolean resizable)	创建不可关闭的、不可最大化的、不可图标化的，以及具有指定标题和可调整大小的 JInternalFrame
public JInternalFrame(String title,boolean resizable,boolean closable)	创建不可最大化的、不可图标化的，以及具有指定标题、可调整大小和可关闭的 JInternalFrame。
public JInternalFrame(String title,boolean resizable,boolean closable,boolean maximizable)	创建不可图标化的，但具有指定标题、可调整大小、可关闭和可最大化的 JInternalFrame。
public JInternalFrame(String title,boolean resizable, boolean closable,boolean maximizable,boolean iconifiable)	创建具有指定标题、可调整、可关闭、可最大化和可图标化的 JInternalFrame。所有 JInternalFrame 构造方法都使用此构造方法。

构造方法参数	说明
title	为内部窗体的标题
resizable	是否允许自由调整大小，默认值false
closable	是否提供可关闭按钮，默认值false
maximizable	是否提供最大化按钮，默认值false
iconifiable	是否提供最小化按钮，默认值false

常用方法	说明
public void setResizable(boolean b)	设置是否可以调整 JInternalFrame 的大小。
public void setClosable(boolean b)	设置是否提供关闭按钮。
public void setMaximizable(boolean b)	设置是否提供最大化按钮。
public void setIconifiable(boolean b)	设置是否提供最小化按钮。
public void setSelected(boolean selected) throws PropertyVetoException	设置窗体是否被激活，设为true表示激活窗体，false为默认值（即是否选中该窗体）
public boolean isMaximum()	查看窗体是否处于最大化状态
public boolean isIcon()	查看窗体是否处于最小化状态
public boolean isClosed()	查看窗体是否已经被关闭
public void setFrameIcon(Icon icon)	设置窗体标题栏显示的图标
public void setVisible(boolean aFlag)	使该窗体是否可见
public void setBounds(int x,int y,int width,int height)	移动组件并调整其大小。
setTitle(String title)	设置标题

注意：内部窗体与普通窗体差不多，可以使用其有方法

示例：
public class ExampleFrame_03 extends JFrame {
	private static final long serialVersionUID = 1L;
	JDesktopPane desktopPane = null;// 定义一个桌面面板对象
	InternalFrame pInFrame = null;// 定义一个人事管理内部窗体对象
	InternalFrame rInFrame = null;// 定义一个账套管理内部窗体对象
	InternalFrame tInFrame = null;// 定义一个待遇报表内部窗体对象
	public static void main(String args[]) {
		ExampleFrame_03 frame = new ExampleFrame_03();
		frame.setVisible(true);
	}
	public ExampleFrame_03() {
		super();
		setTitle("企业人事管理系统");
		setBounds(100, 100, 570, 470);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		// 创建桌面面板
		desktopPane = new JDesktopPane();// 创建桌面面板对象
		// 设置内部窗体的拖动模式
		desktopPane.setDragMode(JDesktopPane.OUTLINE_DRAG_MODE);
		getContentPane().add(desktopPane, BorderLayout.CENTER);
		// 为桌面面板添加背景图片
		final JLabel backLabel = new JLabel(); // 创建一个标签组件对象
		// 获得背景图片的路径
		URL resource = this.getClass().getResource("/back.JPG");
		ImageIcon icon = new ImageIcon(resource); // 创建背景图片对象
		backLabel.setIcon(icon); // 令标签组件显示背景图片
		// 设置组件的显示位置及大小
		backLabel.setBounds(0, 0, icon.getIconWidth(), icon.getIconHeight());
		// 将标签组件添加到指定索引位置
		desktopPane.add(backLabel, new Integer(Integer.MIN_VALUE));
		// 添加按钮
		final JPanel panel = new JPanel();
		final FlowLayout flowLayout = new FlowLayout();
		flowLayout.setAlignment(FlowLayout.LEFT);
		panel.setLayout(flowLayout);
		getContentPane().add(panel, BorderLayout.NORTH);
		
		final JButton personnelButton = new JButton();
		personnelButton.setText("人事管理");
		personnelButton
				.addActionListener(new BAListener(pInFrame, "人事管理"));
		panel.add(personnelButton);
		
		final JButton reckoningButton = new JButton();
		reckoningButton.setText("账套管理");
		reckoningButton
				.addActionListener(new BAListener(rInFrame, "账套管理"));
		panel.add(reckoningButton);
		
		final JButton treatmentButton = new JButton();
		treatmentButton.setText("待遇报表");
		treatmentButton
				.addActionListener(new BAListener(tInFrame, "待遇报表"));
		panel.add(treatmentButton);
	}
	
	private class BAListener implements ActionListener {
		InternalFrame inFrame;
		String title;
		public BAListener(InternalFrame inFrame, String title) {
			this.inFrame = inFrame;
			this.title = title;
		}
		public void actionPerformed(ActionEvent e) {
			if (inFrame == null || inFrame.isClosed()) {
				// 获得桌面面板中的所有内部窗体
				JInternalFrame[] allFrames = desktopPane.getAllFrames();
				// 获得桌面面板中拥有内部窗体的数量
				int titleBarHight = 30 * allFrames.length;
				int x = 10 + titleBarHight, y = x;// 设置窗体的显示位置
				int width = 250, height = 180;// 设置窗体的大小
				inFrame = new InternalFrame(title);// 创建指定标题的内部窗体
				// 设置窗体的显示位置及大小
				inFrame.setBounds(x, y, width, height);
				inFrame.setVisible(true);// 设置窗体可见
				desktopPane.add(inFrame);// 将窗体添加到桌面面板中
			}
			try {
				inFrame.setSelected(true);// 选中窗体
			} catch (PropertyVetoException propertyVetoE) {
				propertyVetoE.printStackTrace();
			}
		}
	}
	private class InternalFrame extends JInternalFrame {
		private static final long serialVersionUID = 1L;
		public InternalFrame(String title) {
			super();
			setTitle(title);// 设置内部窗体的标题
			setResizable(true);// 设置允许自由调整大小
			setClosable(true);// 设置提供关闭按钮
			setIconifiable(true);// 设置提供图标化按钮
			setMaximizable(true);// 设置提供最大化按钮
			// 获得图片的路径
			URL resource = this.getClass().getResource("/in_frame.png"); 
			ImageIcon icon = new ImageIcon(resource); // 创建图片对象
			setFrameIcon(icon); // 设置窗体图标
		}
	}
}

二、文件选择器

文件选择对话框（JFileChooser类）
步骤：
1.创建一个JFileChooser类的对象
2.设置选择模式，默认情况下只允许选择文件 public void setFileSelectionMode(int mode)
3.默认情况下每次只能选择一个文件，如果希望允许同时选择多个文件，通过public void setMultiSelectionEnabled(boolean b)设置
4.如果只希望在对话框中列出指定类型的文件，可以设置文件过滤器调用public void setFileFilter(FileFilter filter)
5.调用public int showOpenDialog(Component parent) throws HeadlessException 方法显示文件对话框，该方法返回一个int型值，用来判断用户是否选择了文件或文件夹。
6.如果用户选择了文件或文件夹，可以通过public File getSelectedFile()或public File[] getSelectedFiles()方法获得。

构造方法	说明
JFileChooser()	构造一个指向用户默认目录的 JFileChooser。
JFileChooser(File currentDirectory)	使用给定的 File 作为路径来构造一个JFileChooser。
JFileChooser(File currentDirectory, FileSystemView fsv)	使用给定的当前目录和 FileSystemView 构造一个 JFileChooser。
JFileChooser(FileSystemView fsv)	使用给定的 FileSystemView 构造一个 JFileChooser。
JFileChooser(String currentDirectoryPath)	构造一个使用给定路径的 JFileChooser。
JFileChooser(String currentDirectoryPath, FileSystemView fsv)	使用给定的当前目录路径和 FileSystemView 构造一个 JFileChooser。

常用方法	说明
public void setFileSelectionMode(int mode)	设置 JFileChooser，允许用户只选择文件、只选择目录，或者可选择文件和目录。mode静态常量取值：JFileChooser.FILES_ONLY（只能选择文件，默认值）、JFileChooser.DIRECTORIES_ONLY（只选择文件夹）、JFileChooser.FILES_AND_DIRECTORIES（可选择文件和目录）
public void setMultiSelectionEnabled(boolean b)	设置文件选择器，是否允许选择多个文件。如果可以选择多个文件，则为 true，默认为false
public void setFileFilter(FileFilter filter)	设置当前文件过滤器。文件选择器使用文件过滤器从用户的视图中过滤文件。
public int showOpenDialog(Component parent) throws HeadlessException	parent 为该对话框的父组件，返回值为JFileChooser.CANCEL_OPTION（选择 cancel 后的返回值。）、JFileChooser.APPROVE_OPTION（选择确认后返回该值。）、JFileCHooser.ERROR_OPTION（发生错误后返回该值。）
public File getSelectedFile()	返回选中的文件。
public File[] getSelectedFiles()	如果将文件选择器设置为允许选择多个文件，则返回选中文件的列表。

示例：
		final JButton button = new JButton();
		button.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				JFileChooser fileChooser = new JFileChooser();// 创建文件选择对话框
				// 显示文件选择对话框
				int i = fileChooser.showOpenDialog(getContentPane());
				// 判断用户单击的是否为“打开”按钮
				if (i == JFileChooser.APPROVE_OPTION) {
					// 获得选中的文件对象
					File selectedFile = fileChooser.getSelectedFile();
					// 显示选中文件的名称
					textField.setText(selectedFile.getName());
				}
			}
		});
		button.setText("上传");
		panel.add(button);

文件过滤器（FileNameExtensionFilter类）

FileFilter类：该类为抽象类

象方法	说明
public abstract boolean accept(File f)	此过滤器是否接受给定的文件。用来过滤文件，如果返回true，则表示显示到文件选择对话框中。
ublic abstract String getDescription()	此过滤器的描述。用来返回对话框中“文件类型”的描述信息

可通过实现该类对文件进行过滤。

FileNameExtensionFilter类：FileFilter类的实现类。

造方法	说明
public FileNameExtensionFilter(String description,String… extensions)	description :过滤器的文本描述,为“文件类型”的描述信息；extensions :接受的文件扩展名

示例：
public class ExampleFrame_10 extends JFrame {
	private static final long serialVersionUID = 1L;

	public static void main(String args[]) {
		ExampleFrame_10 frame = new ExampleFrame_10();
		frame.setVisible(true);
	}
	
	public ExampleFrame_10() {
		super();
		setTitle("选择照片对话框");
		setBounds(100, 100, 500, 375);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		final JLabel label = new JLabel("<双击选择照片>", SwingConstants.CENTER);
		label.addMouseListener(new MouseAdapter() {
			JFileChooser fileChooser;
			{
				// 创建文件选择对话框
				fileChooser = new JFileChooser();
				// 设置文件过滤器，只列出JPG或GIF格式的图片
				FileFilter filter = new FileNameExtensionFilter(
						"图像文件（JPG/GIF）", "JPG", "JPEG", "GIF");
				fileChooser.setFileFilter(filter);
			}
			
			public void mouseClicked(MouseEvent e) {
				if (e.getClickCount() == 2) {
					// 显示文件选择对话框
					int i = fileChooser.showOpenDialog(getContentPane());
					// 判断用户单击的是否为“打开”按钮
					if (i == JFileChooser.APPROVE_OPTION) {
						// 获得选中的图片对象
						File selectedFile = fileChooser.getSelectedFile();
						label.setIcon(new ImageIcon(selectedFile
								.getAbsolutePath()));// 将图片显示到标签上
						label.setText(null);
					}
				}
			}
		});
		getContentPane().add(label, BorderLayout.CENTER);
	}
}

三、进度条

JProgressBar类

用构造方法	说明
public JProgressBar()	创建一个显示边框但不带进度字符串的水平进度条。初始值和最小值都为 0，最大值为 100。

常用方法	说明
public void setIndeterminate(boolean newValue)	设置进度条的 indeterminate 属性，该属性确定进度条处于确定模式（false）中还是处于不确定模式（true）中。不确定进度条连续地显示动画，指示发生未知长度的操作。默认情况下，此属性为 false。有些外观可能不支持不确定进度条；它们将忽略此属性。
ublic void setStringPainted(boolean b)	设置 stringPainted 属性的值，该属性确定进度条是否应该呈现进度字符串。默认值为 false：不绘制任何字符串。有些外观可能不支持进度字符串，或者只有在进度条处于确定模式时才支持它们。
ublic void setValue(int n)	将进度条的当前值（存储在进度条的数据模型中）设置为 n（0-100）。
ublic void setString(String s)	设置进度字符串的值。默认情况下，此字符串为 null。

注意：进度条并不能自动获取任务的执行进度，必须通过setValue(int n)方法反复修改当前的执行进度。采用不确定进度的进度条，则需要在任务执行完成后将其设置为采用确定进度的进度条，并将任务的执行进度设置为100%或者提示已经完成。

四、系统托盘

SystemTray类（桌面系统托盘类）
该类可以访问系统托盘。每个Java应用程序在运行时都会被分配一个该类实例，可以通过该类静态方法getSystemTray()获得，某些系统可能不支持系统托盘功能可通过调用静态方法isSupported()判断当前系统是否支持该功能。
注意：该类位于java.awt.SystemTray

常用方法	说明
public static boolean isSupported()	判断当前系统是否支持系统托盘
public static SystemTray getSystemTray()	获取表示桌面托盘区域的SystemTray实例。
public void add(TrayIcon trayIcon) throws AWTException	为当前应用程序添加托盘图标到系统托盘。添加后，系统托盘中的托盘图标就会显示。
public void remove(TrayIcon trayIcon)	移除指定的托盘图标
public Dimension getTrayIconSize()	返回托盘图标在系统托盘中占用的空间大小（以像素为单位）。在创建托盘图标之前，开发人员可以使用此方法获取托盘图标的图像属性的首选大小。为方便起见，在TrayIcon类中有一个类似的方法TrayIcon.getSize() 。

TrayIcon类（托盘图标类）
每个TrayIcon类的对象代表一个托盘图标。
注意：该类位于java.awt.TrayIcon

用构造方法	说明
public TrayIcon(Image image)	用指定的图像创建一个 TrayIcon 。
public TrayIcon(Image image,String tooltip)	使用指定的图像和工具提示文本（鼠标停留提示）创建 TrayIcon 。
ublic TrayIcon(Image image,String tooltip, PopupMenu popup)	使用指定的图像，工具提示和弹出菜单（右击图标）创建 TrayIcon 。

用方法	说明
public Dimension getSize()	返回托盘图标在系统托盘中占用的空间大小（以像素为单位）。

示例：
public class ExampleFrame_12 extends JFrame {
	private static final long serialVersionUID = 1L;

	public static void main(String args[]) {
		ExampleFrame_12 frame = new ExampleFrame_12();
		frame.setVisible(true);
		try {
			frame.addIconToTray();
		} catch (AWTException e) {
			e.printStackTrace();
		}
	}
	
	public ExampleFrame_12() {
		super();
		setTitle("使用系统托盘");
		setBounds(100, 100, 500, 375);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		final JLabel label = new JLabel();
		label.setForeground(new Color(0, 128, 0));
		label.setFont(new Font("", Font.BOLD, 16));
		label.setHorizontalAlignment(SwingConstants.CENTER);
		label.setText("请查看系统托盘中的变化！");
		getContentPane().add(label, BorderLayout.CENTER);
		//
	}
	
	public void addIconToTray() throws AWTException {
		if (SystemTray.isSupported()) {// 判断系统是否支持系统托盘功能
			URL resource = this.getClass().getResource("/img.JPG");// 获得图片路径
			ImageIcon icon = new ImageIcon(resource);// 创建图片对象
			PopupMenu popupMenu = new PopupMenu();// 创建弹出菜单对象
			MenuItem item = new MenuItem("退出");// 创建“退出”菜单项目对象
			// 为菜单项目添加动作监听器
			item.addActionListener(new ActionListener() {
				public void actionPerformed(ActionEvent e) {
					System.exit(0);// 退出系统
				}
			});
			popupMenu.add(item);// 将“退出”菜单项目添加到弹出菜单中
			TrayIcon trayIcon = new TrayIcon(icon.getImage(), "使用系统托盘",
					popupMenu);// 创建托盘图片对象
			// 获得系统托盘对象
			SystemTray systemTray = SystemTray.getSystemTray();
			systemTray.add(trayIcon);// 将托盘图片添加到系统托盘中
		}
	}
}

五、桌面集成控件

Desktop类：没有构造方法，可通过public static Desktop getDesktop()获得对象。
该类可以在Java应用程序中启动已经在本机上注册的应用程序，如通过启动默认浏览器显示指定的网站、打开或编辑指定的文件等。通过Desktop类的静态方法public static boolean isDesktopSupported()可以判断当前系统是否提供了对该类的支持，因为有些系统是没有桌面应用的，比如服务器的系统。Desktop类提供的每一种操作都属于Desktop.Action（枚举类型）类表示的一种动作类型，所有在执行具体操作之前，还可以通过isSupported(Desktop.Action action)方法判断是否支持相应的动作。

用方法	说明
public static boolean isDesktopSupported()	测试此类是否在当前平台上得到支持。
public boolean isSupported(Desktop.Action action)	测试当前平台是否支持操作。
public static Desktop getDesktop()	返回当前系统的Desktop实例
public void browse(URI uri) throws IOException	启动默认浏览器以显示URI 。
public void edit(File file)throws IOException	启动相关的编辑器应用程序并打开一个文件进行编辑。
public void open(File file) throws IOException	启动相关应用程序以打开文件。

示例：
public class ExampleFrame_13 extends JFrame {
	private static final long serialVersionUID = 1L;

	public static void main(String args[]) {
		ExampleFrame_13 frame = new ExampleFrame_13();
		frame.setVisible(true);
	}
	
	public ExampleFrame_13() {
		super();
		setTitle("使用桌面集成控件");
		setBounds(100, 100, 500, 375);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		final JPanel panel = new JPanel();
		getContentPane().add(panel, BorderLayout.NORTH);
		
		final JButton dickButton = new JButton();
		dickButton.setText("打开编程词典网");
		dickButton.addActionListener(new ButtonListener(1));
		panel.add(dickButton);
		
		final JButton noteButton = new JButton();
		noteButton.setText("打开记事本");
		noteButton.addActionListener(new ButtonListener(2));
		panel.add(noteButton);
		
		final JButton wordButton = new JButton();
		wordButton.setText("打开Word");
		wordButton.addActionListener(new ButtonListener(0));
		panel.add(wordButton);
		//
	}
	
	private class ButtonListener implements ActionListener {
		
		int index;
		
		public ButtonListener(int index) {
			this.index = index;
		}
		
		public void actionPerformed(ActionEvent e) {
			try {
if (Desktop.isDesktopSupported()) { // 判断系统是否提供了对该类的支持
	Desktop desktop = Desktop.getDesktop();// 获得该类的对象
	switch (index) {
		case 1:
			// 判断是否支持“浏览”动作
			if (desktop.isSupported(Desktop.Action.BROWSE))
				desktop.browse(new URI(
						"http://www.mrbccd.com"));// 浏览网站
			break;
		case 2:
			// 判断是否支持“编辑”动作
			if (desktop.isSupported(Desktop.Action.EDIT))
				desktop.edit(new File("src/new.txt"));// 编辑记事本
			break;
		default:
			// 判断是否支持“打开”动作
			if (desktop.isSupported(Desktop.Action.OPEN))
				desktop.open(new File("src/new.doc"));// 打开Word
	}
}
			} catch (Exception ex) {
				ex.printStackTrace();
			}
		}
	}
	
}

六、菜单
包括菜单栏和弹出式菜单
(1)菜单栏

JMenuBar类（菜单栏）

构造方法	说明
public JMenuBar()	创建新的菜单栏。

常用方法	说明
public JMenu add(JMenu c)	将指定的菜单追加到菜单栏的末尾。
public boolean isSelected()	如果当前已选择了菜单栏的组件，则返回 true。

注意：setJMenuBar(menuBar);//将菜单栏对象添加到窗体的菜单栏中

示例：
JMenuBar menuBar = new JMenuBar();
setJMenuBar(menuBar);//将菜单栏对象添加到窗体的菜单栏中

JMenu类（菜单）
继承了JMenuItem类

常用构造方法	说明
public JMenu()	构造没有文本的新 JMenu。
public JMenu(String s)	构造一个新 JMenu，用提供的字符串作为其文本。

常用方法	说明
public JMenuItem add(JMenuItem menuItem)	将某个菜单项或子菜单（JMenu向上转型JMenuItem）追加到此菜单的末尾。返回添加的菜单项。
public JMenuItem add(String s)	创建具有指定文本的菜单项，并将其追加到此菜单的末尾。
public JMenuItem insert(JMenuItem mi, int pos)	在给定位置插入指定的菜单项。
public void insert(String s,int pos)	在给定的位置插入一个具有指定文本的新菜单项。
public int getMenuComponentCount()	返回菜单中包含的的组件数，组件包括菜单项、子菜单、分隔线
public boolean isTopLevelMenu()	如果菜单是“顶层菜单”（即菜单栏的直接子级），则返回 true。
public boolean isMenuComponent(Component c)	如果在子菜单层次结构中存在指定的组件，则返回 true。
public void addSeparator()	将新分隔符追加到菜单的末尾。
public void setMnemonic(int mnemonic)	设置当前模型上的键盘助记符。助记符是某种键，它与外观的无鼠标修饰符（通常是 Alt）组合时（如果焦点被包含在此按钮祖先窗口中的某个地方）将激活此按钮。一个助记符必须对应键盘上的一个键，并且应该使用 java.awt.event.KeyEvent 中定义的 VK_XXX 键代码之一指定。助记符是不区分大小写的，所以具有相应键代码的键事件将造成按钮被激活，不管是否按下 Shift 修饰符。
public void setIcon(Icon defaultIcon)	添加图标
public void addSeparator()	在菜单末尾附加一个新的分隔符。
public void setEnabled(boolean b)	启用或禁用菜单。

JMenuItem（菜单项）
当用户单击菜单项时，将触发一个动作事件，通过捕获该事件，可以完成菜单项对应的业务逻辑。

常用构造方法	说明
public JMenuItem()	创建不带有设置文本或图标的 JMenuItem。
public JMenuItem(Icon icon)	创建带有指定图标的 JMenuItem。
public JMenuItem(String text)	创建带有指定文本的 JMenuItem。
public JMenuItem(String text, Icon icon)	创建带有指定文本和图标的 JMenuItem。
public JMenuItem(String text,int mnemonic)	创建带有指定文本和键盘助记符的 JMenuItem。

常用方法	说明
public void setEnabled(boolean b)	启用或禁用菜单项。
public void setIcon(Icon defaultIcon)	添加图标
public void setMnemonic(int mnemonic)	设置当前模型上的键盘助记符。助记符是某种键，它与外观的无鼠标修饰符（通常是 Alt）组合时（如果焦点被包含在此按钮祖先窗口中的某个地方）将激活此按钮。一个助记符必须对应键盘上的一个键，并且应该使用 java.awt.event.KeyEvent 中定义的 VK_XXX 键代码之一指定。助记符是不区分大小写的，所以具有相应键代码的键事件将造成按钮被激活，不管是否按下 Shift 修饰符。

示例：
public class ExampleFrame_05 extends JFrame {
	private static final long serialVersionUID = 1L;
	public static void main(String args[]) {
		ExampleFrame_05 frame = new ExampleFrame_05();
		frame.setVisible(true);
	}
	
	public ExampleFrame_05() {
		super();
		setTitle("创建菜单栏");
		setBounds(100, 100, 500, 375);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		JMenuBar menuBar = new JMenuBar();// 创建菜单栏对象
		setJMenuBar(menuBar);// 将菜单栏对象添加到窗体的菜单栏中
		
		JMenu menu = new JMenu("菜单名称");// 创建菜单对象
		menuBar.add(menu);// 将菜单对象添加到菜单栏对象中
		
		JMenuItem menuItem = new JMenuItem("菜单项名称");// 创建菜单项对象
		menuItem.addActionListener(new ItemListener());// 为菜单项添加事件监听器
		menu.add(menuItem);// 将菜单项对象添加到菜单对象中
		
		JMenu sonMenu = new JMenu("子菜单名称");// 创建菜单的子菜单对象
		menu.add(sonMenu);// 将子菜单对象添加到上级菜单对象中
		
		JMenuItem sonMenuItem = new JMenuItem("子菜单项名称");// 创建子菜单的菜单项对象
		sonMenuItem.addActionListener(new ItemListener());// 为菜单项添加事件监听器
		sonMenu.add(sonMenuItem);// 将子菜单的菜单项对象添加到子菜单对象中
		
		JMenu menu2 = new JMenu("菜单名称2");// 创建菜单对象
		menuBar.add(menu2);// 将菜单对象添加到菜单栏对象中
		
		JMenuItem menuItem2 = new JMenuItem("菜单项名称2");// 创建菜单项对象
		menuItem2.addActionListener(new ItemListener());// 为菜单项添加事件监听器
		menu2.add(menuItem2);// 将菜单项对象添加到菜单对象中
		
		JMenu sonMenu2 = new JMenu("子菜单名称2");// 创建菜单的子菜单对象
		menu2.add(sonMenu2);// 将子菜单对象添加到上级菜单对象中
		
		JMenuItem sonMenuItem2 = new JMenuItem("子菜单项名称2");// 创建子菜单的菜单项对象
		sonMenuItem2.addActionListener(new ItemListener());// 为菜单项添加事件监听器
		sonMenu2.add(sonMenuItem2);// 将子菜单的菜单项对象添加到子菜单对象中
		//
	}
	
	private class ItemListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			JMenuItem menuItem = (JMenuItem) e.getSource();
			System.out.println("您单击的是菜单项：" + menuItem.getText());
		}
	}
	
}

（2）弹出式菜单
弹出式菜单与菜单栏步骤相似，只是第一步创建的是JPopupMenu类对象，然后通过为需要弹出该菜单的组件添加鼠标事件监听器，在捕获弹出菜单事件时弹出该菜单。

JPopupMenu类

构造方法	说明
public JPopupMenu()	构造一个不带“调用者”的 JPopupMenu。
public JPopupMenu(String label)	构造一个具有指定标题的 JPopupMenu。

常用方法	说明
public void show(Component invoker,int x, int y)	在组件调用者的坐标空间中的位置 X、Y 处显示弹出式菜单。

MouseListener接口（鼠标事件监听器）

方法	触发
void mouseClicked(MouseEvent e)	在组件上单击（按下并释放）鼠标按钮时调用。
void mousePressed(MouseEvent e)	在组件上按下鼠标按钮时调用。
void mouseReleased(MouseEvent e)	在组件上释放鼠标按钮时调用。
void mouseEntered(MouseEvent e)	当鼠标进入组件时调用。
void mouseExited(MouseEvent e)	当鼠标退出组件时调用。

MouseEvent类（鼠标事件）

常用方法	说明
public boolean isPopupTrigger()	返回此鼠标事件是否为该平台的弹出菜单触发事件。
public int getX()	返回事件相对于源组件的水平 x 坐标。
public int getY()	返回事件相对于源组件的垂直 y 坐标。
public Component getComponent()	返回事件的始发者。

示例：
import java.awt.*;
import java.awt.event.*；
import javax.swing.*;
public class ExampleFrame_06 extends JFrame {
	private static final long serialVersionUID = 1L;

	public static void main(String args[]) {
		ExampleFrame_06 frame = new ExampleFrame_06();
		frame.setVisible(true);
	}
	
	public ExampleFrame_06() {
		super();
		setTitle("创建弹出式菜单");
		setBounds(100, 100, 500, 375);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		final JLabel label = new JLabel();
		label.setText("                请在窗口中单击鼠标右键！");
		getContentPane().add(label, BorderLayout.CENTER);
		
		final JPopupMenu popupMenu = new JPopupMenu();// 创建弹出式菜单对象
		// 为窗体的顶层容器添加鼠标事件监听器
		getContentPane().addMouseListener(new MouseAdapter() {   //适配器，可以只实现想要的方法，不必全部实现。
			// 鼠标按键被释放时触发该方法
			public void mouseReleased(MouseEvent e) {
				// 判断此次鼠标事件是否为该组件的弹出菜单触发事件
				// 如果是则在释放鼠标的位置弹出菜单
				if (e.isPopupTrigger())
					popupMenu.show(e.getComponent(), e.getX(), e.getY());
			}
		});
		
		final JMenuItem cutItem = new JMenuItem("剪切");
		cutItem.addActionListener(new ItemListener());
		popupMenu.add(cutItem);
		
		final JMenuItem copyItem = new JMenuItem("复制");
		copyItem.addActionListener(new ItemListener());
		popupMenu.add(copyItem);
		
		final JMenuItem pastItem = new JMenuItem("粘贴");
		pastItem.addActionListener(new ItemListener());
		popupMenu.add(pastItem);
		
		final JMenu editMenu = new JMenu("编辑");
		popupMenu.add(editMenu);
		
		final JMenuItem readItem = new JMenuItem("只读");
		readItem.addActionListener(new ItemListener());
		editMenu.add(readItem);
		
		final JMenuItem writeItem = new JMenuItem("可写");
		writeItem.addActionListener(new ItemListener());
		editMenu.add(writeItem);
		
		final JMenu fontMenu = new JMenu("字体");
		editMenu.add(fontMenu);
		
		final JMenuItem boldfacedItem = new JMenuItem("加粗");
		boldfacedItem.addActionListener(new ItemListener());
		fontMenu.add(boldfacedItem);
		
		final JMenuItem italicItem = new JMenuItem("斜体");
		italicItem.addActionListener(new ItemListener());
		fontMenu.add(italicItem);
		//
	}
	
	private class ItemListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			JMenuItem menuItem = (JMenuItem) e.getSource();
			System.out.println("您单击的是菜单项：" + menuItem.getText());
		}
	}
	
}

注意：弹出式菜单与菜单栏的创建方式不同弹出式菜单需要用到鼠标监听，其它用法基本相同。

定制个性化菜单
1.使用分隔线
JMenuBar类：无分隔线方法
JMenu类：

方法	说明
public void addSeparator()	在菜单末尾附加一个新的分隔符。
ublic void insertSeparator(int index)	在指定位置插入分隔符。索引值从0开始。

JMenuItem类：无分隔线方法

2.使用图标
JMenuBar类：无加入图标方法
JMenu类：继承了JMenuItem类

方法	说明
public void setIcon(Icon defaultIcon)	设置图标

JMenuItem类：继承了AbstractButton类

方法	说明
public void setIcon(Icon defaultIcon)	设置图标

3.设置快捷键和加速器
快捷键：展开菜单时，用于快速选中菜单（可为JMenu和JMenuItem设置）

方法	说明
public void setMnemonic(char mnemonic)	这种方法现在已经过时了，请使用setMnemonic(int)设置一个按钮的助记符。该方法仅用于处理“a”和“z”或“A”和“Z”之间的字符值。
public void setMnemonic(int mnemonic)	设置快捷键，入口参数为与键盘助记符对应的键值，可以是键盘上的任意键。

注意：第二种方法中可以通过java.wat.event.KeyEvent类中定义的以VK_开头的静态常量指定。并且快捷键不区分大小写。

加速器：不展开菜单时，使用快捷键实现菜单功能（可为JMenuItem设置）

法	说明
public void setAccelerator(KeyStroke keyStroke)	返回作为菜单项的加速器的 KeyStroke。

注意：KeyStroke类为敲击按键类，无法通过new获得事例，可以通过public static KeyStroke getKeyStroke(int keyCode,int modifiers)获得，入口参数keyCode为键值，可以通过KeyEvent类中定义的VK_开头的静态常量指定，modifiers为采用什么作为组合键，可以为KeyEvent或者InputEvent类的静态常量指定当 modifiers为0时，表示一个键为快捷键，没有组合，如果为多个可用“|”隔开。

示例：
newItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A,InputEvent.CTRL_MASK|InputEvent.ALT_MASK)）;//加速器按键为Ctrl+Alt+A

4.使用单选按钮菜单项和复选框菜单项（都继承JMenuItem）
单选按钮菜单项：JRadioButtonMenuItem类（需添加到按钮组ButtonGroup，才能实现单选按钮的功能）
复选框菜单项：JCheckBoxMenuItem类

5.启用禁用菜单和菜单项

方法	说明
public void setEnabled(boolean b)	启用或禁用菜单或菜单项。

七、工具栏

JToolBar
如果希望工具栏可以随意拖动，窗体一定要采用边界布局方式，且边界布局内不能添加组件，如果不是边界布局，当随意拖动工具栏时，可能会出现工具栏看不见的结果。

构造方法	说明
public JToolBar()	创建新的工具栏；默认的方向为 HORIZONTAL。
public JToolBar(int orientation)	创建具有指定 orientation方向的新工具栏。orientation 不是 HORIZONTAL 就是 VERTICAL。
public JToolBar(String name)	创建一个具有指定 name 的新工具栏。名称用作浮动式工具栏的标题。默认的方向为 HORIZONTAL。
public JToolBar(String name,int orientation)	创建一个具有指定 name 和 orientation 的新工具栏。所有其他构造方法均调用此构造方法。如果 orientation 是一个无效值，则将抛出异常。

常用方法	说明
public void setFloatable(boolean b)	设置 floatable 属性，如果要移动工具栏，此属性必须设置为 true。通常，可以将浮动工具栏拖动到同一个容器中的不同位置，或者拖动到自己的窗口中。此属性的默认值为 true。
public void addSeparator()	将默认大小的分隔符追加到工具栏的末尾。默认大小由当前外观确定。
public void addSeparator(Dimension size)	将指定大小的分隔符追加到工具栏的末尾。
public Component add(Component comp)	将指定组件追加到尾部。

示例：
public class ExampleFrame_08 extends JFrame {
	private static final long serialVersionUID = 1L;

	public static void main(String args[]) {
		ExampleFrame_08 frame = new ExampleFrame_08();
		frame.setVisible(true);
	}
	
	public ExampleFrame_08() {
		super();
		setTitle("使用工具栏");
		setBounds(100, 100, 500, 375);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		final JToolBar toolBar = new JToolBar("工具栏");// 创建工具栏对象
		toolBar.setFloatable(false);// 设置为不允许拖动
		getContentPane().add(toolBar, BorderLayout.NORTH);// 添加到网格布局的上方
		final JButton newButton = new JButton("新建");// 创建按钮对象
		newButton.addActionListener(new ButtonListener());// 添加动作事件监听器
		toolBar.add(newButton);// 添加到工具栏中
		toolBar.addSeparator();// 添加默认大小的分隔符
		final JButton saveButton = new JButton("保存");// 创建按钮对象
		saveButton.addActionListener(new ButtonListener());// 添加动作事件监听器
		toolBar.add(saveButton);// 添加到工具栏中
		toolBar.addSeparator(new Dimension(20, 0));// 添加指定大小的分隔符
		final JButton exitButton = new JButton("退出");// 创建按钮对象
		exitButton.addActionListener(new ButtonListener());// 添加动作事件监听器
		toolBar.add(exitButton);// 添加到工具栏中
	}
	
	private class ButtonListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			JButton button = (JButton) e.getSource();
			System.out.println("您单击的是：" + button.getText());
		}
	}
	
}