《Pure JFC Swing实战指南》：提升Java Swing效率的关键

需积分: 3 177 浏览量更新于2024-08-02 收藏 2.46MB PDF 举报

《纯Java Foundation Classes (JFC) Swing》是由Satyaraj Pantham所著的一本专业书籍，由Sams出版社于1999年出版，书号为0672314231。这本806页的著作专为希望在Java 2 SE环境中利用轻量级、便携式Swing API的程序员设计，旨在通过提供丰富的代码示例来简化开发任务并提升项目的效率。书中内容深入，涵盖了Swing的核心概念和技术。前356页主要侧重于理论与实践，包括基本组件如窗口（Frames）、面板（Panels）和容器（Panels）、布局管理器（LayoutManagers）、图标、边框、按钮、组合框、表格、文本控件、滚动条、滑块、菜单、工具栏、提示对话框（Tooltips）、树形结构以及定时器和进度指示器等。作者采用直接编码的形式，使读者能迅速理解和掌握这些关键概念。后309页则专门介绍了语法参考，这部分内容是开发者在不同开发阶段不可或缺的参考资料。《纯Java FCSwing》的特点是简洁明了，图片较少，注重实用性，因此非常适合经验丰富的Java程序员使用，是他们Swing开发工具箱中的重要一员。书中的"Introduction"部分首先为读者提供了整体的Swing概述，接着"Part I Conceptual Reference"部分从基础开始，逐步深入，让读者对Swing的框架有全面理解。这部分章节包括了应用程序的构建、事件处理机制，以及如何构建和设计用户界面。 "Part II Technique Reference"则转向具体的编程技巧，着重讲解如何运用这些组件和概念来创建高效、美观的GUI应用。通过"Frames, Panes, and Panels"章节，读者可以学习如何组织和管理界面层次结构；"Layout Managers"章节详细介绍了如何控制组件在屏幕上的排列方式；而"Swing Design"章节则探讨了设计原则和最佳实践。《(Sams) Pure JFC Swing》是一本实用的指南，无论是初学者还是高级开发者，都能从中找到提升Java Swing技能所需的知识和实例，有助于加速项目开发过程和提升代码质量。

- 16 -

Figure 2.2: The THello program running as an application.

Listing 2.1 A Simple Swing Applet/Application to Demonstrate JApplet

(THello.java)

// Your first Swing program.

* <Applet code=THello width=300 height=150>

* </Applet>

import javax.swing.*; // Import the Swing classes

import java.awt.event.*; // for the WindowAdapter and WindowEvent

classes

// This is your Swing applet (by extending JApplet).

public class THello extends JApplet {

public void init() {

// Here is the only program statement.

// Create a string label to display the text as shown

here

// with an icon made from the animated GIF file.

// The text and icon are centered by using JLabel.CENTER

// The label is added to the content pane

// of the applet (see Code Details).

getContentPane().add(new JLabel(

"Hello! Swing World",

new ImageIcon("AnimSpeaker.gif"),

JLabel.CENTER));

}

// When you run this program as an application.

// The main method to instantiates the application frame.

public static void main(String[] args) {

// Create a Swing frame.

JFrame f = new JFrame("THello");

// Create an instance of the THello applet.

THello helloApplet = new THello();

// Initialize the applet instance.

helloApplet.init();

// Add the applet to the JFrame (to it's content pane).

f.getContentPane().add(helloApplet);

- 17 -

// Add the listener to close the frame.

f.addWindowListener(new WindowEventHandler());

// Assign the frame size and display it.

f.setSize(300, 150); // frame: width=300, height = 150

f.show(); // Display the frame

}

// Class to close the frame and exit the application.

class WindowEventHandler extends WindowAdapter {

public void windowClosing(WindowEvent e) {

System.exit(0);

}

Code Details

As stated previously, the program can function as both an applet and an application.

Thus, you can expect the methods init() as well as main() in the same program. The

init() method contains the statement that creates a label with the text "Hello! Swing

World" and an animated icon (a speaker sending sound waves). Then the label is added

to the applet. The init() method is invoked when you run the program as an applet.

Before you proceed to the code inside the init() method, you should observe two

more important features in the program. As you can see, the import statement contains

the Swing package as javax.swing.*. This is the key package that contains the Swing

classes JApplet and JFrame. Throughout your Swing programming career, you will

continually be using this import statement at the top of all your programs.

The other point of interest is that the class THello extends JApplet. This is because

the program is a Swing applet and thus extends JApplet, which is the Swing applet

class. The applet tag <Applet>...</Applet> at the top of the program allows you to

run the file THello.java by using the appletviewer. This avoids the unnecessary

creation of another file named THello.html while testing the code. Note that all the

applets in this book are tested by using this convention.

Next, coming to the main() method inside the program, you need this to allow the code

to function as an application. To create a Swing application, you need to use a JFrame

object to contain the label. However, in the case of this program, the applet that contains

the "Hello! Swing World" label is added to the frame. This is shown in the following code

statement:

// Create a Swing frame.

JFrame f = new JFrame("THello");

// Create an instance of THello applet.

THello helloApplet = new THello();

// Initialize the applet instance.

helloApplet.init();

// Add the applet to the JFrame (to its content pane).

f.getContentPane().add(helloApplet);

- 18 -

The remaining code statements display the frame with the specified size. The frame also

features a window listener to perform a clean exit when closing the frame. One final point

is that a component, such as label, is added to something called the "content pane"

instead of directly adding it to the applet or frame. A reference to the content pane can be

obtained by using the method getContentPane(). You will learn more about the

content pane as you progress through the book.

Tip

You can use the wrapper code in this program (allowing the program to function

as both an applet and an application) in your other programs that require similar

functionality.

Swing Applets

The Swing set introduces its own version of the applet, whose parent is the AWT applet.

Swing applets are made more sophisticated so that they can support menu bars and

layering of components in the dimension of depth, and allow painting over the

components already laid inside the applet.

With support for menu bars, Swing applets can possess a menu bar. The layering of

components is essentially placing components in multiple layers overlapping each other.

This in turn allows the components to be positioned so that the feeling of depth is

created. Swing applets contain a special component called a layered pane to achieve this

feature.

The other feature that allows painting over components inside the applet can be

accomplished by using a component called a glass pane. The glass pane is a transparent

component that allows the background components to be visible. However, you can paint

over the glass pane to make the painting visible in the foreground.

Swing applets are represented by the class JApplet, which is stored in the package

javax.swing. You can create a Swing applet by creating a class that extends

JApplet. While adding children to it, you need to add them to something called a

content pane, which receives the applet's children. The Swing library introduces this

intermediate container to deal with the complexities involved in mixing up the lightweight

and heavyweight components in an applet. The following code statement shows how a

component can be added to the content pane inside a Swing applet:

// Get a handle on the applet's content pane.

Container contentPane = this.getContentPane();

// You may want to assign a new layout.

contentPane.setLayout(someLayoutObject);

// Add the component to the applet.

contentPane.add(someComponent);

You can also obtain references to the applet's layered pane, glass pane, and menu bar

by calling the following methods on the applet's instance:

public void getLayeredPane()

public void getGlassPane()

public void getJMenuBar()

JApplet Example Program

Listing 2.2, TJApplet.java, shows the code to implement a Swing applet that displays

- 20 -

TJApplet extends the Swing class JApplet and thus qualifies itself as a Swing applet.

Inside the init() method, snippet-1 gets a handle on the applet's content pane. This

reference will be used to add any components to the applet.

Snippet-2 creates a Swing label with the specified text label and the icon. Snippet-3

assigns a border to the label. The border is of type matte border and uses an icon for the

matte pattern. The border thickness of the four sides of the label is assigned through the

respective insets. Snippet-4 is the statement to add the label to the applet. Note that you

have to add the label to the applet's content pane rather than the applet itself.

Chapter 3: Event Handling

Overview

User interface elements fire events in response to user input. These events are

propagated down the application to execute the specified functionality. If no functionality

has been defined, the events produce no effect.

The AWT in JDK 1.1 introduced the delegation event model to handle user interface

events. Because the Swing set is an extension of AWT, Swing components also function

based on the delegation event model.

This chapter initially discusses the concepts of the delegation event model and describes

the high-level events generated by Swing components. This chapter also explains the

corresponding event listeners and the classes needed to create event listeners. Note that

most of the Swing components use the classes of AWT events and event listeners. The

low-level events generated by the mouse, keyboard, and other devices will be discussed

later.

Delegation Model

The delegation event model supports a clean separation between the core program and

its user interface. The delegation pattern allows robust event handling that is less error

prone due to strong compile-time checking. In addition, the delegation event model

improves performance because the toolkit can filter out undesirable events (like high

frequency mouse events) that are not targeted to execute any function.

The delegation event model consists of three separate objects to deal with event

handling: event sources, events, and listeners. Event sources are any of the user

interface components such as buttons, text fields, scrollbars, and sliders. Event sources

generate and fire events, and the events propagate until they are finally attended to by

their listeners.

Events are objects of specific class types that are extended from the class

java.util.EventObject.

Event listeners are objects that implement specific event listener interfaces extended

from the root interface java.util.EventListener. The methods implemented inside

the listener classes contain the functionality that needs to be executed when the

corresponding user interface component is operated.

To attend to the events generated by an event source, the listener object needs to be

registered with that source. This is performed by either using the method

setEventTypeListener() or more often addEventTypeListener() because it

supports multi-casting. When a source supports multi-casting, multiple listeners can be

registered or removed from the source.

Swing Events, Sources, and Listeners

剩余627页未读，继续阅读

aliahmed

粉丝: 41
资源: 26

《Pure JFC Swing实战指南》：提升Java Swing效率的关键

深入学习：JFC Swing-Java基础类组件集

Sams-Pure.JSP

[Sams]Pure_JSP.zip

SAMS 2.0

SAMS PostgreSQL

sams-2

sams.sql

SAMS.c

SAMS.exe

sams-mods

最新资源