- 浏览: 16100 次
- 性别:
- 来自: 苏州
最新评论
-
kuaile777.happy:
楼主,能把这本书的电子版给我发一份吗,317086992@qq ...
《Java 2 图形设计卷Ⅱ- SWING》第1章 简 介
第2章 Swing的基本知识
本章介绍开发Swing小应用程序和应用程序时要用到的Swing的基本知识。
虽然Swing是AWT的扩展,但是两者的基本概念还是有许多不同之处。首先,Swing小应用程序和应用程序的实现方式与AWT小应用程序和应用程序的实现方式有所不同。而且,如果开发人员想要开发同时使用AWT组件和Swing组件的小应用程序或应用程序,则还必须注意混合使用轻量组件和重量组件所带来的许多问题。
Swing是线程不安全的,这就是说,在大多数情况下,只能从事件派发线程中访问Swing组件。本章将介绍采用这种方法的原因及使用这种方法所带来的结果,另外,本章还介绍了Swing提供的一些机制,这些机制使其他线程能从事件派发线程中执行代码。
使用Swing组件的小应用程序和应用程序应该分别扩展Swing的JApplet(java.applet.Applet的一个扩展)和JFrame(java.awt.Frame的一个扩展)。JApplet和JFrame除具有它们的超类所提供的功能外,还提供对Swing的支持。虽然可以分别使用Applet类和Frame类来实现Swing的小应用程序和应用程序,但是,这样很可能出现事件处理问题和重新绘制问题。因此,应当总是使用JApplet和JFrame来实现Swing的小应用程序和应用程序。
JApplet和JFrame都是只包含一个组件的容器,这个组件是JRootPane的一个实例,JRootPane在12.2节“JRootPane”中介绍。目前,只需知道JRootPane包含一个称作为内容窗格的容器即可。内容窗格包含与特定的小应用程序或应用程序有关的所有内容。这里,内容指包含在小应用程序和或应用程序中的组件。实际上,这就是说小应用程序和应用程序必须把组件添加到内容窗格中而不是把它们直接添加到小应用程序或应用程序(或根窗格)中。而且,我们不应该直接为Swing小应用程序或应用程序设置布局管理器。因为组件添加到内容窗格中,所以应该为内容窗格而不是小应用程序或应用程序设置布局管理器。
包含一个JRootPane实例的Swing容器重载用来添加组件和设置布局管理器的方法。这些方法会弹出提醒人们的异常信息:不能把组件直接添加到包含一个JRootPane实例的Swing容器中,也不能为该容器设置布局管理器。
图2-1所示的小应用程序包含一个JLabel实例,该实例有一个图标和一些文本。该小应用程序扩展JApplet并通过调用JApplet.getContentPane()方法来获得对其内容窗格的引用。这个标签随后被实例化并被添加到这个内容窗格中。
图2-1 Swing小应用程序
例2-1列出了图2-1所示的小应用程序的代码。
例2-1 一个Swing小应用程序
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Test extends JApplet {
public void init() {
Container contentPane = getContentPane();
/*原文
Icon icon = new
ImageIcon("swing.gif","An animated GIF of Duke on a
swing");
JLabel label = new
JLabel("Swing!",icon,SwingConstants.CENTER);
*/
//修改后
JLabel label = new JLabel("Swing!",
new
ImageIcon(getImage(getCodeBase(),"swing.gif"),"An animated GIF
of Duke on a swing"),
SwingConstants.CENTER);
contentPane.add(label, BorderLayout.CENTER);
}
}
JApplet类使用BorderLayout的一个实例作为其内容窗格的布局管理器。为了强调这一点,例2-1的小应用程序指定其布局约束条件为BorderLayout.CENTER,它使标签在内容窗格中居中显示。用BorderLayout布局组件的缺省约束条件是BorderLayout.CENTER,所以,在该小应用程序中指定这个布局约束条件不是必须的。
注意:当在Internet Explorer中使用例2-1的小应用程序时,必须使用BorderConstraints.CENTER。(我根本就找不到)
JApplet的内容窗格用BorderLayout的一个实例来布局组件。记住这一点是很重要的,因为java.applet.Applet与JApplet不同,它使用FlowLayout的一个实例来布局组件。
Swing的JApplet类扩展java.applet.Applet并实现Accessibility接口和RootPaneContainer接口。Accessibility接口是可访问包的一部分,而RootPaneContainer接口(如其名字所指出的)是一个包含根窗格的容器。RootPaneContainer接口被所有包含一个JRootPane实例的Swing容器所实现。
类总结2-1中列出了JApplet提供的public和protected方法
类总结 2-1 JApplet
扩展:java.applet.Applet
实现:javax.accessibility.Accessible、RootPaneContainer
1.构造方法
public JApplet()
JApplet中提供了一个不带参数的构造方法。由于小应用程序是由浏览器(或小应用程序阅读器)进行实例化的,所以,正常情况下,不需要直接把JApplet的一个实例进行实例化。要了解直接实例化一个JApplet实例的情况,请参见2.1.5节“小应用程序/应用程序组合”。
2.方法
(1)从java.awt.Container中重载而获得的方法
protected void addImpl(Component,Object,int)
public void setLayout(LayoutManager)
public void addNotify()
public void removeNotify()
上面列出的四种方法都是重载java.awt.Container类中的方法而得到。
AddImpl()是最终把组件添加到容器中的方法。如果直接把组件添加到小应用程序中,那么JApplet.addImpl()将弹出一个异常信息。这个异常中所显示的消息是定制的(注:消息是通过JApplet的扩展的名字定制的)。例如,如果例2-1小应用程序中的标签直接添加到该小应用程序中,那么异常信息将如下显示:
java.lang.Error:Do not use Test.add()use
Test.getContentPane().add)instead
at
javax.swing.JApplet.createRootPaneException(JApplet.java:198)
at javax.swing.JApplet.addImpl(JApplet.java:220)
at java.awt.Container.add(Container.java:179)
at Test.init(Test.java:11)
与JApplet重载addImpl()的原因一样,JApplet也重载setLayout()。如果设置了小应用程序的布局管理器,setLayout()将会弹出一个异常信息。如果修改例2-1的小应用程序,让该小应用程序试图设置它的布局管理器,则将弹出带有下面错误消息的异常信息:
java.lang.Error:Do not use Test.setLayout()use
Test.getContentPane().setLayout()instead
at
javax.swing.JApplet.createRootPaneexception(JApplet.java:198)
at javax.swing.JApplet.setLayout(JApplet.java:244)
at Test.init(Test.java:10)
at sun.applet.AppletPanel.run(AppletPanel.java:287)
at java.lang.Thread.run(Thread.java:474)
当实例化一个组件的对等组件时,将调用addNotify()方法。JApplet重载addNotify()以激发键盘事件并把小应用程序的可见性设置为true。
(2)根窗格/内容窗格/玻璃窗格
protected JRootPane createRootPane()
protected boolean isRootPaneCheckingEnabled()
protected void setRootPaneCheckingEnabled(boolean)
public Container getContentPane()
public Component getGlassPane()
public JLayeredPane getLayeredPane()
public JRootPane getRootPane()
public void setContentPane(Container)
public void setGlassPane(Component)
public void setLayeredPane(JLayeredPane)
public void setRootPane(JRootPane)
Swing小应用程序通过调用protected
JApplet.createRootPane方法,接着,这个方法又调用setRootPane()方法来创建根窗格。createRootPane方法可以被JApple的扩展所重载,以便替代JRootPane类的扩展作为该小应用程序的根窗格。
如前所述,把组件直接添加到JApplet的一个实例中或显式地设置其布局管理器都可能会信息弹出一个异常。然而,有时必须把JRootPane的一个实例直接添加到小应用程序中,并且不信息。通过调用以boolean值为为参数的setRootPaneCheckingEnabled()方法来设置一个标志,该标志跟踪是否允许根窗格检查。如果这个boolean值是true,则说明允许根窗格检查,如果这个boolean值是false,则说明禁止根窗格检查。
isRootPaneCheckingEnabled()方法返回最后传送给setRootPaneCheckingEnabled()方法的boolean值。
注意:setRootPaneCheckingEnabled()和isRootPaneCheckingEnabled()都是protected方法。虽然不可能把组件直接添加到JApplet的一个实例中或显式地设置其布局管理器,但是,实现可以控制是否允许根窗格检查的JApplet的扩展是可能的。这种功能使JAppelt的扩展能够在需要时直接添加组件或设置小应用程序的布局管理器。
实际中,很少重载JApplet.createRootPane(),JApplet的扩展也很少用setRootPaneCheckingEnabled()来直接添加组件或设置小应用程序的布局管理器。
上面列出的第二组方法是由RootPaneContainer接口定义的,这些方法能够获取和设置包含在JRootPane的一个实例中的容器。JRootPane和RootPaneContainer将在第12章和12.2节“JRootPane” 中介绍。
(3)可访问的相关内容/菜单栏/键盘事件/更新
public AccessableContext getAccessableContext()
public JMenuBar getMenuBar()
public void setMenuBar(JMenuBar)
proteted voidprocessKeyEvent(KeyEvent)
public void update(Graphics)
getAccessibleContext()返回AccessibleContext的一个实例,这个实例把小应用程序的可访问信息提供给可访问工具。
--------
JApplet实例可以有一个菜单栏,它是由setJMenuBar方法指定的。注意,Swing小应用程序能有一个菜单栏,而AWT小应用程序却不能。参见图2-2。
实际上有两种方法把菜单栏添加到Swing小应用程序中的方法。一种方法当然是调用JApplet.setJMenuBar,另一种方法是获得对小应用程序根窗格的引用,然后把菜单栏直接添加到根窗格中。
重载ProcessKeyEvent()来处理键绑定问题。有关Swing组件中键击处理的更多信息,请参见4.8节“键出处理”。
重载JApplet.update方法以便直接调用paint()。缺省时,AWT组件将实现它们的update方法以便擦除背景,然后调用paint()。这种技术在组件反复更新时,会导致许多闪烁。有关绘制和更新AWT组件的更多信息,请参见《Java 2 图形设计,卷Ⅰ:AWT》。
Swing提示
JApplet和JFrame的内容窗格使用一个BorderLayout实例
如果你用AWT开发过应用程序,就一定熟悉这样一个事实:java.applet.Applet使用一个FlowLayout实例作为其布局管理器,而java.awt.Frame则使用一个BorderLayout实例作为其布局管理器。
由于AWT小应用程序和应用程序使用不同的布局管理器,所以,当把小应用程序移植为应用程序时或把应用程序移植为小应用程序时,就可造成混乱,这里还没有涉及到实现一个小应用程序和应用程序组合的情况。相比之下,Swing在小应用程序和应用程序的内容窗格中使用相同的布局管理器(即一个BorderLayout实例)。
例2-2所示的应用程序与例2-1所示的小应用程序在功能上是完成相同的。它们都把JLabel的一个实例添加到它们的根窗格的内容窗格中。
例2-3列出了图2-3所用的应用程序的代码。
例2-3 一个Swing应用程序
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Test extends JFrame {
public Test() {
super("An Application");
Container contentPane = getContentPane();
/*原文:
Icon icon = new ImageIcon("swing.gif",
"An animated GIF of Duke on a swing");
JLabel label = new JLabel("Swing!", icon,
SwingConstants.CENTER);
----*/
//修改成:
java.net.URL codebase=getClass().getResource("swing.gif");
JLabel label = new JLabel("Swing!",new ImageIcon(codebase), SwingConstants.CENTER);
//---
contentPane.add(label, BorderLayout.CENTER);
}
public static void main(String args[]) {
final JFrame f = new Test();
f.setBounds(100,100,300,250);
f.setVisible(true);
f.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
f.addWindowListener(new WindowAdapter() {
public void windowClosed(WindowEvent e) {
System.exit(0);
}
});
}
}
应用程序比小应用程序要稍微复杂些,这是因为它们不是在浏览器内部运行的,即浏览器不启动它们也不设置它们的大小。应用程序必须提供main方法,必须把一个窗体实例化,随后确定该窗体的大小(注:可使用JFrame.pack()显式地给出窗体的大小)并使该窗体可见。
例2-2中的应用程序还设置窗体的缺省关闭操作并添加一个窗口监听器,该监听器在窗体被关闭后会退出这个应用程序。有关Swing窗体的缺省关闭操作的更多信息,请参见2.1.4节“JFrame类”。
Swing小应用程序和应用程序有许多共同点。它们都含有一个JRootPane实例,都必须把组件添加到根窗格的内容窗格中。而且,不能显式地设置Swing小应用程序或Swing应用程序的布局管理器。
JFrame类扩展java.awt.Frame,与JApplet类似,它也实现Accessible接口和RootPaneCotainer接口。JFrame还实现Swing.WindowsConstants接口,该接口定义缺省关闭操作的常量。有关Swing常量的更多信息,请参见6.4节“Swing常量”。
JFrame实惠许多在JApplet中能找到的、相同的方法。与JApplet类似,为了不显式地设置其布局管理器或不把组件直接添加到窗体中,JFrame重载setLayout和addImpl方法。JRame实现了所有在RootPaneContainer接口中定义的方法,还实现了通话和禁止根窗格检查的方法。JFrame还实惠了确定当前是束启用了根窗格检查的方法。
类总结2-2总结了JFrame类。
类总结2-2 JFrame
扩展:java.applet.Frame
实现:javax.accessibility.Accessible、RootPaneContainer
1.构造方法
public JFrame()
public JFrame(String title)
JFrame有两个构造方法,一个构造方法不带参数,一个构造方法以一个字符串为参数,该字符串代表窗体的标题。
浏览器或小应用程序的阅读器会调用Swing小应用程序的构造方法,因此,通常不需要开发人员编写代码来调用它的构造方法,但是,应用程序必须负责构造窗体并负责设置窗体的大小。通常为JFrame的实例选择带一个字符串的构造方法,不带参数的构造方法将产生没有标题的窗体。
(1)与JApplet交叠的方法
protected void addImpl(Component,Object,int)
prrotected JRootPane createRootPane()
public AccessibleContext getAccessibleContext()
public Container getContentPane()
public Component getGlassPane()
public JMenuBar getMenuBar()
public JLayeredPane getLayeredPane()
public JRootPane getRootPane()
protected boolean isRootPaneCheckingEnabled()
protected void processKeyEvent(KeyEvent)
public void setContentPane(Container)
public void setGlassPane(Component)
public void setMenuBar(JMenu Bar)
public void setLayeredPanec(JlayeredPane)
public void setLayout(LayoutManager)
protected void setRootPane(JRootPane)
protected void setRootPaneCheckingEnabled(boolean)
public void update(Graphics)
上面列出的JFrame方法与JApplet中定义的方法交叠。其中的大部分方法与JApplet中相应方法的实现方式是相同的。例如,如果允许根窗格检查,则JFrame.setLayout和JFrame.addImpl都将弹出一个异常信息。
有关上述方法的更多信息,请参见“类总结2-1JApplet”。
(2)窗体初始化/缺省的关闭操作/窗口事件
protected void frameInit()
public int getDefaultCloseOperation()
protected void setDefaultCloseOperation(int)
protected void processWindowEvent(WindowEvent)
JFrame构造方法调用frameInit方法来初始化窗体。JFrame的frameInit()方法允许窗体的键盘事件和窗口事件,设置窗体的根窗格和背景色,并允许根窗格检查。如果缺省的设置不令人满意的话,也可扩展JFrame以重载frameInit()。
使用AWT窗体时,开发人要负责处理窗口关闭事件。通常,这需要重载事件处理方法,需要简单地隐藏窗口或隐藏窗口并清除其本地资源。而Swing通过把一个缺省关闭操作与每一个JFrame实例相关联来使窗口的关闭事件较容易处理。可以用setDefaultCloseOperation方法来设置缺省的关闭操作,而且可以用getDefaultCloseOperation()来获取缺省的关闭操作。可以传送给setDefaultCloseOperation()的integer值在WindowConstants类中定义,表2-1,表2-1列出了integer值。
表2-1 WindowContants public常数
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
方法名 实现
─────────────────────────────────
DO_NOTHNG_ON_CLOSE 关闭窗口时什么也不做
HIDE_ON_CLOSE 关闭窗口隐藏该窗口
DISPOSE_ON_CLOSE 关闭窗口时隐藏该窗口并清除其本地资源
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
如果没有显式地设置JFrame的缺省关闭操作,则缺省值是DO_NOTHING_ON_CLOSE。
DISPOSE_ON_CLOSE隐藏窗体并清除与这个窗体有关的系统资源。如果该窗体是应用程序窗体,则在该窗体清除后,应用程序将继续运行。例如,例2-2所列的应用程序把应用程序窗体的缺省关闭操作设置为DISPOSE_ON_CLOSE,但是,应用程序仍然负责处理窗体关闭事件。到应用程序得到窗体已关闭(当调用windowClosed方法时)窗体已隐藏并清除通知时,应用程序仍在运行;结果,应用程序在windowClosed方法中调用System.exit()。
有时需要实现这样一个源文件,它既可作为应用程序运行又可作为小应用程序运行。例2-3示出了一种实现小应用程序/应用程序组合的方法。
例2-3 Swing小应用程序/应用程序组合
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Test extends JApplet {
public void init() {
Container contentPane = getContentPane();
/*原文
Icon icon = new ImageIcon("swing.gif");
JLabel label = new JLabel(icon);
*/
//原文如不修改,不能正常显示图标
//修改后--------
java.net.URL
codebase=getClass().getResource("swing.gif");
JLabel label = new JLabel(new ImageIcon(codebase));
//----------修改后的程序有个毛病,既作为applet使用时,不能刷新,一旦刷新图就没了。
contentPane.setLayout(new FlowLayout());
contentPane.add(label);
//contentPane.add(label);
}
public static void main(String args[]) {
final JFrame f = new JFrame();
JApplet applet = new Test();
applet.init();
f.setContentPane(applet.getContentPane());
f.setBounds(100,100,308,199);
f.setTitle("An Application");
f.setVisible(true);
f.setDefaultCloseOperation(
WindowConstants.DISPOSE_ON_CLOSE);
f.addWindowListener(new WindowAdapter() {
public void windowClosed(WindowEvent e) {
System.exit(0);
}
});
}
}
其思想是实现一个小应用程序,这个小应用程序包含一个main方法。这个main方法把JFrame实例化,而且还创建这个小应用程序的一个实例。在调用小应用程序的init方法后,窗体用该小应用程序的内容窗格来替代该窗体的内容窗格。这个窗体接着设置其边界和标题。并把它的可见性设置为true。
从本质上讲,这种技术会产生共享一个内容窗格的应用程序和小应用程序。当例2-3中的代码被编译后,它可以既作为小应用程序运行又可以作为应用程序运行。
应该注意的是,作为应用程序/小应用程序组合实现的应用程序,在使用main方法创建的小应用程序实例时必须非常小心。因为浏览器或小应用程序阅读器不能把这种小应用程序实例化,所以这种小应用程序是不完善的(从技术上说,它没有小应用程序的相关内容)。因此,这种小应用程序不能使用,例如,用Applet.getImage方法来获取一幅图像。实际应用中,也没有那么多限制,因为应用程序除借用小应用程序的内容窗格外不需要使用小应用程序。例如,应用程序通常使用AWT工具包来获取图像,因此,不需要使用Applet.getImage方法。
Swing提示
不要直接把组件添加到Swing小应用程序或应用程序中,也不要显式地设置其布局管理器
Swing小应用程序和应用程序都有一个JRootPane实例,该实例又含有一个称作内容窗格的容器。小应用程序或应用程序的内容(即组件)必须添加到内容窗格中。如果把组件直接添加到JApplet或JFrame的实例中,则会弹出一个异常信息,指出只能把组件添加到内容窗格中。
Swing小应用程序和应用程序都使用BorderLayout布局管理器来布局它们的JRootPane实例,并且不允许显式地设置它们的布局管理器。如果试图显式地设置JApplet或JFrame的布局管理器,则会弹出一个异常信息,指出不可以显式地设置其布局管理器。
本书介绍的应用程序都是在GJApp类的帮助下实现的,该类提供了一个状态区,并能从属性文件中读取资源。图2-4所示的应用程序是一个JFrame扩展,这个扩展用GJApp类来访问一个状态区,这个状态区显示从GJApp.properties文件中获取一个字符串。
GJApp.properties文件定义了一个属性:
# Simple properties file
statusAreaText=text in the status area
例2-4列出了图2-4所示的应用程序的代码。
例2-4 使用GJApp类
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
public class Test extends JFrame {
public Test() {
Container contentPane = getContentPane();
JPanel panel = new JPanel();
panel.setBorder(BorderFactory.createEtchedBorder());
contentPane.add(panel,BorderLayout.CENTER);
contentPane.add(GJApp.getStatusArea(),BorderLayout.SOUTH);
GJApp.showStatus(GJApp.getResource("statusAreaText"));
}
public static void main(String args[]) {
GJApp.launch(new Test(),"Status
Area",300,300,450,300);
}
}
这个应用程序创建JPanel的一个实例,指定该实例为内容窗格的中心组件。用面板来突出状态区上面的空间,并且这个面板还有一个蚀该边框。
应用程序通过调用static GJApp.getStatusAreas方法来获取对GJApp状态区的引用。状态区指定为内容窗格南边的组件。
static GJApp.showStatus方法以statusAreaText资源的字符串为参数把这个状态区初始化。资源的字符串用static GJApp.getResource方法来获得。
GJApp类有三个功能:
·初始化并显示传送给static launch方法的窗体。
·提供对小应用程序状态区面板的访问
·从GJApp.properties文件中查找资源字符串。
例2-5列出了GJApp类。
例2-5 GJApp类
class GJApp {
static private JPanel statusArea = new JPanel();
static private JLabel status = new
JLabel("");
static private ResourceBundle resources;
static {
resources = ResourceBundle.getBundle(
"GJApp", Locale.getDefault());
};
private GJApp() {} // defeat instantiation
public static void launch(final JFrame f, String
title,
final int x, final int y,
final int w, int h) {
f.setTitle(title);
f.setBounds(x,y,w,h);
f.setVisible(true);
statusArea.setBorder(BorderFactory.createEtchedBorder());
statusArea.setLayout(new
FlowLayout(FlowLayout.LEFT,0,0));
statusArea.add(status);
status.setHorizontalAlignment(JLabel.LEFT);
f.setDefaultCloseOperation(indowConstants.DISPOSE_ON_CLOSE);
f.addWindowListener(new WindowAdapter() {
public void windowClosed(WindowEvent e) {
System.exit(0);
}
});
}
static public JPanel getStatusArea() {
return statusArea;
}
static public void showStatus(String s) {
status.setText(s);
}
static String getResource(String key) {
return (resources == null) ? null :
resources.getString(key);
}
}
严格地说,GJApp是一个帮助类,它实现独有的static方法。GJApp的实例不能实例化,这是GJApp private构造方法强加的规定。
一个static代码块(它在main()方法之前执行)试图获得对GJApp.properties文件资源包的一个引用。在GJApp.getResource方法中使用这个资源包可以获得一个与一个给定资源关键字相关的字符串。
GJApp.launch方法为传送给它的窗体设置边界和标题,把这个窗休的可见性设置为true,并打开这个窗体。这个launch方法还配置状态区并把窗体的缺省关闭操作设置为WindowConstants.DISPOSE_ON_CLOSE。添加到这个窗体中的窗口监听器在窗口关闭时会退出该应用程序。
GJApp类用getStatusArea方法访问其状态区面板。与小应用程序一样,GJApp类用showStatus方法来更新状态区。
注意:本书以后介绍的应用程序都是在GJApp类帮助下实现的。但是,为了简短些,例2-5是本书中唯一列出了GJApp类的地方。
原来的AWT只是为重量组件设计的;在AWT1.1版本发布前,还没有轻量组件。结果,AWT不得不重做AWT,以提供轻量组件。
任何软件开发人员都可证实,把一个复杂的系统和以前未预见的设计组合起来不是一个简单的任务,把轻量组件合并到AWT中也不例外。直到现在,在一个小应用程序或应用程序中混用轻量组件和重量组件还是有许多问题,尤其是把重量组件嵌入轻量容器中时更是如此。
组件的层序是同一容器中组件之间显示的层次关系。
如果容器是同类的(即它包含的组件都是轻量组件或都是重量组件),则按组件被添加到容器中的顺序来确定其层序。第一个被添加到容器中的组件有最高的层序,即它在同一容器中所有其他组件的上面显示。最后添加到容顺中的组件的层序最低,即它在同一个容器中的所有其他组件的下面显示。
如果容器是异类的(即它既有轻量组件又有重量组件),则事情要稍微复杂些。从第1.2节“轻量组件与重量组件的比较”中,我们知道,轻量组件不是显示在它们自己的窗口中,而是显示在它们的重量容器的窗口中。所以,轻量组件的层序与重量容器的层序相同。如果多个轻量组件被添加到一个容器中,则这些轻量组件的层序是由组件被添加到容器中的顺序来决定的。
如果对此还不太明白,下面的两个小应用程序将会有助于理解。图2-5所示的小应用程序有七个按钮,其中四个是重量AWT按钮,其他三个是Swing轻量按钮。所有的重量按钮都显示在轻量按钮的上面,因为轻量按钮的层序与它们的容器的层序相同。
例2-6列出了图2-5所示的少应用程序的代码。
例2-6 混合使用重量组件和轻量组件
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Test extends JApplet {
Button b1, b2, b3, b4;
JButton jb1, jb2, jb3;
public void init() {
Container contentPane = getContentPane();
contentPane.setLayout(null);
// create heavyweight AWT buttons
b1 = new Button("Heavyweight Button #1");
b2 = new Button("Heavyweight Button #2");
b3 = new Button("Heavyweight Button #3");
b4 = new Button("Heavyweight Button #4");
// create lightweight Swing buttons
jb1 = new JButton("Swing Button #1");
jb2 = new JButton("Swing Button #2");
jb3 = new JButton("Swing Button #3");
// set bounds for heavyweight buttons
b1.setBounds(10, 10, 150, 25);
b2.setBounds(110, 25, 150, 25);
b3.setBounds(210, 40, 150, 25);
b4.setBounds(310, 55, 150, 25);
// set bounds for lightweight buttons
jb1.setBounds(85, 25, 150, 65);
jb2.setBounds(100, 65, 150, 65);
jb3.setBounds(115, 105, 150, 65);
// add lightweight buttons
contentPane.add(jb1);
contentPane.add(jb2);
contentPane.add(jb3);
// add heavyweight buttons
contentPane.add(b1);
contentPane.add(b2);
contentPane.add(b3);
contentPane.add(b4);
}
}
这个小应用程序把内容窗格的布局管理器设置为null,以便这些按钮可以显式地定位和确定大小,使这些按钮朴素重叠。然后,这个小应用程序创建按钮,设置按钮的边界并把每个按钮添加到内容窗格中。
即使轻量按钮在重量按钮之前添加到内容窗格中,轻量按钮也仍在重量按钮下显示。因为轻量组件的层序与它们所在的重量容器的层序相同,所以轻量按钮和它们的容器的层序相同。轻量按钮的容器就是小应用程序的内容窗格。
注意 第一个添加到内容窗格的轻量按钮在其他轻量按钮之上显示。同样,第一个添加到内容窗格的重量按钮在其他重量按钮之上显示。
图2-6所示的小应用程序强调了这样一个事实:轻量组件的层序与它们的重量容器的层序相同。这个小应用程序几乎与图2-5所示的小应用程序一样,然而,图2-6所示的小应用程序把三个轻量按钮放在一个重量面板中。然后遭到把该面板添加到内容窗格中,使这个重量面板在第二个重量按钮之后
,在第三个重量按钮之前。结果,轻量按钮具有与它们所在的面板相同的层序,它们在第二个重量按钮之下,第三个重量按钮之上显示。
例2-7列出了图2-6所示的小应用程序的代码。
例2-7 控制轻量按钮的层序
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Test extends JApplet {
Button b1, b2, b3, b4;
JButton jb1, jb2, jb3;
public void init() {
Container contentPane = getContentPane();
Panel p = new BorderedPanel();
// set layout managers for content pane and panel
// to null so their components can be explicitly
// positioned and sized
contentPane.setLayout(null);
p.setLayout(null);
// create heavyweight AWT buttons
b1 = new Button("Heavyweight Button #1");
b2 = new Button("Heavyweight Button #2");
b3 = new Button("Heavyweight Button #3");
b4 = new Button("Heavyweight Button #4");
// create lightweight Swing buttons
jb1 = new JButton("Swing Button #1");
jb2 = new JButton("Swing Button #2");
jb3 = new JButton("Swing Button #3");
// set bounds for heavyweights
b1.setBounds(10, 10, 150, 25);
b2.setBounds(110, 25, 150, 25);
b3.setBounds(210, 40, 150, 25);
b4.setBounds(310, 55, 150, 25);
// set bounds for lightweights
jb1.setBounds(5, 5, 150, 65);
jb2.setBounds(20, 45, 150, 65);
jb3.setBounds(35, 85, 150, 65);
// set bounds for panel and add lightweights
p.setBounds(85, 15, 195, 155);
p.add(jb1);
p.add(jb2);
p.add(jb3);
// add AWT buttons and panel to content pane
contentPane.add(b1);
contentPane.add(b2);
contentPane.add(p);
contentPane.add(b3);
contentPane.add(b4);
}
}
class BorderedPanel extends Panel {
public void paint(Graphics g) {
Dimension size = getSize();
g.setColor(Color.black);
g.drawRect(0,0,size.width-1,size.height-1);
super.paint(g); // paint lightweights
}
}
例2-7的小应用程序实现java.awt.Panel类的一个扩展(BorderedPanel),BorderedPanel在面板的外面画了一个黑边框,以使面板可见。
另外还要注意,BorderedPanel类调用super.paint()。无论何时扩展了一个容口并重载了它的paint方法,都必须显式地调用super.paint(),这样,容器中的轻量组件才能重新绘制(注:有关轻量组件的更多信息,请参见《Graphic Java》第1卷)。如果没有调用super.paint(),则不会重新绘制面板中的轻量Swing按钮。
缺省时,Swing弹出式菜单是轻量组件(注:这是一种简化的说法,但适用于此处的讨论。完整的介绍请参见10.8节“JPopupMenu”)。如果轻量弹出式菜单与重量组件重叠,则弹出式菜单将在该重量组件下面显示。如图2-7小应用程序所示。
有些Swing组件使用弹出式菜单。Swing菜单组件就是一种使用弹出式菜单的组件,它在一个菜单被激活时,显示一个弹出式菜单。缺省时,如果一个与某个菜单相关联的弹出式菜单完全处在弹出式菜单所在的窗口吕,则弹出式菜单使用轻量组件。图2-7所示的小应用程序中与File菜单相关联的弹出式菜单是一个轻量组件,所以它在重量组件AWT按钮的下面显示。
例2-8列出了图2-7所示的小应用程序的代码。
例2-8 在重量组件下面显示的轻量弹出式菜单
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Test extends JApplet {
public void init() {
Container contentPane = getContentPane();
JMenuBar menubar = new JMenuBar();
JMenu menu = new JMenu("File");
menu.add("New ...");
menu.add("Open ...");
menu.add("Save As ...");
menu.add("Save");
menu.add("Exit");
contentPane.setLayout(new FlowLayout(FlowLayout.LEFT));
contentPane.add(new Button("An AWT Button
............"));
menubar.add(menu);
setJMenuBar(menubar);
}
}
这个小应用程序创建了一个菜单条、一个AWT按钮和一个菜单。把菜单项添加到菜单中,再把菜单添加到菜单条中,按钮则被添加到小应用程序的内容窗格中。最后,调用JApplet.setJMenuBar(),把菜单条添加到小应用程序中。
幸运的是,Swing提供了一个机制,它迫使弹出式菜单是重量组件,这样,它们就不会在重量组件下面弹出来。JPopupMenu类提供了一个static方法,该方法可决定弹出式菜单是重量的还是轻量的(注:某些弹出式菜单即可以指定为轻量的,也可以指定为重量的。)
JPopupMenu.setDefaultLightWeightPopupEnabled()以一个boolean值为参数,这个值指出是把弹出式菜单实例化为轻量的还是把弹出式菜单实例化为重量的,调用setDefaultLightWeightPopupEnabled()时,如果这个boolean值为true,则创建的弹出式菜单是轻量的,如果这个boolean值为false,则创建的弹出式菜单是重量的(注:这也是简化的说法,但同样适用于这里的讨论)。
图2-8所示的小应用程序除了在菜单条被实例化之前调用了JPopupMenu.setDefaultLightWeightPopupEnabled(false)以外,其余部分都与图2-7所示的小应用程序相同。
例2-9列出了图2-8所示的小应用程序的代码
例2-9 使用重量弹出式菜单
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Test extends JApplet {
public void init() {
JPopupMenu.setDefaultLightWeightPopupEnabled(false);
Container contentPane = getContentPane();
JMenuBar menubar = new JMenuBar();
JMenu menu = new JMenu("File");
menu.add("New ...");
menu.add("Open ...");
menu.add("Save As ...");
menu.add("Save");
menu.add("Exit");
contentPane.setLayout(new FlowLayout(FlowLayout.LEFT));
contentPane.add(new Button("An AWT Button
............"));
menubar.add(menu);
setJMenuBar(menubar);
}
}
把重量组件和轻量组件混合使用时所要关心的另一个问题是滚动。
Swing提供了一个替代AWT重量滚动窗格的轻量组件——JScrollPane组件。由于JScrollPane是轻量的,所以任何添加到JScrollPane实例中的重量组件都将在这个滚动窗格之上显示。如果重量组件滚动超出了JScrollPane实例的边框,则它就不能正确地显示了。
图2-9所示的小应用程序说明了把一个重量组件添加到JScrollPane实例中并滚动重量组件使其超出滚动窗格边框的情况。
图2-9中上图显示了这个小应用程序刚启动时的样子,图2-9中下图显示了滚动窗格滚动后,这个小应用程序的样子。注意,在这两种情况下,AWT按钮都没有能够正确地显示。
例2-10列出了图2-9所示的小应用程序的代码。
例2-10用JScrollPane滚动重量组件
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Test extends JApplet {
public void init() {
JPanel panel = new JPanel();
panel.add(new JButton("Swing Button ..."));
panel.add(new Button("AWT Button ..."));
Container contentPane = getContentPane();
JScrollPane scrollPane = new JScrollPane(panel);
scrollPane.setPreferredSize(new Dimension(125,50));
contentPane.setLayout(new
FlowLayout(FlowLayout.LEFT));
contentPane.add(scrollPane);
}
}
图2-9所示的小应用程序把一个Swing按钮和一个AWT按钮添加到一个面板中,这个面板是要滚动的组件。这个小应用程序为滚动窗格设置了首选大小,并把滚动窗格添加到其内容窗格中。
图2-9所示的组件效果是我们不想要的。遗憾的是,与弹出式菜单不同,JScrollPane没有能实例化为重量组件的选项。但是,幸运的是,AWT的ScrollPane组件是一个重量滚动窗格,它和Swing的JScrollPane几乎完全相同。
图2-10示出了与图2-9相同的小应用程序,但图2-10中的小应用程序用重量AWT的ScrollPane替代了Swing的轻量JScrollPane。由于AWT滚动窗格是重量的,所以它们滚动轻量组件和重量组件都没有问题。
例2-11列出了图2-10示的小应用程序的代码
例2-11 使用AWT的ScrollPane来滚动重量组件
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Test extends JApplet {
public void init() {
JPanel panel = new JPanel();
panel.add(new JButton("Swing Button ..."));
panel.add(new Button("AWT Button ..."));
Container contentPane = getContentPane();
SizedScrollPane scrollPane = new SizedScrollPane();
scrollPane.add(panel);
contentPane.setLayout(new FlowLayout(FlowLayout.LEFT));
contentPane.add(scrollPane);
}
}
class SizedScrollPane extends ScrollPane {
public Dimension getPreferredSize() {
return new Dimension(125,50);
}
}
注意:在例2-11列出的小应用程序中实现了java.awt.ScrollPane的一个扩展,以便把滚动窗格的大小设置为首选尺寸。有关Swing组件与AWT组件在设置首选尺寸方面的差别的更多信息,请参见4.2.2节“最小尺寸、最大尺寸和首选尺寸。”
Swing的内部窗体是包含在桌面窗格中的窗体(参见第15章“内部窗体和桌面窗格”),Swing的内部窗体是轻量组件,如果把重量组件添加到一个内部窗体,则这个窗体很可能会遇到到麻烦。
图2-11所示的小应用程序包含两个JInternalFrame实例。它们都包含一个重量AWT画布。如果一个内部窗体与另一个内部窗体重叠,则下面的内部窗体的重量画布将会使上面的内部窗体的一部分变模糊,因为重量画布的层序比轻量内部窗体的层序高。
例2-12 列出了图2-11所示的小应用程序的代码
例2-12把重量组件添加到Swing内部窗体中
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class InternalFrameTest extends JApplet {
JDesktopPane dtp = new JDesktopPane();
public void init() {
JPanel controlPanel = new ControlPanel(dtp);
Container contentPane = getContentPane();
JPanel centerPanel = new JPanel();
contentPane.setLayout(new BorderLayout());
contentPane.add(controlPanel, BorderLayout.NORTH);
contentPane.add(dtp, BorderLayout.CENTER);
}
}
class ControlPanel extends JPanel {
private static int cnt=0;
public ControlPanel(final JDesktopPane dtp) {
JButton b = new JButton("make frame");
add(b);
b.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
JInternalFrame jif = new JInternalFrame();
Container contentPane = jif.getContentPane();
jif.setLocation(10,50);
jif.setTitle("Internal Frame" + cnt++);
jif.setResizable(true);
jif.setMaximizable(true);
jif.setClosable(true);
jif.setVisible(true);
jif.setIconifiable(true);
contentPane.setLayout(new FlowLayout());
contentPane.add(new ColoredCanvas(),
"Center");
jif.pack();
dtp.add(jif, 2); // add at layer 2
}
});
}
}
class ColoredCanvas extends Canvas {
public void paint(Graphics g) {
Dimension sz = getSize();
g.setColor(Color.blue);
g.fillRect(0,0,sz.width,sz.height);
}
public Dimension getPreferredSize() {
return new Dimension(200,200);
}
}
Swing提示
混合使用AWT组件和Swing组件的原则
一般不提倡把Swing轻量组件与AWT重量组件混合使用。大多数情况下,这不会是一个问题,因为Swing对所有AWT组件都提供了替代的轻量组件。对已有的、使用AWT组件的小应用程序或应用程序,最好的方法是用Swing的相应组件来替代AWT组件。如果不能替代,则必须遵守如下原则:
1)如果轻量组件必须在重量组件之上显示,则不要在一个容器中混合使用轻量组件和重量组件。
2)如果弹出式菜单与重量组件重叠,则必须强迫弹出式菜单成为重量组件
3)如果把重量组件添加到一个JScrollPane实例中,而应该把重量组件添加到一个java.awt.ScrollPane实例中。
4)不要把重量组件添加到Swing内部窗体中。
大多数情况下,Swing是线程不安全的,即只能从单线程来访问Swing组件。首先,我们要讨论为什么Swing是线程不安全的,然后介绍在Swing开发过程中单线程设计所带来的结果。
让我们面对这个事实,甚至在java中,开发多线程的应用程序也是不容易的。设计一个线程安全的工具包就更不是一个简单的事情。例如,确定如何同步对类的访问就是一个复杂的任务(注:参见Lea,Doug,“java中的并发编程”,Addison-Wesley,1997。)。同样,扩展线程安全的类需要较高的技术,对非线程编程高手的开发人员(大多数开发人员都属此范围)是充满危险的。Swing是线程不安全的一个主要原因是为了简化扩展组件的任务。
Swing是线程不安全的另一个原因是由于获取和释放锁定及恢复状态所带来的开销。使用线程安全GUI工具包的所有应用程序(无论它们是否是多线程的)都必须付出同样的性能代价。
线程的使用增加了调试、测试、维护和扩展的困难度。例如,测试和维护等通常已经很艰苦的工作对于大多数多线程应用程序就更困难了,有时甚至是不可能的。
有些Swing组件方法确实支持多线程访问。例如,JComponent的repaint、revalidate和invalidate等方法都对放在事件派发线程上的请求进行排队。因此,可从任何线程中调用这些方法。另外,可以从多个线程把监听器添加到事件监听器列表(参见6.2节“事件监听器列表”)中或从列表中删掉。最后,有些组件方法是同步的。例如,JCheckBoxMenuItem.setState()是同步的,因此,可以从多线程中调用它。
Swing单线程设计的主要结果是:大多数情况下,只能从事件派发线程中访问将要在屏幕上绘制的Swing组件。
事件派发线程是调用paint和update等回调方法的线程,而且,它还是事件监听器接口中定义的事件处理方法。例如,ActionListener和PropertyListener接口的实现使它们的actionPerformed方法和propertyChange方法在事件派发线程中调用。
技术上说,在Swing组件的对等组件创建之前(指可在屏幕上绘制之前)(注:对等组件是用addNotify方法创建的),它们可以从多个线程中访问。例如,可以有一个小应用程序的init方法中构造和操纵组件,只要在操纵它们之前,还没有使它们成为可见的。
2.4.2 SwingUtilties类的invokeLater和invokeAndWait方法
由于AWT和Swing都是事件驱动工具包,所以在回调方法中更新可见的GUI就是很自然的事。例如,如果在一个按钮激活,项目列表需要更新时,则通常在与该按钮相关联的事件监听器的actionPerformed方法中来实现该列表的更新。
然而,有时可能需要从事件派发线程以外的线程中更新Swing组件。例如,如果上述项目列表中包含了很多来自数据库或Internet的数据,则可能在按钮激活后还要等一段时间才能看到更新的列表。如果信息的获取是在actionPerformed中实现的,则按钮仍保持按下的状态,直到对actionPerformed的调用返回,不仅按钮的弹起需要一段时间,而且一般来说,耗时较长的操作也不应当在事件方法中的执行,因为在事件处理方法返回之前,其他的事件不能派发。
有时,在独立的线程上执行耗时的操作可能更好,这将允许立即更新用户界面和释放事件派发线程去派发其他的事件,幸运的是,Swing提供了两种机制,它们都支持这种想法。
SwingUtilities类提供了两个方法:invokdLater和invokdAndWait,它们都使事件派发线程上的可运行对象排队。当可运行对象排在事件派队列的队首时,就调用基run方法。其效果是允许事件派发线程调用另一个线程中的任意一个代码块。
1.SwingUtilities invokeLater
在介绍invokeLater和invokeAndWait方法之前,我们首先来看一个小应用程序,由于是从事件派发线程以外的线程中更新Swing组件,所以该小应用程序运行不正常。图2-12所示的小应用程序有一个按钮和一个进度条。当激活按钮后,就开始模仿获取信息的长操作。当获取了信息(即一个integer值)后,就用该信息来更新小应用程序的进度条。
图2-12左图显示的是这个小应用程序的初始状态。图2-12右图显示的则是当激活start按钮后,这个小应用程序的样子,此时,已获取了信息,也更新了进度条。
小应用程序把一个动作监听器添加到该按钮中,该监听器创建一个新线程,这个线程不断收到信息并更新进度条。每隔半秒获取一次信息,而且这个线程会获得一个对这个小应用程序进度条的引用。
public class Test extends JApplet {
...
public void init() {
...
startButton.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e) {
GetInfoThread t = new GetInfoThread(Test.this);
t.start();
// this is ok, because actionPerformed
// is called on the event dispatch thread
startButton.setEnabled(false);
}
});
}
...
}
class GetInfoThread extends Thread {
Test applet;
public GetInfoThread(Test applet) {
this.applet = applet;
}
public void run() {
while(true) {
try {
// simulate "lengthy" information
retrieval
Thread.currentThread().sleep(500);
System.out.println(".");
// this is not ok, because it is not called
// on the event dispatch thread
applet.getProgressBar().setValue(
(int)Math.random()*100);
}
catch(InterruptedException e) {
e.printStackTrace();
}
}
}
}
在该按钮的监听器启动上述线程后,监听器把按钮的允许状态设置为false。由于在事件派发线程上调用actionPerformed方法,所以,这是一个有效的操作。但是,在GetInfoThread中设置进度条是一个危险的做法,因为事件派发线程以外的线程将更新进度条。
例2-13列出了图2-12所示的小应用程序的完整的代码。
例2-13 从另一个线程更新组件的错误方法
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Test extends JApplet {
JProgressBar pb = new JProgressBar();
public void init() {
Container contentPane = getContentPane();
final JButton startButton = new
JButton("start");
contentPane.setLayout(new FlowLayout());
contentPane.add(startButton);
contentPane.add(pb);
startButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
GetInfoThread t = new GetInfoThread(Test.this);
t.start();
// this is ok, because actionPerformed
// is called on the event dispatch thread
startButton.setEnabled(false);
}
});
}
public JProgressBar getProgressBar() {
return pb;
}
}
class GetInfoThread extends Thread {
Test applet;
public GetInfoThread(Test applet) {
this.applet = applet;
}
public void run() {
while(true) {
try {
// simulate "lengthy" information retrieval
Thread.currentThread().sleep(500);
System.out.println(".");
// this is not ok, because it is not called
// on the event dispatch thread
applet.getProgressBar().setValue(
(int)Math.random()*100);
}
catch(InterruptedException e) {
e.printStackTrace();
}
}
}
}
更新例2-13所示的小应用程序中的进度条的正确方法是使用SwingUtilities.invokeLater(或invokeAndWait)。下面列出的GetInfoThread类的构造方法被修改了以便实例化一个可运行的对象,该对象获取对小应用程序进度条的引用并更新进度条的值。GetInfoThread类的run方法调用SwingUtilities.invokeLater并把对进度条的引用传送给可运行对象。
class GetInfoThread extends Thread {
Runnable runnable;
int value;
public GetInfoThread(final Test applet) {
runnable = new Runnable() {
public void run() {
JProgressBar pb = applet.getProgressBar();
pb.setValue(value);
}
};
}
public void run() {
while(true) {
try {
Thread.currentThread().sleep(500);
// This is okay because the runnable抯 run()
// is invoked on the event dispatch thread
value = (int)(Math.random() * 100);
SwingUtilities.invokeLater(runnable);
}
catch(InterruptedException e) {
e.printStackTrace();
}
}
}
}
例2-14是例2-13所列的小应用程序的修改版。
例2-14 从另一个线程中更新组件的正确方法(演示图)
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Test extends JApplet {
JProgressBar pb = new JProgressBar();
public void init() {
Container contentPane = getContentPane();
final JButton startButton = new
JButton("start");
contentPane.setLayout(new FlowLayout());
contentPane.add(startButton);
contentPane.add(pb);
startButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
GetInfoThread t = new GetInfoThread(Test.this);
t.start();
// this is ok, because actionPerformed
// is called on the event dispatch thread
startButton.setEnabled(false);
}
});
}
public JProgressBar getProgressBar() {
return pb;
}
}
class GetInfoThread extends Thread {
Runnable runnable;
int value;
public GetInfoThread(final Test applet) {
runnable = new Runnable() {
public void run() {
JProgressBar pb = applet.getProgressBar();
pb.setValue(value);
}
};
}
public void run() {
while(true) {
try {
Thread.currentThread().sleep(500);
// This is okay because the runnable抯 run()
// is invoked on the event dispatch thread
value = (int)(Math.random() * 100);
SwingUtilities.invokeLater(runnable);
}
catch(InterruptedException e) {
e.printStackTrace();
}
}
}
}
2.SwingUtilities.InvokeAndWait
与invokeLater一样,SwingUtilities.InvokeAndWait也把可运行对象排入事件派发线程的队列中。虽然,invokeLater在把可运行对象放入队列后就返回,而InvokeAndWait一直等待直到已启动了可运行对象的run方法才返回。如果在另一个操作能够在另一个线程上执行之前必须从一个组件获取信息,则InvokeAndWait方法是很有用的。
例如,例2-14列出的小应用程序总是更新进度条的值而不管该新值是否与当前的值相同。如果只在新值与当前值不同时才更新进度条的值,则效率更高。修改这个小应用程序,使得这个小应用程序只在新值与当前值不同时才更新进度条的值。这将使我们有机会进一步介绍InvokdAndWait方法。
首先,修改GetInfoThread类以创建两个可运行的对象:一个对象获取进度条当前的值,另一个对象用于设置进度条的值。
class GetInfoThread extends Thread {
Runnable getValue, setValue;
int value, currentValue;
public GetInfoThread(final Test applet) {
getValue = new Runnable() {
public void run() {
JProgressBar pb = applet.getProgressBar();
currentValue = pb.getValue();
}
};
setValue = new Runnable() {
public void run() {
JProgressBar pb = applet.getProgressBar();
pb.setValue(value);
}
};
}
接着,使用invokeAndWait()来修改GetInfoThread类的run方法以获取进度条的当前值。
public void run() {
while(true) {
try {
Thread.currentThread().sleep(500);
// This is okay because the getValue's run()
// is invoked on the event dispatch thread
value = (int)(Math.random() * 100);
try {
SwingUtilities.invokeAndWait(getValue);
}
catch(InvocationTargetException ite) {
ite.printStackTrace();
}
catch(InterruptedException ie) {
ie.printStackTrace();
}
if(currentValue != value) {
SwingUtilities.invokeLater(setValue);
}
}
catch(InterruptedException e) {
e.printStackTrace();
}
}
}
SwingUtilities.invokeAndWait()获取进度条的当前值,invokeLater()则设置进度条的值。对InvokeAndWait的调用直到getValue可运行对象的run方法返回后才返回。
SwingUtilities.invokeAndWait可能会弹出下面两个异常信息之一:InterruptedException或InvocationTargetException。无论何时使用invokeLater()都必须捕捉这些异常,否则,调用invokeLater()的方法中必须有一个throw子句。
例2-15显示了这种方法的完整代码
例2-15 使用SwingUtilities.InvokeAndWait()
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.lang.reflect.*; // for
InvocationTargetException
public class Test extends JApplet {
private JProgressBar pb = new JProgressBar();
public void init() {
Container contentPane = getContentPane();
final JButton startButton = new
JButton("start");
contentPane.setLayout(new FlowLayout());
contentPane.add(startButton);
contentPane.add(pb);
startButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
GetInfoThread t = new GetInfoThread(Test.this);
t.start();
// this is okay because actionPerformed
// is called on the event dispatch thread
startButton.setEnabled(false);
}
});
}
public JProgressBar getProgressBar() {
return pb;
}
}
class GetInfoThread extends Thread {
Runnable getValue, setValue;
int value, currentValue;
public GetInfoThread(final Test applet) {
getValue = new Runnable() {
public void run() {
JProgressBar pb = applet.getProgressBar();
currentValue = pb.getValue();
}
};
setValue = new Runnable() {
public void run() {
JProgressBar pb = applet.getProgressBar();
pb.setValue(value);
}
};
}
public void run() {
while(true) {
try {
Thread.currentThread().sleep(500);
// This is okay because the getValue's run()
// is invoked on the event dispatch thread
value = (int)(Math.random() * 100);
try {
SwingUtilities.invokeAndWait(getValue);
}
catch(InvocationTargetException ite) {
ite.printStackTrace();
}
catch(InterruptedException ie) {
ie.printStackTrace();
}
if(currentValue != value) {
SwingUtilities.invokeLater(setValue);
}
}
catch(InterruptedException e) {
e.printStackTrace();
}
}
}
}
invokeLater()和invokeAndWait()之间一个重要的区别是:可以从事件派发线程中调用invokeLater(),却不能从事件派发线程中调用invokeAndWait。从事件派发线程调用invokeAndWait()所带来的问题是:invokeAndWait()锁定调用它的线程,直到可运行对象从事件派发线程中派出去并且该可运行对象的run方法激活。如果从事件派发线程调用invokeAndWait(),则将发生线程死锁的情况,因为invokeAndWait()正在等待事件派发,但是,由于是从事件派发线程中调用invokeAndWait()的,所以,直到invokeAndWait()返回后事件才能派发。
Swint提示
使用SwingUilities.invokeLater()和SwingUtilities.invokeAndWait()从事件派发线程之外的线程访问组件
由于Swing是线程不安全的,所以,从事件派发线程之外的线程访问Swing组件是不安全的。SwingUtilities类提供了两个用于执行事件派发线程中代码的方法,这两种方法是invokeLater和invokeAndWait。
注意:可以从事件派发线程调用SwingUtilities.invokeLater,却不能从事件派发线程调用SwingUtilities.invokeAndWait。如果从事件派发线程调用SwingUtilities.invokeAndWait,则将发生线程死锁。因为invokeAndWait正在等待可运行对象被从事件派发线程中派发出去,但是调用SwingUtilities.invokeAndWait的线程返回前事件不能派发。
Swing的设计目标之一是为实现小应用程序和应用程序的完整性制定一些约定,大多数情况下,这个目标已经达到了。Swing小应用程序和应用程序含有JRootPane的一个实例,这意味着不能把组件直接添加到JApplet或JFrame的实例中,也不能显式地为JApplet或JFrame的实例设置布局管理器。组件应该添加到根窗格的内容窗格中,同理,必须为内容窗格设置布局管理器而不是为小应用程序和应用程序布局管理器。幸运的是,无论何时组件直接添加、或是显式地为小应用程序或窗体设置了布局管理器,JApplet和JFrame都会弹出带错误的异常消息。
把Swing实现为线程不安全的决定是肯定会遭到反对的。毕竟,Java语言本身就内置了多线程特性,因此,就会有人主张应当以线程安全的模式实现Swing。
然而,正是因为Java内置了对多线程的支持,但这并不意味着在Java中实现安全的多线程小应用程序或应用程序是一件简单的事情,更不用提工具包了。事实正相反,以线程安全的方式实现复杂的小应用程序和应用程序是相当困难的。另外,大多数开发人员不精通开发复杂的多线程代码。当多线程被引入到面向对象语言中以后,人们遇到的较困难的领域之一就是如何扩展线程安全的类。相比之下,Swing开发人员使用的单线程方法使得类很容易扩展。
总之,禁止从事件派发线程外的其他线程访问Swing组件的决定是正确的,它产生了一个较容易扩展的、较简单的工具包。另外,除事件派发线程外的其他线程可以调度在事件派发线程上实现的可运行对象。
Swing是一个可靠的、工业标准的用户界面工具包,比AWT大有改进。但是,与任何重要的软件一样,Swing很容易学习,但也有程序错误。
发表评论
-
《Java 2 图形设计卷Ⅱ- SWING》第22章 文本组件
2014-02-14 15:37 0第22章 文本组件 Swing提供两种完全不同的文本 ... -
《Java 2 图形设计卷Ⅱ- SWING》第21章 文本基础
2014-02-14 15:37 0第21章 文本基础 Swing文本组件是相对比较简单的 ... -
《Java 2 图形设计卷Ⅱ- SWING》第20章 树
2014-02-14 15:36 0第20章 树 Swing树 ... -
《Java 2 图形设计卷Ⅱ- SWING》第19章 表格
2014-02-14 15:35 0第19章 表格 19.1 表格和滚动 例19-1 表格和 ... -
《Java 2 图形设计卷Ⅱ- SWING》第18章 组合框
2014-02-14 15:34 0第18章 组合框 由JComboBox类实现的组合框是 ... -
《Java 2 图形设计卷Ⅱ- SWING》第17章 列表
2014-02-14 15:34 0第17章 列表 由JList类代表的Swing列表显示 ... -
《Java 2 图形设计卷Ⅱ- SWING》第16章 选取器
2014-02-14 15:33 0第16章 选取器 本 ... -
《Java 2 图形设计卷Ⅱ- SWING》第15章 内部窗体和桌面窗格
2014-02-14 15:31 0第15章 内部窗体和桌面 ... -
《Java 2 图形设计卷Ⅱ- SWING》第14章 窗口和对话框
2014-02-14 15:28 0第14章 窗口和对话框 ... -
《Java 2 图形设计卷Ⅱ- SWING》第13章 滚动
2014-02-14 15:27 0第13章 滚动 本章 ... -
《Java 2 图形设计卷Ⅱ- SWING》第12章 轻量容器
2014-02-14 15:26 1180第12章 轻量容器 本章讨论如下Swing轻量容器: ... -
《Java 2 图形设计卷Ⅱ- SWING》第11章 进度条、滑杆和分隔条
2014-02-14 15:26 878第11章 进度条、滑杆和 ... -
《Java 2 图形设计卷Ⅱ- SWING》第10章 菜单和工具条
2014-02-14 15:25 1144第10章 菜单和工具条 菜单和工具条是现代用户界面的重 ... -
《Java 2 图形设计卷Ⅱ- SWING》第8章 标签与按钮
2014-02-14 15:22 1216第8章 标签与按钮 Swing的标签和按钮分别用JLa ... -
《Java 2 图形设计卷Ⅱ- SWING》第7章 插入式界面样式
2013-06-04 09:26 1459第7章 插入式界面样式 插入式界面样式是建立在第3章“ ... -
《Java 2 图形设计卷Ⅱ- SWING》第6章 实用工具
2013-06-04 09:25 1170第6章 实用工具 Swing包括许多实用工具,本章将介 ... -
《Java 2 图形设计卷Ⅱ- SWING》第5章 边框、图标和动作
2013-05-28 08:49 1414第5章 边框、图标和动作 本章介绍Swing的三种实用 ... -
《Java 2 图形设计卷Ⅱ- SWING》第4章 JComponent类
2013-05-28 08:47 1602第4章 JComponent类 JComponent类 ... -
《Java 2 图形设计卷Ⅱ- SWING》第3章 Swing组件的体系结构
2013-02-16 11:02 1284第3章 Swing组件的体系结构 轻量Swing组件把 ... -
《Java 2 图形设计卷Ⅱ- SWING》第1章 简 介
2012-12-18 12:39 1743第1章 简 介 Java的基础类(JFC)是开发图 ...
相关推荐
一本比较经典的Swing的书。PDF版本。因为文件太大分为两部分。
Java 2图形设计卷Ⅱ:SWING 是一本专注于Java Swing技术的专业书籍,它深入探讨了如何使用Java的GUI(图形用户界面)库来构建功能丰富的桌面应用。Swing是Java AWT(Abstract Window Toolkit)的扩展,提供了更为...
第2章 Swing的基本知识 2.1 小应用程序与应用程序 2.1.1 小应用程序 2.1.2 JApplet类 2.1.3 应用程序 2.1.4 JFrame类 2.1.5 小应用程序/应用程序的组合 2.2 GJApp 2.3 混合使用Swing组件和AWT组件...
第2章 Swing的基本知识 2.1 小应用程序与应用程序 2.1.1 小应用程序 2.1.2 JApplet类 2.1.3 应用程序 2.1.4 JFrame类 2.1.5 小应用程序/应用程序的组合 2.2 GJApp 2.3 混合使用Swing组件和AWT组件...
有关Java2图形设计方面的电子教程,exe格式,阅读方便。...第二部分是关于Swing的应用,内容涉及Swing基础知识、组件结构、JComponent类库、标签与按钮、插入式界面样式、进度条和工具栏、窗口和对话框等。
比较经典的Swing书。PDF版本,因为文件太大分为两部分。
Java 2 图形设计卷1 AWT 是一本深入探讨Java图形用户界面(GUI)编程的书籍,主要聚焦在Abstract Window Toolkit(AWT)这个Java早期的GUI库上。AWT是Java平台的基础部分,提供了创建窗口、按钮、文本框等基本组件的...
总之,“java图形设计卷2swing”这份资料将帮助你深入了解Java Swing的各个方面,从基础组件到高级特性,从简单的窗口应用到复杂的数据驱动的界面设计,都是开发者提升界面设计技能的宝贵资源。通过学习和实践,你...
本次实验是基于《Java面向对象程序设计》课程中的一个实践环节,旨在通过实际操作加深对Swing图形用户界面的理解与掌握。实验的具体目的是让学生学会处理ActionEvent事件、使用布局管理器、了解焦点与鼠标键盘事件,...
### 第十八章 图形界面...本章主要介绍了Java图形界面开发的基础知识和常用技术,包括AWT、Swing和SWT等。通过本章的学习,读者可以了解到图形界面开发的基本流程和技术要点,为进一步深入研究和实践打下坚实的基础。
3. 第二十章可能涉及高级主题,如自定义组件或者Swing的高级特性。 4. 第十三章和第十四章可能涵盖了特定的GUI设计技巧或特定组件的深入使用。 5. 第四、五、八、九、十七章则可能分别讲解了不同的Swing组件、布局...
这个Java Swing图书管理系统项目,不仅涵盖了基本的GUI设计和数据库操作,还涉及了权限控制和业务逻辑的实现,对于Java初学者和爱好者来说,是一个很好的实践案例,有助于提升实际开发能力。通过深入研究和运行源码...
【基于Java Swing的图书管理系统-版本二】是一个利用Java编程语言和Swing GUI库开发的图书管理应用程序。这个系统提供了一系列功能,旨在帮助用户高效地管理和操作图书信息。以下是该系统的详细知识点: 1. **图书...
Java语言程序设计中的第十二章主要探讨了图形用户界面(GUI)的基础知识,特别是使用Java进行GUI编程。GUI是用户与计算机系统交互的一种直观方式,Java提供了强大的API来支持这一功能,包括AWT(Abstract Window ...
Java Swing 是Java GUI(图形用户界面)库的一部分,它提供了丰富的组件和功能,用于构建桌面应用程序。本资源“java-swing 实例集合及其源码”包含了一系列基于Swing的示例应用,包括中国象棋、蜘蛛纸牌、网络...
2. **Swing入门-第二讲至第四讲源码**:可能会深入讲解组件的属性设置、事件监听机制,例如鼠标事件和键盘事件,以及如何处理这些事件。此外,还可能涉及布局管理器(如FlowLayout、BorderLayout、GridLayout和...
在Swing这一Java的图形用户界面(GUI)工具包中,虽然提供了基本的组件和布局管理器,但默认的UI设计往往显得较为朴素。为了使Swing应用看起来更加现代化和吸引人,我们可以引入第三方库,如本案例中的"substance....
Java Swing 是Java标准库中的一个组件,用于创建图形用户界面(GUI)。Swing 提供了丰富的组件集合,如按钮、文本框、菜单等,用于构建桌面应用程序。然而,Swing 的默认界面风格(LookAndFeel)在视觉上可能相对...
《Java Swing图形界面开发与案例详解》全书共20章,其中第1~2章主要介绍有关Swing的基础知识,包括Swing的基本概述、如何使用IDE开发Swing程序;第3~15章结合众多实例和问题介绍最常用、最有用的组件及其应用方法...