Core Java Foundation Classes [Paperback]

Kim Topley (Author)

Book Description

ISBN-10: 0130803014 | ISBN-13: 978-0130803016 | Publication Date: July 1, 1998 | Edition: Bk&CD-Rom

JFC is about to extend the Java AWT, dramatically improving Java's graphic capabilities and making it possible for developers to build state-of-the-art user interfaces. With practical, detailed examples, Core JFC shows experienced developers how to use JFC as effectively as possible. Understand what the Java Foundation Classes are, what they allow you to accomplish, and how they work together. Walk step-by-step through developing JFC-based applications and components. Learn about each significant JFC class, starting with the JFrame class that establishes the shell of an application. Understand the Java 1.1 event model; approaches for managing the user interface, establishing application control through dialog boxes; and creating menus and toolbars. Learn how to use enhanced JFC user interface components, including the JBorder class; application progress bars with JProgressBar; list and combo boxes; overlapping components. Take an in-depth look at the powerful new text components and the underlying document architecture; examine in detail the tree and table controls and see how to customize them to meet your needs. Finally, learn how to extend the JFC with custom components and how to write a custom look-and-feel of your own. Essential coverage of all the new "Swing" classes, which dramatically simplify the development of state-of-the-art GUIs. The perfect bridge book to help Java developers migrate from AWT to JFC - and the perfect state-to-finish tutorial for experienced developers new to Java GUI building. Proven Core Series format! The best information and code for real developers with real problems and real deadlines!

Editorial Reviews

Amazon.com Review

With the arrival of Sun's Java Foundation Classes (JFC), developers can write Java applications that behave just like "native"-style applications, such as those written in Windows. Core Java Foundation Classes shows you how you can take advantage of the new JFC Swing classes to create Java applications with all the advanced features that today's users expect.

After a tour of the JFC/Swing packages, the author jumps right into building basic Swing applications, focusing on layout managers (which control the arrangement of JFC components onscreen) and basic graphics programming. The book aims to let you create sophisticated Java applications, and so the author discusses topics such as menus and the toolbar, keyboard handling (and mouseless operation), and dialog boxes to let you do this. The book also covers powerful Swing components, the tree and table controls. The author even looks at creating multiple document interface (MDI) applications. --Richard Dragan

From the Inside Flap

The term Java Foundation Classes (JFC) refers to a collection of features that are included in, or can be used with, version 1.1 of the Java Development Kit (JDK) together with some new features introduced by JDK 1.2. The JFC is such a large topic area that to cover it in one volume and give it the treatment that it deserves, and that an experienced programmer would expect, is an impossible task. So, this book doesn't attempt to describe everything that falls under the JFC banner. Instead, I have chosen to concentrate on the parts that are of most immediate interest to programmers working in the commercial Java development environment today and left out those pieces that are not yet stable or would take up too much space in this volume. Most of this book is, therefore, concerned with the subset of the JFC that you can use with both JDK 1.1 and JDK 1.2. Specifically, this means the AWT as it exists in JDK 1.1, which is briefly covered as introductory or refresher material, printing, a JDK 1.1 feature that is deemed to be part of the JFC, and the Swing component set, which is the book's prime concern.

In writing about Swing, I have tried to include material that is of most interest to programmers who will want to use it to create real applications. The approach taken throughout is to explain how the Swing components and the various new Swing mechanisms (such as keyboard accelerators) work, by giving an overview of each topic and then presenting examples that show the basic principles. Then, typically, I move on to show more complex use of the component or feature and how it can be used together with other components and features to solve real application- related problems. Much of the time, you can find out some of what you want to know by reading the documentation that you get with the JDK or with the Swing package, but this documentation often falls short of explaining the more complex features and how they interact. These are the things that programmers usually need to understand before they can make full use of what is available. You'll find those explanations in this book.

I have tried to write this book as I would have liked to have seen it as an experienced programmer wanting to learn about Swing. By reading the documentation, studying the source code, disassembling the class files and trying various test cases, I have tried to do more than just scratch the surface of this large and complex topic by gathering together material and examples that are not available in Sun's documentation and presenting it in an organized, focused manner.

Who This Book Is For

This book is for experienced Java programmers who want to find out about the Java Foundation Classes and, in particular, the Swing component set. Because this book is aimed at experienced programmers, you'll find that most of the examples are not trivial, with the exception of some of those in the early chapters that illustrate basic points that can't be embedded in a more complex setting for clarity. Many of the examples that you'll find in this book are intended to be used as a starting point for writing production code that you can include in your own applications and some of the material here has been included specifically to address the most common questions that have been aired in the various news and discussion groups since the early versions of Swing were released. In particular, I have tried to address the following issues that seemed to be causing most confusion:
Creating and customizing tree components.
Custom renderers and editors for list boxes, trees and tables.
How to use the powerful Swing text components, including a detailed description of how they work.
Making proper use of the internal frames feature to create multi- document applications.
Customizing individual components by creating your own look-and- feel classes.

If you're looking for examples on how to write slick Java applets with Swing, then this book probably won't suit you. The focus in this book is entirely on writing Java applications. However, if you're already thoroughly familiar with JDK 1.1 applets, you'll find that you can use write applets using Swing very quickly and most of this book will still apply, since Swing components can be used in applets just as easily as in applications.

What You'll Need

This book is written with the assumption that you are familiar with the Java language and the core Java classes and that you can compile and run Java applications. Although this book is mainly about the Swing components, the first few chapters cover the basic principles of the Abstract Windows Toolkit (AWT), knowledge of which is a prerequisite for understanding Swing. You'll get most from this book if you have read Core Java 1.1, Volume I—Fundamentals by Cay S. Horstmann and Gary Cornell, also published by Prentice Hall, and you understand inner classes, which are heavily used both in the Swing source code and in the examples shown in this book. Core Java includes excellent coverage of this topic.

Assuming that you have a computer running Windows 95, Windows NT version 4 or later, or a version of Solaris supported by JDK 1.1 or JDK 1.2, almost everything else that you need, including versions of JDK 1.1 and JDK 1.2 and the Swing components for all of these platforms, is included on the CD- ROM, with the exception of the Swing components for use with JDK 1.1, which you will need to download from the JavaSoft web site, as described in EAbout the CD-ROM” below.. You will, of course, need some kind of basic development environment. However, a basic text editor that you can invoke from the command line is sufficient.

How This Book Is Organized

The book is divided into three sections. Section 1, “From AWT to Swing,” (Chapters 1 through 4) describes the relationship between the Abstract Windows Toolkit and Swing. Because Swing is a development based on the AWT, some understanding of the AWT is needed before you can fully utilize the Swing components. Although there are many good books on the AWT, this book opens by presenting the fundamentals for those who are not entirely confident that they fully understand them and as revision for those who do. These early chapters are, however, written not simply as a short course on the AWT — they are written with a Swing slant to them so that as early as Chapter 2 you will meet your first Swing components. I recommend that everybody reads Chapter 1. Then, depending on your background, you should read, or at least skim, Chapters 2 through 4.

Section 2, “Using Swing to Create Better Applications” (Chapters 5 through 8) deals with the various new mechanisms and components that Swing offers that have no real parallel in the AWT. Much of this section deals with individual Swing components or Swing concepts and, to a certain extent, the chapters in this section can be read in any order. Finally, Section 3, “Advanced Topics,” (Chapters 9 through 13) covers larger topic areas such as the tree and table components and the pluggable look- and -feel.

Chapter 1 introduces the Java Foundation Classes (JFC) and puts them into perspective by comparing them to the AWT. You'll learn the scope of the JFC and get a quick overview of the main features of the Swing component set. The last part of this chap ter introduces you to one of the more novel features of Swing — the so-called “pluggable look-and- feel,” which allows applications to adapt their appearance to suit the platform that they are running on or to take on the same appearance across all plat forms. It also explains the basis of this facility, the Model/View/Controller architecture (MVC).

Chapter 2 is the first of the AWT revision chapters. This chapter begins by introducing the Swing JFrame class as the top-level window of an application and uses it to illustrate basic AWT concepts such as components, containers, position, size, color, fonts and so on. The second half of the chapter includes material on event handling and introduces Swing's JLabel and JButton classes, which allow you to include text and an image on the same component. Here, you'll also find out about Swing improvements on the AWT, such as icons and accelerator keys, which now work outside of menus, to which they were confined in JDK 1.1.

Chapter 3 is concerned with global user-interface issues, principal among which is controlling the layout of components in the interface. With this in mind, almost the whole chapter is devoted to in-depth coverage of the AWT and Swing layout managers. Layout managers are a topic that has, in the past, been given only fleeting coverage in most Java books and represents a large proportion of the questions that are asked in the Java-related Internet newsgroups. Here, I have tried to create a consistent picture of all of the layout managers and to address the most common misunderstandings by illustrating how each layout manager lays out its container and how resizing the container affects the positioning of the components.

Swing includes a useful new feature that can help with understanding problems with component layout—Graphics Debugging. This feature allows you to see how your components are drawn, line-by-line, in slow motion. Chapter 3 looks at this feature and shows you how to use it and concludes with a look at the events generated by windows and by individual components.

Chapter 4 covers the AWT Graphics object and describes how you can use it to render text and draw graphics. The main body of this chapter is devoted to building a complete Swing application that allows you to use the mouse to draw and fill colored graphic shapes. While constructing this application, you'll put into practice much of what was covered in the previous two chapters and you'll also discover how to create custom icons and components with borders. The completed application will serve as a starting point for several improvements that will be made to it in rest of the book. Chapter 4 closes with a discussion of printing, another topic that has caused much confusion in the past.

Chapter 5 shows you how to develop applications that work well when the user prefers to use the keyboard rather than the mouse and introduces focus handling and the powerful concept of Actions. Actions are often used in Swing to abstract an action to be performed from the stimulus to perform itÑsuch as a keystroke or a button press. The second half of the chapter looks at how Swing supports scrolling using the new JScrollPane and JScrollBar components, which are much more powerful than their AWT counterparts.

Chapter 6 introduces the Swing menu system. Swing menus are more consistent than those available with AWT. Keyboard accelerators are available on any menu or menu item and you can use icons as well as, or instead of, text. YouÕll also see how to integrate the Actions that were introduced in Chapter 5 with the menu system and with another new Swing facility, the toolbar.

Chapter 7 is the first of two chapters that contain extensive coverage of dialogs. This chapter concentrates on dialogs that you can easily create using the JOptionPane component. These dialogs allow you to post error, warning and information messages or present options to the user and wait for a choice to be made. Two more useful standard dialogs, the file chooser and color chooser, are also covered in this chapter.

Chapter 8 shows you how to use the Swing JDialog class to create your own dialogs. This chapter also introduces many of the Swing components that are useful in dialogs, such as tabbed panes, list boxes, combo boxes, progress controls and sliders.

In Chapter 9, you'll find an in-depth description of the Swing text controls, starting with the simple JTextField and JTextArea components, which are related to the AWT TextField and TextArea controls. The Swing controls are underpinned by a complex but powerful document model that is covered in detail in this chapter. The description of the document model is followed by a description of two new Swing text controls — JTextPane, which allows multiple fonts, colors, images and event components to be mixed in a view of a document and the flexible JEditorPane, which adapts itself to render documents held as plain text, HTML, Rich Text Format and a potentially infinite number of other formats.

Chapter 10 describes the Swing tree control and shows you how to build a tree, how to control which parts of it are expanded or collapsed and how to traverse the tree in various different ways. This chapter also shows you a custom control based on the tree that presents a file system in a manner familiar to users of the Windows platform and it describes in detail how to customize trees using specially-developed renderers to control how the various pieces of the tree are drawn.

Chapter 11 is concerned with the table component. This component allows you to present data in a tabular form. You'll see how to determine the order of columns and their sizes and how to change the way in which the data in the table is displayed. There is also a section on table cell editors, which shows you how to present to the user a suitable interface for changing the content of the table.

Chapter 12 discusses SwingÕs support for multiple-document applications. Starting with a discussion of the basic components that make multiple- document applications possible, the chapter moves on to discuss desktop panes and icons and the desktop manager. You'll also see how to create a custom desktop pane that automatically cascades or tiles the windows that it manages and how to customize the desktop manager itself.

Finally, Chapter 13 returns to the theme of the pluggable look-and-feel that was first touched on in Chapter 1. This chapter shows the underlying support for changing the look-and-feel of an application, then shows you how to create your own user interface for the Swing button component.

Finally, you'll see various ways to introduce look-and-feel related customizations into your application and how to create your own look-and- feel.

This book covers all of the Swing components and most of the other important Swing features. For ease of reference, the following table lists the Swing components, along with the chapters in which they are described.
Component

Chapter Component

Chapter
Box 3

JRadioButtonMenuItem

6 BoxLayout 3

JRootPane

2 JButton 2

JScrollBar

5 JCheckBox 8

JScrollPane

5 JCheckBoxMenuItem 6

JSeparator

8 JComboBox 8

JSlider

8 JComponent 2

JSplitPane

9 JDesktopPane 12

JTabbedPane

8 JDialog 8

JTable

11 JEditorPane 9

JTextArea

9 JFrame 2

JTextField

9 JInternalFrame 12

JTextPane

9 JLabel 2

JToggleButton

8 JLayeredPane 12

JToolBar

6 JList 8

JToolTip

8 JMenu 6

JTree

10 JMenuBar 6

JViewport

5 JMenuItem 6

JWindow

2 JOptionPane 7

OverlayLayout

3 JPanel 2

ProgressMonitor

8 JPasswordField 9

ProgressMonitorInputStream

8 JPopupMenu 6

Timer

8 JProgressBar 8

UIDefaults

13 JRadioButton 8

UIManager

13

Conventions Used in This Book

Courier font is used to indicate Java code, both in the listings and in the shorter code extracts that you'll find included in the text. The same font is also used to indicate key words and class names (such as JFrame). In some cases, we show a code extract and then explain how to modify it to change its behavior. In this case, the code that is added or modified is shown in bold courier font.

Icons are used to call out material that is of significance and that the reader should be alerted to:
Core Note, Alert, Tip
Note: This is information that deserves special attention, such as an interesting fact about the topic at hand, or that the reader may want to keep in mind while programming.
Alert: This is information that, while useful, may cause unexpected results or serious frustration.
Tip: This is particularly useful information that will save the reader time, highlight a valuable programming tip, or offer specific advice on increasing productivity.

About the CD-ROM

The CD-ROM that accompanies this book has the following directory structure:
COREJFC

JDK1.1

CJFC11.ZIP

JDK1.2

CJFC12.ZIP WINDOWS

JDK1.1

JDK1.2 SOLARIS

JDK1.1

JDK1.2

The COREJFC directory contains the source code and compiled class files for the examples in this book. The WINDOWS directory contains a version of JDK1.1 for Windows 95 and Windows NT (version 4 or later) and a beta version of JDK 1.2 for Windows platforms. The SOLARIS directory has the same software for use with the Solaris operating system.

Installation Instructions

Since Swing can be used either with JDK 1.1 or JDK 1.2, you have a choice as to how to use the CD-ROM. If you want to use Swing with JDK 1.1, you need to do the following:
Install the appropriate version of JDK 1.1 for your platform.
Download and install the appropriate version of Swing for your platform.
Install the JDK 1.1 examples.
Optionally compile the example source files.

On the other hand, if you are going to use Swing with JDK 1.2, then you should:
Install the version of JDK 1.2 appropriate for your platform.
Install the examples for JDK 1.2.
Optionally compile the example source files.

Because Swing is an integral part of JDK 1.2, you donÕt need to download the Swing package if you intend to work with JDK 1.2.

The installation instructions in this section use the Windows platform when presenting typical command lines. If you are installing on the Solaris platform, you should amend the command lines as appropriate.

Installing for JDK 1.1
Install the JDK

If you already have JDK 1.1 installed, you can skip this step. However, you must install a new JDK if you do not have version 1.1.5 or higher, because Swing is not supported on earlier versions. To install the JDK, proceed as follows:
1.

Locate the subdirectory on the CD-ROM that matches your operating system (WINDOWS\JDK1.1 or SOLARIS/JDK1.1). In this directory, you will find an installation file for the JDK in a format that is appropriate for your platform. For example, for Windows, the JDK will be in a .exe file.

2.

Install the JDK files onto your computer by executing the installation file. We recommend that you place the JDK in a directory called jdk. If you have an older version of the JDK, completely remove it or move it to a new location before installing the newer version.

3.

Add the jdk\bin directory to your PATH variable. For example, under Windows 95, if you install the JDK in the directory c:\jdk, then place the following line at the end of your AUTOEXEC.BAT file:
PATH=c:\jdk\bin;%PATH%

Core Note

The JDK setup program will offer a default location which is different for each JDK version, such as jdk1.1.5. We recommend that you install the JDK in the directory jdk, but if you are using multiple versions, go ahead and accept the default. Be careful to modify the remaining instructions in this section to reflect your choice, however.

Download and Install Swing

If you don't already have a copy of the Swing components for JDK 1.Choose a suitable location and unpack the archive using any utility that can handle ZIP files. If you donÕt have a native utility for your platform, you can use the JDK jar tool to unpack the archive but, in this case, you should first reboot your computer if you have just installed the JDK.

Having installed Swing, you need to add the appropriate JAR files to your CLASSPATH. Swing contains several JAR files, all of which are found in the swing-1.0.x directory:
swing.jar windows.jar motif.jar multi.jar beaninfo.jar swingall.jar

Core Note

The name of the Swing directory will depend on the current version at the time that you download it. Here, we use the generic name swing-1.0.x. You should substitute the appropriate name for the version you download -for example, you might need to use swing-1.0.2.

You can either choose to include the minimum set of files for your platform, or you can simply add swingall.jar to your CLASSPATH. If you just want to use the standard Metal look-and-feel, you can get away with just adding swing.jar. If you want to use either the Windows or Motif look-and- feel, add windows.jar and/or motif.jar as well. If you plan to develop Java Accessibility features (a topic outside the scope of this book), you need to add multi.jar. You wonÕt need to use beaninfo.jar file unless you need to recreate your own version of swingall.jar — see the README.txt file in the swing-1.0.x1 directory for details.

If you are going to use Swing in conjunction with a third-party development environment, or you want to be able to use all of the look-and-feels, you should add swingall.jar to your CLASSPATH. Refer to “Set the CLASSPATH variable” below for further details.

Install the Examples

The Core JFC example source files for JDK 1.1 are held in the archive COREJFC\JDK1.1\CJFC11.ZIP. To install them, first create a directory, say C:\CoreJFCBook, and copy the archive from the CD-ROM into this directory. If you have a utility for your platform that can handle ZIP files (such as WinZip), you can go ahead and unpack the archive, making sure that the files are all installed in the C:\CoreJFCBook directory. Refer to ÒUnpack the ExamplesÓ below to confirm that you have unpacked the archive correctly. If you do not have such a utility, you can unpack them using the JDK jar tool.

Set the CLASSPATH variable

Next, you need to set the CLASSPATH environment variable. This must contain:
jdk\lib\classes.zip.
The appropriate Swing jar files.
The directory into which you copied the Core JFC examples.

For example, under Windows 95, add a line like this to your AUTOEXEC.BAT file:
SET CLASSPATH=c:\jdk\lib\classes.zip;c:\swing- 1.0.x\swingall.jar;c:\CoreJFCBook
If you use the C-shell under Solaris, place the following in your .cshrc file (as one line):
setenv CLASSPATH /jdk/lib/classes.zip:$HOME/swing-
1.0.x/swingall.jar:$HOME/CoreJFCBook
assuming that you have the JDK installed in /jdk and the examples and that the Swing archives have been installed under your home directory.

Obviously, if your CLASSPATH variable is already set, you will need to modify these instructions accordingly.

Finally, log out or reboot the computer.

Unpack the Examples

If you did not unpack the examples when you installed them, you should do so now. Make the directory in which the CJFC11.ZIP file has been installed (CoreJFCBook) your working directory, then execute the following command:
jar xvf CJFC11.ZIP

This will extract all of the examples. You should now have a directory called JFCBook in your CoreJFCBook directory, with one subdirectory per chapter. A typical layout might be as follows:
C:\CoreJFCBook\JFCBook\Chapter2 C:\CoreJFCBook\JFCBook\Chapter3 C:\CoreJFCBook\JFCBook\Chapter4
and so on. If you do not have this layout, you have done something wrong and the example programs will not work. One possible problem you might have at this stage is inability to run the jar command or an error while running it. If this is the case, either your PATH variable or your CLASSPATH variable is not correctly set. Check that you have correctly followed the instructions in this section, then reboot your computer to make sure that the settings have been incorporated into your environment.

Finally, using your favorite editor or file viewer, open any of the Java source files, for example JFCBook\Chapter2\AddExample.java. Near the top of this file, you should see a line like this:
import com.sun.java.swing.*;
If, instead, you see this line:
import java.awt.swing.*;
then you have installed the examples for JDK 1.2 Remove the CJFC12.ZIP file and all of the other files in this directory, copy the CJFC11.ZIP file from the CD-ROM directory COREJFC\JDK1.1 and unpack it again.

Installing for JDK 1.2

Install the JDK

Installation JDK 1.2 is the same as for JDK 1.1, so refer to “Install the JDK” under “Installing for JDK 1.1.” Note that JDK 1.2 includes the Swing components, so return here after installing JDK 1.2 — do not attempt to install the JDK 1.1 Swing components with JDK 1.2.

Install the Examples

The Core JFC example source files are held in the archive COREJFC\JDK1.2\ CJFC12.ZIP. To install them, first create a directory, say C:\CoreJFCBook, and copy the file from the CD-ROM into this directory. If you have a utility for your platform that can handle ZIP files (such as WinZip), you can go ahead and unpack the archive, making sure that the files are all installed in the C:\CoreJFCBook directory. Refer to “Unpack the Examples” below to confirm that you have unpacked the archive correctly. If you do not have such a utility, you can unpack them later using the JDK jar tool.

Set the CLASSPATH variable

Next, you need to add the CLASSPATH environment variable. This must contain:
jdk\lib\classes.zip.
The directory into which you copied the Core JFC examples.

For example, under Windows 95, add the following line to your AUTOEXEC.BAT file:
SET CLASSPATH=c:\jdk\lib\classes.zip;c:\CoreJFCBook
If you use the C-shell under Solaris, place the following in your .cshrc file:
setenv CLASSPATH /jdk/lib/classes.zip:$HOME/CoreJFCBook
assuming that you have the JDK installed in /jdk and the examples under your home directory.

Obviously, if your CLASSPATH variable is already set, you will need to modify these instructions accordingly.

Finally, log out or reboot the computer.

Unpack the Examples

If you did not unpack the examples when you installed them, you should do so now. Make the directory in which the CJFC12.ZIP file has been installed (CoreJFCBook) your working directory, then execute the following command:
jar xvf CJFC12.ZIP

This will extract all of the examples. You should now have a directory called JFCBook in your CoreJFCBook directory, with one subdirectory per chapter. A typical layout might be as follows:
C:\CoreJFCBook\JFCBook\Chapter1 C:\CoreJFCBook\JFCBook\Chapter2 C:\CoreJFCBook\JFCBook\Chapter3
and so on. If you do not have this layout, you have done something wrong and the example programs will not work. One possible problem you might have at this stage is inability to run the jar command or an error while running it. If this is the case, either your PATH variable or your CLASSPATH variable is not correctly set. Check that you have correctly followed the instructions in this section, then reboot your computer to make sure that the settings have been incorporated into your environment. Finally, using your favorite editor or file viewer, open any of the Java source files, for example JFCBook\Chapter2\AddExample.java. Near the top of this file, you should see a line like this:
import java.awt.swing.*;
If, instead, you see this line:
import com.sun.java.swing.*;
then you have installed the examples for JDK 1.2. Remove the CJFC11.ZIP file and all of the other files in this directory, copy the CJFC12.ZIP file from the CD-ROM directory COREJFC\JDK1.2 and unpack it again.

Building and Running the Examples

The example programs on the CD-ROM have been compiled using JDK 1.1.5 and Swing 1.0.1 and also with JDK 1.2 Beta 3. It is recommended that you just use the compiled class files that you'll find with the source files in the CoreJFCBook directories. If you need to rebuild the example files, perhaps because you want to try out some modifications of your own or to use a later version of the JDK or Swing that has incompatible changes, you should follow the procedure described in this section. The examples for each chapter are held in a directory named after that chapter and all the examples in that directory must be compiled together. You must also build the examples in ascending chapter-number order, apart from those in Chapter 13, which must b e built after those in the directory Cjfc. The correct build order is, therefore, as follows:
Chapter 2 through Chapter 12
Cjfc
Chapter13

To build the examples for Chapter 2, do the following:
cd C:\CoreJFCBook\JFCBook\Chapter2
javac *.java

This process should be repeated for each chapter, in the order just shown.

Core Alert

There are dependencies between the examples for different chaptersÑthe examples for some of the later chapters reuse classes developed earlier. If you compile the examples out of order, you will probably find that your compilations will fails because of missing classes.

To run the examples, you must have the directory C:\CoreJFCBook on your CLASSPATH. You must then supply the full class name of the example that you want to run along with any required parameters as described in the appropriate chapter. For example, t o run the first example in Chapter 2, use the following command:
java JFCBook.Chapter2.BasicFrame

In some cases, you will find explicit instructions that tell you how to run particular examples. Usually, however, you just need to use the exampleÕs class name and its chapter number as shown here.

A Note on Swing Versions

Since it was first released in developer form, the Swing API has undergone dramatic changes. Unfortunately, this process is not yet complete. At the time of writing, the current version of Swing for JDK 1.1 is Swing 1.0.1. The same version is also included in JDK 1.2 Beta 3, which you will find on the CD-ROM. The text and examples in this book relate to this particular version of Swing. Because most (over 90%) of the public API was frozen when Swing 1.0.1 was released, what you read in this book will continue to apply to later versions of Swing in almost all cases.

However, two of the Swing components, JFileChooser and JColorChooser (both of which are described in Chapter 7), did not have their API frozen in Swing 1.0.1. The API of these components is expected to change before JDK 1.2 is released and these same changes will also appear in the JDK 1.1 version of Swing. Be aware, therefore, that if incompatible changes are made to these components, some of the examples on the CD-ROM that use them may not work and their source code may no longer compile with later versions of Swing and JDK 1.2. To keep you up-to-date with the latest changes, there is a Web page at the following URL that you can use to download updated examples, should this become necessary:
topley.demon.co.uk/corejfc.html

Feedback

No book is perfect and this one is unlikely to be an exception to that rule. Even though it has been through a long period of revision and technical review, there are, of course, errors still to be found and improvements still to be made. If you find an error or if there is something that you think might make the book more useful, we want to know about them. Please send comments and corrections to the following e-mail address:
[e-mail]

Further Information

Java is a fast-moving subject. To keep up with developments, reading books is not enough.The following two groups in particular frequently discuss Swing and JFC-related issues:
comp.lang.java.gui
comp.lang.java.programmer

Acknowledgments

I seem to have spent all of my life buying and reading books. It is probably not too great an exaggeration to say that almost everything I know I have read in a book somewhere, some time. So it was only to be expected that when Java first appeared, I turned to the bookshop to help me find out about it. After examining the (then) limited number of books available on the subject, I settled on the one that stood out as most appropriate for an experienced programmer and took down from the bookshelf the copy in best condition. That book was the first edition of Core Java, by Cay S. Horstmann and Gary Cornell.

A little over a year later, having decided to try to make some money from books instead of spending money on them, I submitted a very basic outline for a book to a small group of publishers. The next day, I found two e-mail items waiting for me — one from Gary Cornell, the other from Greg Doench at Prentice Hall. Of course, there was a lot more work to do before a contract was agreed, but of all the people that deserve thanks for making this book possible, these two are at the head of the queue. It still amazes me that they were willing to put such faith in someone who had not yet written a book, on the strength of a vague outline and two chapters of a different book idea that never came to fruition. Throughout the writing process, which seems to have taken such a long time, I found that I could always approach either of them with questions or problems and have them addressed quickly. They helped me with all kinds of issues, from determining the scope of the book, right down to the details of the template with which the manuscript was written. But, most of all, they trusted me to deliver and it is for this that I am most grateful to them. As the writing phase drew to a close, Greg introduced me to Jim Markham, the book's development editor. It fell to Jim to read the entire manuscript and turn what was essentially a jumble of programmerÕs language into more fluent sentences and paragraphs, all under pressure of time. I can't thank Jim enough for the attention he paid to this taskÑthe book you now hold in your hands is much more readable than the collection of chapters he started with. As well as being an excellent development editor, I have to say that I used Jim frequently as a sounding board for ideas and asked him to do other things that went well beyond the bounds of his job and was never disappointed.

On the technical review front, my thanks go to Buzzy Brown (of IBM Retail Store Solutions), Blake Ragsdell and Cameron Laird, who all read parts of the manuscript at various stages of its development, for their comments which have helped improve the presentation of the technical content as well as remove several errors of fact. Special thanks, though, are due to two people who have contributed significantly to the technical side of this book. First, Rayme Jernigan read and commented on the entire manuscript as it was being overhauled for the penultimate time. Called to the task at the last minute, Rayme did an incredible job against a deadline that at first looked aggressive and then almost impossible. Nevertheless, he made it and is still alive to tell the tale! Secondly, I am indebted to Timothy Prinzing of the JavaSoft Swing development team who, at the same time as working on the Swing 1.0 release, graciously agreed to review the chapter describing the Swing Text Components, for which he was responsible. His feedback helped me to include the Swing 1.0 changes much more quickly than would otherwise have been possible and has made this a much more useful and accurate chapter.

I would also like to thank all the other people at Prentice Hall who helped with the production of this book, especially Mary Treacy for making sure that the contract details were sorted out, Yvette Raven for putting together the book's CD-ROM, and Joe Czerwinski, who answered many questions on the document template and saw the book through the production phase against a tight schedule. Despite the efforts of all of these people, and many others, as with most books of this size, there will undoubtedly be errors that remain. For these, I claim all credit.

Writing a book of this size takes a long time. In the year or so that I have devoted to this task, there have been times when I was inclined to take a long break or even consider giving up completely. Apart from my own stubbornness (and, of course, a possible breach of contract), several groups of people have inspired me to keep going with this project, possibly without realizing it. Most significantly, I would like to mention my work colleagues, Dave Martin and Tim Lowe, who made it their business to ask about the state of the book almost every day of every week and thus made it totally unacceptable to stop work and my supervisor, Polly Yee, for being understanding when asked for a few days' leave to get through a particularly busy part of the schedule.

Finally, I would like to express my gratitude to my family for putting up with my effective absence for most of the last year and for not complaining too much about the state of the study, which has been buried under books, notes and computers for the duration of this project.

See all Editorial Reviews

Product Details

• Paperback: 1168 pages
• Publisher: Prentice Hall Ptr; Bk&CD-Rom edition (July 1, 1998)
• Language: English
• ISBN-10: 0130803014
• ISBN-13: 978-0130803016
• Product Dimensions: 9.1 x 7 x 1.7 inches
• Shipping Weight: 3.8 pounds
• Average Customer Review: 4.6 out of 5 stars  See all reviews (39 customer reviews)
• Amazon Best Sellers Rank: #2,897,492 in Books (See Top 100 in Books)

Customer Reviews

Most Helpful Customer Reviews

8 of 8 people found the following review helpful:

5.0 out of 5 stars Great JFC Book, January 10, 2000

By 

JonP (USA) - See all my reviews

This review is from: Core Java Foundation Classes (Paperback)

Outstanding. I was a beginner with Java & JFC. This book took me through intermediate & up to expert level. JFC underlying structure is explained early on. Each new component family is explained in great detail & lots of high-quality examples. I am a very tough critic when it comes to these sw books, and this was the first one I actually wanted to write the author & thank him/her for such a great job. I couldn't stop reading it! This book is true gold. Only negatives: some minor typos; covered beta of JFC (swing) so once in a while an api changed - this did not hinder the effectiveness of the book (just refer to the Java API when in doubt).

3 of 3 people found the following review helpful:

5.0 out of 5 stars Best Swing book, the only Swing book that you need., September 6, 2000

By 

Dean Tran (San Diego, USA) - See all my reviews

This review is from: Core Java Foundation Classes (Paperback)

I am a newbie in both java and Swing world, and have auctioned at least 10 Swing books, until I find this one...

Topey UNDERSTANDS Swing very well and it makes difference. He also takes great care of writting this book, he provides clear building blocks to build a Swing application; and nothing is overlooked--e.g. what are RGB number and how to manipulate it....In the first few chapters, he provides many details about Swing which require time to digest before most reader can advance to the next.

The book is printed on high quality paper and is inexpensive for its contents. It serves both as tutorial for novices and as reference for advanced programmer.

I own many technical books in different fields, most of them are mediocre, some are good, few are great. Overall, This book is exceptional.

3 of 3 people found the following review helpful:

5.0 out of 5 stars Excellent, complete, well-written, July 7, 1999

By A Customer

This review is from: Core Java Foundation Classes (Paperback)

This may be the best technical book I've ever read on any topic. All aspects of Swing are covered in thorough and carefully explained detail. This excellent book promotes a deep understanding of what is going on in Swing, and despite its depth of treatment, it is so well-organized and well-written I believe it is suitable for beginners as well. The examples are numerous and highly instructive. The author keeps the material up to date with changes in Swing through addenda on his web site. One note of caution -- the book only covers Swing, not the entirety of JFC as the title suggests.