Java 1.2 Unleashed -- Table of Contents - SRM CSE-A

Java 1.2 Unleashed -- Table of Contents - SRM CSE-A
Java 1.2 Unleashed
Table of Contents:
●
Introduction
Part I - Programming With JDK 1.2
●
●
●
●
Chapter 1 - What's New in JDK 1.2
Chapter 2 - The JDK 1.2 API
Chapter 3 - The Extended Java Security Model
Chapter 4 - Overview of JDK 1.2 Programming
Part II - Applet Programming
●
●
●
●
Chapter 5 - JDK 1.2 Applet Writing Basics
Chapter 6 - GUI Building
Chapter 7 - Working with the Canvas
Chapter 8 - Applet Security
Part III - Application Programming
●
●
●
Chapter 9 - Creating Window Applications
Chapter 10 - Writing Console Applications
Chapter 11 - Using the Utility and Math Packages
Part IV - Swing Programming
●
●
●
Chapter 12 - Introducing Swing
Chapter 13 - Working with Swing Components
Chapter 14 - Changing the Look and Feel of Your Swing Components
Part V - Enhancing Your Applets and Applications
●
●
●
●
●
Chapter 15 - Using the Clipboard
Chapter 16 - Working with Drag and Drop
Chapter 17 - Input/Output Streams
Chapter 18 - Printing
Chapter 19 - Internationalization
Part VI - Multimedia Programming
●
●
●
●
Chapter 20 - Working with 2D and 3D Graphics
Chapter 21 - Using Audio and Video
Chapter 22 - Creating Animations
Chapter 23 - Integrating Speech and Telephony Capabilities
Part VII - Creating JavaBeans
●
●
●
●
●
●
Chapter 24 - The Software Component Assembly Model
Chapter 25 - The JavaBeans Development Kit
Chapter 26 - Developing Beans
Chapter 27 - Notable Beans
Chapter 28 - Using InfoBus
Chapter 29 - Glasgow Developments
Part VIII - Network Programming
●
●
●
●
●
●
●
Chapter 30 - Network Programming with the java.net Package
Chapter 31 - Client Programs
Chapter 32 - Server Programs
Chapter 33 - Content and Protocol Handlers
Chapter 34 - Using JavaMail
Chapter 35 - Naming and Directory Services
Chapter 36 - Working with the Java Management API
Part IX - Developing Distributed Applications
●
●
●
●
●
●
Chapter 37 - Distributed Application Architecture
Chapter 38 - Building Distributed Applications with the java.rmi Packages
Chapter 39 - Working with Remote Objects
Chapter 40 - Using Object Serialization and JavaSpaces
Chapter 41 - Java IDL and ORBs
Chapter 42 - Network Computers
Part X - Database Programming
●
●
●
●
Chapter 43 - Database Fundamentals
Chapter 44 - Connecting to Databases with the java.sql Package
Chapter 45 - Using JDBC
Chapter 46 - Integrating Database Support into Web Applications
Part XI - Server-Side Java
●
●
●
●
Chapter 47 - Sun's Java Web Server
Chapter 48 - Programming Other Servers
Chapter 49 - Pushing Java
Chapter 50 - Java Commerce and JavaCard
Part XII - Extending Java
●
●
●
●
●
●
Chapter 51 - Java Platforms and Extensions
Chapter 52 - JavaOS
Chapter 53 - Native Methods
Chapter 54 - Dirty Java
Chapter 55 - Java Command Language
Chapter 56 - Java Development Tools
Appendixes
●
●
●
●
●
●
Appendix A - Java Language Summary
Appendix B - Java Environment Variables
Appendix C - The JDK 1.2 Toolset
Appendix D - Generating Documentation and Help Files
Appendix E - The Java Extensions Framework
Appendix F - JDK 1.2 API Description
© Copyright 1998, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
Introduction
●
●
●
Who Should Read This Book
Conventions Used in This Book
Getting Started
Dedication
This book is dedicated to my son and favorite writer, Jason Jaworski.
Acknowledgments
I'd like to thank everyone who helped to see this book to completion. In particular, I'd like to thank
Margot Maley of Waterside Productions for making the book possible, Jeff Taylor, Tim Ryan,
Rebecca Mounts, and Jon Steever of Macmillan Computer Publishing for their numerous suggestions
that improved the overall quality of the book, and Jeff Perkins for his excellent technical input.
Finally, I'd like to thank Emily, Lisa, and Jason for their patience, love, and understanding.
About the Author
Jamie Jaworski is a professional Java programmer who develops advanced systems for the United
States Department of Defense. He has used Java in several research and development projects,
including a terrain analysis program and a genetic algorithm demonstration. He is also the author of
The Java Developer's Guide, and Mastering JavaScript.
Tell Us What You Think!
As the reader of this book, you are our most important critic and commentator. We value your
opinion and want to know what we're doing right, what we could do better, what areas you'd like to
see us publish in, and any other words of wisdom you're willing to pass our way.
As the Executive Editor for the Web Publishing team at Macmillan Computer Publishing, I welcome
your comments. You can fax, email, or write me directly to let me know what you did or didn't like
about this book--as well as what we can do to make our books stronger.
Please understand that I won't have time to help you with technical problems related to the topic of
this book, and that due to the high volume of mail I receive, I might not be able to reply to every
message.
When you write, please be sure to include this book's title and author as well as your name and phone
or fax number. I will carefully review your comments and share them with the author and editors who
worked on the book.
Fax: 317-817-7070
E-mail: [email protected]
Mail: Tim Ryan, Executive Editor Java Macmillan Computer Publishing 201 West 103rd Street
Indianapolis, IN 46290 USA
Introduction
Never before has a new programming language received so much attention and become so popular so
quickly. In the first year of its existence, Java took the Web by storm and became its adopted
programming language. Since then, Java has become the language of choice for developing both
Internet and intranet applications, and is used for both business and consumer software development.
The Java phenomenon has captivated the imaginations of programmers around the world and is
leading the way toward the next era of distributed application development.
Java's appeal lies in its simplicity, its familiarity, and the careful selection of features that it includes
and excludes. Java was not designed by a government committee or a clique of academics. It shares
its spirit with C more than any syntactical similarities. It is a programming language that was
designed by programmers for programmers.
This book shows you how to program in Java, with the emphasis on version 1.2 of the Java
Development Kit (JDK). It provides you with plenty of programming examples and arms you with
the mindset needed to write Java code in a manner that is simple, efficient, and true to the nature of
the language.
Who Should Read This Book
This book is for Java programmers. If you are not already a Java programmer, I suggest that you pick
up an introductory Java book, such as Sams Teach Yourself Java 1.2 in 21 Days by Laura Lemay and
Rogers Cadenhead. This book takes up where the introductory books leave off. It is an intermediateto-advanced book that assumes you know how to use Java programming statements and that you have
a basic understanding of exceptions and threads programming. If you have written programs in C or C
++, you should have the background necessary to understand the material presented in this book. The
syntax of Java is very similar to C and C++.
If you want to learn how to program using the JDK 1.2, this book is for you. You will learn how to
program using all of the application programming interfaces (APIs) of the JDK 1.2. You'll use these
APIs to develop Java applets, standalone window and console applications, beans, servlets, and
distributed objects. You'll learn how to work with GUI controls, Swing components, TCP/IP sockets,
remote method invocation, CORBA, multimedia, JDBC, and plenty of other new Java technologies.
If you want to upgrade your Java programming skills to JDK 1.2, this book will show you how.
Conventions Used in This Book
This book uses certain conventions that make it easier for you to use.
A monospaced font is used to identify program code. Anything that you type while using Java is
displayed in a bold monospaced font. An italic monospaced font is used to identify placeholders
used in Java syntax descriptions.
NOTE: Notes like this are used to call your attention to information that is important
to understanding and using Java.
TIP: Tips like this are used to identify ways that you can use Java more efficiently or
take advantage of undocumented features in the Java Development Kit and Javaenabled browsers.
WARNING: Warnings like this are used to help you to avoid common problems
encountered when using Java, and to keep you clear of potential programming
difficulties.
In order for you to understand where you are going and where you have been, each chapter begins
with a short description of the information that will be presented and ends with a summary of the
material that has been covered.
Getting Started
To use this book, you'll need a computer and operating system that support version 1.2 of the Java
Development Kit. There are a wide variety of operating systems that support the JDK 1.2, including
Windows 98, Windows 95, Windows NT, and Solaris. Ports of the JDK 1.2 to Linux, Macintosh OS,
OS/2, and other operating systems are in the works. This book focuses on using Java under Windows
95, but all of the book's examples are pure Java and will run with any JDK 1.2 implementation (with
the exception of those examples that show how to work with Microsoft's implementation of Java).
The CD-ROM that accompanies this book contains all the source code and complete applications
found in the book. The CD-ROM is a hybrid that will work on Windows 95, Windows 98,
Macintosh, and UNIX platform.
The best way to use this book is to start with Chapter 1, "What's New in JDK 1.2," and proceed
through each chapter in order, working through each programming example that is presented. You
will learn to use the JDK 1.2 by compiling, running, analyzing, and understanding the sample
programs. You can get additional hands-on practice by tinkering with the sample programs,
modifying them, and augmenting their capabilities.
© Copyright, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
-1What's New in JDK 1
●
●
●
●
The Java Foundations Classes
❍ Abstract Windowing Toolkit (AWT)
❍ Swing
❍ Accessibility
❍ Java 2D
❍ Drag and Drop
Other New Capabilities
❍ Java IDL
❍ The Collections API
❍ The Java Extensions Framework
❍ Reference Objects
❍ Package Version Identification
❍ Input Method API
Enhancements
❍ Security
❍ JavaBeans
❍ Reflection
❍ Audio
❍ JAR
❍ RMI and Serialization
❍ JDBC
❍ Native Interface
❍ Performance
Important Language Changes
●
●
Tools Changes
Summary
The JDK 1.2 is a major upgrade of the Core and Standard Extension APIs of the Java Development
Kit. It includes version 1.1 of the Java Foundations Classes (JFC), CORBA support, a more secure
and flexible security model, improvements to the APIs of JDK 1.1, and performance enhancements.
In this chapter you'll learn about the new capabilities added to JDK 1.2 and how these capabilities can
be used to enhance your Java applets and applications. When you finish this chapter, you'll have a
good understanding of what the JDK 1.2 provides and how to use this book to upgrade your Java
programming skills to JDK 1.2.
The Java Foundations Classes
Probably the single most important new feature added to JDK 1.2 is version 1.1 of the Java
Foundations Classes (JFC). JFC is a set of APIs for building the GUI-related components of Java
applets and applications. JFC 1.1 was released separately from the JDK in February of 1998 so that
they could be used with the then-current JDK 1.1. JDK 1.2 integrates JFC 1.1 as a Core API and adds
the Java 2D and Drag and Drop APIs. The APIs included with JFC include the following:
●
The Abstract Windowing Toolkit
●
Swing
●
Java 2D
●
Drag and Drop
●
Accessibility
These five APIs are introduced in the following subsections.
Abstract Windowing Toolkit (AWT)
If you've programmed in Java before, you know about the AWT. It provides the capability to create
platform-independent, GUI-based programs and is a very important contributor to Java's popularity.
Any programmer who has written programs using the arcane APIs of Microsoft Windows
immediately appreciates the clarity, simplicity, and power of the AWT. Not only is the AWT a better
API for developing Windows applications, it is a better API for programming window-based
applications on platforms ranging from Motif to OS/2.
The AWT of JDK 1.2 has been augmented with many new classes and interfaces that add drawing,
printing, and image-processing capabilities, and support the Accessibility, Drag and Drop, and Java
2D APIs. You'll learn to use the AWT in Chapter 6, "GUI Building," Chapter 7, "Working with the
Canvas," and Chapter 9, "Creating Window Applications."
Swing
Of all the new capabilities provided by the JFC 1.1, one API, referred to as Swing, has far-reaching
consequences for Java programmers. Swing is the code word used by the JavaSoft programming team
for the next generation of the AWT. Swing extends AWT by supplying many more types of GUI
components, providing 100% pure Java implementations of these components, and allowing the
appearance and behavior of these components to be easily tailored.
The new components that are included with Swing include everything from tabbed panes and fancy
borders to sliders and spinners. These new components, in and of themselves, make Swing an
outstanding addition to the Java API. The Swing Component Gallery, located at http://java.sun.com/
products/jfc/swingdoc-current/comp_gal.html, exhibits some of these new components. Swing also
comes with a great demo program named SwingSet.
The Swing components are 100% pure Java. This means that they don't depend on the native
windows implementation to support them. It also means that Swing components are available and
consistent across all platforms. Although Swing components are implemented in terms of the
underlying AWT, these components do not use AWT components. In fact, many of the traditional
AWT components, such as buttons, lists, and dialog boxes, have been reimplemented as Swing
components. Because of this, the AWT components behave more consistently across different
platforms and are capable of providing additional features not supported by their native windowing
platforms.
The most talked about feature of Swing is its support for pluggable look and feel (PL&F). If you like
to customize your desktop, dabble in new color schemes, and do what it takes to make your windows
fit your tastes and needs, PL&F is for you. The Swing PL&F architecture makes it easy to customize
both the appearance and the behavior of any particular Swing control or any group of those controls.
Swing also comes with several predefined L&Fs, including the default Metal L&F, the Motif L&F,
and the Windows L&F. L&Fs for Macintosh and other platforms are also being developed.
You'll learn to program using Swing in Part IV, "Swing Programming."
Accessibility
The Accessibility API is a JFC API that has been added to JDK 1.2. It provides support for the use of
assistive technologies with other JFC components. Assistive technologies, such as screen magnifiers
and speech recognition systems, are intended for use by disabled users, but are also valuable tools for
the average non-disabled user. These technologies provide non-standard ways of interacting with
software applications. The Accessibility API of JDK 1.2 allows software developers to comply with
the Federal Rehabilitation Act and Americans with Disabilities Act.
The Accessibility API consists of classes and interfaces for incorporating accessibility features into
applets and applications. These classes and interfaces are provided in the java.awt.accessibility
package. Chapter 9 covers the use of the Accessibility API.
Java 2D
If you develop any kind of graphics-related software, you'll appreciate the new Java 2D API. This
API provides comprehensive support for two-dimensional drawing, image processing, graphics
rendering, color management, and printing. It consists of an imaging model that supports line art,
text, images, spatial and color transformations, and image compositing. The model is deviceindependent, allowing displayed and printed graphics to be rendered in a consistent manner. The Java
2D API is incorporated into the java.awt and java.awt.image packages. Chapter 20, "Working with
2D and 3D Graphics," covers the Java 2D API.
Drag and Drop
One of the nicer features of most windowing environments that has been conspicuously missing from
Java is support for drag and drop. Drag and drop is typically used to organize desktops, manage files,
open documents, and execute applications. The Drag and Drop API allows the JDK 1.2 to provide
platform-independent support of drag and drop. It supports drag and drop within Java applications,
between Java applications, and between Java and native platform applications. The Drag and Drop
API is implemented in the java.awt.dnd package and is supported by classes and interfaces in other
JFC packages. Chapter 16, "Working with Drag and Drop," shows how to use the Drag and Drop API.
Other New Capabilities
Besides integrating JFC 1.1 as a set of Core APIs, the JDK 1.2 provides a number of other new
capabilities. These capabilities are covered in the following subsections.
Java IDL
The Common Object Request Broker Architecture (CORBA) is a standard approach to developing
distributed objects for use in distributed object-oriented systems. CORBA was developed by the
Object Management Group (OMG), a consortium of software companies and other organizations.
The capability to use Java objects within CORBA is referred to as Java IDL and has been
incorporated into JDK 1.2. Java IDL provides an API and a set of tools for interfacing Java objects
with CORBA objects, and for developing CORBA objects in Java. Java IDL also includes a Java
Object Request Broker (ORB) and an ORB name server. Chapter 41, "Java IDL and ORBs," shows
how Java and CORBA can be used together.
The Collections API
The Collections API is a set of classes and interfaces that provide an implementation-independent
framework for working with collections of objects. This API consists of eleven classes and eight
interfaces that have been added to the java.util package. These classes and interfaces provide support
for generic collections, sets, bags, maps, lists, and linked lists. These classes and interfaces can be
easily extended to provide support for custom object collections. The Collections API is covered in
Chapter 11, "Using the Utility and Math Packages."
The Java Extensions Framework
JDK 1.2 provides the capability to extend the Core API classes. Extensions are implemented as Java
Archive (JAR) files that are installed in a particular directory or downloaded from a URL. Appendix
E, "The Java Extensions Framework," shows how to work with both installed and downloaded
extensions.
Reference Objects
Reference objects, introduced with JDK 1.2, store references to other objects. They are similar in
function to C and C++ pointers, but do not provide access to specific memory addresses. The java.
lang.ref package provides six classes that implement reference objects. These classes also provide the
capability to notify a program when a referenced object is subject to garbage collection. This
capability enables reference objects to be used to implement object-caching mechanisms. Chapter 10
introduces reference objects.
Package Version Identification
Package version identification is also a new capability that was introduced with JDK 1.2. It allows
applets and applications to obtain version information about a particular Java package. This version
information enables large complex applications to evolve over time, with some application packages
being upgraded independently of others. The new Package class provides methods for obtaining
package version information. This version information is stored in the manifest of .jar files. Chapter
10, "Writing Console Applications" covers the methods of the Package class.
Input Method API
The Input Method API is an addition to the JDK's internationalization support that enables textediting components to receive foreign language text input through input methods. It is designed to
support large character sets, such as Chinese, Japanese, and Korean. An input method lets users enter
thousands of different characters using keyboards with far fewer keys. Typically, a sequence of
several characters is typed and then converted to create one or more characters. The input method
framework is covered in Chapter 19, "Internationalization."
Enhancements
In addition to the new capabilities identified in previous sections, the JDK 1.2 provides significant
enhancements to APIs, tools, and language features that were introduced in JDK 1.1 and 1.0. These
enhancements are covered in the following subsections.
Security
The security model enforced by the JDK has evolved from JDK 1.0 through JDK 1.1 to JDK 1.2. The
model enforced by JDK 1.2 is both more secure and more flexible than that of preceding JDK
releases. It eliminates security flaws found in previous JDK versions. Its flexibility has been
enhanced because it provides users with the capability to specify security policies simply by editing
the security permissions contained in their policy text files. In addition to policy improvements, the
JDK 1.2 provides enhanced support and tools for working with digital certificates. Chapter 3, "The
Extended Java Security Model," and Chapter 8, "Applet Security," cover the security enhancements
of JDK 1.2.
JavaBeans
The JavaBeans support provided with JDK 1.2 includes the Glasgow JavaBeans release. The
Glasgow release adds the runtime containment and services protocol, support for drag and drop, and
the JavaBeans activation framework. The runtime containment and services protocol provides beans
with the capability to interoperate with other beans and to learn information about their execution
environment. The new drag and drop support provides beans with a more complete graphical user
interface capability. The JavaBeans activation framework allows beans to be selectively instantiated
and used to support dynamic program requirements. Part VII, "Creating JavaBeans," covers
JavaBeans programming. Chapter 29, "Glasgow Developments," covers the new features added with
the Glasgow JavaBeans release.
Reflection
Reflection support was introduced in JDK 1.1. Reflection enables classes, interfaces, and objects to
be examined and their public fields, constructors, and methods to be discovered and used at runtime.
These capabilities are used by JavaBeans, object inspection tools, Java runtime tools such as the
debugger, and other Java applications and applets. JDK 1.2 provides the capability to identify a field,
method, or constructor as suppressing default Java language access controls. This permits reflection
to be better used with the more flexible JDK 1.2 security model. Chapter 10 covers the use of
reflection.
Audio
JDK 1.1 provided the capability for applets to play audio files that were in the Sun Audio (AU)
format. JDK 1.2 provides a new sound engine that allows audio files to be played by both applets and
applications. The sound engine also provides support for the Musical Instrument Digital Interface
(MIDI), the Microsoft Windows audio file format (WAVE), the Rich Music Format (RMF), and the
Audio Interchange File Format (AIFF). Chapter 21, "Using Audio and Video," covers these new
audio capabilities.
JAR
Java Archive (JAR) files were introduced in JDK 1.1. These files provide the capability to store
multiple files within a single archive file. JAR files help you organize applets, applications, beans,
and class libraries and provide more efficient use of network resources. JDK 1.2 JAR enhancements
include improved tools for working with JAR files and new classes for performing JAR file input and
output. Chapter 8 covers the use of JAR files.
RMI and Serialization
The Remote Method Invocation (RMI) API was introduced in JDK 1.1. It provides the capability for
Java objects executing on a local computer to invoke the methods of objects that execute on remote
computers. Object serialization is used to pass objects as parameters and return values in the remote
method invocations.
The RMI API has been significantly enhanced in JDK 1.2. The Remote Object Activation framework
supports remotely activated objects and object references that persist across multiple object
activations. Serialization improvements provide the capability for alternative objects to be written to
and read from streams in support of serialization. RMI is covered in Part 9, "Developing Distributed
Applications." Object serialization is covered in Chapter 40, "Using Object Serialization and
JavaSpaces."
JDBC
JDBC provides the capability to access databases from Java. According to JavaSoft, JDBC doesn't
stand for anything. However, it is sometimes associated with "Java database connectivity." JDBC was
introduced in JDK 1.1. JDK 1.2 includes an improved version of the JDBC-ODBC bridge driver and
support for JDBC 2.0. Part X, "Database Programming," covers all aspects of JDBC.
Native Interface
The Java Native Interface (JNI) provides the capability for Java objects to access methods written in
languages other than Java. In JDK 1.2, the JNI includes new capabilities for controlling the manner in
which native methods interact with the Java Virtual Machine. Chapter 53, "Native Methods," shows
how to develop native methods using the Java Native Interface.
Performance
The overall performance of the JDK tools has been greatly improved. First and foremost is the
inclusion of a just-in-time (JIT) compiler with the JDK. Other performance enhancements include the
use of native libraries for some performance-critical Core API classes, improvements to
multithreading performance, and reduction in memory usage for string constants.
Important Language Changes
In JDK 1.2, the stop(), suspend(), and resume() methods of the Thread class have been deprecated
because of errors and inconsistencies that may occur as the result of their use. Instead of using the
stop() method, it is recommended that threads monitor their execution and stop by returning from
their run() method. A thread may determine that its execution should be stopped as the result of
monitoring the state of a shared variable. In addition, it is recommended that threads suspend and
resume their own execution as the result of monitoring interface events, such as the value of shared
variables. The wait() and notify() methods of the Object class should be used to cause a thread to wait
on changes to the value of a shared variable.
NOTE: In addition to changes to the Thread class, other classes, interfaces, and
methods have been deprecated in JDK 1.2. A complete description of these changes is
included with the JDK 1.2 documentation. A deprecated API element is one that is still
supported for backward-compatibility but is being phased out of future JDK versions.
Tools Changes
The tools provided with JDK 1.1 have been improved in JDK 1.2, and new tools have been added.
The new keytool and javasigner tools replace the javakey tool of JDK 1.1. New tools included with
JDK 1.2 include the following:
●
rmid--Remote activation system daemon
●
keytool--Maintains a database of key pairs and digital certificates
●
javasigner--Used to sign JAR files and verify the signatures of signed files
●
policytool--Edits the local system security policy
●
tnameserv--Implements the CORBA Common Object Services (COS) Naming Service
Appendix C, "The JDK 1.2 Toolset," summarizes the use of the tools provided with JDK 1.2.
Summary
In this chapter you learned about the new capabilities added to JDK 1.2. You learned about the JFC
1.1, the other new Core APIs added to JDK 1.2, the Servlets Standard Extension API, and
improvements to the APIs of JDK 1.1. The next chapter, "The JDK 1.2 API," provides an overview
of the packages that are contained in the Core and Standard Extension APIs of JDK 1.2.
© Copyright 1998, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
-2The JDK 1.2 API
●
●
●
●
API Overview
Core API
❍ The java.applet Package
❍ The JFC Packages
❍ The JavaBeans Packages
❍ The java.io Package
❍ The Language Packages
❍ The java.math Package
❍ The java.net Package
❍ The RMI Packages
❍ The Security Packages
❍ The java.sql Package
❍ The java.text Package
❍ The Utility Packages
❍ The CORBA Packages
Standard Extensions
Other APIs
❍ Java 3D
❍ The Java Media Framework
❍ The Speech API
❍ The Telephony API
❍ JavaMail
❍ Java Naming and Directory Services
❍ The Java Management API
❍
❍
JavaSpaces
JavaCommerce
Chapter 1, "What's New in JDK 1.2," provided an overview of the new features incorporated into
JDK 1.2. This chapter examines the JDK 1.2 API in closer detail. It provides an overview of the API
packages and identifies the packages that have been added since JDK 1.1. It then describes all of the
packages of JDK 1.2, highlighting important classes and interfaces. When you finish this chapter,
you'll know your way around the packages of JDK 1.2 and know what packages to use for different
programming needs.
API Overview
The JDK 1.2 API consists of 57 packages, all of which are in the Core API. Of the 53 Core API
packages, 22 are part of the Java Foundations Classes (JFC). Figure 2.1 provides an overview of the
JDK 1.2 packages.
The Core API is the minimum subset of the Java API that must be supported by the Java Platform.
All classes and interfaces that are part of the JDK but are not in the Core API are in the Standard
Extension API. The JFC are Core API classes and interfaces that support GUI development for
applets and applications.
Figure 2.2 identifies the packages provided with JDK 1.1. By comparing Figure 2.1 with Figure 2.2,
you can see that JDK 1.2 added 35 packages to the 22 packages provided with JDK 1.1. This is a
substantial addition. The new JDK 1.2 packages are represented in boldface in Figure 2.1.
Core API
The Core API grew significantly from JDK 1.1 to 1.2. Of the 35 Core API packages that were added
in JDK 1.2, 19 are in the JFC (10 Swing and 9 non-Swing), 9 are Java IDL (CORBA and
CosNaming), 2 are security, 2 are utility packages (JAR and MIME support), 1 is JavaBeans, 1 is
RMI, and 1 is object references (java.lang.ref). The bulk of the new JDK 1.2 packages are JFC and
CORBA.
The following subsections summarize the JDK 1.2 Core API packages and identify what's new and
what has been updated.
The java.applet Package
The java.applet package is one of the smallest packages in the Core API. It consists of one class and
three interfaces that provide the basic functionality needed to implement applets. The Applet class
provides methods to display images, play audio files, respond to events, and obtain information about
an applet's execution environment. The AppletContext interface defines methods that allow an applet
to access the context in which it is being run. The AppletStub interface supports communication
between an applet and its browser environment, and is used to develop custom applet viewers. The
AudioClip interface provides methods that support the playing of audio clips. The java.applet
package is covered in detail in Part II, "Applet Programming."
FIGURE 2.1. The packages of JDK 1.2.
FIGURE 2.2. The packages of JDK 1.1.
The JFC Packages
The JFC packages provide the capability to create graphical user interfaces for applets and
applications. The JFC packages subsume and extend the AWT of JDK 1.1. The number of JFC/AWT
packages grew from 4 in JDK 1.1 to 23 in JDK 1.2. The 19 new packages include 10 Swing
packages, written entirely in Java, that provide a pluggable look and feel for GUI controls. Other new
packages support accessibility, drag and drop, 2D graphics, and imaging.
The java.awt Package
The java.awt package implements the core classes and interfaces of the Abstract Windowing Toolkit
(AWT). It is a large package, containing 63 classes and 14 interfaces. These classes and interfaces
provide the standard AWT GUI controls, as well as drawing, printing, and other capabilities. The java.
awt package is covered in Chapter 6, "GUI Building," Chapter 7, "Working with the Canvas,"
Chapter 9, "Creating Window Applications," Part V, "Enhancing Your Applets and Applications,"
and Part VI, "Multimedia Programming."
The com.sun.java.accessibility Package
The com.sun.java.accessibility package provides seven classes and seven interfaces that support the
use of assistive technologies for disabled users. It is covered in Chapter 9.
The java.awt.color Package
The java.awt.color package is part of the Java 2D API. It provides five classes that support the
capability to work with different color models. The java.awt.color package is covered in Chapter 20,
"Working with 2D and 3D Graphics."
The java.awt.datatransfer Package
The java.awt.datatransfer package provides four classes and three interfaces that support clipboard
operations. It is covered in Chapter 15, "Using the Clipboard."
The java.awt.dnd Package
The java.awt.dnd package supports the new JDK 1.2 drag-and-drop capability. It contains 15 classes
and four interfaces and is covered in Chapter 16, "Working with Drag and Drop."
The java.awt.event Package
The java.awt.event package provides the foundation for JDK 1.1-style event processing. It contains
21 classes and 13 interfaces, and is covered in Chapter 6.
The java.awt.font Package
The java.awt.font package is new to JDK 1.2. It provides 15 classes and two interfaces that support
advanced font capabilities. The java.awt.font package is covered in Chapter 20.
The java.awt.geom Package
The java.awt.geom package is another new JDK 1.2 package that is part of the Java 2D API. It
provides 30 classes and one interface that support standard geometrical objects and transformations.
The java.awt.geom package is covered in Chapter 20.
The java.awt.im Package
The java.awt.im package is a new package that supports the Input Method API. It contains two
classes and one interface. The Input Method API is covered in Chapter 19, "Internationalization."
The java.awt.image Package
The java.awt.image package is a Java 2D API package that supports image processing. It provides 38
classes and 8 interfaces that support common image filters. The java.awt.image package is covered in
Chapter 20.
The com.sun.image.codec.jpeg Package
The com.sun.image.codec.jpeg package provides three classes and four interfaces that support JPEG
image compression. It is covered in Chapter 20.
The java.awt.image.renderable Package
The java.awt.image.renderable package provides four classes and three interfaces that support image
rendering. It is covered in Chapter 20.
The java.awt.print Package
The java.awt.print package is a Java 2D API package that supports the printing of text and graphics.
It contains four classes and three interfaces. This package is covered in Chapter 18, "Printing."
The Swing Packages
The Swing packages are an important addition to the JDK 1.2. Swing is a 100 percent Java extension
to the AWT that provides many new GUI components, improvements to existing components, and
the capability to select from a variety of GUI look-and-feels, such as Metal, Windows, Motif, and
Macintosh. Swing consists of 10 packages that are summarized in the following subsections and
covered in detail in Part IV, "Swing Programming."
The com.sun.java.swing Package
The com.sun.java.swing package is the core Swing package. It contains 90 classes and 23 interfaces
that provide the foundation for the Swing API. This package is introduced in Chapter 12,
"Introducing Swing."
The com.sun.java.swing.border Package
The com.sun.java.swing.border package provides nine classes and one interface that implement
borders and border styles. It is covered in Chapter 13, "Working with Swing Components."
The com.sun.java.swing.event Package
The com.sun.java.swing.event package provides 23 classes and 23 interfaces that implement Swing
events and event listeners. It is covered in Chapter 12 and Chapter 13.
The com.sun.java.swing.plaf Package
The com.sun.java.swing.plaf package provides 42 classes and one interface that support the use of the
pluggable look and feel. It is covered in Chapter 14, "Changing the Look and Feel of Your Swing
Components."
The com.sun.java.swing.table Package
The com.sun.java.swing.table package provides seven classes and four interfaces that implement the
Swing table component. It is covered in Chapter 13.
The com.sun.java.swing.text Package
The com.sun.java.swing.text package provides 59 classes and 21 interfaces that implement text
processing components. It is covered in Chapter 12.
The com.sun.java.swing.text.html Package
The com.sun.java.swing.text.html package consists of 22 classes that provide basic HTML editing
capabilities. This package is covered in Chapter 12.
The com.sun.java.swing.text.rtf Package
The com.sun.java.swing.text.rtf package consists of a single class, RTFEditorKit, that provides the
capability to edit Rich Text Format (RTF) documents. It is covered in Chapter 12.
The com.sun.java.swing.tree Package
The com.sun.java.swing.tree package provides four classes and seven interfaces that provide the
capability to work with com.sun.java.swing.JTree components. The JTree component is a GUI
component that displays a set of hierarchical data as an outline. The com.sun.java.swing.tree package
is covered in Chapter 13.
The com.sun.java.swing.undo Package
The com.sun.java.swing.undo package provides five classes and two interfaces that support the
implementation of undo and redo capabilities. It is covered in Chapter 13.
The JavaBeans Packages
Two JavaBeans packages are provided with JDK 1.2. The java.beans package was present in JDK
1.1. The java.beans.beancontext package has been added to support the implementation for a bean
container that provides an execution context for beans during design and runtime execution.
The java.beans Package
The java.beans package contains 15 classes and eight interfaces that provide the basic JavaBeans
functionality. The java.beans package is covered in Part VII, "Creating JavaBeans."
The java.beans.beancontext Package
The java.beans.beancontext package provides 11 classes and eight interfaces that implement an
execution context for beans. The java.beans.beancontext package is covered in Chapter 29, "Glasgow
Developments."
The java.io Package
The java.io package provides 50 classes and 10 interfaces that implement stream-based input and
output. Chapter 17, "Input/Output Streams," shows how to use java.io to perform a wide variety of
input and output.
The Language Packages
The three java.lang packages implement the core classes of the Java language and runtime
environment. The java.lang.ref package is new to JDK 1.2. This package introduces reference
objects, which are objects that are used to reference other objects.
The java.lang Package
The java.lang package provides 29 classes and three interfaces that implement fundamental Java
objects. Because of its importance, the java.lang package is included with all Java platforms, ranging
from EmbeddedJava to the full-blown JDK. The java.lang package is covered in Chapter 10, "Writing
Console Applications."
The java.lang.ref Package
The java.lang.ref package provides five classes that implement the new JDK 1.2 reference object
capability. Reference objects are objects that are used to refer to other objects. They are similar to C
and C++ pointers. The java.lang.ref package is covered in Chapter 10.
The java.lang.reflect Package
The java.lang.reflect package contains seven classes and one interface that provide the capability to
implement runtime discovery of information about an object's class. The AccessibleObject and
ReflectPermission classes are new to JDK 1.2. The java.lang.reflect package is covered in Chapter 10.
The java.math Package
The java.math package provides two classes, BigDecimal and BigInteger, that provide the capability
to perform arbitrary-precision arithmetic. This package is covered in Chapter 11, "Using the Utility
and Math Packages."
The java.net Package
The java.net package provides 21 classes and five interfaces for TCP/IP network programming. The
java.net package is covered in Part VIII, "Network Programming."
The RMI Packages
The five Remote Method Invocation (RMI) packages provide the capability to use distributed objects
within Java. The java.rmi.activation package is new to JDK 1.2. It supports persistent remote object
references and automatic object activation. Part IX, "Developing Distributed Applications," covers
programming with the RMI packages.
The java.rmi Package
The java.rmi package provides three classes and one interface that support basic RMI capabilities.
The MarshalledObject class is new to JDK 1.2. It supports object persistence for remote object
activation. The Naming class provides static methods for accessing remote objects via RMI URLs.
The RMISecurityManager class defines the default security policy used for remote object stubs. The
Remote interface is used to identify an object as being remotely accessible. The java.rmi package is
covered in Chapter 38, "Building Distributed Applications with the java.rmi Packages," and Chapter
39, "Remote Method Invocation."
The java.rmi.activation Package
The java.rmi.activation package supports persistent object references and remote object activation. It
contains seven classes and four interfaces. Chapter 39 shows how to work with these classes and
interfaces.
The java.rmi.dgc Package
The java.rmi.dgc package supports distributed garbage collection. It contains two classes and one
interface. The Lease class creates objects that are used to keep track of object references. The VMID
class implements an ID that uniquely identifies a Java virtual machine on a particular host. The DGC
interface is implemented by the server side of the distributed garbage collector. The java.rmi.dgc
package is covered in Chapter 38.
The java.rmi.registry Package
The java.rmi.registry package supports distributed registry operations. It contains one class and two
interfaces. The LocateRegistry class provides methods for accessing the Registry on a particular host.
The Registry interface provides methods for associating names with remotely accessible objects. The
RegistryHandler interface provides methods for accessing a Registry implementation. These methods
have been deprecated in JDK 1.2. The java.rmi.registry package is covered in Chapter 38.
The java.rmi.server Package
The java.rmi.server package provides the low-level classes and interfaces that implement RMI. It
contains 11 classes and nine interfaces. The SocketType class is new to JDK 1.2. The java.rmi.
registry package is covered in Chapter 38.
The Security Packages
The five java.security packages support the implementation of the JDK 1.2 configurable security
policy and cryptographic security mechanisms. These packages are covered in Chapter 3, "The
Extended Java Security Model," and Chapter 8, "Applet Security."
The java.security.cert and java.security.spec packages are introduced in JDK 1.2. The java.security.
cert package supports digital certificates. The java. security.spec package provides specifications for
the keys used in common cryptographic algorithms.
The java.security Package
The java.security package provides 37 classes and eight interfaces that form the foundation for the
Security API. Refer to Chapter 3 and Chapter 8.
The java.security.acl Package
The java.security.acl package provides five interfaces that form the basic elements for implementing
security access controls. This package is covered in Chapter 8.
The java.security.cert Package
The java.security.cert package provides seven classes and one interface that implement digital
certificates. It is covered in Chapter 8.
The java.security.interfaces Package
The java.security.interfaces package provides eight interfaces that support implementation of the
NIST digital signature algorithm. It is covered in Chapter 8.
The java.security.spec Package
The java.security.spec package provides nine classes and two interfaces that provide specifications
for cryptographic keys. It is covered in Chapter 8.
The java.sql Package
The java.sql package provides six classes and 18 interfaces that provide Java database connectivity.
This package is covered in Part X, "Database Programming."
The java.text Package
The java.text package provides 20 classes and two interfaces that support internationalization. The
java.text package is covered in Chapter 19.
The Utility Packages
The four java.util packages provide a variety of useful classes and interfaces for both applets and
applications. These packages are covered in Chapter 11.
The java.util.jar and java.util.mime packages are new to JDK 1.2. The java.util.jar package provides
classes for working with Java Archive (JAR) files. The java.util.mime package provides classes for
working with Multipurpose Internet Mail Extensions (MIME) types.
The java.util Package
The java.util package, like java.lang and java.io, is fundamental to any Java platform. It provides 34
classes and 13 interfaces that cover a wide variety of common programming needs. Most of the new
classes and interfaces support the Collections API. The java.util package is covered in Chapter 11.
The java.util.jar Package
The java.util.jar package provides seven classes for working with JAR files. It is covered in Chapter
11. Chapter 8 shows how to use the jar tool to create JAR files.
The java.util.mime Package
The java.util.mime package provides two classes for working with MIME types. The MimeType
class provides an object representation of a MIME type. The MimeTypeParameterList class provides
the capability to work with a MIME type's parameters. The java.util.mime package is covered in
Chapter 11.
The java.util.zip Package
The java.util.zip package provides 14 classes and one interface for working with compressed files. It
is covered in Chapter 11.
The CORBA Packages
The six new CORBA packages represent a sizable addition to the Core API and a significant
capability for the Java programmer. These packages allow Java objects to make remote method
invocations of CORBA objects. They also allow Java objects to be accessed as CORBA objects. The
following subsections summarize these packages. Chapter 41, "Java IDL and ORBs," shows how to
use these packages to interface Java with CORBA.
The org.omg.CORBA Package
The org.omg.CORBA package consists of 57 classes and 42 interfaces that implement the foundation
for supporting Java-CORBA integration.
The org.omg.CORBA.ContainedPackage Package
The org.omg.CORBA.ContainedPackage package contains a single class, Description, that describes
the type and value of a contained object.
The org.omg.CORBA.ContainerPackage Package
The org.omg.CORBA.ContainerPackage package contains a single class, Description, that describes
the type, value, and object of a contained in the container object.
The org.omg.CORBA.InterfaceDefPackage Package
The org.omg.CORBA.InterfaceDefPackage package contains a single class,
FullInterfacedescription, that describes an interface definition.
The org.omg.CORBA.ORBPackage Package
The org.omg.CORBA.ORBPackage package defines the InvalidName exception, which is raised
when an invalid name is passed to an object request broker.
The org.omg.CORBA.TypeCodePackage Package
The org.omg.CORBA.TypeCodePackage package defines the BadKind and Bounds exceptions,
which are used to signal exceptions related to type usage and constraints.
The org.omg.CORBA.portable Package
The org.omg.CORBA.portable package consists of five classes and three interfaces that are used to
support vendor-specific CORBA implementations.
The org.omg.CosNaming Package
The org.omg.CosNaming package consists of 20 classes and two interfaces that implement a treestructured naming service.
The org.omg.CosNaming.NamingContextPackage Package
The org.omg.CosNaming.NamingContextPackage package consists of 13 classes that implement
aspects of the naming service's name context. The name context implements nodes within the treestructured naming scheme.
Standard Extensions
The Servlet API is a Standard Extension API, which provides the capability to perform server-side
programming with Java. Java Servlets are used to replace Common Gateway Interface programs on
Web servers. They can also be used to implement other, non-Web services. The Servlet API consists
of the javax.servlet and javax.servlet.http packages. The javax.servlet package consists of three
classes and six interfaces that allow Servlets to communicate with clients, process client requests, and
send return responses to these requests. The javax.servlet.http package contains four classes and five
interfaces that support the Hypertext Transfer Protocol (HTTP). Chapters 47, "Sun's Java Web
Server," and Chapter 48, "Programming Other Servers," cover the Servlets API.
Other APIs
In addition to the Core and Standard Extension API packages covered in the previous sections,
JavaSoft is currently developing other APIs that support other programming needs. Many of the APIs
will become incorporated into future versions of the JDK as Core API or Standard Extension API
packages. The new APIs covered in this book are described in the following subsections.
Java 3D
The Java 3D API provides the capability to create three-dimensional graphics applets and
applications. It consists of classes and interfaces that support 3D objects and transformations. The
Java 3D API is covered in Chapter 20.
The Java Media Framework
The Java Media Framework provides support for playing audio, video, and other multimedia within
Java applets and applications. It supports a wide range of audio and video formats and provides
animation capabilities. The Java Media Framework is covered in Chapter 21, "Using Audio and
Video."
The Speech API
The Speech API adds speech recognition and synthesis capabilities to Java. The Speech API is
covered in Chapter 23, "Integrating Speech and Telephony Capabilities."
The Telephony API
The Telephony API provides the capability to develop telephony applications, such as call center
applications. The Telephony API is covered in Chapter 23.
JavaMail
JavaMail provides a set of classes and interfaces for developing client and server components of
email systems. JavaMail is covered in Chapter 34, "Using JavaMail."
Java Naming and Directory Services
The Java Naming and Directory Interface (JNDI) allows Java applets and applications to access
naming and directory services using protocols such as the Lightweight Directory Access Protocol
(LDAP). The JNDI API is covered in Chapter 35, "Naming and Directory Services."
The Java Management API
The Java Management API provides a Java-based framework for managing enterprise networks and
network resources. It is covered in Chapter 36, "Working with the Java Management API."
JavaSpaces
JavaSpaces supports the development of distributed applications by providing persistent distributed
object capabilities. It is covered in Chapter 40, "Using Object Serialization and JavaSpaces."
JavaCommerce
The JavaCommerce API provides the capability to build electronic commerce applications in Java. It
is covered in Chapter 50, "Java Commerce and JavaCard."
Summary
This chapter examined the JDK 1.2 API in close detail. It provided an overview of the API packages
and identified the packages that have been added since JDK 1.1. It described all of the packages of
JDK 1.2, highlighting important classes and interfaces. The next chapter will focus on Java security
and the new extendible security model that is supported by JDK 1.2.
© Copyright 1998, Macmillan Publishing. All rights reserved.
Java 1.2 Unleashed
-3The Extended Java Security Model
●
●
●
●
●
●
●
Configurable Security Policy
❍ The Evolution of the Sandbox
❍ Specifying a Security Policy
❍ The Contents of the Security Policy File
❍ The Syntax of Grant Entries
❍ An Example Security Policy
Policy Permissions
❍ The java.awt.AWTPermission Class
❍ The java.net.NetPermission Class
❍ The java.util.PropertyPermission Class
❍ The java.lang.reflect.ReflectPermission Class
❍ The java.lang.RuntimePermission Class
❍ The java.security.SecurityPermission Class
❍ The java.io.SerializablePermission Class
❍ The java.io.FilePermission Class
Extending the Sandbox
Application Security
Cryptographic Support
❍ Overview of Cryptography
❍ The JDK 1.2 Cryptographic Architecture
Using Certificates
Summary
One of the most appealing features of Java in its debut as a Web programming language was the
comprehensive security built into the Java runtime environment. The Java sandbox provided a
mechanism for untrusted code to be downloaded from the Web and executed in a secure manner. The
sandboxes of JDK 1.0 and 1.1 had some holes, but Sun encouraged the Internet community to find
those holes and then quickly fixed them. The security model implemented by the Java sandbox has
been strengthened and at the same time made more flexible from JDK 1.0 to JDK 1.2. In addition,
JDK 1.2 provides a number of security mechanisms that can be used within the sandbox.
In this chapter you'll study the new security features of JDK 1.2 that can be used to secure Java
applets and applications. You'll learn how to specify the security policy for your Java installation and
how to use permissions to implement fine-grain access controls that extend the capabilities permitted
to certain applets. You'll learn about the use of digital certificates and the cryptographic architecture
supported by the JDK 1.2 Security API. When you finish this chapter, you'll understand how to use
the security features of JDK 1.2 to enhance the security and functionality of your applets and
applications.
Configurable Security Policy
One of the most powerful security features introduced in JDK 1.2 is the capability to specify a
security policy for applets and applications. This feature gives software developers a great deal of
flexibility in the functionality that they can incorporate into their applets and applications. At the
same time, it provides users with total control over the access they allow to these programs. The
configurable security policy of JDK 1.2 allows Java software developers to provide the capabilities
their users want, and enables users to limit those capabilities based on their degree of trust in the
source of the Java software they execute.
The Evolution of the Sandbox
To understand how the configurable security policy works and why it is useful, it is helpful to trace
the evolution of Java security. JDK 1.0 introduced the "sandbox" approach to applet security. In this
approach, all standalone Java applications are trusted by default and are allowed unrestricted access
to your system resources (file system, network, and other programs). Applets that are loaded over the
network are, by default, untrusted and prevented from accessing your local file system and other
programs. In addition, applets are only allowed to make network connections to the host from which
they are loaded.
The objective of the JDK 1.0 sandbox is to protect users from malicious applets that are downloaded
from the Web. With the exception of a few security holes (which were subsequently corrected), the
JDK 1.0 sandbox met this objective. However, in blocking potentially hostile applet accesses, the 1.0
sandbox also removed useful applet capabilities. Figure 3.1 summarizes the operation of the JDK 1.0
sandbox.
FIGURE 3.1. The JDK 1.0 sandbox.
In addition to extending the sandbox for signed applets, JDK 1.0 also allows the SecurityManager
class to be subclassed to implement a custom security policy for standalone Java applications, such as
those that load applets. If SecurityManager is overridden, the capabilities of standalone applications
can be restricted. However, the capability to implement a custom SecurityManager is provided for
software developers but not users. If a user runs a standalone Java application, it is executed with
unrestricted privileges unless the application polices itself.
For an example of the security provided by the JDK 1.0 sandbox, consider the applet shown in
Listing 3.1. This applet reads the file specified in an applet's fileName parameter and displays the
file's contents in a TextArea object. (If a security exception occurs, it is displayed in the TextArea
object instead.) When you view the applet using Microsoft Internet Explorer 4.0, you receive the
security exception shown in Figure 3.2. The applet in Listing 3.1 and the HTML file (used to access
the applet) in Listing 3.2 can be accessed on my Web server at http://www.jaworski.com/ju/
ReadFileApplet.htm. You can also set the applet up on your Web server using the files contained in
the \ju\ch03 directory of this book's CD-ROM.
FIGURE 3.2. A security exception is thrown when an applet tries to go outside of the sandbox.
LISTING 3.1. THE ReadFileApplet.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
public class ReadFileApplet extends Applet {
TextArea text = new TextArea();
Button goButton = new Button("Read Local File");
Panel panel = new Panel();
String fileName = "";
public void init() {
fileName = getParameter("fileName");
setLayout(new BorderLayout());
goButton.addActionListener(new ButtonHandler());
panel.add(goButton);
add("North",panel);
add("Center",text);
}
class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent e){
String s = e.getActionCommand();
if("Read Local File".equals(s)){
try {
FileInputStream inStream = new FileInputStream(fileName);
int inBytes = inStream.available();
byte inBuf[] = new byte[inBytes];
int bytesRead = inStream.read(inBuf,0,inBytes);
text.setText(new String(inBuf));
}catch(Exception ex){
text.setText(ex.toString());
}
}
}
}
}
LISTING 3.2. THE ReadFileApplet.htm FILE.
<HTML>
<HEAD>
<TITLE>An Applet that reads local files</TITLE>
</HEAD>
<BODY>
<H1>An Applet that reads local files.</H1>
<APPLET CODE="ReadFileApplet.class" HEIGHT=300 WIDTH=600>
<PARAM NAME="fileName" VALUE="C:\AUTOEXEC.BAT">
Text displayed by browsers that are not Java-enabled.
</APPLET>
</BODY>
</HTML>
The JDK 1.1 sandbox is designed to maintain the security of the JDK 1.0 approach while allowing
certain applets to be designated as trusted. Trusted applets are allowed to perform accesses that
exceed the bounds of the sandbox. The Security API of JDK 1.1 provides the capability to digitally
sign an applet and then verify that signature before an applet is loaded and executed. This capability
enables browsers to authenticate that an applet is signed by a trusted party and that it has not been
modified since the time of its signature. Given this additional level of security assurance, signed
applets are considered to be as trustworthy as (or more than) standalone application programs. Figure
3.3 shows how the JDK 1.1 sandbox extends the JDK 1.0 sandbox.
FIGURE 3.3. The JDK 1.1 security approach.
When I configure Internet Explorer 4.0 to trust www.jaworski.com and to allow applets from trusted
hosts to access local files, I can execute the ReadFileApplet in Listing 3.1 and have it read, as well as
display the contents of my AUTOEXEC.BAT file, as shown in Figure 3.4.
FIGURE 3.4. JDK 1.1 security allows trusted applets to go outside of the sandbox.
The JDK 1.1 security approach is a significant improvement on the JDK 1.0 approach because it
allows applet designers to add useful capabilities like reading from and writing to the local file
system, launching programs, and advanced networking. The shortcomings of the JDK 1.1 sandbox
stem from its bipolar approach to security--an applet is either untrusted and confined to the sandbox,
or it is trusted and given unrestricted access outside the sandbox. Applications are always trusted and
given unrestricted access.
The problem with the JDK 1.1 approach is that it violates the security principle of least privilege.
This principle states that an application should be given only those privileges that it needs to carry out
its function and no more. According to least privilege, trusted applets and applications should be
limited in the privileges they are allowed. For example, now that Internet Explorer 4.0 is reconfigured
to run the ReadFileApplet, it will allow all applets from www.jaworski.com full access to my local
file system. If Internet Explorer 4.0 implemented least privilege, I would be able to select the applets
from www.jaworski.com that would have the privilege of accessing my local files.
JDK 1.2 introduces a security architecture for implementing least privilege. This architecture is based
on the capability to specify a security policy that determines what accesses an applet or application is
allowed, based on its source and on the identities of those who have signed the applet on application
code.
The security policy feature of JDK 1.2 allows you to specify the following types of policies easily
and without programming:
●
●
●
●
Grant all applets from http://www.trusted.com/ permission to read files in the C:\tmp
directory.
Grant all applets (from any host) permission to listen on TCP ports greater than 1023.
Grant all applets signed by Mary and Ted (hypothetical Java programmers) that are from http://
www.trusted.com permission to read and write to files in the C:\tmp directory.
Grant all applications loaded from the C:\trusted directory permission to set security
properties.
The next section shows how to specify the details of a particular security policy. Figure 3.5 shows
how JDK 1.2 extends the JDK 1.0 and 1.1 sandboxes using a configurable security policy.
FIGURE 3.5. The JDK 1.2 configurable security policy.
NOTE: To restrict the capabilities of a Java application, you must run it under a
SecureClassLoader, as described in the section "Application Security" later in this
chapter.
Specifying a Security Policy
Specifying a custom security policy is easy to do. All you have to do is edit the appropriate policy
configuration file. JDK 1.2 provides you with a number of ways to do this:
●
●
●
●
●
●
You can create or edit the default system policy file located at <java.home>\lib\ security\java.
policy, where <java.home> identifies the location of your JDK 1.2 installation. It is specified
by the value of the java.home system property. By default, java.home is C:\jdk1.2. If you edit
java.policy, the new policy will apply to all users of your JDK 1.2 installation.
You can set the value of the policy.java system property to the name of an alternative security
policy file.
You can create or edit the user policy file located at <user.home>\.java.policy, where <user.
home> identifies the current user's home directory. It is specified by the value of the user.
home system property.
You can set the value of the java.security.policy property to a different user security policy file
using the -D command-line option. For example, suppose that you want to run the Test class
using the test.policy user security policy file. You could use the -D option as follows:
java -Djava.security.policy=="test.policy" Test
You can also use the -Djava.security.manager option to ensure that the policy is installed. The
double equal sign specifies that the policy should be the only policy that is in effect. A single
equal sign specifies that the policy is added to the current policy that is in effect.
You can change the class used to implement the security policy from java. security.PolicyFile
to another class by editing the java.security file located at <java.home>\lib\security\java.
security. Change the line policy.provider=java.security.PolicyFile to policy.
provider=OtherClass, where OtherClass is the fully qualified name of the class to be used.
When the Java byte code interpreter is run, it loads in the system policy followed by the user policy.
If neither of these policies is available, the original sandbox policy is used.
You can also use the -Djava.security.manager option to ensure that the policy is installed. The double
equal sign specifies that the policy should be the only policy that is in effect. A single equal sign
specifies that the policy is added to the current policy that is in effect.
The Contents of the Security Policy File
The policy file (system or user) consists of a series of statements, referred to as grant entries, that
identify the permissions granted to code (applet or application) based on the location from which it is
loaded and any signers of the code.
NOTE: In JDK 1.2, all code, whether it is an applet that is loaded from a remote host
or an application from the local file system, is associated with a code source. This code
source is defined by the URL from which the code is loaded and a list of signers of the
code. These signers are identified by the names associated with the signer's public
keys. These names are referred to as aliases. The aliases and keys are stored in a user's
keystore, as shown in Figure 3.6.
FIGURE 3.6. The keystore stores aliases, keys, certificates, and other information about entities.
A keystore is a repository for the aliases, certificates, public keys, and other information about the
entities (organizations and individuals) that are recognized by a user. A user's keystore resides in the .
keystore file located in the user's home directory. The .keystore file is generated and maintained using
JDK 1.2's keytool program. On Windows systems, the user's home directory is defined by the user.
home property. If the HOMEDRIVE and HOMEPATH environment variables are defined, user.home
is the concatenation of HOMEDRIVE and HOMEPATH. Otherwise, the value of user.home is the
same as java.home.
NOTE: You'll learn more about the keytool in Chapter 8, "Applet Security."
The grant entries of the security policy identify a code source (URL and list of signers), followed by
the permissions granted to that code source. The permissions (also referred to as permission entries)
specify the actions that a code source may take with respect to a protected resource. If all this seems
too abstract, hang in there. After we cover the syntax of grant entries and provide a few examples, the
process of setting up a security policy will appear quite simple.
The Syntax of Grant Entries
Grant entries begin with the keyword grant, followed by optional SignedBy or CodeBase clauses,
followed by an opening bracket ({), followed by a list of permission entries, followed by a closing
bracket (}) and a semicolon. The syntax of a grant entry follows:
grant [SignedBy "signer_names"] [, CodeBase "URL"] {
permission entries
};
The SignedBy clause contains a comma-separated list of the aliases of the signers of the code to
which the grant entry applies. If the code has not been signed or the signers don't factor into the
policy, the SignedBy clause may be omitted. Examples of SignedBy clauses follow:
SignedBy "Bill"
SignedBy "Bill,Ted"
SignedBy "Bill,Ted,Alice"
The aliases are not case sensitive. For example, "Bill" and "bill" are equivalent.
The CodeBase clause identifies the URL of the location from which the code is loaded. Examples
follow:
CodeBase "http://www.trusted.com"
CodeBase "http://www.trusted.com/omega/version5/"
CodeBase "file:/local/applets/"
The first example specifies that the grant entry applies to all code that is loaded from www.trusted.
com. The second example specifies that the grant entry applies to all code that is loaded from /omega/
version5/ (and all subdirectories) of www.trusted.com. The third example specifies that the grant
entry applies to all code that is loaded from the \local\applets directory (and all subdirectories) of the
local file system.
If the CodeBase clause is omitted, the grant entry applies to all code locations. Note that syntactically
the CodeBase clause may appear before the SignedBy clause. If both clauses are present, they are
separated by a comma.
Permission Entries
Each grant entry specifies one or more permission entries to define the permissions that are granted to
the code source described by the SignedBy and CodeBase clauses. A permission entry consists of the
keyword permission, followed by the fully qualified name of a Java permission class, followed by an
optional target name, action list, and SignedBy clause. The syntax of a permission entry is as follows:
permission permission_class_name [ "target_name" ]
[, "action_list"] [, SignedBy "signer_names"];
The permission class name identifies the permission to be granted. It is the fully qualified name of the
Java class that implements the permission. Examples of permission class names follow:
java.io.FilePermission
java.net.SocketPermission
java.util.PropertyPermission
The java.io.FilePermission class is used to control the accesses that code may make of the local file
system. The java.net.SocketPermission class is used to control the ways in which code may access
TCP/IP sockets. The java.util.PropertyPermission class is used to control the ways in which code may
access Java properties.
TIP: The implementation of permissions in terms of permission classes is covered in
the section "Policy Permissions" later in this chapter. When reading it, just try to get a
feel for what permissions are and how they are used to specify a security policy.
Two important characteristics of a permission are its target and its action list. The target identifies the
resource or service to which access is being granted. For example, the target of java.io.FilePermission
is the name of the file or directory to which access is being granted. The target of java.util.
PropertyPermission is the property to which access is being granted.
The action list identifies the actions that the code source is permitted to make on the target. For
example, actions related to java.io.FilePermission include read, write, delete, and execute. Actions
related to java.net.SocketPermission include accept, connect, listen, and resolve. The action list is a
comma-separated list of actions enclosed in quotation marks. Some permissions, such as java.
RuntimePermission, are service-related and do not have actions. In these cases, the action list may be
omitted.
NOTE: A complete list of the predefined permissions, targets, and actions is provided
in the section "Policy Permissions" later in this chapter.
The last element of a permission entry is an optional SignedBy clause. Any SignedBy clause that is
included with a permission entry indicates a signed permission entry. This means that the permission
class itself must be signed by everyone in the specified signer list or must be a class that is found on
the CLASSPATH. For example, the following permission entry requires the code for com.jaworski.
DevicePermission.class to be signed by jamie or to be accessible from the CLASSPATH.
permission com.jaworski.DevicePermission "transmitter", "send,
receive", SignedBy "jamie";
In this example, the com.jaworski.DevicePermission class has "transmitter" as its target and "send"
and "receive" as the permitted actions.
An Example Security Policy
Having covered the syntax of the security policy file, in this section I'll create an example policy and
go through it on a line-by-line basis, explaining what its grant and permission entries mean and what
the resultant policy permits and restricts. After that, I'll list and explain the java.policy file that is the
default for JDK 1.2.
Listing 3.3 shows the example.policy file. It contains four grant entries. The first grant entry specifies
the CodeBase as the URL http://www.trusted.com/verified/. This indicates that the grant entry applies
to code that is loaded from that URL. Because there is no SignedBy clause, the grant entry applies to
all code from this URL. The grant entry contains a single permission entry. This permission entry
grants permission for the code to open up a client TCP socket to the host other.trusted.com on port 23
(the Telnet port).
The second grant entry specifies the CodeBase as the URL http://jaworski.com and the signer list as
jason and emily. This indicates that the grant entry applies to all code that is loaded from jaworski.
com that is signed by both Jason and Emily. The grant entry contains three permission entries. The
first permission entry grants the code source permission to read, write, and delete all files and
directories in the local file system. The "-" target indicates all files in the file system. The second
permission entry grants the code source permission to read and write all Java properties. The "*"
target indicates all properties. The third permission entry grants the code source permission to print to
the local print queue.
The third grant entry has a CodeBase corresponding to all code that is loaded from the \local\trusted
path of the local file system. There are no code signers. The grant entry has a single permission entry
that grants the code source permission to create its own class loader.
The last grant entry does not specify a CodeBase or a signer list. This means that the grant entry
applies to all code, no matter where it is loaded from or who signs it. The grant entry contains a
single permission entry. This entry grants the code source permission to read the java.version
property.
NOTE: You can use Java-style comments in a security policy configuration file.
LISTING 3.3. THE example.java POLICY FILE.
// example.java
/* Grant all code that is from the /verified path of www.trusted.com
permission to create a TCP socket and connect it to other.
trusted.com
on port 23.
*/
grant CodeBase "http://www.trusted.com/verified/" {
permission java.net.SocketPermission "other.trusted.com:23",
"connect";
};
/* Grant all code from jaworski.com that is signed by Emily and
Jason the
following permissions:
1. Permission to read, write, delete, or execute any file
in the local file system.
2. Permission to read or write any property.
3. Permission to send a print job to the local print queue.
*/
grant CodeBase "http://jaworski.com", SignedBy "jason,emily" {
permission java.io.FilePermission "-", "read,write,delete,
execute";
permission java.util.PropertyPermission "*", "read,write";
permission java.lang.RuntimePermission "queueJob";
};
/* Grant all code from the /local/trusted path of the local file
system
permission to create its own class loader.
*/
grant CodeBase "file:/local/trusted" {
permission java.lang.RuntimePermission "createClassLoader";
};
/* Grant all code from any location, signed or not, permission to
read
the java.version property.
*/
grant {
permission java.util.PropertyPermission "java.version", "read";
};
Listing 3.4 shows the default java.policy file that comes with JDK 1.2. This file is located in the
\jdk1.2\lib\security directory and contains a single grant entry. This grant entry does not specify a
CodeBase or a list of signers. This means that the grant entry applies to all code. The grant entry
contains 11 permission entries. The first permission entry grants permission for code to listen on TCP
or UDP sockets on ports 1024 and higher. The target "localhost:1024-" identifies the host on which
the code executes (using localhost) and ports 1024 and higher (using 1024-).
Permission entries 2 through 11 are similar. They grant permission to read the properties java.version
through line.separator.
LISTING 3.4. THE DEFAULT java.policy FILE.
grant {
// allows anyone to listen on un-privileged ports
permission java.net.SocketPermission "localhost:1024-",
"listen";
// "standard" properties that can be read by anyone
permission java.util.PropertyPermission "java.version", "read";
permission java.util.PropertyPermission "java.vendor", "read";
permission java.util.PropertyPermission "java.vendor.url",
"read";
permission java.util.PropertyPermission "java.class.version",
"read";
permission java.util.PropertyPermission "os.name", "read";
permission java.util.PropertyPermission "os.version", "read";
permission
permission
"read";
permission
"read";
permission
"read";
};
java.util.PropertyPermission "os.arch", "read";
java.util.PropertyPermission "file.separator",
java.util.PropertyPermission "path.separator",
java.util.PropertyPermission "line.separator",
Policy Permissions
Security policy is implemented by the java.security.Permission classes and their subclasses. The
permissions classes are used to specify that permission has been granted to specific system services
and resources. Most subclasses of java.security.Permission, such as java.net.SocketPermission and
java.io.FilePermission, are defined in the packages that provide the services and resources being
protected. The Permission class hierarchy is shown in Figure 3.7.
FIGURE 3.7. The Permission class hierarchy.
The java.security.Permisson class is subclassed by java.security. BasicPermission, java.io.
FilePermission, and java.net.SocketPermission. The java.security.BasicPermission class provides a
common subclass that implements permissions specifying targets that are named with the hierarchical
naming convention used by properties and fully qualified class names. This naming convention
separates naming levels using periods, as in level1name.level2name.level3name.
The java.security.BasicPermission class has seven subclasses that are identified in Figure 3.7. These
seven classes, and the java.io.FilePermission and java.net.SocketPermission classes, are covered in
the following subsections.
The java.security.AllPermission class defines a permission that implies all other permissions. This
permission should be used only with extreme care.
The java.awt.AWTPermission Class
The java.awt.AWTPermission class is used to control access to AWT resources. This class defines
the following three targets:
●
accessEventQueue--Grants permission to access the system event queue.
●
accessClipboard--Grants permission to the system clipboard.
●
showWindowWithoutWarningBanner--Grants an applet permission to create a window
without a warning banner.
None of these targets requires an action to be specified.
The java.net.NetPermission Class
The java.net.NetPermission class is used to control access to network resources and defines the
following targets:
●
●
requestPasswordAuthentication--Grants permission to ask the registered authenticator for a
password.
setDefaultAuthenticator--Grants permission to set the authenticator to be used with
networking code, such as in HTTP authentication.
Neither of these targets requires an action to be specified.
The java.util.PropertyPermission Class
The java.util.PropertyPermission class is used to control access to system properties. The target of
this permission is a system property. The wildcard "*" is used to specify all properties. A wildcard
character may also appear at the end of a hierarchical property name following the last period. For
example, "java.*" specifies all properties beginning with "java.". The read and write actions may be
specified with the target property.
The java.lang.reflect.ReflectPermission Class
The java.lang.reflect.ReflectPermission class is used to circumvent the access checks performed on
reflected objects. It allows all members of an object to be accessed, no matter what access is specified
via the public, protected, and private keywords. Only the "suppressAccessChecks" target is defined
for this permission. No actions may be specified. Reflection is covered in Chapter 10, "Writing
Console Applications."
The java.lang.RuntimePermission Class
The java.lang.RuntimePermission class is used to control access to services of the Java runtime
environment. It defines the following targets:
●
createClassLoader--Grants permission to create a class loader.
●
getClassLoader--Grants permission to retrieve a class loader.
●
setContextClassLoader--Grants permission to set the context class loader of a thread.
●
setSecurityManager--Grants permission to change the current security manager.
●
createSecurityManager--Grants permission to create a new security manager.
●
exitvm--Grants permission to exit the runtime system.
●
setFactory--Grants permission to set the socket factory, URL stream handler factory, content
handler factory, and other aspects of how networking is implemented.
●
setIO--Grants permission to set/reset the standard input, output, and error streams.
●
modifyThread--Grants permission to alter a thread's execution.
●
stopThread--Grants permission to stop a thread's execution.
●
modifyThreadGroup--Grants permission to alter a thread group.
●
getProtectedDomain--Grants permission to retrieve the protected domain of a class.
●
readFileDescriptor--Grants permission to create an input stream using a file descriptor.
●
writeFileDescriptor--Grants permission to create an output stream using a file descriptor.
●
●
●
loadLibrary--Grants permission to load a dynamic link library. The name of the library is
appended to "loadLibrary.".
accessClassInPackage--Grants permission to load a class from a specified package. The name
of the package is appended to "accessClassInPackage".
defineClassInPackage--Grants permission to define a class as part of the specified package.
The name of the package is appended to "defineClassInPackage".
●
queuePrintJob--Grants permission to initiate a print job.
●
accessDeclaredMembers--Grants permission to access the members of a class.
None of these targets requires actions to be specified.
The java.security.SecurityPermission Class
This class is used to grant a variety of security-related permissions. These permissions are specified
as hierarchical target names:
●
addIdentityCertificate--Grants permission to add certificates for Identity objects.
●
removeIdentityCertificate--Grants permission to remove certificates for Identity objects.
●
setIdentityPublicKey--Grants permission to set the public key of Identity objects.
●
setIdentityInfo--Grants permission to set information related to Identity objects.
●
setSystemScope--Grants permission to set the system's identity scope.
●
getPolicy--Grants permission to get the installed Policy object.
●
setPolicy--Grants permission to set the installed Policy object.
●
●
●
●
●
●
●
clearProviderProperties--Grants permission to clear the properties of a specified security
provider. The provider name is appended to "clearProviderProperties".
putProviderProperty--Grants permission to set the property of a security provider. The
property name is appended to "putProviderProperty".
removeProviderProperty--Grants permission to remove a specified property from a security
provider. The property name is appended to "removeProviderProperty".
insertProvider--Grants permission to insert a specified security provider in the list of available
providers. The provider name is appended to "insertProvider.".
removeProvider--Grants permission to remove a specified security provider. The provider
name is appended to "removeProvider.".
getProperty--Grants permission to retrieve a specific security property. The property is
appended to "get Property."
setProperty--Grants permission to set a specific security property. The property is appended to
"setProperty.".
●
setSignerKeyPair--Grants permission to set the public and private key pairs for a signer.
●
getPrivateKey--Grants permission to retrieve the public key of a signer.
None of these targets requires actions to be specified.
The java.io.SerializablePermission Class
This class is used to grant permission to use serialization. The enableSubstitution permission grants
permission for objects in object input and output streams to be replaced. The
enableSubclassImplementation permission allows subclasses of ObjectInputStream and
ObjectOutputStream to override an object's serialization property.
The java.io.FilePermission Class
The java.io.FilePermission class is an important class in that it is used to grant permission for file and
directory operations. The targets for this permission are file and directory names. The "-" target is
used to specify all files in the file system. The target "directory/-" is used to specify all files in the file
system that are in directory or its subdirectories. The target "directory/*" is used to specify all files in
the file system that are in directory but not its subdirectories.
The actions that can be specified are read, write, delete, and execute. The read, write, and delete
actions apply to files and directories. The execute action applies to executable files and operating
system commands.
THE JAVA.NET.SOCKETPERMISSION CLASS
The java.net.SocketPermission class is used to grant permission to TCP/IP socket programming. The
targets of this permission are of the form "host" or "host:port_range", where host can be specified as
one of the following:
●
host name
●
IP address
●
*.domain (All hosts in a domain or subdomain)
* (All hosts)
The port range can be specified using the following notation (where n and m represent port numbers):
●
n (A single port)
●
n- (All ports greater than or equal to n)
●
-n (All ports less than or equal to n)
●
n-m (All ports between n and m inclusive)
The actions that are defined for this permission are as follows:
●
accept--Permits socket connections to be accepted from remote hosts.
●
connect--Permits TCP, UDP, and multicast socket connections to remote hosts.
●
listen--Permits listening on TCP, UDP, and multicast sockets on the local host.
●
resolve--Allows DNS lookups to be performed.
TCP/IP network programming is covered in Part 8.
Extending the Sandbox
Having covered the development of a security policy in detail, let's put it all together and show how
the security capabilities of an applet can be extended by adding permissions to the JDK security
policy. Listing 3.5 contains the source code of the ExtendedApplet applet. This applet attempts to
read the user.name system property, which is forbidden by the default JDK 1.2 security policy. The
user.name property contains the current user's login name. The file extended.htm, shown in Listing
3.6, is an HTML file that is used to access ExtendedApplet.
LISTING 3.5. THE ExtendedApplet SOURCE CODE.
import java.applet.*;
import java.awt.*;
import java.util.*;
public class ExtendedApplet extends Applet {
String text;
int x = 30;
int y = 120;
public void init() {
try {
text=System.getProperty("user.name");
}catch(Exception ex){
text=ex.toString();
}
}
public void paint(Graphics g) {
g.setFont(new Font("TimesRoman",Font.BOLD,12));
g.drawString(text,x,y);
}
}
LISTING 3.6.THE extended.htm HTML FILE.
<HTML>
<HEAD>
<TITLE>Extended Applet</TITLE>
</HEAD>
<BODY>
<H1>An Applet that reads the user.name property.</H1>
<APPLET CODE="ExtendedApplet.class" HEIGHT=300 WIDTH=600>
Text displayed by browsers that are not Java-enabled.
</APPLET>
</BODY>
</HTML>
NOTE: An introduction to applets and HTML is provided in Chapter 5, "JDK 1.2
Applet Writing Basics."
I've compiled ExtendedApplet.java and put the ExtendedApplet.class and extended.htm files on my
Web server in the http://www.jaworski.com/ju/ path. You can run ExtendedApplet by opening the
URL http://www.jaworski.com/ju/extended.htm with the appletviewer:
appletviewer http://www.jaworski.com/ju/extended.htm
Run appletviewer from a directory other than your ch03 directory to make sure that ExtendedApplet.
class is loaded from my Web server and not your local file system. When you run appletviewer, the
applet should display the exception shown in Figure 3.8.
FIGURE 3.8. The ExtendedApplet generates an AccessControlException.
NOTE: If you use appletviewer to view ExtendedApplet from your local file system,
appletviewer will not throw the access control exception.
Now, let's extend the capabilities of applets by adding the following permission to your java.policy
file.
permission java.util.PropertyPermission "user.name", "read";
This file should be located in the C:\jdk1.2\lib\security directory. Modify the file as shown in Listing
3.7.
LISTING 3.7. THE MODIFIED java.policy FILE.
grant {
// allows anyone to listen on un-privileged ports
permission java.net.SocketPermission "localhost:1024-",
"listen";
// "standard" properties that can be read by anyone
permission
permission
permission
"read";
permission
"read";
permission
permission
permission
permission
"read";
permission
"read";
permission
"read";
permission
};
java.util.PropertyPermission "java.version", "read";
java.util.PropertyPermission "java.vendor", "read";
java.util.PropertyPermission "java.vendor.url",
java.util.PropertyPermission "java.class.version",
java.util.PropertyPermission
java.util.PropertyPermission
java.util.PropertyPermission
java.util.PropertyPermission
"os.name", "read";
"os.version", "read";
"os.arch", "read";
"file.separator",
java.util.PropertyPermission "path.separator",
java.util.PropertyPermission "line.separator",
java.util.PropertyPermission "user.name", "read";
Now that you've added the permission for all code to access the user.name property, rerun
appletviewer http://www.jaworski.com/ju/extended.htm. The applet should now display your login
name, as shown in Figure 3.9. Note that Figure 3.9 displays my login name, not yours. I suggest that
you edit java.policy one more time to remove the permission to read the user.name property.
FIGURE 3.9. The ExtendedApplet displays my login name.
Application Security
The previous section shows how to configure your security policy to give additional privileges to
applets. You can also require applications to be governed by your security policy. In order to do this,
you must run the applications under a SecureClassLoader. Normally, all classes that are loaded from
the CLASSPATH are treated as system classes, are trusted, and not subject to the security policy.
These classes are loaded with a null system ClassLoader.
JDK 1.2 allows local classes to be loaded from a second class path that is specified by the system
property java.app.class.path. If you specify the second class path when you invoke the java
interpreter, you can load an application using a SecureClassLoader that will require the application to
abide by the security policy. For example, the following command loads MyApplication from the C:
\untrusted directory using a SecureClassLoader object:
java -Djava.app.class.path="/untrusted" MyApplication
The SecureClassLoader object will ensure that MyApplication obeys the security policy that is in
effect.
Cryptographic Support
The JDK 1.1 expanded the security capabilities of JDK 1.02 to support application-level security.
This new security support is provided by the Security API of the java.security packages and includes
support for message digests, digital signatures, digital certificates, and key management. JDK 1.2
extended the capabilities provided by JDK 1.1 to include support for X.509 version 3 certificates and
added new tools for working with certificates. The Java Cryptography Extension (JCE) is a separate
add-on to the Security API that implements cryptographic algorithms that are subject to U.S. export
controls. The JCE is available at http://www.javasoft.com.
The application-level security controls provided by the Security API can be used to protect
information from unauthorized modification and disclosure as it traverses the Internet. They can also
be used to authenticate the contents of messages and files and the identities of applications and
individuals.
In this section you'll be introduced to the cryptographic capabilities provided by the Security API.
Don't worry if you are unfamiliar with the basics of cryptography--they will be summarized in the
next section.
NOTE: This section provides an overview of the cryptographic capabilities of the
Security API. Chapter 8, "Applet Security," investigates the java.security packages and
shows how to use the security-related tools of the JDK.
Overview of Cryptography
Cryptography is the study of algorithms and protocols for securing messages during transmission and
storage. However, cryptographic techniques can be applied to other applications, such as identity
verification and data authentication.
One of the most fundamental applications of cryptography is to disguise a message so that it can only
be read by those who know how to recover the original message content. Encryption is the process of
disguising a message, and decryption is the process of recovering the original message. An encrypted
message is referred to as ciphertext, and an unencrypted or decrypted message is referred to as
plaintext. Figure 3.10 provides an overview of these concepts.
FIGURE 3.10. \Encryption and decryption.
NOTE: Cryptographic techniques are oriented toward the protection of messages.
However, these techniques can be used to protect other forms of data, such as files,
database records, and Java byte codes.
Although a number of approaches to encryption have been developed over the years, most current
encryption algorithms are based on the use of secret keys. A key is a sequence of binary digits that are
used to encrypt or decrypt data. In key-based cryptography, the encryption and decryption algorithms
are publicly known. Data is encrypted using one key and decrypted using another. Figure 3.11
provides an overview of key-based encryption. It is important that the decryption key be kept secret,
or else anyone will be able to use it to decrypt messages.
FIGURE 3.11. Key-based encryption.
In some encryption algorithms, the encryption and decryption keys are the same, or the decryption
key can be calculated from the encryption key within a useful time frame. These algorithms are
known as secret-key algorithms or symmetric algorithms. Secret-key algorithms require the
encryption key to be kept secret and require the sender and receiver to coordinate on the use of their
secret keys. The Data Encryption Standard (DES) is an example of a secret-key algorithm.
Other encryption algorithms, known as public-key algorithms or asymmetric algorithms, are based on
the use of separate encryption and decryption keys. Public-key algorithms require that it be
computationally unfeasible to calculate the decryption key from the encryption key. Because of this
requirement, the encryption key can be made public without affecting the security of the encryption
algorithm. Figure 3.12 shows how public-key cryptography works.
FIGURE 3.12. Public key cryptography.
In public-key cryptosystems, each communicating entity (individual, organization, software program,
and so on) is assigned a public key and a private key. Entities encrypt messages using the public key
of the receiver. The receiver decrypts messages using his, her, or its private key. The public key
cannot be used to determine the private key, so it does not need to be kept secret and can be openly
published. Because of this feature and others, public-key encryption is very popular in open
communication environments, such as the Internet. The RSA encryption algorithm is an example of a
public-key algorithm.
Cryptographic techniques are not limited to preserving the secrecy of messages. They are also used to
maintain message integrity and to verify the authenticity of a message. One-way functions are used in
these applications. A one-way function is one that is easy to compute, but computationally unfeasible
to reverse. A real-life example of a one-way function is a shredding machine. It is easy to put a
document in a shredder and produce paper strips, but it is very difficult to reverse the process.
Message digest functions are also one-way functions. They compute values, referred to as message
digests or hash values, that are used as fingerprints for messages. Good message digest functions
have the following properties:
●
●
Given a particular message digest value, it is computationally unfeasible to compute a
message that will produce that value under the message digest function.
It is computationally unfeasible to find two messages that yield the same message digest value
under the message digest function.
Figure 3.13 illustrates the use of message digest functions. Note that there is nothing secret about a
message digest function--it is publicly available and uses no keys. The MD5 and MD4 algorithms are
examples of message digest algorithms.
FIGURE 3.13. Message digest functions.
A digital signature is a value that is computed from a message using a secret key. It indicates that the
person who holds the secret key has verified that the contents of the message are correct and
authentic. Digital signatures often use public-key encryption algorithms with a slight twist--a private
key is used for encryption, and a public key is used for decryption. This approach is often
implemented as follows:
Signature generation:
1. A message digest is computed.
2. The message digest is encrypted using the private key of a public/private key pair,
producing the message's digital signature.
Signature verification:
1. The signature is decrypted using the public key of a public/private key pair, producing a
message digest value.
2. The message digest value is compared with the message digest calculated from the original
message.
3. If both digest values match, the signature is authentic. Otherwise, either the signature or the
message has been tampered with.
The preceding approach to signature generation/verification has the following features of real-world
signatures, as well as other features that provide additional benefits:
●
●
●
Unforgeability--Because the signer uses his private key and the private key is secret, only he
can sign messages with that key.
Verifiability--Since the signer's public key is openly available, anyone with access to the
message and signature can verify that the message was signed by the signer and that neither
the message nor signature have been altered.
Single use--A signature is unique to a particular message. It is computationally unfeasible to
use a signature with another message.
●
●
Non-repudiation--After a signer has signed a message and the message and signature have
been sent to others, the signer cannot claim that he didn't sign the message. (Unless the signer
can prove that his private key was stolen.)
Sealing--A signed message is digitally sealed; it cannot be altered without inv alidating the
signature.
Figure 3.14 summarizes the mechanics of using digital signatures. An example of a digital signature
algorithm is the National Institute of Standards and Technology's (NIST) Digital Signature Algorithm
(DSA).
FIGURE 3.14. Digital signatures.
Digital certificates, based on digital signatures, are messages signed by a certification authority that
certify the value of an entity's public key. The X.509 certificates of the International Standards
Organization are a popular digital certificate format. Figure 3.15 illustrates the use of digital
certificates.
FIGURE 3.15. Digital certificates.
Central to the use of digital certificates is the notion of a certification authority (CA). A certification
authority is an entity that is trusted to verify that other entities are who they claim to be and that they
use a particular public key with a particular public-key encryption algorithm. To obtain a certificate
from a CA, you usually have to submit documentation that proves your identity or that of your
organization. For example, the certification process helps prevent unauthorized individuals from
setting up business on the Web using the identity of Microsoft or Bank of America.
In a large networking environment, such as the Internet, multiple levels of CAs may be required. In
this case a high-level CA, such as Verisign, Inc., the U.S. Post Office, or the National Security
Agency, may provide certificates for second-level CAs. These second-level CAs may then provide
certificates for other organizations. Individual companies may themselves act as a certification
authority for their employees. A hierarchical certification structure, like that shown in Figure 3.16, is
the result. Certification of an entity at the leaves and branches of this hierarchy depends on the
certification of entities at higher levels within the hierarchy. These hierarchical certification
relationships are referred to as certification chains.
FIGURE 3.16. Certification authorities form a tree-like hierarchy.
We'll study the use of digital certificates later in this chapter in the section "Using Certificates."
Before we do that, we'll look at how the JDK 1.2 cryptographic architecture supports the topics
discussed so far.
The JDK 1.2 Cryptographic Architecture
The Java Security API provides a flexible framework for implementing cryptographic functions and
other security controls. It contains the hooks for message digest and digital signature computation,
key generation and management, and certificate processing. It includes standard algorithms (such as
MD5 and DSA) that support these security functions, but leaves out encryption algorithms (due to the
restrictions of U.S. export controls). Instead of promoting a small set of cryptographic algorithms, the
Java Security API implements an approach where different cryptographic packages may be provided
by vendors and then be plugged in and installed within the common Security API framework.
Package Providers
The Provider class of java.security lays the foundation for using pluggable packages of cryptographic
algorithms that support common functions such as message digest computation, digital signing,
certificate processing, and key generation. The Provider class is a subclass of the Properties class of
java.util. It encapsulates the notion of a cryptographic provider in terms of a provider name, version
number, and information about the services provided by the provider.
The rationale for the Provider class is that it can be used to separate specific implementations of a
cryptographic function (such as Company A's implementation of MD5, Company B's implementation
of SHA-1, and Company C's implementation of MD5) from their provider-specific implementation.
For example, several DSA packages may be available--some faster than others, some approved by the
U.S. Department of Defense, and others supported by the Citizens Against Big Brother.
NOTE: The JDK 1.2 comes with a default provider, named "SUN", that includes an
implementation of the MD5 and SHA-1 message digest algorithms, the DSA, and a
DSA key generation capability.
The Security Class
The Security class provides a set of static methods that are used to manage providers. Providers are
ranked in order of preference, with the most preferred provider receiving a rank of 1 and less
preferred providers receiving a larger number. The methods of the Security class can be used to
install providers, adjust their preference ranking, and retrieve information about the providers that are
installed.
Cryptographic Engines
The Security API supports the notion of cryptographic engines. These engines are generic algorithm
types--such as message digest, digital signature, and key generation--that support common
cryptographic functions. The engines of the Security API include the MessageDigest, Signature,
KeyPairGenerator, KeyFactory AlgorithmParameters and AlgorithmParameterGenerator classes.
The MessageDigest class, as you would expect, supports the computation of a message digest. The
Signature class is an engine for calculating digital signatures based on provider-furnished digital
signature algorithms. The Signature class supports both the creation of a digital signature and the
verification of a digital signature.
The KeyPairGenerator class is an engine that provides a mechanism by which provider-furnished key
generation algorithms may be accessed. Unlike MessageDigest and Signature, key generation is
difficult to implement in an algorithm-independent manner. Because of this, KeyPairGenerator
supports both algorithm-independent and algorithm-specific key generation--the difference being in
the way that the algorithms are initialized. The KeyFactory class is used to translate algorithmspecific keys into objects that can be handled in a generic fashion.
The AlgorithmParameters class is used to manage the parameters of cryptographic algorithms, and
the AlgorithmParameterGenerator class is used to generate parameters for algorithms. Specific
implementations of the engine classes are provided by cryptographic package providers.
In addition to the engine classes described in the previous paragraphs, JDK 1.2 introduces the java.
security.cert package to support the processing of digital certificates. The Certificate class provides
an abstract class for managing certificates. It is extended by the X509Certificate, which supports
X.509 certificate processing. The X509Extension interface is provided to support the extensions of
X.509 version 3. The java.security.cert package also provides classes for working with revoked
certificates.
Using Certificates
X.509 identifies a particular format and content for digital certificates. This format has been
popularized by Netscape's Secure Sockets Layer (SSL), the Java Archive (JAR) file format, and
Privacy Enhanced Mail (PEM), as well as other emerging Internet security standards. X.509
certificates contain the following information:
●
The version of X.509 being used with the certificate (1, 2, or 3).
●
The entity's name and public key.
●
A range of dates for which the certificate is valid.
●
A serial number assigned by the CA.
●
The name of the CA.
●
A digital signature created by the CA.
The current version of X.509 is 3, although version 1 certificates are still in use. Version 3 added the
capability to add custom extensions to certificates, such as email and IP addresses.
With respect to Java, the primary use for digital certificates is to support code authentication, as
shown in Figure 3.17. Developers of Java code can digitally sign their code using their private keys.
Users of the code verify the developers' signatures using the developer's public keys. Developers use
digital certificates as a secure way to inform users of their public keys. Users manage developer
certificates, identities, and public keys using the keytool, and establish developer-specific policies
using the policytool.
FIGURE 3.17. Certificates are used to support code authentication.
NOTE: Chapter 8, "Applet Security," shows how to use the security-related tools of
JDK 1.2.
Summary
In this chapter you studied the new security features of JDK 1.2. You learned how to specify the
security policy for applets and applications and how to use permissions to implement fine-grain
access controls. You learned a little bit about cryptography, delved into the JDK 1.2 cryptographic
architecture, and covered the use of digital certificates. In the next chapter you'll explore the different
ways in which Java can be used to develop software applications.
© Copyright 1998, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
-4Overview of JDK 1.2 Programming
●
●
●
●
●
●
●
●
Applet Programming
Application Programming
JavaBeans Programming
Servlet Programming
Developing RMI Objects
Developing CORBA Objects
Other Possibilities
❍ Why Move to Java?
❍ Reasons Against Moving to Java
❍ Transition Approaches and Issues
❍ Translation Approaches and Issues
Summary
Although Java became popular as the programming language of the Web, it has evolved beyond that
to become a language for developing a wide range of software. For example, you can use Java to
write applets, window and console applications, beans, servlets, and distributed objects. Don't worry
if you're not familiar with these terms, because you'll learn about them in this chapter. You'll also
learn how to move your legacy C and C++ code to Java. When you finish this chapter, you'll have a
better understanding of which types of software you can develop with Java and how to convert your
existing software to Java-based applications.
Applet Programming
Java is most closely associated with applets. An applet is a Java program that is executed in the
context of a Web page. It's loaded and executed by any Java-capable Web browser that displays a
Web page referencing the applet.
Applets are referenced in Web pages using the Hypertext Markup Language (HTML) <APPLET>
tag. Chapter 5, "JDK 1.2 Applet Writing Basics," shows how to use this tag to include applets in Web
pages.
Applets consist of compiled Java code that is stored on a Web server, along with the Web pages from
which they are referenced. The applet code can be stored in the same directory as the Web pages or in
separate directories that are used to store only applets.
Applets can be used in a variety of ways. They can be used to create fancy Web page widgets, such
as animated advertisements, drop-down menus, or advanced forms. They can also be used to
implement complex Web-based applications, such as database front-ends, Web-based training
systems, and terminal emulators, and to bring entertainment to the Web by providing custom
multimedia players and, of course, a wide range of games. The major advantage of applets is that
they transform passive Web pages into programs that interact with Web users.
Applets are developed by creating subclasses of the Applet class of the java.applet package. You
create special methods that support applet initialization, the starting and stopping of an applet, and
applet termination. You also provide GUI controls in your applets and methods for handling GUI
events. The Applet class is covered in Chapter 5 in the section "The Applet Class."
The Java execution environments of Web browsers and the tools of the JDK provide a high level of
security, aimed at protecting Web users from malicious applets. As you learned in Chapter 3, "The
Extended Java Security Model," the security mechanisms provided by these execution environments
are modeled after a sandbox--applets are permitted unrestricted access within the sandbox, but are
blocked from making any accesses outside the sandbox. The extended security model, introduced
with JDK 1.2, provides a more flexible approach to permitting trusted applet access outside the
sandbox.
If your main interest in Java software development is applet programming, you're in luck. Part II of
this book, "Applet Programming," begins with the next chapter.
Application Programming
Most of the programs that we run on a day-to-day basis are standalone programs that we execute on
our PCs. With the advent of the Macintosh and Microsoft Windows, most of these programs are
window-based. Java is a great language for developing these window-based programs. The JDK
provides an extensive API for window program development. The Abstract Window Toolkit (AWT)
of the java.awt packages allows window programs to be developed in a platform-independent
manner. Once you develop a window program in Java, you can run it on Microsoft Windows (98, 95,
NT, and CE), Macintosh, UNIX, OS/2, and other windowing environments. This is an incredible
capability, considering the difficulty involved in porting non-Java window programs from one
windowing environment to another.
In addition to the powerful windowing capabilities provided by the AWT, JavaSoft has introduced
the Swing API with JDK 1.2. This API provides a broad range of advanced GUI controls, ranging
from spinners to multilevel list boxes. It also provides the capability to easily tailor the look and feel
of the overall GUI presented to the user. You'll learn how to develop Java window applications in
Part III, "Application Programming." You'll learn how to use the Swing API in Part IV, "Swing
Programming."
NOTE: The AWT, Swing, Java 2D API, Accessibility API, and Drag and Drop API
are all part of the Java Foundations Classes (JFC) 1.1, which is integrated with the
Core API of JDK 1.2.
In addition to being used to write attractive window programs, Java can also be used to write console
programs. These programs read data entered by the user at the keyboard and write data to the user's
console window. If you're an old-timer, you probably remember using console programs on MS-DOS
or UNIX systems. Java console programs don't have to be simple. You can develop a range of
sophisticated applications as console programs. For example, in Chapter 32, "Server Programs,"
you'll develop a multithreaded Web server as a console program. You'll learn the basics of how to
write console programs in Chapter 10, "Writing Console Applications."
JavaBeans Programming
Since the advent of structured programming, the goal of software engineering has been the
development of software components that can be reused in a variety of software applications. This
goal was partially achieved by the last generation of component development tools pioneered by
Microsoft's Visual Basic and Borland's Delphi. These tools supported the development of Component
Object Model (COM) software components that could be reused in Microsoft Windows programs.
JavaBeans picks up where these tools left off and provides the capability to develop platformindependent software components that can be reused in applets, standalone applications, and server
programs.
JavaBeans are Java-based software components that are designed for maximum reuse. They are
intended for use in visual software development environments. You use visual development tools to
construct JavaBeans. Once a bean has been developed, you use the drag-and-drop capabilities of
visual tools to add beans to your applets and applications and tailor them to your particular needs.
Beans are often visible GUI components, but they can also be invisible algorithmic components. You
can use beans for developing user programs such as applets and applications. However, you can also
use beans in server programs and in distributed applications. JavaSoft provides a bean bridge so that
beans can even be used in legacy COM-based applications, such as Microsoft Word and Excel.
Beans are self-contained software components that easily can be tailored and added to a wide range
of software applications. Since the introduction of JavaBeans, thousands of Java beans have been
developed, hundreds of which are available as off-the-shelf software components. If you are
interested in writing Java-based software components, be sure to read Part VII, "Creating JavaBeans."
Servlet Programming
Most of us are familiar with applets, standalone applications, and GUI-based software components
because they're designed for end users. We use these types of programs on a daily basis to perform
our work, interact with the world, or entertain ourselves. Another category of software that we may
be less familiar with is server software. Server programs run behind the scenes to provide vital data
and services for our user applications. Examples of server programs are Web servers, mail servers,
file servers, database servers, and so on. Server programming is covered in Chapter 32, "Server
Programs."
In addition to these large server programs, there is a need for small customized server programs that
perform specialized tasks. For example, the Common Gateway Interface (CGI) programs are
executed by Web servers to perform Web searches, process form data, and provide dynamic feedback
to Web users. CGI programs are designed to be small, fast, and efficient, and are written to support
specialized Web applications.
Recognizing the need for this type of server programming, JavaSoft has developed the Java Server
Toolkit and the Servlet API. The Java Server Toolkit is a client-server framework for building
Internet and intranet servers. It implements the functions that are common to many servers, such as
listening for client connections, processing client connections in a multithreaded manner, and
servicing requests made by clients over these connections.
The Servlet API is used to develop custom server-side programs for the processing of client requests.
It can be used as a Java API for writing CGI programs, and is supported by all major Web server
products. However, the Servlet API extends beyond CGI programming. It is envisioned that servers
of all types (not just Web servers) will support the use of servlets for servicing client requests.
You'll learn about server programming in Java in Part VIII, "Network Programming," and in Part XI,
"Server-Side Java."
Developing RMI Objects
Now that we live in a networked world, the natural course of software development is to create
applications that are distributed over a network. The client-server computing of applets and Web
servers is an example of a distributed application. However, future distributed applications will
consist of many objects that are distributed over several computers.
For example, a financial application running on your personal computer may invoke methods of
objects that run on another computer belonging to your company's intranet. These objects may search
company databases for the information used by your financial application, process that data
according to your company's business rules, and make that data available to your financial
application. The results calculated by your financial application may be automatically forwarded to
an information distribution object, which will make the results available to other employees within
your company as well as selected vendors and customers. Figure 4.1 depicts this example distributed
application.
FIGURE 4.1. An example of a distributed application.
JavaSoft provides a Java-based approach to developing distributed objects that can be used to build
distributed applications. This approach is referred to as remote method invocation (RMI). RMI allows
Java objects executing on one host to invoke the methods of objects that execute on remote hosts-hence the name remote method invocation. The remotely invoked objects perform services and may
return values that are used by the local objects.
The Remote Method Invocation (RMI) API of Java is a Java-specific approach to developing
distributed systems. RMI's major advantage is that it is fully integrated with the Java object model,
highly intuitive, and easy to use. In addition to the RMI API, the JDK provides a number of tools for
building distributed systems.
What RMI means for you as a software developer is that you can build distributed applications with
remote Java objects that are purchased off-the-shelf or custom-developed by others. You can also
develop distributed objects that can be used by others. Part IX, "Developing Distributed
Applications," covers the use of RMI in developing remotely accessible objects and integrating these
objects into distributed applications.
Developing CORBA Objects
RMI is a 100% Java solution for developing distributed applications. If you have the flexibility to
develop your distributed applications entirely (or almost entirely) in Java, RMI is the way to go.
However, large enterprise applications tend to be heterogeneous, and sometimes Java alone is not
enough. In these cases, a mixed-language distributed object development approach, such as that
supported by the Common Object Request Broker Architecture (CORBA) is a better solution to
distributed application development.
CORBA's strong point is that it supports a language-independent model. It provides a standard
architecture for developing distributed object-oriented systems. This architecture specifies how a
client object written in one language can invoke the methods of a remote server object developed in a
different language. Figure 4.2 provides an overview of this architecture.
FIGURE 4.2. Using CORBA to build distributed applications.
CORBA makes use of objects that are accessible via Object Request Brokers (ORBs). ORBs are used
to connect objects to one another across a network. An object on one computer (client object) invokes
the methods of an object on another computer (server object) via an ORB.
The client's interface to the ORB is a stub that is written in the Interface Definition Language (IDL).
The stub is a local proxy for a remote object. The IDL provides a programming-language
independent mechanism for describing the methods of an object.
The ORB's interface to the server is through an IDL skeleton. The skeleton provides the ORB with a
language-independent mechanism for accessing the remote object.
Remote method invocation under CORBA takes place as follows. The client object invokes the
methods of the IDL stub corresponding to a remote object. The IDL stub communicates the method
invocations to the ORB. The ORB invokes the corresponding methods of the IDL skeleton. The IDL
skeleton invokes the methods of the remote server object implementation. The server object returns
the result of the method invocation via the IDL skeleton, which passes the result back to the ORB.
The ORB passes the result back to the IDL stub, and the IDL stub returns the result to the client
object.
JDK 1.2 provides support for interfacing Java objects with CORBA objects. This support is provided
through Java IDL (an ORB), the idltojava compiler (used to generate stubs and skeletons), and
tnameserv, an object naming service.
The capability to interface with CORBA objects means that Java can be used to develop industrialstrength enterprise objects for use in large, heterogeneous distributed applications. This capability
opens yet another door for the Java programmer. Chapter 41, "Java IDL and ORBs," shows how to
use Java IDL to interface Java objects with CORBA objects. If distributed application development is
of interest to you, also check out Chapter 54, "Dirty Java," where you'll learn how Java can be used to
support Microsoft's approach to distributed application development (known as the Distributed
Component Object Model or DCOM).
Other Possibilities
The preceding sections covered some of the broad areas of Java software development. Within each
of these areas, there are numerous specialty areas for Java software development. Part V, "Enhancing
Your Applets and Applications," shows how to use the capabilities provided by the Java API to add
features such as drag-and-drop and internationalization to your programs. Part VI, "Multimedia
Programming," shows how to take advantage of the new multimedia features supported by JDK 1.2.
Part X, "Database Programming," shows how to use JDBC to access online databases from your
applets, applications, and server programs. The rest of this chapter provides suggestions on how to
move your existing legacy software, written in C and C++, to Java.
MOVING C/C++ LEGACY CODE TO JAVA
Java is a powerful language that provides many useful features to the software developer. However, if
your software organization is typical of most, you will have to trade off moving to Java with the
constraints imposed by a dependency on in-place legacy code. This section summarizes the pros and
cons of moving existing legacy code to Java. It identifies a spectrum of approaches for accomplishing
software transition and discusses the issues involved with each approach. It also covers approaches to
translating C and C++ code to Java. This section assumes that the transition of C/C++ code to Java is
being performed by a moderately large software organization. Some of the software porting issues
become insignificant if only a few small programs are translated into Java.
Why Move to Java?
When you're deciding whether to move existing applications to Java, you must consider the trade-off
between the advantages and disadvantages of such a move. This section identifies many of the
advantages of Java programs over C-based and C++-based applications. The following section
considers some disadvantages of using Java and identifies roadblocks to any software-transition
effort.
Platform Independence
One of the most compelling reasons to move to Java is its platform independence. Java runs on most
major hardware and software platforms, including Windows 98, 95, and NT, Macintosh, and several
varieties of UNIX. Java applets are supported by Java- compatible browsers, such as Netscape
Navigator and Internet Explorer. By moving existing software to Java, you can make it instantly
compatible with these software platforms. Your programs become more portable, and any hardware
and operating-system dependencies are removed.
Although C and C++ are supported on all platforms that support Java, these languages are not
supported in a platform-independent manner. C and C++ applications that are implemented on one
operating system platform are usually severely intertwined with the native windowing system and OSspecific networking capabilities. Moving between OS platforms requires recompilation, at a
minimum, and significant redesign in most cases.
Object Orientation
Java is a true object-oriented language. It does not merely provide the capability to implement objectoriented principles; it enforces those principles. You can develop object-oriented programs in C++,
but you are not required to do so; you can use C++ to write C programs as well. Java does not allow
you to slip outside the object-oriented framework. You either adhere to Java's object-oriented
development approach or you do not program in Java.
Security
Java is one of the first programming languages to consider security as part of its design. The Java
language, compiler, interpreter, and runtime environment were each developed with security in mind.
The compiler, interpreter, API, and Java-compatible browsers all contain several levels of security
measures that are designed to reduce the risk of security compromise, loss of data and program
integrity, and damage to system users. Considering the enormous security problems associated with
executing potentially untrusted code in a secure manner and across multiple execution environments,
Java's security measures are far ahead of even those developed to secure military systems. C and C++
do not have any intrinsic security capabilities. Can you download an arbitrary untrusted C or C++
program and execute it in a secure manner?
Reliability
Security and reliability go hand in hand. Security measures cannot be implemented with any degree
of assurance without a reliable framework for program execution. Java provides multiple levels of
reliability measures, beginning with the Java language itself. Many of the features of C and C++ that
are detrimental to program reliability, such as pointers and automatic type conversion, are avoided in
Java. The Java compiler provides several levels of additional checks to identify type mismatches and
other inconsistencies. The Java runtime system duplicates many of the checks performed by the
compiler, and performs additional checks to verify that the executable bytecodes form a valid Java
program.
Simplicity
The Java language was designed to be a simple language to learn, building on the syntax and many of
the features of C++. However, in order to promote security, reliability, and simplicity, Java has left
out those elements of C and C++ that contribute to errors and program complexity. In addition, Java
provides automated garbage collection, freeing you from having to manage memory deallocation in
your programs. The end result of Java's focus on simplicity is that it is easy to learn how to write Java
programs if you have programmed in C or C++. Java programs are also less complex than C and C++
programs, due to the fact that many of the language elements that lead to program complexity have
been removed.
Language Features
The Java language provides many language features that make it preferable to C or C++ for modern
software development. On the top of this list is Java's intrinsic support for multithreading, which is
lacking in both C and C++. Other features are its exception-handling capabilities, which were
recently introduced into C++, its strict adherence to class and object-oriented software development,
and its automated garbage-collection support. In addition to these features, Java enforces a common
programming style by removing the capability to slip outside of the class- and object-oriented
programming paradigm to develop C-style function-oriented programs.
Standardization
Although C and C++ have been standardized by the American National Standards Institute (ANSI),
many C and C++ compilers provide custom enhancements to the language, usually through additional
preprocessor directives. These enhancements usually make their way into source code programs,
resulting in a general lack of standardization. Java does not yet suffer from any standardization
problems because its syntax and semantics are controlled by a single organization.
The Java API
The predefined classes of the Java API provide a comprehensive, platform-independent foundation
for program development. These classes provide the capability to develop window and network
programs that execute on a wide range of hosts. The Java API's support of remote method invocation,
database connectivity, and security are unmatched by the API of any other language. In addition, no
other language provides as much platform-independent power as Java's API.
Transition to Distributed Computing
Sun has taken important steps to support fully distributed computing with its support of RMI,
CORBA, and JDBC. These APIs provide the capability to develop and integrate remote objects into
standalone programs and applet-based Web applications.
Rapid Code Generation
Because Java is an interpreted language, it can be used to rapidly prototype applications that would
require considerably more base software support in languages such as C or C++. The Java API also
contributes to the capability to support rapid code generation. The classes of the Java API provide an
integrated, easy-to-use repository for the development of application-specific software. Because the
Java API provides high-level windows, networking, and database support, custom application
prototypes can be constructed more quickly using these classes as a foundation.
Ease of Documentation and Maintenance
Java software is essentially self-documenting when doc comments and the javadoc tool are used to
generate software documentation. The excellent Java API documentation is an example of the
superior documentation capabilities provided by Java. Because Java software is inherently better
structured and documented than C or C++ software, it is generally easier to maintain. In addition, the
package orientation of Java software provides considerable modularity in software design,
development, documentation, and maintenance.
Reasons Against Moving to Java
Java's many benefits make it an attractive language for developing new applications and porting
existing legacy code. The previous section discussed some of the advantages of porting existing code
to Java. This section identifies some of the disadvantages of any migration from C or C++ to Java.
Compatibility
Although Java is supported on many platforms, it is not supported on all of them. If your target
hardware or software platform does not support Java, you are out of luck. Your alternatives are to
switch to a different platform or to wait for Java to be ported to your existing software platform.
Also, your operating system or browser platform may not support the latest version of Java. For
example, Netscape Communicator 4.0 supports JDK 1.1, but Microsoft Internet Explorer supports
most of JDK 1.1 but not all of it. Earlier browsers support JDK 1.02. In order to develop Java
software that is compatible with a wide range of users, you must ensure that your users are upgraded
to an execution platform that runs the version of Java required by your software.
Compatibility may also be a problem at the design level. Suppose that your target software platform
does support the latest version of Java. If your legacy code is unstructured and incompatible with a
class- and object-oriented model, the effort required to migrate the software may be prohibitive.
Performance
Java is interpreted, and although its execution is efficient, it might not meet the performance demands
of applications in which execution speed is of paramount importance. Examples of these types of
applications include numerical "number crunching" programs, real-time control processes, language
compilers, and modeling and simulation software.
Just because your application fits into one of these categories does not necessarily rule out Java. For
example, the Java compiler is written in Java and performs admirably for small programs. However,
its performance is greatly enhanced when it is compiled into native machine code instructions. Javato-C translators allow programs to be developed in Java and translated into C for native machine code
compilation. (See http:// www.cern.ch/WebOffice/Projects/Newspaper/tools/toba/doc/ for an
example.) The translation process generally improves the performance of Java programs. Some Java
development tools, such as Symantec Visual Café for Java Professional, provide the capability to
create native binary code executable files (.exe) directly from Java code.
Probably the biggest boost to Java's performance is the HotSpot technology from JavaSoft. HotSpot
allows Java programs to execute as fast as or faster than compiled programs. HotSpot increases
execution performance by integrating a just-in-time compiler and a code optimizer with the Java
interpreter.
Retraining
Although Java is simple, easy to learn, and based on C++, some training will be required to get
programmers up and running with it. This is especially true if the programmers haven't been using C+
+ in a structured, object-oriented fashion. I never really appreciated the object-oriented programming
features provided by C++ before I began programming in Java. Until I had adopted the Java programdevelopment mindset, I was trying to apply my outdated and inefficient C++ programming
techniques to Java software development. After I had made the mental transition to the Java objectoriented programming model, I became much more comfortable and efficient in writing Java
programs.
Impact on Existing Operations
Moving legacy code to Java may result in adverse effects on company operations that are supported
with legacy software. This is especially true when the legacy code is implemented in the poorly
structured, convoluted manner that typically evolves from extensive software patches and upgrades.
In the case when existing system software is tightly coupled and fragile, a transition to Java (or any
other language) may break the software application to the point where a complete software
redevelopment is required.
Cost, Schedule, and Level of Effort
Any software transition effort is subject to cost and schedule constraints. Moving current legacy
software to Java might not be cost-effective, given the current software investment and its expected
operational life. The software transition may also have a significant impact on system availability and
prior scheduled activities. Transition from C or C++ to Java might also require a significant level of
effort that would exceed the expected budget for the maintenance of the legacy code.
Transition Approaches and Issues
There are many ways to integrate Java into existing software applications. This section identifies
some of these approaches and explores the issues involved in making the transition to a Java-based
software environment.
Interfacing with Existing Legacy Code
One of the easiest ways to introduce Java to an operational environment is to use it to add
functionality to existing legacy code. Java programs do not replace existing legacy software; they
merely enhance it to support new applications. This approach involves minimal impact to existing
software, but introduces a potentially thorny maintenance issue because Java is added to the current
list of languages that must be used to maintain the system.
Incremental Reimplementation of Legacy Code
You can reimplement legacy code in Java in increments, moving over to a Java-based softwaredevelopment approach while minimizing the impact on existing legacy software. This approach
assumes that the legacy software is developed in a modular fashion and can be replaced in an
incremental manner. If this is the case, legacy software can be migrated to Java on a module-bymodule basis, with the legacy code ultimately replaced by new Java software.
Off-Boarding Access to Legacy Objects
If in-place legacy code can be upgraded using Java software that is implemented on separate
hardware platforms, Java can be used to off-board many of the functions performed by the legacy
code. The use of off-board server software allows the investment in legacy code to be preserved,
while expanding the services provided by the system as a whole.
Full-Scale Redevelopment
In some cases, it is more cost-effective to keep legacy code in place while completely redeveloping
system software from scratch. This is typically the case when the system is subject to large-scale
reengineering, or when it is so fragile that it breaks as the result of the simplest upgrades. If full-scale
system redevelopment is necessary, this is actually an advantage to Java software development
because the developed software is under no legacy-compatibility constraints and can take full
advantage of Java's capabilities.
Translation Approaches and Issues
Translation of existing C and C++ code into Java can be performed in several different ways,
depending upon the compatibility of the existing software with Java. This section describes some of
the different approaches to software translation.
Automated Translation
Tools and utilities have been developed that allow Java source code and bytecode to be translated
into C to support native machine code compilation. Future Java integrated software-development
environments are planned, where either Java or C++ code may be generated based on the
configuration of the development software. These development tools will allow easy movement
between C++ and Java and require a common set of libraries that can be used by either Java or C++
programs. Automated translation between these two languages will be supported to some extent.
The degree to which C++ programs may be automatically translated into Java will depend on the
planning and effort put into the code's design. Factors to be considered include compatible libraries,
the use of single inheritance, the use of object-oriented programming capabilities, and the
minimization of the use of incompatible language features.
Manual Translation
Manual translation of C and C++ to Java will probably be the most common approach to moving C
and C++ legacy programs to Java. This approach requires you to use two editor windows--one for the
legacy C++ code being translated, and the other for the Java program being created. Some of the
translation is accomplished by cutting and pasting C++ statements into the Java window, making the
corrections necessary to adjust for language differences. Other parts of the translation require that
new Java classes, interfaces, variables, and methods be developed to implement C++ functions and
data structures that cannot be directly translated from C++ to Java. The effectiveness of the manual
translation process will be determined by the degree to which the C++ legacy code meets the
compatibility considerations identified at the end of the previous section.
Source-Level Redesign
In many cases, manual translation is hampered because the C++ legacy code is written in a style that
renders it impossible to migrate using cut-and-paste translation methods. In these cases, a class- and
object-oriented design of the legacy code needs to be extracted from the legacy code and used as the
basis for the Java source code development. A two-level approach to software translation is followed.
The legacy code is reverse-engineered to an object-oriented design, and the recovered design
information is used to develop a Java software design, which is in turn translated into Java source
code. Code is not translated from one language to another. Instead, legacy code is translated into
general design information that is used to drive the Java design and implementation.
Summary
In this chapter you've explored the broad range of Java software development. You learned how Java
is used to develop applets, console and window applications, beans, servlets, and objects for
distributed systems. You also learned how to move your legacy C and C++ code to Java. In the next
chapter you focus on applets and learn how they're used to bring interactive content to the Web.
© Copyright 1998, Macmillan Publishing. All rights reserved.
Java 1.2 Unleashed
-5JDK 1
●
●
●
●
●
●
●
●
Applets and the World Wide Web
❍ The Applet Class
❍ A Brief HTML Primer
The Life Cycle of an Applet
Responding to Events
Using Window Components
Adding Multimedia Features
❍ An Audio Player Applet
A Word About JavaBeans
Java Plug-In
Summary
JDK 1.2 Applet Writing Basics
This chapter introduces the classes of the java.applet package and explains how applets are integrated
within Web documents using the HTML <APPLET> tag. It describes how applets use window
components and identifies the major phases in an applet's life cycle. Applet audio capabilities,
JavaBeans, and Java Plug-In are also covered. When you finish this chapter, you will have a good
understanding of how applets work.
Applets and the World Wide Web
Applets are Java programs that are integrated into Web pages. When a Web page containing an applet
is displayed by a Web browser, the applet is loaded and executed. The applet's output is displayed
within a subset of the browser's display area. Figure 5.1 illustrates this concept.
FIGURE 5.1. How an applet is displayed by a Web browser.
The Applet class is a subclass of the Panel class, and an applet is implemented as a panel within a
Web document. You'll learn more about the Panel class when you study window programming in
Chapter 9, "Creating Window Applications." Because the Applet class is a subclass of the Panel
class, it inherits all the methods of the Panel class and is capable of using most window GUI
components. In addition, applet events are handled in the same manner as in standalone Java window
programs.
The Applet Class
The java.applet package is one of the smallest packages in the Java API. It consists of a single class,
the Applet class, and three interfaces: AppletContext, AppletStub, and AudioClip.
The Applet class contains a single default parameterless constructor, which is generally not used.
Applets are constructed by the runtime environment when they are loaded and do not have to be
explicitly constructed.
The Applet class contains 23 methods that are used to display images, play audio files, respond to
events, and obtain information about an applet's execution environment (or context).
The getImage() and getAudioClip() methods are used to retrieve an Image or AudioClip object that is
identified by an URL. The play() methods are used to play audio files at specified URLs. JDK 1.2
introduces the newAudioClip() method, a static method that allows AudioClip objects to be created
without an applet context.
NOTE: The newAudioClip() method is the only new Applet method introduced with
JDK 1.2.
The init(), start(), stop(), and destroy() methods are used to implement each of the four life cycle
stages of an applet. The init() method is invoked by the runtime environment when an applet is
initially loaded. It is invoked to perform any required initialization processing. The start() method is
invoked by the runtime system when an applet is started, or when it's restarted as a result of a user
switching between Web pages. The stop() method is invoked by the runtime system when the user
switches from the Web page containing the applet to another Web page or program. The destroy()
method is invoked when an applet's execution is terminated, usually as the result of the user exiting
the browser. The isActive() method is used to determine whether an applet is currently active.
The getAppletContext() method is used to obtain the AppletContext object associated with an applet.
The AppletContext interface defines methods by which an applet can access its execution
environment. The getAppletInfo() method returns a String object that provides information about an
applet. This information can include version, copyright, and authorship data, as well as appletspecific data. The getAppletInfo() method is overridden by Applet subclasses to provide this
information. The getCodeBase() method returns the base URL specifying the applet's location. The
getDocumentBase() returns the URL of the document in which the applet is contained. The
getParameter() method is used to obtain parameter data that is passed to an applet in an HTML file.
The getParameterInfo() method returns an array that describes all the parameters used by an object. It
is overridden by Applet subclasses in the same manner as the getAppletInfo() method.
The resize() methods are used to resize an applet. The setStub() method is used to set the AppletStub
associated with the applet. It should not be used unless you are constructing your own custom applet
viewer. The showStatus() method is used to display a status message using the applet's context. The
getLocale() method returns the Locale object associated with the applet. It is used to support
language-independent applet programming.
The AppletContext interface defines methods that allow an applet to access the context in which it is
being run. This is typically a Web browser, such as Netscape Navigator or Microsoft Internet
Explorer, but could also be the applet viewer. The AppletContext interface of an applet is accessed
using the getAppletContext() method of the Applet class. AppletContext provides seven methods that
allow an applet to obtain information about and manipulate its environment. The getApplets() method
returns an Enumeration object that contains all applets that are accessible in the applet's context. The
getApplet() method returns an Applet object whose name matches a String parameter. The
getAudioClip() method returns an AudioClip object that is referenced using an URL. The getImage()
method returns an Image object that is identified by an URL. The two showDocument() methods are
used to instruct a Web browser to display the Web document located at a particular URL. The
showStatus() method is used to display a status message via the Web browser executing the applet.
The AppletStub interface is used to implement an applet viewer. It is not generally used by applets. It
provides six methods that are used to retrieve applet information that can be used to support applet
viewing.
The AudioClip interface defines three methods: play(), stop(), and loop(). The play() method plays an
audio clip. The stop() method terminates the playing of an audio clip. The loop() method starts and
plays an audio clip in a continuous loop.
A Brief HTML Primer
Web documents are written in Hypertext Markup Language (HTML). HTML uses tags to describe the
structure of Web documents. Tags are used to identify headings, paragraphs, and lists, as well as
other elements of Web pages such as links, images, forms, and applets. In order to use applets in your
Web documents, you need to learn about a few basic HTML tags. Although a complete introduction
to HTML is beyond the scope of this book, this section provides a quick summary of the basic HTML
tags that you will need to use the examples in this book.
NOTE: For more information on HTML, point your Web browser to http://www.
jaworski.com/htmlbook/. Here you'll find links to introductory tutorials on HTML, as
well as links to more advanced HTML topics.
Using HTML Tags
HTML tags begin with a < and end with a >, and the name of the tag is placed between them. The tag
name may be written using any combination of upper- or lowercase characters. I write tags in
uppercase to set them apart from the text to which they apply. For example, the title tag is written
<TITLE>, the head tag is written <HEAD>, and the body tag is written <BODY>.
HTML supports two types of tags--separating tags and surrounding tags. Separating tags are placed
between the text elements to which they apply. For example, the break tag, written <BR>, is used to
insert a line break within a line of text. It is placed at the point in the line where the break is desired,
as shown in the following HTML:
This line ends at the break tag.<BR>This text is displayed on the
next line.
Surrounding tags consist of pairs of tags that surround the text to which they apply. The first tag in
the pair is the opening tag and the second tag is the closing tag. The closing tag contains a / between
the opening < and the tag's name. Examples of surrounding tags are <HTML> and </HTML>,
<HEAD> and </HEAD>, and <BODY> and </BODY>. You'll learn about these tags in subsequent
sections.
Some HTML tags are allowed to specify attributes. Attributes are used to identify properties of the
tag and are included in the tag between the tag name and the closing >. When attributes are used with
surrounding tags, they are included in the opening tag but not in the closing tag. For example, the
<APPLET> tag uses attributes to identify the name of the class to be loaded, the dimensions of the
applet display region within the browser window, and other properties of the applet. The following
HTML is an example of an <APPLET> tag that uses attributes:
<APPLET CODE="TestApplet.class" WIDTH=300 HEIGHT=300>
[alternate text to be displayed]
</APPLET>
The opening <APPLET> tag has three attributes: CODE, WIDTH, and HEIGHT. The CODE
attribute has the value of "TestApplet.class" and identifies the name of the applet's bytecode file. The
WIDTH and HEIGHT attributes both have the value 300 and specify a 300¥300 pixel applet display
region within the browser window. The text [alternate text to be displayed], appearing between the
opening and closing <APPLET> tags, identifies text that a browser should display if it does not
support Java applets.
The <HTML>, <HEAD>, and <BODY> Tags
HTML documents are written in ASCII text, with the <HTML> and </HTML> tags marking the
beginning and end. They consist of a single head and a single body. The head is used to identify
information about the HTML document, such as its title, while the body contains the information
displayed by the HTML document. The head and body are identified using the <HEAD>, </HEAD>,
<BODY>, and </BODY> tags. The following HTML illustrates the use of these tags:
<HTML>
<HEAD>
The document title appears here.
</HEAD>
<BODY>
The information displayed by the HTML document appears here.
</BODY>
</HTML>
The <TITLE> Tag
The title of an HTML document is typically displayed at the top of the browser window, as shown in
Figure 5.2. The title is placed in the head of the Web document and is surrounded by the <TITLE>
and </TITLE> tags.
FIGURE 5.2. The title of a Web document appears in the title bar at the top of the window.
The HTML used to create the Web page in Figure 5.2 is shown in Listing 5.1.
LISTING 5.1. USING THE <TITLE> TAG.
<HTML>
<HEAD>
<TITLE>This is the document title</TITLE>
</HEAD>
<BODY>
This is the document body.
</BODY>
</HTML>
The Heading and Paragraph Tags
The heading and paragraph tags are the most common tags found within the body of a Web
document. The heading tags are used to specify document headings, which in turn are used to
organize Web documents into sections and subsections in the same manner in which the chapters of
this book are organized into sections and subsections. HTML supports six heading levels. First-level
headings are identified by the <H1> and </H1> tags, second-level headings are identified by the
<H2> and </H2> tags, and so on. The HTML in Listing 5.2 shows how all six heading levels are
displayed.
LISTING 5.2. USING HEADING TAGS.
<HTML>
<HEAD>
<TITLE>HTML
</HEAD>
<BODY>
<H1>Heading
<H2>Heading
<H3>Heading
<H4>Heading
<H5>Heading
<H6>Heading
</BODY>
</HTML>
Headings</TITLE>
Level
Level
Level
Level
Level
Level
1</H1>
2</H2>
3</H3>
4</H4>
5</H5>
6</H6>
Figure 5.3 shows how this HTML file is displayed by my Web browser.
FIGURE 5.3. HTML heading levels.
Paragraph tags are used to mark paragraphs within HTML documents. Spaces, tabs, carriage returns,
and line feeds are referred to as whitespace characters in HTML. One or more whitespace characters
are normally displayed as a single space by Web browsers. In order to mark the beginning and end of
a paragraph, the HTML paragraph tags, <P> and </P>, must be used. The HTML shown in Listing
5.3 illustrates the use of paragraph tags. Figure 5.4 shows how this HTML is displayed by a Web
browser.
LISTING 5.3. USING PARAGRAPH TAGS.
<HTML>
<HEAD>
<TITLE>HTML Paragraphs</TITLE>
</HEAD>
<BODY>
<H1>How paragraphs are marked in HTML</H1>
<P>This is paragraph 1.</P><P>This is paragraph 2.</P>
<P>This is paragraph 3.
This text also belongs to paragraph 3.
Notice that carriage returns and
multiple spaces
not affect the way paragraphs are formatted.</P>
</BODY>
</HTML>
do
FIGURE 5.4. HTML paragraphs.
The paragraph tag may also be written as a single separating tag, <P>, although this is considered bad
form. The previous example could also have been written to display identically using separating
paragraph tags rather than surrounding paragraph tags.
The <APPLET> and Parameter Tags
Although there are a number of different HTML tags that you can learn, the <APPLET> and
parameter tags are the primary tags of interest to Web programmers.
The <APPLET> tag is a surrounding tag. It may surround zero or more parameter tags. It may also
surround alternative text. Alternative text is text that appears between the <APPLET> and </
APPLET> tags that is not included in a parameter tag. It is displayed by browsers that are not Javaenabled as an alternative to the applet's display.
The parameter tag is used to pass named parameters to a Java applet. It is a separating tag that has
two attributes: NAME and VALUE. The NAME attribute identifies the name of a parameter, and the
VALUE attribute identifies its value. The following are examples of the use of parameter tags:
<PARAM NAME="speed" VALUE="slow">
<PARAM NAME="duration" VALUE="long">
<PARAM NAME="delay" VALUE="short">
An applet uses the getParameter() method of the Applet class to retrieve the value of a parameter.
The parameter tag may only appear between the <APPLET> and </APPLET> tags.
The <APPLET> tag supports 11 attributes: ALIGN, ALT, ARCHIVES, CODE, CODEBASE,
HEIGHT, HSPACE, NAME, OBJECT, VSPACE, and WIDTH.
●
The ALIGN attribute specifies the alignment of an applet's display region with respect to the
rest of the line being displayed by a browser. This line may consist of text, images, or other
HTML elements. Values for this attribute are TOP, TEXTTOP, BOTTOM, ABSBOTTOM,
BASELINE, MIDDLE, ABSMIDDLE, LEFT, and RIGHT. The TOP attribute value causes
the top of an applet to be aligned with the top of the line being displayed by a browser. The
TEXTTOP attribute causes the top of an applet to be aligned with the top of the text being
displayed in the current line. The BASELINE and BOTTOM attributes cause the bottom of
the applet to be aligned with the baseline of the text in the line being displayed. The
ABSBOTTOM attribute causes the bottom of an applet to be aligned with the bottom of the
current line being displayed. The MIDDLE attribute causes the middle of the applet to be
aligned with the middle of the text displayed in the current line. The ABSMIDDLE attribute
causes the middle of the applet to be aligned with the middle of the line being displayed. The
LEFT and RIGHT attributes cause the applet to be aligned at the left and right margins of the
browser window.
●
●
●
●
●
●
●
●
●
●
The ALT attribute identifies text that should be displayed by a browser if it understands the
<APPLET> tags, but does not support Java applets or has applet processing disabled.
The ARCHIVES attribute identifies class archives that are preloaded to support applet
execution.
The CODE attribute is a relative URL that identifies the name of the bytecode file of the
applet.
Normally, the URL of the Web document displaying the applet is used as the base URL for
locating the bytecode file referenced by the CODE attribute. The CODEBASE attribute is
used to change the base URL to another location.
The HEIGHT attribute identifies the height of the display area required by the applet.
The HSPACE attribute specifies the number of pixels to be used as the left and right margins
surrounding an applet.
The NAME attribute is used to assign a name to an applet. This name is used to support interapplet communication.
The OBJECT attribute identifies a file that contains a serialized representation of an applet.
The VSPACE attribute specifies the number of pixels to be used as the top and bottom
margins surrounding an applet.
The WIDTH attribute identifies the width of the display area required by the applet.
Of the 11 applet attributes, only the CODE, HEIGHT, and WIDTH attributes are required.
The HTML file sample.htm, which is shown in Listing 5.4, shows how an applet may be specified in
a Web document.
LISTING 5.4. THE sample.htm FILE.
<HTML>
<HEAD>
<TITLE>Using the Applet Tag</TITLE>
</HEAD>
<BODY>
<H1>An Applet that Displays Text at a Designated Location</H1>
<APPLET CODE="SampleApplet.class" HEIGHT=300 WIDTH=300>
<PARAM NAME="text" VALUE="Applets are fun!">
<PARAM NAME="x" VALUE="50">
<PARAM NAME="y" VALUE="50">
Text displayed by browsers that are not Java-enabled.
</APPLET>
</BODY>
</HTML>
The applet specified in the applet tag displays the text Applets are fun! at the coordinates 50,50
within the 300¥300 pixel applet display area, as shown in Figure 5.5.
The source code of the SampleApplet applet is provided in Listing 5.5.
LISTING 5.5. THE SampleApplet.java SOURCE CODE FILE.
import java.applet.*;
import java.awt.*;
public class SampleApplet extends Applet {
String text = "error";
int x = 0;
int y = 20;
public void init() {
text = getParameter("text");
try {
x = Integer.parseInt(getParameter("x"));
y = Integer.parseInt(getParameter("y"));
}catch(NumberFormatException ex){
}
}
public void paint(Graphics g) {
g.setFont(new Font("TimesRoman",Font.BOLD+Font.ITALIC,36));
g.drawString(text,x,y);
}
}
Compile SampleApp.java using the command javac SampleApplet.java. Then open the sample.htm
file using your Web browser. This should result in a display similar to that shown in Figure 5.5.
FIGURE 5.5. The display of SampleApplet.
The SampleApplet class extends the Applet class. It declares three field variables: text, x, and y. The
text variable is used to hold the text that is displayed in the Applet display area. The x and y variables
specify the location where the text is to be displayed. The default value of the text variable is set to
"error". The default value of the x variable is set to 0. The default value of the y variable is set to 20.
The init() method is invoked by the Java runtime system to perform any required initialization. The
init() method uses the getParameter() method of the Applet class to get the value of the text, x, and y
parameters. The parseInt() method of the Integer class is used to convert the String value returned by
the getParameter() method to an int value.
The paint() method is invoked by the Java runtime system to update the Java display area. It is
automatically passed a Graphics object as a parameter. This object is used to draw on the applet's
display area. The paint() method uses the setFont() method of the Graphics class to set the current
font to a 36-point bold italic TimesRoman font. The drawString() method of the Graphics class is
used to display the value of the text variable at the x,y coordinate.
Other HTML Tags
The HTML tags covered in the preceding sections are the minimum needed to get you started using
applets with HTML documents. There are many more HTML tags that you can use with your Web
pages. The URL http://www.jaworski.com/jdg contains links to Web documents that describe these
other HTML tags.
The Life Cycle of an Applet
An applet has a well-defined life cycle, as shown in Figure 5.6. Applets do not need to be explicitly
constructed. They are automatically constructed by the runtime environment associated with their
applet context--the Web browser or applet viewer. The init() method provides the capability to load
applet parameters and perform any necessary initialization processing. The start() method serves as
the execution entry point for an applet when it is initially executed and restarted as the result of a user
returning to the Web page that contains the applet. The stop() method provides the capability to stop()
an applet's execution when the Web page containing the applet is no longer active. The destroy()
method is used at the end of an applet's life cycle to perform any termination processing.
Responding to Events
Because the Applet class is a subclass of the Panel class and therefore part of the window class
hierarchy, applets handle events in the same manner as other window components. All the window
event handling approaches that you will learn for window applications will also apply to Applet event
handling. The init(), start(), stop(), and destroy() methods that were covered in the previous section
are used to handle events that are generated by the Java runtime system. These methods are specific
to applets and do not apply to other window components.
FIGURE 5.6. The stages of an applet's life cycle.
Using Window Components
Because the Applet class is a subclass of the Panel class, it can use most of the GUI components that
are used by standalone window programs. This includes labels, buttons, checkboxes, radio buttons,
lists, text components, canvases, and scrollbars. You will learn to use these components in the next
chapter. The only major GUI components that cannot be used within an applet are menu components.
Menu components are attached to Frame objects, which are associated with an application window. It
is possible for an applet to create and open a separate application window in the form of a Frame
object, but such an application window would only be trusted to the extent allowed by the applet
security policy. This prevents the window from masquerading as other programs running on the user's
system.
Adding Multimedia Features
The Applet class provides the capability to display images and play audio files. Images are displayed
on the Canvas object associated with the applet's display area. Before JDK 1.2, applets only
supported audio files that were in the Sun audio format (.au files). JDK 1.2 introduces a new sound
engine and the capability to play audio files in both applets and applications. The new sound engine
supports the following audio file formats:
●
●
●
●
●
MIDI (type 0 and type 1)--The Musical Instrument Digital Interface, a digital format for
musical instruments.
RMF--The Rich Music Format, an audio file format created by Headspace, Inc. for online
playback through the Beatnik plug-in.
WAVE--The Microsoft Windows audio file format.
AIFF--The Audio Interchange File Format, typically used with Macintosh and Silicon
Graphics computers.
AU--The Sun audio file format.
Support for the preceding formats greatly enhances the audio capabilities of Java applets and
applications.
The play() method of the Applet class can be used to play an audio file that is identified by an URL.
A more flexible approach is to load an object that implements the AudioClip interface and then
invoke the object's play(), loop(), and stop() methods. The getAudioClip() method can be used to load
an audio file by identifying its URL.
The JDK 1.2 also introduced the newAudioClip() method of the Applet class. This static method
allows AudioClip objects to be created independently of an applet context, reducing the dependency
of applets on the capabilities provided by differing browsers.
In addition to image display and audio playback, Java also provides the capability to include
animation in applets and standalone window programs. Chapter 22, "Creating Animations," covers
this topic.
An Audio Player Applet
The AudioPlayer applet, developed in this section, shows how easy it is to include multimedia
features in applets. The source code for the AudioPlayer applet is shown in Listing 5.6.
NOTE: You need a sound board and speaker(s) to run this applet. You also need to be
connected to the Internet.
LISTING 5.6. THE SOURCE CODE OF THE AudioPlayer APPLET.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.net.*;
public class AudioPlayer extends Applet {
AudioClip music;
Image background;
public void init() {
URL codeBase = getCodeBase();
music = getAudioClip(codeBase,"spacemusic.au");
background = getImage(codeBase,"space.gif");
setLayout(new BorderLayout());
Panel buttons = new Panel();
Button playButton = new Button("Play");
Button stopButton = new Button("Stop");
Button loopButton = new Button("Loop");
playButton.addActionListener(new ButtonHandler());
stopButton.addActionListener(new ButtonHandler());
loopButton.addActionListener(new ButtonHandler());
buttons.add(playButton);
buttons.add(stopButton);
buttons.add(loopButton);
add("South",buttons);
}
public void stop() {
music.stop();
}
public void paint(Graphics g) {
g.drawImage(background,0,0,this);
}
class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent e){
String s = e.getActionCommand();
if("Play".equals(s)) music.play();
else if("Stop".equals(s)) music.stop();
else if("Loop".equals(s)) music.loop();
}
}
}
Compile AudioPlayer.java using javac AudioPlayer.java. The HTML file that is used to display the
applet is shown in Listing 5.7. Note that the CODE, WIDTH, and HEIGHT attributes of the applet
have been specified. You will need two additional files to run the applet: space.gif and spacemusic.
au. These files are located in the ch05 directory.
LISTING 5.7. THE audio.htm FILE.
<HTML>
<HEAD>
<TITLE>Audio Player</TITLE>
</HEAD>
<BODY>
<APPLET CODE="AudioPlayer.class" WIDTH=300 HEIGHT=350>
[AudioPlayer applet]
</APPLET>
</BODY>
</HTML>
Open the audio.htm file with appletviewer using the following command:
appletviewer audio.htm
The appletviewer will create a window display similar to the one shown in Figure 5.7.
FIGURE 5.7. The audio.htm file, as displayed by appletviewer.
You can also use your browser to load the applet over the Internet. The audio.htm, AppletViewer.
class, AppletViewer$ButtonHandler.class, space.gif, and spacemusic.au files are located in the \java
directory of my Web server. Use your browser to go to http://www.jaworski.com/java/audio.htm. It
will display the window shown in Figure 5.8.
Your browser loads the audio.htm file and then the AudioPlayer.class and AudioPlayer
$ButtonHandler.class files. The applet itself loads the background image and an audio file. To play
the audio file, click on the Play button. The space music is played, using your sound board and
speakers. When the music file ends, the sound ends. If you click on the Loop button, the music is
played continuously. Clicking the Stop button causes the music to cease.
FIGURE 5.8. The audio.htm file, as displayed by HotJava.
The AudioPlayer class is fairly simple. It declares two field variables, music and background, which
are used to hold the audio file and background image. The music variable is declared as type
AudioClip, which is an interface defined in the java.applet package.
The AudioPlayer class contains three access methods: init(), stop(), and paint().
The init() method is invoked by the browser's runtime system when an applet is initially loaded. It
performs any initialization required before the main part of the applet is executed. The stop() method
is invoked when an applet is terminated as the result of an applet's Web page no longer being
displayed by the browser. You never need to invoke init() or stop() directly. They are invoked by the
runtime system.
The init() method of AudioPlayer begins by loading the audio and image files. The getCodeBase()
method returns the URL of the directory where the applet file is located. The getAudioClip() method
of the Applet class loads an audio file that is referenced by this URL and the spacemusic.au file
name. The space.gif file is loaded in a similar manner.
After the audio and image files are loaded, the layout of the applet is set to a BorderLayout object.
You'll learn about layouts in the next chapter. A Panel object is created and assigned to the buttons
variable. The Play, Stop, and Loop buttons are created and added to the buttons panel. ButtonHandler
objects are used to handle the events associated with these buttons. The buttons panel is then added to
the bottom of the applet display area.
When the applet is no longer being displayed by the browser, the stop() method of the AudioPlayer
class invokes the stop() method of the AudioClip interface to stop the music.
The paint() method draws the space.gif image assigned to the background variable on the Graphics
context of the applet's display area.
The actionPerformed() method of the ButtonHandler inner class handles the three prominent events
associated with the applet. These events are the clicking of the Play, Stop, and Loop buttons. When
the Play button is clicked, the play() method of the AudioClip interface is invoked to play the audio
clip. When the Stop button is clicked, the stop() method of the AudioClip interface is invoked to stop
the music. Finally, when the Loop button is clicked, the loop() method of the AudioClip interface is
invoked to cause the music to be played in a never-ending loop.
A Word About JavaBeans
As you learned in Chapter 4, "Overview of JDK 1.2 Programming," JavaBeans are software
components that are designed for maximum reuse. They support the software component assembly
model pioneered by Microsoft's Visual Basic and Borland's Delphi. For most people, they are the
simplest way to create applets. Using a visual design tool, you just drag and drop beans into your
applet. After that, all you need to do is to adjust the beans' properties to your liking and specify how
the beans are to interact with each other.
However, the power of JavaBeans goes beyond rapid applet development. JavaSoft has developed the
JavaBeans Bridge for ActiveX 1.0, which allows beans to interoperate with ActiveX. This means that
you can use JavaBeans as ActiveX components in a number of Windows applications, including
Microsoft Office, Visual Basic, and even Internet Explorer. Part VII of this book is dedicated to
JavaBeans. You'll learn to develop your own beans, use them in applets, and work with bridges.
Java Plug-In
One of the biggest problems facing applet developers is maintaining backward compatibility with
older browsers, such as Navigator 3.0 and Internet Explorer 3.0, that don't support JDK 1.1, let alone
JDK 1.2. In order to provide applets that work with most of the installed browser base, applet
developers were forced into a "least common denominator" approach. This approach generally results
in applets that do not exceed the capabilities of JDK 1.02. JavaSoft developed Java Plug-In as a
solution to this problem. Java Plug-In, formerly known as Activator, allows users to use various
versions of Sun's Java Runtime Environment with their browser instead of the Java Virtual Machine
provided by the browser vendor. This frees users of Internet Explorer from having to use Microsoft's
broken JVM, and allows users of older Netscape browsers to conveniently upgrade to JDK 1.1 and
JDK 1.2 runtime environments. Java Plug-In works with Navigator 3.0 or later and Internet Explorer
3.02 or later. Java Plug-In acts as an ActiveX control when used with Internet Explorer and as a
browser plug-in when used with Navigator.
Summary
This chapter introduced the classes of the java.applet package and explained how applets are
integrated within Web documents. It included a short introduction to HTML and explained how to
use the HTML <APPLET> tag. It described how applets use window components and identified the
major phases in an applet's life cycle. Applet multimedia capabilities, JavaBeans, and Activator were
also introduced. Chapter 6, "GUI Building," shows how to build a graphical user interface for your
applets.
© Copyright 1998, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
-6GUI Building
●
●
●
●
●
●
●
●
Labels
Buttons
Handling Events
❍ JDK 1.02 Event Handling
❍ JDK 1.1 Event Handling
❍ The Buttons Applet
Components and Containers
Using Layouts
❍ The LayoutManager and LayoutManager2 Interfaces
❍ The BorderLayout Class
❍ The CardLayout Class
❍ The FlowLayout Class
❍ The GridLayout Class
❍ The GridBagLayout Class
❍ The Layouts Applet
❍ Using a null Layout for Absolute Positioning
❍ The Positions Applet
Text Components
❍ TextField
❍ TextArea
❍ The Text Applet
Checkboxes
❍ The CheckboxTest Applet
Choices and Lists
The Chooser Applet
❍ The Scroller Applet
❍ The ScrollPane Class
Summary
❍
●
One of the reasons for Java's massive appeal is the Abstract Windowing Toolkit (AWT). This API
allows powerful graphical user interfaces to be developed quickly and easily. If you have ever
programmed in Microsoft Windows, you will greatly appreciate the simplicity and efficiency of the
GUI-programming capabilities of the AWT. Also, most of its classes and interfaces can be used for
both applets and applications.
In this chapter, you'll learn how to build a GUI using the classes of the AWT. You'll work with
labels, buttons, text fields, checkboxes, choices, lists, and scrollbars. You'll learn how to use
components and containers, and how to handle events. When you finish this chapter, you'll be able to
build a basic GUI using the AWT classes.
NOTE: Part 4 of this book introduces Swing programming. Swing extends the AWT
to provide numerous components for GUI building and to support pluggable look and
feel. Many of the AWT components that you'll learn about in this chapter have Swing
counterparts.
Labels
The most basic GUI component is the label, which is simply text that is displayed at a particular
location of a GUI container. The Label class of the java.awt package provides the capability to work
with labels. This class provides three Label() constructors: a default parameterless constructor for
creating blank Label objects, a constructor that takes a String object that specifies the label's text, and
a constructor that takes a String object (the label's text) and an alignment constant. The alignment
constant may be one of the following:
●
CENTER
●
LEFT
●
RIGHT
The alignment constants determine the justification of text within the label. The Label class provides
six methods for working with the label's text and alignment, and for performing other operations. The
setText() and getText() methods are used to access the label's text. You'll see an example of using
labels in the section "Handling Events," later in this chapter.
Buttons
Buttons are another fundamental GUI component. Unlike labels, which are used solely to provide
information to the user, buttons allow users to interact with your applets and applications. The
clicking of a button triggers an event that can be handled by your GUI. You'll learn about event
handling in the next section.
The Button class of java.awt provides the capability to use labeled buttons in your GUI. The Button
class has two constructors: a default parameterless constructor that creates unlabeled buttons, and a
constructor that takes a String object (the button's label) as a parameter. The Button class provides 10
methods for getting and setting the buttons label and handling button-related events. These methods
are as follows:
●
setLabel()--Sets the label displayed on the button.
●
getLabel()--Returns the label displayed on the button.
●
paramString()--Returns the button's state as a String object.
●
●
●
●
●
●
●
addNotify()--Causes the button's peer to be created. This peer is the native windowing
system's button implementation. This method is automatically invoked when a Button object
is added to a container and should not be invoked directly by user code.
addActionListener()--Adds an object that implements the ActionLister interface to the list of
objects that are used to handle the button's action events.
removeActionListener()--Removes an object from the list of objects that are used to handle
the button's action events.
processActionEvent()--Causes events to be processed by sending them to the registered
ActionListener objects.
processEvent()--Manages overall event processing for the button.
getActionCommand()--Returns the command associated with the button's action event. This
defaults to the button's label.
setActionCommand()--Sets the command associated with the button's action event.
Most of these methods are used for handling button-related events. The following section provides an
introduction to Java event handling.
Handling Events
The user communicates with window programs by performing actions such as clicking a mouse
button or pressing a key on the keyboard. These actions result in the generation of events. The
process of responding to an event is known as event handling. Window programs are said to be eventdriven because they operate by performing actions in response to events.
The JDK 1.02 supported an approach to event handling referred to as an inheritance model. In this
approach, events are handled by subclassing window components and overriding their action() and
handleEvent() methods. These methods return true or false to indicate whether they have successfully
handled an event. If a true value is returned, the event processing is complete. Otherwise, the event is
sent to the object's container for further processing.
The JDK 1.02 approach to event handling was replaced by an event delegation model in JDK 1.1;
however, the old inheritance event model was still supported. The event delegation model provides
the capability to deliver events to specific objects--a capability that was lacking in JDK 1.02. The
event delegation approach is less complex and more efficient. It uses special classes, called adapter
classes, whose objects listen for the occurrence of events on behalf of objects of other classes.
NOTE: The JDK 1.02 event model is being phased out, and you should no longer use
it. JDK 1.2 relies heavily on the JDK 1.1 event delegation model. When you study
Swing in Part 4, you'll find that it relies entirely on the event delegation model, which
wasn't frozen in JDK 1.1. In fact, there are new event classes that have been added in
JDK 1.2--especially in Swing. However, the term "JDK 1.1 event model" is often used
to refer to the event delegation model, since it was introduced with JDK 1.1.
In the event delegation model, event handling is delegated to specific event handling adapter classes.
In this model, a source object generates events that are listened for by a listener object. The source
object is usually a window GUI component, such as a button. The listener object is an adapter class
that implements an event listener interface. The source object provides methods that allow listener
objects to register themselves to listen for its events. For example, an object that handles the clicking
of a button implements the ActionListener interface. This object is registered with a particular button
via the button's addActionListener()method.
NOTE: Many of the adapter classes are provided in the java.awt.event package. These
classes can be extended to support custom event handling.
The JDK 1.1 event model is a significant improvement over that of Java 1.02, which required GUI
components to be subclassed in order to handle events. Although it is still possible to do so in JDK
1.1, it is no longer necessary. Events can be handled by adapter classes that are separate from the
component from which the event is generated.
The following subsections describe the classes and interfaces used for JDK 1.02 event handling,
followed by those used for JDK 1.1 event handling.
JDK 1.02 Event Handling
In the JDK 1.02 inheritance model, the Event class encapsulates all Windows event processing. The
Event class defines the entire list of events handled by window programs using class constants. These
constants are used to identify the events that are passed to event-handling methods. You can review
the Java API description of the Event class to familiarize yourself with these constants.
The Event class provides three constructors for creating events, but you probably won't need to use
these constructors because events are internally generated by the Java runtime system in response to
user interface actions. The Event class also provides methods for determining whether the Ctrl, Shift,
or Meta (Alt) keys were pressed during the generation of an event.
JDK 1.1 Event Handling
In the JDK 1.1 event delegation model, the java.util.EventObject class is the top-level class of an
event hierarchy. This class provides a source field variable to identify the object that is the source of
an event, a getSource() method to retrieve this object, and a toString() method to convert an event
into a String representation. It provides a single constructor that takes the object that is the source of
the event as an argument.
The java.awt.AWTEvent class extends the java.util.EventObject class to support AWT events. It
provides several variables, constants, and methods that are used to identify events and determine
whether they are consumed. The AWTEvent class is extended by the following classes of java.awt.
event:
●
●
●
●
●
ActionEvent--Generated by user interface actions, such as clicking on a button or selecting a
menu item.
AdjustmentEvent--Generated by scrolling actions.
ComponentEvent--Generated by changes to the position, focus, or sizing of a window
component, or by a keyboard input or other mouse action.
InputMethodEvent--Generated by changes to the text being entered via an input method.
InvocationEvent--Generated by the invocation of the invokeLater() and invokeAndWait()
methods of the java.awt.EventQueue class.
●
ItemEvent--Generated by a component state change, such as selecting an item from a list.
●
TextEvent--Generated by text-related events, such as changing the value of a text field.
The ComponentEvent class is further extended by the following classes:
FocusEvent--Generated by a change in the status of a component's input focus.
●
●
●
●
InputEvent--Subclassed by KeyEvent and MouseEvent to cover events generated by keyboard
actions and low-level mouse events.
ContainerEvent--Generated by events associated with adding and removing components from
a container.
PaintEvent--Generated by the painting/repainting of a window.
WindowEvent--Generated by events such as the opening, closing, and minimizing of a
window.
The AWTEvent class and its subclasses allow window-related events to be directed to specific
objects that listen for those events. These objects implement EventListener interfaces. The java.util.
EventListener interface is the top-level interface of the event listener hierarchy. It is an interface in
name only because it does not define any constants or methods. It is extended by the following
interfaces of java.awt.event:
●
ActionListener--Implemented by objects that handle ActionEvent events.
●
AdjustmentListener--Implemented by objects that handle AdjustmentEvent events.
●
ComponentListener--Implemented by objects that handle ComponentEvent events.
●
ContainerListener--Implemented by objects that handle ContainerEvent events.
●
EventQueueListener--Implemented by objects that monitor the system event queue.
●
FocusListener--Implemented by objects that handle FocusEvent events.
●
InputMethodListener--Implemented by objects that handle InputMethodEvent events.
●
ItemListener--Implemented by objects that handle ItemEvent events.
●
KeyListener--Implemented by objects that handle KeyEvent events.
●
MouseListener--Implemented by objects that handle clicking-related MouseEvent events.
●
MouseMotionListener--Implemented by objects that handle movement-related MouseEvent
events.
●
TextListener--Implemented by objects that handle TextEvent events.
●
WindowListener--Implemented by objects that handle WindowEvent events.
As a convenience, the java.awt.event package provides adapter classes that implement the event
listener interfaces. These classes may be subclassed to override specific event handling methods of
interest. The adapter classes of java.awt.event are as follows:
●
●
ComponentAdapter--Implements the ComponentListener interface and handles
ComponentEvent events.
ContainerAdapter--Implements the ContainerListener interface and handles ContainerEvent
events.
●
FocusAdapter--Implements the FocusListener interface and handles FocusEvent events.
●
KeyAdapter--Implements the KeyListener interface and handles KeyEvent events.
●
●
●
MouseAdapter--Implements the MouseListener interface and handles clicking-related
MouseEvent events.
MouseMotionAdapter--Implements the MouseListener interface and handles movementrelated MouseEvent events.
WindowAdapter--Implements the WindowListener interface and handles WindowEvent
events.
These adapter classes are convenience classes, in that they provide stubs for the methods of the
interfaces that you don't want to implement yourself.
The java.awt.EventQueue class supports the queuing of events. It allows event listeners to monitor
the queue and retrieve specific events for processing.
The java.awt.AWTEventMulticaster class provides the capability to listen for multiple events and
then forward them to multiple event listeners. It provides a thread-safe mechanism by which event
listeners can be added and removed from its event listening destination list.
The Buttons Applet
The Buttons applet, shown in Listing 6.1, ties together what you've learned about the Label and
Button classes and AWT event handling. Listing 6.2 shows an HTML file that can be used to run the
Buttons applet with the appletviewer tool.
The Buttons applet declares and constructs a Label object called "Default Label" and assigns the
object to the label variable. It then creates three Button objects, labeled "One," "Two," and "Three,"
and assigns them to the button1, button2, and button3 variables. It then creates two Panel objects and
assigns them to the panel1 and panel2 variables. Panel objects are objects that are used to contain and
organize other GUI objects. You'll learn about them in the section "Components and Containers,"
later in this chapter.
The init() method sets the layout for the applet to an object of the BorderLayout class. Layouts are
used to determine how GUI objects are displayed within a container. You'll learn about them later in
this chapter in the section "Using Layouts." The Applet class is a subclass of the Panel class. This
allows applets to act as containers.
The add() method of the Panel object referenced by panel1 is invoked to add the label to the panel.
The addActionLister() method is used to set up objects of the ButtonHandler class to handle the
events associated with the three buttons. The buttons are then added to the second panel. The first
panel is then added to the top (north) part of the applet display area, and the second panel is added to
the center of the applet display area.
The ButtonHandler class is an inner class of the Buttons class. It is used to handle events associated
with the clicking of the applet's buttons. It implements the actionPerformed() method of the
ActionListener interface. The actionPerformed() method is invoked to handle the clicking of the
buttons for which the ButtonHandler objects are registered. It uses the getActionCommand() method
to get the label of the button that was clicked. It then invokes the setText() method to set the label of
the Label object to the button's label.
Figure 6.1 shows how the Buttons applet is displayed. When you click any of the three buttons, the
label is updated to identify the button that was last clicked, as shown in Figure 6.2.
FIGURE 6.1. The initial display of the Buttons applet.
FIGURE 6.2. The label is updated to identify the button that was clicked.
LISTING 6.1. THE Buttons APPLET.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class Buttons extends Applet {
Label label = new Label("Default Label");
Button button1 = new Button("One");
Button button2 = new Button("Two");
Button button3 = new Button("Three");
Panel panel1 = new Panel();
Panel panel2 = new Panel();
public void init() {
setLayout(new BorderLayout());
panel1.add(label);
button1.addActionListener(new ButtonHandler());
button2.addActionListener(new ButtonHandler());
button3.addActionListener(new ButtonHandler());
panel2.add(button1);
panel2.add(button2);
panel2.add(button3);
add("North",panel1);
add("Center",panel2);
}
class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent e){
String s = e.getActionCommand();
label.setText(s);
}
}
}
LISTING 6.2. AN HTML FILE FOR RUNNING THE Buttons APPLET.
<HTML>
<HEAD>
<TITLE>Labels, Buttons, and Events</TITLE>
</HEAD>
<BODY>
<APPLET CODE="Buttons.class" WIDTH=400 HEIGHT=250>
</APPLET>
</BODY>
</HTML>
Components and Containers
The Component class is the superclass of the set of AWT classes that implement graphical user
interface controls. These components include windows, dialog boxes, buttons, labels, text fields, and
other common GUI components. The Component class provides a common set of methods that are
used by all these subclasses, including methods for working with event handlers, images, fonts, and
colors. More than 100 methods are implemented by this class. It is a good idea to browse the API
pages of the Component class to get a feel for the kinds of methods that are available.
Although Component contains many GUI-related subclasses, its Container subclass is used to define
components that can contain other components. It provides methods for adding, retrieving,
displaying, counting, and removing the components that it contains. The Container class also
provides methods for working with layouts. The layout classes control the layout of components
within a container.
The Container class has three major subclasses: Window, Panel, and ScrollPane. Window provides a
common superclass for application main windows (Frame objects) and Dialog windows. You'll learn
about these classes in Chapter 9, "Creating Window Applications." The Panel class is a generic
container that can be displayed within an applet or window. It is subclassed by the java.applet.Applet
class as the base class for all Java applets. The ScrollPane class is a scrollable container that can have
vertical and horizontal scrollbars.
In the Buttons applet, we used two Panel objects to act as containers for the Label and Button objects
that were displayed as part of the applet's GUI.
Using Layouts
The method by which the components of a Container object are organized is determined by an object
that implements the LayoutManager interface. The layout of a Container is specified using the
setLayout() method of the Container class. It passes an object that implements the LayoutManager
interface as a parameter. For example, in the Buttons applet, the applet's layout was set as an object of
the BorderLayout class.
The LayoutManager and LayoutManager2 Interfaces
The LayoutManager interface provides a set of methods that are implemented by classes that control
the layout of a container. These methods include those that add or remove components from a layout,
specify the size of the container, and lay out the components of the container. The LayoutManager2
interface extends the LayoutManager interface to deal with constraint-based layouts.
The BorderLayout Class
The BorderLayout class is used to lay out the GUI components contained in a Container object. It
lays out components along the north, south, east, and west borders of the container and in the center
of the container. The center component gets any space left over from the north, south, east, and west
border components. It is the default layout for Window, Frame, and Dialog objects and provides the
capability to specify the horizontal and vertical gap between the laid-out components and the
container.
The CardLayout Class
The CardLayout class is used to lay out the components of a Container object in the form of a deck of
cards in which only one card is visible at a time. The class provides methods that are used to specify
the first, last, next, and previous components in the container.
The FlowLayout Class
The FlowLayout class is used to lay out the components of a Container object in a left-to-right, top-tobottom fashion. It is the default layout used with Panel objects. It allows the alignment of the
components it lays out to be specified by the LEFT, CENTER, and RIGHT constants.
The GridLayout Class
The GridLayout class is used to lay out the components of a Container object in a grid in which all
components are the same size. The GridLayout constructor is used to specify the number of rows and
columns of the grid.
The GridBagLayout Class
The GridBagLayout class lays out the components of a Container object in a grid-like fashion in
which some components may occupy more than one row or column. The GridBagConstraints class is
used to identify the positioning parameters of a component that is contained within an object laid out
using a GridBagLayout. The Insets class is used to specify the margins associated with an object that
is laid out using a GridBagLayout object. Refer to the API description of the GridBagLayout class for
more information on how to use this layout.
The Layouts Applet
The Layouts applet, shown in Listing 6.3, provides an example of using containers and layouts. This
applet is run using the HTML file provided in Listing 6.4. When you run the Layouts applet using
appletviewer, it displays the opening window shown in Figure 6.3. You can click the Border, Flow,
Card, Grid, and GridBag buttons in the top panel to change the layout displayed in the panel below it.
Figures 6.4 through 6.7 show the other layouts that are displayed. When you select the Card layout, a
bottom panel is displayed (see Figure 6.4) that contains the First, Last, Next, and Previous buttons.
These buttons are used to move through the card deck of buttons displayed in the middle panel. Play
with the applet to familiarize yourself with its operation before going on to the next section, which
describes how the Layouts applet works.
FIGURE 6.3. An example of a BorderLayout.
FIGURE 6.4. An example of a CardLayout.
FIGURE 6.5. An example of a FlowLayout.
FIGURE 6.6. An example of a GridLayout.
FIGURE 6.7. An example of a GridBagLayout.
LISTING 6.3. THE Layouts APPLET.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class Layouts extends Applet {
Panel[] panels;
Panel currentPanel;
static int border=0;
static int card=1;
static int flow=2;
static int grid=3;
static int gridBag=4;
String[] layouts = {"Border","Card","Flow","Grid","GridBag"};
String[] cards = {"First","Last","Next","Previous"};
Button[] layoutButtons = new Button[layouts.length];
Button[] navigateButtons = new Button[cards.length];
Panel layoutButtonPanel = new Panel();
Panel navigateButtonPanel = new Panel();
public void init(){
setLayout(new BorderLayout());
setupButtons();
add("North",layoutButtonPanel);
setupDisplayPanels();
}
void setupButtons() {
for(int i=0;i<layouts.length;++i) {
layoutButtons[i] = new Button(layouts[i]);
layoutButtons[i].addActionListener(new ButtonHandler());
layoutButtonPanel.add(layoutButtons[i]);
}
for(int i=0;i<cards.length;++i) {
navigateButtons[i] = new Button(cards[i]);
navigateButtons[i].addActionListener(new ButtonHandler());
navigateButtonPanel.add(navigateButtons[i]);
}
}
void setupDisplayPanels() {
panels = new Panel[5];
for(int i=0;i<5;++i) panels[i]=new Panel();
panels[border].setLayout(new BorderLayout());
panels[card].setLayout(new CardLayout());
panels[flow].setLayout(new FlowLayout());
panels[grid].setLayout(new GridLayout(2,3));
GridBagLayout gridBagLayout = new GridBagLayout();
panels[gridBag].setLayout(gridBagLayout);
panels[border].add("North",new Button("North"));
panels[border].add("South",new Button("South"));
panels[border].add("East",new Button("East"));
panels[border].add("West",new Button("West"));
panels[border].add("Center",new Button("Center"));
String cardButtons[] = {"First","Second","Third","Fourth","Last"};
String flowButtons[] = {"One","Two","Three","Four","Five"};
String gridButtons[] =
{"(0,0)","(1,0)","(2,0)","(0,1)","(1,1)","(2,1)"};
for(int i=0;i<cardButtons.length;++i)
panels[card].add("next card",new Button(cardButtons[i]));
for(int i=0;i<flowButtons.length;++i)
panels[flow].add(new Button(flowButtons[i]));
for(int i=0;i<gridButtons.length;++i)
panels[grid].add(new Button(gridButtons[i]));
Button gridBagButtons[] = new Button[9];
for(int i=0;i<9;++i) gridBagButtons[i] = new Button("Button"+i);
int gridx[] = {0,1,2,0,2,0,1,1,0};
int gridy[] = {0,0,0,1,1,2,2,3,4};
int gridwidth[] = {1,1,1,2,1,1,1,2,3};
int gridheight[] = {1,1,1,1,2,2,1,1,1};
GridBagConstraints gridBagConstraints[] = new GridBagConstraints
[9];
for(int i=0;i<9;++i) {
gridBagConstraints[i] = new GridBagConstraints();
gridBagConstraints[i].fill=GridBagConstraints.BOTH;
gridBagConstraints[i].gridx=gridx[i];
gridBagConstraints[i].gridy=gridy[i];
gridBagConstraints[i].gridwidth=gridwidth[i];
gridBagConstraints[i].gridheight=gridheight[i];
gridBagLayout.setConstraints(gridBagButtons[i],gridBagConstraints
[i]);
panels[gridBag].add(gridBagButtons[i]);
}
add("Center",panels[border]);
currentPanel=panels[border];
}
void switchPanels(Panel newPanel,boolean setNavigateButtons) {
remove(currentPanel);
currentPanel=newPanel;
add("Center",currentPanel);
remove(navigateButtonPanel);
if(setNavigateButtons) add("South",navigateButtonPanel);
validate();
}
class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent ev){
String s=ev.getActionCommand();
if(s.equals("Border")) switchPanels(panels[border],false);
else if(s.equals("Card")) switchPanels(panels[card],true);
else if(s.equals("Flow")) switchPanels(panels[flow],false);
else if(s.equals("Grid")) switchPanels(panels[grid],false);
else if(s.equals("GridBag")) switchPanels(panels[gridBag],false);
else if(s.equals("First")){
CardLayout currentLayout=(CardLayout)currentPanel.getLayout();
currentLayout.first(currentPanel);
}else if(s.equals("Last")){
CardLayout currentLayout=(CardLayout)currentPanel.getLayout();
currentLayout.last(currentPanel);
}else if(s.equals("Next")){
CardLayout currentLayout=(CardLayout)currentPanel.getLayout();
currentLayout.next(currentPanel);
}else if(s.equals("Previous")){
CardLayout currentLayout=(CardLayout)currentPanel.getLayout();
currentLayout.previous(currentPanel);
}
}
}
}
LISTING 6.4. AN HTML FILE FOR DISPLAYING THE Layouts APPLET.
<HTML>
<HEAD>
<TITLE>Layouts</TITLE>
</HEAD>
<BODY>
<APPLET CODE="Layouts.class" WIDTH=400 HEIGHT=350>
</APPLET>
</BODY>
</HTML>
How the Layouts Applet Works
The Layouts applet begins by declaring a number of variables for use in the applet. These variables
are used as follows:
●
panels--An array of panels used to hold an example of each of the five layouts.
●
currentPanel--Identifies the current panel being displayed.
●
border--Constant used to identify a BorderLayout.
●
card--Constant used to identify a CardLayout.
●
flow--Constant used to identify a FlowLayout.
●
grid--Constant used to identify a GridLayout.
●
gridBag--Constant used to identify a GridBagLayout.
●
layouts--An array of labels for the layout buttons.
●
cards--An array of labels for the card navigation buttons.
●
layoutButtons--The buttons displayed in the top panel.
●
navigateButtons--The buttons displayed in the bottom panel when a CardLayout is selected.
●
layoutButtonPanel--The panel used to display the layout buttons.
●
navigateButtonPanel--The panel used to display the card navigation buttons.
The init() method sets the applet's layout to a BorderLayout. Note that this layout does not change.
Only the layout of the middle panel is changed by clicking the layout buttons. The init() method
invokes the setupButtons() method to initialize the layout and navigation buttons. It adds the panel
used to display the layout buttons at the top (north) of the applet's display. It then invokes the
setupDisplayPanels() method to set up the panels that are used to display the various layouts.
The setupButtons() method initializes the elements of the layoutButtons and navigateButtons arrays,
sets up their event handlers, and adds the buttons to the layoutButtonPanel and navigateButtonPanel.
The setupDisplayPanels() method creates each of the five layout panels, lays them out, and adds
buttons to them. The buttons are used for display purposes and do not handle any events. The panels
are indexed by the border, flow, card, grid, and gridBag constants. The gridx, gridy, gridwidth, and
gridheight arrays are used to set up the GridBagConstraints object for the GridBagLayout. These
constraints determine the position and dimension of the objects being laid out. The panel with the
BorderLayout is the first panel displayed, and is added to the center of the applet's display area.
The switchPanels() method is used to remove the current layout panel being displayed and to add the
new panel identified by the newPanel parameter. The setNavigateButtons parameter determines
whether the card navigation buttons panel is displayed at the bottom of the applet's display area. The
validate() method causes the applet to be laid out and its components to be redisplayed.
The ButtonHandler class provides the event handling for the layout and card navigation buttons. This
event handling is performed by the actionPerformed() method. The layout buttons are handled by
invoking the switchPanels() method to display a new layout panel. The navigation buttons are
handled by invoking the first(), last(), next(), and previous() methods of the CardLayout class to
display other buttons in the card deck.
Using a null Layout for Absolute Positioning
In the preceding sections, you learned how to use the standard AWT layouts to organize the way GUI
components are displayed within a container. But what if you want to organize your GUI in a way
that is not easily supported by the standard layouts? The answer is to use a null layout and to position
and size your components using absolute values. The setBounds() method of the Component class is
used to specify both the position and dimensions of how a component is displayed. Because
setBounds() is defined in the Component class, it can be used with all of the Component subclasses.
NOTE: The upper-left corner of a container is position (0,0). The x-coordinate
increases as you move to the right. The y-coordinate increases as you move down.
The Positions Applet
The Positions applet, shown in Listing 6.5, illustrates the use of the null layout. The HTML file
contained in Listing 6.6 is used to display this applet. The applet's display is shown in Figure 6.8.
Note that this GUI organization is not easily supported by any of the standard layouts.
The Positions applet is short and simple, but it shows how the null layout can be used to produce
custom layouts. Two labels and two buttons are declared and initialized. These buttons and labels
identify the (x,y) coordinates at which they are located. The init() method sets the applet's layout to
null, invokes the setBounds() method for each of the labels and buttons, and then adds the labels and
buttons to the applet container. The setBounds() method used in this example takes the following four
parameters:
The horizontal position of the component.
●
The vertical position of the component.
●
The component's width.
●
The component's height.
Other variations of the setBounds() method are also available. Consult the API description of the
Component class for more information.
FIGURE 6.8. The Positions applet displays GUI components using a null layout.
LISTING 6.5. THE Positions APPLET.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class Positions extends Applet {
Label label1 = new Label("Label at (10,10)");
Label label2 = new Label("Label at (100,100)");
Button button1 = new Button("Button at (150,150)");
Button button2 = new Button("Button at (200,200)");
public void init() {
setLayout(null);
label1.setBounds(10,10,200,30);
label2.setBounds(100,100,200,30);
button1.setBounds(150,150,150,30);
button2.setBounds(200,200,250,60);
add(label1);
add(label2);
add(button1);
add(button2);
}
}
LISTING 6.6. AN HTML FILE DISPLAYING THE Positions APPLET.
<HTML>
<HEAD>
<TITLE>Positions</TITLE>
</HEAD>
<BODY>
<APPLET CODE="Positions.class" WIDTH=500 HEIGHT=350>
</APPLET>
</BODY>
</HTML>
Text Components
The TextComponent class is the superclass of all text-based classes. It provides a common set of
methods used by its TextField and TextArea subclasses. It does not provide any constructors and
cannot be instantiated. It provides methods for getting and setting the text that is displayed in a text
object, setting the text object to an editable or read-only state, handling text-editing events, and
selecting text that is contained within an object.
TextField
The TextField class implements a one-line text entry field. It provides four constructors that are used
to specify the width of the text field in character columns and the default text to be displayed within
the field. It provides several methods for accessing the field's size and for specifying whether the
characters typed by the user should be displayed. The setEchoCharacter() method is used to specify a
character that is to be displayed in lieu of text typed by the user. This method is used to implement
password-like fields.
TextArea
The TextArea class implements scrollable text entry objects that span multiple lines and columns. It
provides five constructors that allow the number of rows and columns and the default text display to
be specified. It provides several methods that return the dimensions of the text area and then insert,
append, and replace the text that is contained in that text area. It also provides the capability to set the
text to read-only or edit mode.
The Text Applet
The Text applet, shown in Listing 6.7, illustrates the use of the TextField and TextArea classes.
Listing 6.8 provides an HTML file for displaying this applet. When you run the applet with
appletviewer, it displays the GUI shown in Figure 6.9. Enter text in the text field and then click the
Append button. The text is appended to the text displayed in the text area, as shown in Figure 6.10.
The Clear button is used to clear the text displayed in the text area.
The Text applet begins by declaring and initializing the TextField, TextArea, and Button objects. The
init() method sets the applet's layout to null and uses setBounds() to position and size the GUI
components. The event handlers for the Append and Clear buttons are registered, and all of the
components are added to the applet container.
The actionPerformed() method of the ButtonHandler class handles the clicking of the Append button
by using the getText() method to get the text contained in the TextArea and TextField objects. It
appends the text from the TextField object to the text of the TextArea object, and then invokes the
setText() method to put the appended text back into the TextArea object. The Clear button is handled
by using setText() to set the text of the TextArea object to a blank string.
FIGURE 6.9. The Text applet's initial display.
FIGURE 6.10. The text area is updated with the text field's contents.
LISTING 6.7. THE Text APPLET.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class Text extends Applet {
TextField textField = new TextField();
TextArea textArea = new TextArea();
Button append = new Button("Append");
Button clear = new Button("Clear");
public void init() {
setLayout(null);
textField.setBounds(10,10,280,25);
textArea.setBounds(10,50,280,150);
append.setBounds(10,210,75,25);
clear.setBounds(100,210,75,25);
append.addActionListener(new ButtonHandler());
clear.addActionListener(new ButtonHandler());
add(textField);
add(textArea);
add(append);
add(clear);
}
class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent ev){
String s=ev.getActionCommand();
if(s.equals("Append")) {
String text = textArea.getText()+textField.getText();
textArea.setText(text);
}else if(s.equals("Clear")) textArea.setText("");
}
}
}
LISTING 6.8. AN HTML FILE FOR DISPLAYING THE Text APPLET.
<HTML>
<HEAD>
<TITLE>TextFields and TextAreas</TITLE>
</HEAD>
<BODY>
<APPLET CODE="Text.class" WIDTH=300 HEIGHT=300>
</APPLET>
</BODY>
</HTML>
Checkboxes
The Checkbox class is used to implement labeled checkbox and radio button GUI controls. If a
Checkbox object is not associated with a CheckboxGroup object, it is implemented as a traditional
checkbox. If a Checkbox object is associated with a CheckboxGroup object, it is implemented as a
radio button.
The Checkbox class provides five constructors that allow the checkbox label, initial state, and
CheckboxGroup object to be specified. The Checkbox class provides methods for getting and setting
the label and state of the checkbox and its CheckboxGroup object, if any. The state of the checkbox is
boolean. The Checkbox class also provides methods for identifying event handling code.
The CheckboxGroup class is used with the Checkbox class to implement radio buttons. All Checkbox
objects that are associated with a CheckboxGroup object are treated as a single set of radio buttons.
Only one button in the group may be set to "on" at a given point in time. The CheckboxGroup
provides a single, parameterless constructor. It also provides methods for getting and setting the
Checkbox object.
The CheckboxTest Applet
The CheckboxTest applet, shown in Listing 6.9, illustrates the use of checkboxes and radio buttons. It
uses the CheckboxPanel and CheckboxGroupPanel classes that are defined in Listings 6.10 and 6.11.
Listing 6.12 provides an HTML file for displaying the CheckboxTest applet.
The initial display of the CheckboxTest applet is shown in Figure 6.11. A list of checkboxes is
displayed on the left, and a list of radio buttons is displayed on the right. When you click on a
checkbox or radio button, the event is handled by displaying the action performed in the text area at
the bottom of the applet display area.
The CheckboxTest applet begins by declaring objects of the CheckboxPanel, CheckboxGroupPanel,
and TextArea classes. The init() method sets the applets layout to a BorderLayout object, creates a
new CheckboxHandler object, and declares the sports array for setting up the checkboxes. A new
CheckboxPanel object is created by passing a prompt, the sports array, a orientation constant, and the
CheckboxHandler object as parameters to the object's constructor. The CheckboxPanel object is
added to the left (west) side of the applet display area. A CheckboxGroupPanel object is created in a
similar fashion and added to the right (east) of the applet's display. Finally, the TextArea object is
added to the bottom (south) of the applet's display.
The itemStateChanged() method of the CheckboxHandler class handles the ItemEvent that is
generated by clicking a checkbox or radio button. It invokes the getItemSelectable() method to obtain
a reference to the object that was selected (or deselected). It uses the getState() method to determine
the object's selection status and the getLabel() method to retrieve the object's label. The selection
results are then displayed to the TextArea object at the bottom of the screen.
Checkboxes are easy to use but tedious to construct and organize. The CheckboxPanel class provides
a more convenient approach to creating and organizing checkboxes. Typically, checkboxes are
created in groups and organized in a panel that is given a title. The CheckboxPanel class provides a
constructor for quickly creating objects of this type. It also provides access methods for getting and
setting the value of an individual checkbox within the panel, based on the checkbox's label.
Two CheckboxPanel constructors are provided. The first constructor uses a title string for the panel,
an array of labels to be associated with the checkboxes, an orientation parameter that specifies
whether the panel is to be organized in a vertical or horizontal fashion, and an ItemListener object to
handle checkbox events.
A GridLayout object is used to organize the Label and Checkbox objects placed within the panel. The
title is added at the top of vertical panels and on the left side of horizontal panels. Then the
checkboxes are created, one at a time, and they fill in the rest of the panel.
The second constructor is similar to the first constructor, except that it uses an additional state[] array
to set the initial state of the checkboxes that are added to the panel. The state of each checkbox is set
using the setState() method of the Checkbox class.
The getState() method takes the label of a checkbox as its parameter, and searches the checkboxes
contained in the panel for one whose label matches the specified label. It then returns the state of this
checkbox. If no matching checkbox is found, it returns false.
The setState() method is similar to the getState() method. It is used to update a checkbox with a given
label.
The CheckboxGroupPanel class extends the CheckboxPanel class to work with radio buttons. The
Checkbox panel constructors are overridden to place the checkboxes in the panel of a single group. If
the second constructor is used, only one checkbox should be specified as being in the "on" state.
The putInGroup() method uses the getComponents() method inherited from the Container class to
create an array of the components contained in the panel. It creates a CheckboxGroup object and then
indexes through the array, putting all checkboxes into this group using the setCheckboxGroup()
method. The first component is skipped because it is the title of the panel.
FIGURE 6.11. The CheckboxTest applet.
LISTING 6.9. THE CheckboxTest APPLET.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class CheckboxTest extends Applet {
CheckboxPanel checkboxPanel;
CheckboxGroupPanel checkboxGroupPanel;
TextArea textArea = new TextArea(5,20);
public void init() {
setLayout(new BorderLayout());
CheckboxHandler ch = new CheckboxHandler();
String sports[] =
{"Baseball","Basketball","Football","Hockey","Soccer"};
checkboxPanel = new CheckboxPanel("What team sports do you like?
",
sports,CheckboxPanel.VERTICAL,ch);
add(checkboxPanel,"West");
String ages[] = {"under 20","20 - 39","40 - 59","60 - 79","80 and
over"};
checkboxGroupPanel = new CheckboxGroupPanel("What is your age? ",
ages,CheckboxPanel.VERTICAL,ch);
add(checkboxGroupPanel,"East");
add(textArea,"South");
}
class CheckboxHandler implements ItemListener {
public void itemStateChanged(ItemEvent e){
String status;
Checkbox checkbox = (Checkbox) e.getItemSelectable();
if(checkbox.getState()) status = "You checked: ";
else status = "You unchecked: ";
status+=checkbox.getLabel();
textArea.setText(status);
}
}
}
LISTING 6.10. THE CheckboxPanel CLASS.
import java.awt.*;
import java.awt.event.*;
public class CheckboxPanel extends Panel {
public static int HORIZONTAL = 0;
public static int VERTICAL = 1;
public CheckboxPanel(String title,String labels[],int orientation,
ItemListener ih) {
super();
int length = labels.length;
if(orientation == HORIZONTAL) setLayout(new GridLayout(1,length
+1));
else setLayout(new GridLayout(length+1,1));
add(new Label(title));
for(int i=0;i<length;++i){
Checkbox ch = new Checkbox(labels[i]);
ch.addItemListener(ih);
add(ch);
}
}
public CheckboxPanel(String title,String labels[],boolean state[],
int orientation,ItemListener ih) {
super();
int length = labels.length;
if(orientation == HORIZONTAL) setLayout(new GridLayout(1,length
+1));
else setLayout(new GridLayout(length+1,1));
add(new Label(title));
for(int i=0;i<length;++i){
Checkbox ch = new Checkbox(labels[i]);
ch.setState(state[i]);
ch.addItemListener(ih);
add(ch);
}
}
public boolean getState(String label) {
Checkbox boxes[] = (Checkbox[])getComponents();
for(int i=0;i<boxes.length;++i)
if(label.equals(boxes[i].getLabel())) return boxes[i].getState();
return false;
}
public void setState(String label,boolean state) {
Checkbox boxes[] = (Checkbox[])getComponents();
for(int i=0;i<boxes.length;++i)
if(label.equals(boxes[i].getLabel())) boxes[i].setState(state);
}
}
LISTING 6.11. THE CheckboxGroupPanel CLASS.
import java.awt.*;
import java.awt.event.*;
public class CheckboxGroupPanel extends CheckboxPanel {
public CheckboxGroupPanel(String title,String labels[],int
orientation,
ItemListener ih) {
super(title,labels,orientation,ih);
putInGroup();
}
public CheckboxGroupPanel(String title,String labels[],boolean
state[],
int orientation, ItemListener ih) {
super(title,labels,state,orientation,ih);
putInGroup();
}
void putInGroup() {
Component components[] = getComponents();
int length = components.length;
CheckboxGroup group = new CheckboxGroup();
for(int i=1;i<length;++i){
Checkbox checkBox = (Checkbox) components[i];
checkBox.setCheckboxGroup(group);
}
}
}
LISTING 6.12. AN HTML FILE FOR DISPLAYING THE CheckboxTest APPLET.
<HTML>
<HEAD>
<TITLE>Checkboxes and Checkbox Groups</TITLE>
</HEAD>
<BODY>
<APPLET CODE="CheckboxTest.class" WIDTH=400 HEIGHT=350>
</APPLET>
</BODY>
</HTML>
Choices and Lists
The Choice class is used to implement pull-down lists that can be placed in the main area of a
window. These lists are known as option menus or a pop-up menu of choices and allow the user to
select a single menu value. The Choice class provides a single, parameterless constructor. It also
provides access methods that are used to add items to the list, count the number of items contained in
the list, select a list item, handle events, and determine which list item is selected.
The List class implements single- and multiple-selection list GUI controls. The lists provided by the
List class are more sophisticated than those provided by the Choice class. The List class lets you
specify the size of the scrollable window in which the list items are displayed and select multiple
items from the list. The List class has three constructors. The first one takes no parameters and
constructs a generic List object. The second one allows the number of rows of the visible window to
be specified. The third one allows the number of rows to be specified, as well as whether or not
multiple selections are allowed.
The List class provides several access methods that are used to add, delete, and replace list items,
count the number of items in the list, determine which items are selected, handle events, and select
items within the list.
The Chooser Applet
The Chooser applet, shown in Listing 6.13, illustrates the use of choices and lists. It uses the
MyChoice and MyList classes, shown in Listings 6.14 and 6.15. Listing 6.16 provides an HTML file
for running the Chooser applet.
The Chooser applet lets you decide what you want to eat for your next meal. Make sure that you have
food on hand when you run the ChoiceListApp program. Its opening window is shown in Figure
6.12. The choice list, shown on the left side of the window, is used to select a meal. This selection
determines which menu items are displayed in the list shown on the right side of the window. More
than one item can be selected from the entree list. The text field on the bottom of the screen identifies
the selections that you have made. Select Lunch from the choice list. Notice that the entree list is
updated with some typical lunch items. The text field tells you that you are now ordering lunch.
When you select Dinner from the choice list you get some dinner entrees, as shown in Figure 6.13.
The text field is updated to list your new selections.
The Chooser applet declares several field variables. The mealChoice variable is used to refer to the
MyChoice object that displays the meals identified in the meals array. Two MyList variables are
declared. The mealList array holds the three MyList objects used for breakfast, lunch, and dinner.
These items are stored in the mealChoices array. The currentList variable points to the current menu
entree list being displayed. The text variable refers to the TextField object displayed on the bottom of
the window.
The init() method sets the applet's layout to BorderLayout and invokes the setupChoice() and
setupLists() methods to set up the MyChoice and MyList objects. The text field is initialized to be 40
characters wide, and then the user interface objects are placed in the appropriate places in the applet
display area.
The setupChoice() method constructs the mealChoice object and sets up its event handler. The
setupLists() method sets up the mealList object by indexing through the mealChoices[] array and
setting up the individual MyList objects.
The ChoiceHandler inner class handles the events associated with the MyChoice object assigned to
mealChoice. It does so by updating the MyList object displayed on the right side of the applet
display. It uses the remove() method of the Container class to remove the currently displayed MyList
object, and then adds the MyList object corresponding to the selected meal choice. The validate()
method is invoked to update the applet's display.
The ListHandler inner class handles the events associated with the meal lists that are implemented as
MyList objects. It invokes the getSelectedItem() method of the Choice class to determine which meal
was selected, and the getSelectedItems() method of the List class to obtain an array containing the
selected list items associated with the meal. It combines the meal choice and associated entrees into a
string that is displayed in the TextArea object.
The MyChoice class simplifies the construction of a Choice object. Rather than constructing a Choice
object and adding all of the items in the choice list, the MyChoice constructor takes an array of labels
and adds them to the Choice object as it is constructed. The addItem() method of the Choice class
throws the NullPointerException, and is handled by adding a blank item to the choice list when a null
pointer is encountered.
The MyList class is similar to the MyChoice class in that it allows a list to be constructed using an
array of list items. The MyList constructor also allows the number of rows displayed in the list and
the multiple-selection parameter to be specified.
FIGURE 6.12. The Chooser applet's initial display.
FIGURE 6.13. The Chooser applet's display is updated based on your selections.
LISTING 6.13. THE Chooser APPLET.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class Chooser extends Applet {
MyChoice mealChoice;
MyList currentList;
MyList mealList[];
String meals[] = {"Breakfast","Lunch","Dinner"};
String mealChoices[][] = {
{"pancakes","eggs","bacon","ham","sausage","cereal",
"toast","coffee","juice"},
{"pizza","hamburger","hot dog","burrito","salad","fries",
"chips","soda","milk"},
{"spaghetti","carne asada","barbequed chicken","soup","salad",
"bread","wine","beer","soda","milk"}
};
TextField text;
public void init() {
setLayout(new BorderLayout());
setupChoice();
setupLists();
text = new TextField(40);
add("North",new Label("Place your order:"));
add("South",text);
add("West",mealChoice);
currentList = mealList[0];
add("East",currentList);
}
void setupChoice(){
mealChoice = new MyChoice(meals);
mealChoice.addItemListener(new ChoiceHandler());
}
void setupLists(){
mealList = new MyList[meals.length];
ListHandler lh = new ListHandler();
for(int i=0;i<meals.length;++i){
mealList[i] = new MyList(5,true,mealChoices[i]);
mealList[i].addItemListener(lh);
}
}
class ChoiceHandler implements ItemListener {
public void itemStateChanged(ItemEvent e){
for(int i=0;i<meals.length;++i)
if(meals[i].equals(mealChoice.getSelectedItem())){
Chooser.this.remove(currentList);
currentList = mealList[i];
Chooser.this.add("East",currentList);
text.setText(meals[i]);
}
Chooser.this.validate();
}
}
class ListHandler implements ItemListener {
public void itemStateChanged(ItemEvent e){
String order = mealChoice.getSelectedItem()+": ";
String items[] = currentList.getSelectedItems();
for(int i=0;i<items.length;++i) order += items[i]+" ";
text.setText(order);
}
}
}
LISTING 6.14. THE MyChoice CLASS.
import java.awt.*;
public class MyChoice extends Choice {
public MyChoice(String labels[]) {
super();
int length = labels.length;
for(int i=0;i<length;++i) {
try {
add(labels[i]);
}catch (NullPointerException ex) {
add("");
}
}
}
}
LISTING 6.15. THE MyList CLASS.
import java.awt.*;
public class MyList extends List {
public MyList(int rows,boolean multiple,String labels[]) {
super(rows,multiple);
int length = labels.length;
for(int i=0;i<length;++i) {
try {
add(labels[i]);
}catch (NullPointerException ex) {
add("");
}
}
}
}
LISTING 6.16. AN HTML FILE FOR RUNNING THE Chooser APPLET.
<HTML>
<HEAD>
<TITLE>Choices and Lists</TITLE>
</HEAD>
<BODY>
<APPLET CODE="Chooser.class" WIDTH=300 HEIGHT=200>
</APPLET>
</BODY>
</HTML>
Scrollbars
The Scrollbar class is used to implement vertical and horizontal scrollbars. It provides three
constructors that allow the orientation of the scrollbar to be specified, as well as parameters that
control the scrollbar's operation. It provides several methods that allow the scrollbar's parameters and
current value to be read and set.
When you use scrollbars in your Java programs, you will most likely use them to scroll through a
Graphics object that is associated with a Canvas object or the main application window. (These
objects are covered in the following chapter.) You create and place scrollbars in your window in the
same manner as any other window component. Their position and size within the window are
determined by the layout associated with the window.
Scrollbars are created using the Scrollbar()constructor. Three forms of this constructor are provided.
The default constructor takes no parameters and is not particularly useful, unless you want to create a
Scrollbar object and then specify its orientation and use later in your program. The second
constructor allows the orientation of a Scrollbar object to be specified. The third Scrollbar()
constructor uses the five parameters that are needed to create a working scrollbar: orientation, value,
visible, minimum, and maximum.
The orientation of a scrollbar is specified by the VERTICAL and HORIZONTAL constants defined
by the Scrollbar class. The minimum and maximum parameters specify the minimum and maximum
values associated with the scrollbar's position. These values should map to the object being scrolled.
For example, if you are scrolling a 1,000-line text object, appropriate minimum and maximum values
for a vertical scrollbar would be 0 and 999. Horizontal values could be determined using the
maximum width of the text to be scrolled (in pixels).
The value parameter identifies the starting value associated with the scrollbar. The value parameter is
usually set to the minimum value of the scrollbar. However, suppose you wanted to initiate the
display of an object with its center displayed on the screen. You would then set the scrollbar's value
parameter to the average of its minimum and maximum values.
The visible parameter is used to specify the size of the viewable area of the object being scrolled. For
example, if you are scrolling a 1,000-line text object and the viewable area of the window is 25 lines
long, you would set the visible variable to 25.
The Scrollbar class provides several methods for getting and setting the parameters of a Scrollbar
object. The getOrientation(), getValue(), getVisibleAmount(), getMinimum(), and getMaximum()
methods retrieve the parameter values discussed so far. The getValue() method is used to determine
the position to which the user has scrolled.
The setUnitIncrement() and setBlockIncrement() methods are used to specify the size of a scrollable
unit and page relative to the minimum and maximum values associated with a scrollbar. For example,
when scrolling text, you can set the line increment of a vertical scrollbar to one so that only one line
of text is vertically scrolled. You can set the page increment to 10 to allow 10 lines of text to be
scrolled when the user clicks between the tab and arrows of a scrollbar. The getUnitIncrement() and
getBlockIncrement() methods provide access to the current line- and page-increment values.
The setValue() method allows you to directly set the current position of a scrollbar. The setValues()
method allows you to specify a scrollbar's value, visible, minimum, and maximum parameters.
Scrollbars implement the Adjustable interface. In order to respond to user scrollbar operations and
implement scrolling of the object associated with a scrollbar, you must handle the AdjustmentEvent
generated by user manipulation of the scrollbar. This event is handled by implementing the
AdjustmentListener interface. The adjustmentValueChanged() method of AdjustmentListener is
invoked to handle scrollbar events. It is passed an object of class AdjustmentEvent.
The AdjustmentEvent class provides methods that can be used to retrieve the scrollbar for which the
event was generated, the new value of the scrollbar, and the type of scrolling action that took place.
The Scroller Applet
The Scroller applet, shown in Listing 6.17, introduces the use of the Scrollbar class. Listing 6.18
provides an HTML file for running the Scroller applet.
Figure 6.14 shows the initial display of the Scroller applet. It consists of horizontal and vertical
scrollbars and a label that displays the result of using either of the two scrollbars. Play with the
scrollbars and watch how the label is updated.
The Scroller applet uses the MyScrollbar class to facilitate the creation and use of the horizontal and
vertical scrollbars. The horizontal scrollbar is constructed with a range of 0 to 100, an initial setting
of 50, and a visible window of 10 units. The vertical scrollbar is constructed with a range of 0 to
1000, an initial setting of 500, and a visible window of 100 units. The applet is laid out using a
BorderLayout, with the horizontal scrollbar on top, the vertical scrollbar at left, and the label in the
center.
The MyScrollbar class extends Scrollbar and provides the capability to display the results of scrollbar
operations using a TextArea object.
The MyScrollbar constructor takes a number of parameters that determine the characteristics of a
scrollbar. These parameters are forwarded to the superclass constructor. A TextArea object is also
passed as a parameter. The orientation parameter is set to the HORIZONTAL and VERTICAL
constants of the Scrollbar class. These constants specify whether the scrollbar should be displayed
horizontally or vertically. The min and max parameters specify a range of integer values that are
associated with the scrollbar. The value parameter sets the initial position of the scrollbar between the
min and max values. The visible parameter identifies the size of the visible portion of the scrollable
area. This determines how the current scrollbar position is updated as the result of a page-up or pagedown scrollbar operation. The addAdjustmentListener() method is used to set up an object of the
HandleScrolling inner class as a scrollbar event handler.
The adjustmentValueChanged() method of the HandleScrolling class handles scrollbar events by
using the getValue() method of the AdjustmentEvent class to obtain the current scrollbar position,
and then displaying this value in the text area. Note that the HandleScrolling class implements the
AdjustmentListener interface.
FIGURE 6.14. The Scroller applet shows how scrollbars work.
LISTING 6.17. THE Scroller APPLET.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class Scroller extends Applet {
Label label = new Label("Scrollbar Position");
MyScrollbar hscroll = new MyScrollbar(Scrollbar.HORIZONTAL,
50,10,0,100,label);
MyScrollbar vscroll = new MyScrollbar(Scrollbar.VERTICAL,
500,100,0,1000,label);
public void init() {
setLayout(new BorderLayout());
add("Center",label);
add("West",vscroll);
add("North",hscroll);
}
}
class MyScrollbar extends Scrollbar {
Label position;
String direction = "
Horizontal";
public MyScrollbar(int orientation,int value,int visible,int min,
int max,
Label label) {
super(orientation,value,visible,min,max);
position=label;
if(orientation==Scrollbar.VERTICAL) direction = "
Vertical";
addAdjustmentListener(new MyScrollbar.HandleScrolling());
}
class HandleScrolling implements AdjustmentListener {
public void adjustmentValueChanged(AdjustmentEvent e){
position.setText(direction+" Position: "+e.getValue());
}
}
}
LISTING 6.18. AN HTML FILE FOR RUNNING THE Scroller APPLET.
<HTML>
<HEAD>
<TITLE>Scrollbars</TITLE>
</HEAD>
<BODY>
<APPLET CODE="Scroller.class" WIDTH=400 HEIGHT=350>
</APPLET>
</BODY>
</HTML>
The ScrollPane Class
Java 1.1 introduced the ScrollPane class to simplify the development of scrollable applications. The
ScrollPane class is like a combination of a panel and vertical and horizontal scrollbars. The great
thing about it is that it performs all of the scrollbar event handling and screen redrawing internally.
The fact that the ScrollPane class handles events is significant. By handling events internally, it
allows scrolling-related operations to run significantly faster.
The ScrollPane class extends the Container class and therefore can contain other components. It is
designed to automate scrolling for a single contained component, such as a Canvas object. It provides
two constructors--a single parameterless constructor and a constructor that takes an int argument. The
parameterless constructor creates a ScrollPane object that displays scrollbars only when they are
needed. The other constructor takes one of the three constants: SCROLLBARS_ALWAYS,
SCROLLBARS_AS_NEEDED, and SCROLLBARS_NEVER. These constants determine if and
when scrollbars are displayed by the ScrollPane object.
The initial size of the ScrollPane object is 100¥100 pixels. The setSize() method can be used to resize
it. The ScrollPane class provides methods for accessing and updating its internal scrollbars, but in
most cases this is both unnecessary and ill-advised. Other methods are provided to get and set the
current scrollbar positions.
Summary
In this chapter, you learned how to build a GUI using the classes of the AWT. You worked with
labels, buttons, text fields, checkboxes, choices, lists, and scrollbars. You learned how to use
components and containers, and how to handle events. In the next chapter, you'll learn how to draw
graphics and text on Canvas object.
© Copyright, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
-7Working with the Canvas
●
●
●
●
●
●
The Canvas and Graphics Classes
Displaying Bitmapped Images
❍ The DisplayImage Applet
Drawing and Painting
❍ The Draw Applet
Using Text and Fonts
❍ Using the Toolkit Class
❍ The FontTest Applet
Fonts, Colors, and Text Components
❍ The Edit Applet
❍ The FontDialog Class
❍ The ColorDialog Class
Summary
In this chapter you'll learn the basics of using the Canvas and Graphics classes of the java.awt
package. You'll also learn how to use the Font class to control the way text is displayed.
Understanding these classes is essential to developing GUI-based applets and applications. More
advanced use of canvas- and graphics-related classes is covered in Chapter 18, "Printing," and
Chapter 20, "Working with 2D and 3D Graphics."
The Canvas and Graphics Classes
The Canvas class of java.awt provides a general GUI component for drawing images and text on the
screen. It does not support any drawing methods of its own, but provides access to a Graphics object
through its paint() method. The paint() method is invoked upon the creation and update of a canvas so
that the Graphics object associated with a Canvas object can be updated. The paint() method should
not be directly invoked, but it can be indirectly accessed using the repaint() method. The Canvas class
is used to provide custom drawing and event handling. You can use the Graphics object associated
with your applet's class by overriding its paint() method.
NOTE: The Canvas and Graphics objects can be used by Java applications as well as
Java applets.
The Graphics class is where all of the low-level drawing methods are implemented. These methods
can be used directly to draw objects and text, or can be combined to display more elaborate screen
objects. The Graphics drawing methods allow a number of geometrical shapes to be drawn and filled,
including lines, arcs, ovals, rectangles, rounded rectangles, and polygons. A special draw3DRect()
method is provided for drawing rectangles that are shaded to give them a three-dimensional
appearance. The Graphics class also provides the capability to draw bitmapped images and text on
the canvas. The "Using Text and Fonts" section later in this chapter covers the drawing of text and
introduces the Font and FontMetrics classes. These classes control the specific manner in which text
is displayed.
Displaying Bitmapped Images
The drawImage() method of the Graphics class is used to display bitmapped images on the Graphics
object associated with a canvas. It takes as its arguments an object of the Image class, an object that
implements the ImageObserver interface, the x- and y-coordinates where the image is to be
displayed, and other parameters.
The Image class is an abstract class that provides format-independent access to graphical images.
Image objects are created by invoking methods of other classes that create images. Examples of these
image-creating methods are the createImage() methods of the Component and Toolkit classes and the
getImage() methods of the Toolkit and Applet classes. The getImage() methods are the most handy
methods for retrieving an image that is stored in a disk file or at a URL. Java currently supports GIFand JPEG-formatted images through these methods.
The ImageObserver interface is defined in the java.awt.image package. This interface provides a set
of constants and methods that support the creation and loading of images. The Component class
implements the ImageObserver interface, and in most cases, the ImageObserver object used as the
parameter to the drawImage() method can be supplied using the this identifier to reference the current
Canvas or Frame object being painted.
The DisplayImage Applet
The DisplayImage applet shows how bitmapped images can be drawn in an applet window using the
drawImage() method of the Graphics class. Its source code is shown in Listing 7.1. Listing 7.2
provides an HTML file to be used to display the applet.
LISTING 7.1. THE SOURCE CODE FOR THE DisplayImage APPLET.
import java.awt.*;
import java.applet.*;
import java.net.*;
public class DisplayImage extends Applet {
int screenWidth = 400;
int screenHeight = 400;
Image image;
public void init() {
setBackground(Color.white);
image = getImage(getDocumentBase(),"test.gif");
resize(screenWidth,screenHeight);
}
public void paint(Graphics g) {
g.drawImage(image,0,0,this);
}
}
LISTING 7.2. THE DisplayImage.htm FILE USED WITH THE DisplayImage APPLET.
<HTML>
<HEAD>
<TITLE>Displaying an Image</TITLE>
</HEAD>
<BODY>
<APPLET CODE="DisplayImage.class" HEIGHT=500 WIDTH=500>
</APPLET>
</BODY>
</HTML>
Before running the DisplayImage applet, copy the test.gif image from the \ju\ch07 directory of the
CD-ROM to your ju\ch07 directory. The DisplayImage program uses the test.gif file.
DisplayImage shows how a bitmapped image can be displayed using the Graphics class. When you
run the applet, it will display the bitmapped image shown in Figure 7.1.
NOTE: Make sure that your TCP/IP software is operating before displaying any of the
applets in this chapter. The best way to do this is to connect to the Internet.
FIGURE 7.1. The DisplayImage applet.
The functionality of the DisplayImage applet isn't all that astounding. Its purpose is to illustrate the
use of the methods involved in loading and displaying image files. You can easily upgrade the applet
to display arbitrary GIF or JPEG files by passing the image file name as an applet parameter.
DisplayImage declares three field variables. The screenWidth and screenHeight variables control the
size of the applet window. The image variable is used to refer to the loaded image.
The setBackground() method of the Component class is used to set the applet background to white.
The getImage() method of the Applet class is used to load the image in the test.gif file and assign it to
the image variable. The getDocumentBase() method is used to obtain the URL from which the
applet's HTML file is loaded. This URL is then used in the loading of test.gif.
The paint() method draws the image referenced by the image variable on the default Graphics object
of the applet window. It accomplishes this using the drawImage() method of the Graphics class. The
arguments to drawImage() are the image to be displayed, the x- and y-coordinates where the image is
to be drawn, and the object implementing the ImageObserver interface associated with the image.
The this identifier is used to indicate that the applet window is the ImageObserver.
Drawing and Painting
Some programs, such as the Microsoft Windows Paint program, are used to construct images by
painting on the screen. These paint programs create an image array of color pixels and update the
array based on user paint commands. These commands may consist of pixel-level drawing operations
or more general operations that draw geometrical objects such as circles, rectangles, and lines.
Painting programs are characterized by the fact that the pixel array is the focus for the drawing that
takes place.
Drawing programs, such as CorelDRAW, support drawing operations using a more objectoriented approach. When you draw a circle or line with a drawing program, you do not merely
update the pixels of the canvas--you add an object to the list of objects that are displayed on the
canvas. Because drawing programs operate at a higher object level, you can select, move, resize,
group, and perform other operations on the objects that you've drawn.
The Graphics class is oriented toward providing the methods that are needed to support higher-level
drawing programs rather than lower-level painting programs. However, it does support important
painting operations, such as displaying bitmapped images, as you saw in the DisplayImage program.
When using the Graphics class to support graphical operations, you will generally maintain a list of
the objects that you've drawn and use that list of objects to repaint the screen as required.
The Draw Applet
The Draw applet shows how the higher-level drawing operations of the Graphics class are used to
display and maintain a list of the objects that are drawn on a canvas. The source code of the Draw
applet is shown in Listing 7.3. Its corresponding HTML file is shown in Listing 7.4.
LISTING 7.3. THE SOURCE CODE FOR THE Draw APPLET.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.lang.Math;
import java.util.Vector;
public class Draw extends Applet {
Button lineButton = new Button("Line");
Button ovalButton = new Button("Oval");
Button rectButton = new Button("Rectangle");
Button clearButton = new Button("Clear");
MyCanvas canvas = new MyCanvas(TwoPointObject.LINE);
int screenWidth = 400;
int screenHeight = 400;
public void init() {
setBackground(Color.white);
setLayout(new BorderLayout());
add("Center",canvas);
setupButtons();
resize(screenWidth,screenHeight);
}
void setupButtons() {
lineButton.addActionListener(new ButtonHandler());
ovalButton.addActionListener(new ButtonHandler());
rectButton.addActionListener(new ButtonHandler());
clearButton.addActionListener(new ButtonHandler());
Panel panel = new Panel();
panel.add(lineButton);
panel.add(ovalButton);
panel.add(rectButton);
panel.add(clearButton);
add("North",panel);
}
class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent ev){
String s=ev.getActionCommand();
if(s.equals("Clear")) canvas.clear();
else if(s.equals("Line"))
canvas.setTool(TwoPointObject.LINE);
else if(s.equals("Oval"))
canvas.setTool(TwoPointObject.OVAL);
else if(s.equals("Rectangle"))
canvas.setTool(TwoPointObject.RECTANGLE);
}
}
}
class MyCanvas extends Canvas {
int tool = TwoPointObject.LINE;
Vector objects = new Vector();
TwoPointObject current;
boolean newObject = false;
public MyCanvas(int toolType) {
super();
tool = toolType;
addMouseListener(new MouseHandler());
addMouseMotionListener(new MouseMotionHandler());
}
public void setTool(int toolType) {
tool = toolType;
}
public void clear() {
objects.removeAllElements();
repaint();
}
public void paint(Graphics g) {
int numObjects = objects.size();
for(int i=0;i<numObjects;++i) {
TwoPointObject obj = (TwoPointObject) objects.elementAt(i);
obj.draw(g);
}
if(newObject) current.draw(g);
}
class MouseHandler extends MouseAdapter {
public void mousePressed(MouseEvent e){
current = new TwoPointObject(tool,e.getX(),e.getY());
newObject = true;
}
public void mouseReleased(MouseEvent e){
if(newObject) {
objects.addElement(current);
newObject = false;
}
}
}
class MouseMotionHandler extends MouseMotionAdapter {
public void mouseDragged(MouseEvent e){
int x = e.getX();
int y = e.getY();
if(newObject) {
int oldX = current.endX;
int oldY = current.endY;
if(tool != TwoPointObject.LINE) {
if(x > current.startX) current.endX = x;
if(y > current.startY) current.endY = y;
int width = Math.max(oldX,current.endX) - current.startX + 1;
int height = Math.max(oldY,current.endY) - current.startY + 1;
repaint(current.startX,current.startY,width,height);
}else{
current.endX = x;
current.endY = y;
int startX = Math.min(Math.min(current.startX,current.endX),
oldX);
int startY = Math.min(Math.min(current.startY,current.endY),
oldY);
int endX = Math.max(Math.max(current.startX,current.endX),
oldX);
int endY = Math.max(Math.max(current.startY,current.endY),
oldY);
repaint(startX,startY,endX-startX+1,endY-startY+1);
}
}
}
}
}
class TwoPointObject {
public static int LINE = 0;
public static int OVAL = 1;
public static int RECTANGLE = 2;
public int type, startX, startY, endX, endY;
public TwoPointObject(int objectType,int x1,int y1,int x2,int y2) {
type = objectType;
startX = x1;
startY = y1;
endX = x2;
endY = y2;
}
public TwoPointObject(int objectType,int x,int y) {
this(objectType,x,y,x,y);
}
public TwoPointObject() {
this(LINE,0,0,0,0);
}
public void draw(Graphics g) {
if(type == LINE) g.drawLine(startX,startY,endX,endY);
else{
int w = Math.abs(endX - startX);
int l = Math.abs(endY - startY);
if(type == OVAL) g.drawOval(startX,startY,w,l);
else g.drawRect(startX,startY,w,l);
}
}
}
LISTING 7.4. THE Draw.htm FILE.
<HTML>
<HEAD>
<TITLE>A Drawing Applet</TITLE>
</HEAD>
<BODY>
<APPLET CODE="Draw.class" HEIGHT=400 WIDTH=400>
</APPLET>
</BODY>
</HTML>
The Draw applet is quite a bit more sophisticated than the DisplayImage applet with respect to the
capabilities that it provides. When you run Draw with your browser, you will see the opening
window shown in Figure 7.2.
FIGURE 7.2. The Draw opening window
.The Draw applet is initially configured for you to draw lines in its window area. You can draw a line
by clicking the left mouse button and dragging the mouse. When you have finished drawing the line,
release the left mouse button and the drawn line will be completed. The coordinate where you press
the left mouse button is the beginning of the line, and the coordinate where you release the left mouse
button is the end of the line. Go ahead and draw several lines, as shown in Figure 7.3.
FIGURE 7.3. Drawing lines with the Draw applet.
The Draw applet supports the drawing of lines, ovals, and rectangles. Click the Oval button to change
the drawing tool to draw ovals. You draw an oval in the same way that you draw a line. When you
click the left button of your mouse, mark the upper-left corner of the oval. Drag the mouse to where
you want the lower-right corner of the oval and release the left mouse button. Try drawing a few
ovals, as shown in Figure 7.4.
Now click the Rectangle button to begin drawing rectangles. Draw rectangles in the same way that
you draw ovals. Go ahead and draw a rectangle, as shown in Figure 7.5.
You can experiment with the applet before going on to find out how it works. If you want to
clear the drawing screen, click the Clear button.
FIGURE 7.4. Drawing ovals with the Draw applet.
FIGURE 7.5. Drawing rectangles with the Draw applet.
The Draw applet is a little (but not much) longer than the applets you've developed so far in this
book. It consists of three major classes and three event handling inner classes. The Draw class is the
main class used to implement the applet. The MyCanvas class is used to implement the main canvas
component of the applet. The TwoPointObject class is used to implement the line, oval, and rectangle
objects that are drawn on the screen. It is called TwoPointObject because it supports objects that can
be characterized by a starting point (mouse down) and an ending point (mouse up).
The Draw applet declares several variables. Four button variables are declared and initialized to
implement the Clear, Line, Oval, and Rectangle buttons. The canvas variable is used to refer to the
MyCanvas object that implements the applet drawing. This object is constructed by passing the
TwoPointObject.LINE constant as an argument. This tells the constructed object that the line tool
should be initially used to support drawing. The height and width of the Draw window is set to 400
¥400 pixels.
The applet's init() method sets the background color to white, sets the applet's layout to a
BorderLayout object, and adds the MyCanvas object to the center of the applet window. It then sets
up the button event handlers and lays out the buttons via setupButtons().
The actionPerformed() method of the MenuItemHandler class handles the clicking of the buttons.
The Clear button is handled by invoking the clear() method of the MyCanvas class to clear the canvas
to a blank state. The Line, Oval, and Rectangle buttons are handled by invoking the setTool() method
of the MyCanvas class to set the current drawing tool. It uses the LINE, OVAL, and RECTANGLE
constants defined in the TwoPointObject class.
MyCanvas
The MyCanvas class extends the Canvas class to provide custom drawing capabilities. The tool
variable is used to identify the current drawing tool that is in effect. The objects variable is declared
as a Vector. It is used to store all of the objects drawn by the user. The current variable is used to
refer to the current TwoPointObject object being drawn by the user. The newObject flag is used to
track whether the user has begun drawing a new object.
The MyCanvas constructor invokes the constructor of the Canvas class using the superclass
constructor call statement, and then sets the tool variable to the toolType argument passed to the
constructor.
The setTool() method changes the tool used to draw an object.
The clear() method invokes the removeAllElements() method of the Vector class to remove all
drawing objects stored in the Vector referenced by the objects variable.
The paint() method is used to paint and repaint the screen. It uses the size() method of the Vector
class to determine how many objects are stored in the objects vector and sets the numObjects variable
to this value. It then iterates through each object stored in objects and draws each one on the canvas.
The elementAt() method of the Vector class is used to retrieve an object from the objects vector. The
object is cast into an object of class TwoPointObject and assigned to the obj variable. The draw()
method of the TwoPointObject class is invoked to draw the object on the current Graphics context.
Notice that the paint() method does not have to know how to support limited area repainting. Only
full canvas painting needs to be implemented by paint(). Support of limited area repainting is
provided by the local AWT implementation.
The MouseHandler and MouseMotionHandler inner classes handle the events associated with
pressing, releasing, and dragging the mouse. They do this by extending the MouseAdapter and
MouseMotionAdapter classes of java.awt.event. The MouseHandler class handles the pressing and
releasing of the mouse button via the mousePressed() and mouseReleased() methods. The
MouseMotionHandler class handles the dragging of the mouse via the mouseDragged() method.
The mousePressed() method handles the event that is generated when the user clicks the left mouse
button in the canvas. The method is called by the Java runtime system with the position of the mouse
click. A new TwoPointObject object is created, with the tool variable and the position of the mouse
click as its arguments. The newly created object is assigned to the current variable, and the
newObject flag is set to true.
The mouseReleased() method is used to handle the event that is generated when the user releases the
left mouse button. This action marks the completion of the drawing of an object. The event is handled
by adding the object referenced by the current variable to the objects vector. The newObject flag is
then set to False. The object referenced by the current variable is updated with its ending position
during the processing of the mouseDragged() event handling method. The newObject flag is checked
to make sure that the mouse was not clicked outside of the current window and then released.
The mouseDragged() method performs somewhat more sophisticated event handling than the
mousePressed() and mouseReleased() methods. It checks the newObject flag to make sure that an
object is currently being drawn. It then sets the oldX and oldY variables to the ending position of the
object being drawn. These variables will be used to determine which portion of the canvas needs to
be repainted. Repainting the entire canvas is not visually appealing because it causes previously
drawn objects to flicker.
If the current drawing tool is not a line, an oval or a rectangle is being drawn by the user. The x- and
y-coordinates of the mouse motion are provided via the MouseEvent argument to the mouseDragged
() method. These coordinates are checked to determine whether the mouse was dragged below and to
the right of the object being drawn. If this is the case, the ending position of the current object is
updated. If the mouse is dragged to the left or above the starting point of the object, the current
position of the mouse is ignored. This is to ensure that the starting position of the oval or rectangle is
indeed its upper-left corner. The new width and height of the area to be repainted are calculated as the
maximum area covered by the previous ending position and the current object ending position. This
is to ensure that the repaint operation will erase any previous boundaries of the object being drawn.
The max() method of the java.lang.Math class is used to determine this maximum area. The repaint()
method of the Component class is then used to repaint the area updated as the result of the mouse
drag. This version of the repaint() method takes as its parameters the x- and y-coordinates of the
upper-left corner of the area to be redrawn and the width and height of this area.
Line drawing is not restricted in the same manner as oval and rectangle drawing. If it were, you
would not be able to draw lines that go up and to the right or down and to the left. The else part of the
if statement updates the starting position of the area to be repainted as the upper-leftmost point of the
line being redrawn. It then updates the ending position of the area to be repainted as the lowerrightmost point of the line. The canvas is then repainted using the starting coordinates and the
updated width and height of the repainted area.
To get a better feel for the process of local screen repainting, try experimenting with the way the
repaint() method is used to update the canvas display.
TwoPointObject
The TwoPointObject class is used to keep track of the objects drawn by the user. It records the type
of object and its starting and ending coordinates. It also draws the objects on a Graphics object passed
as a parameter.
TwoPointObject defines the LINE, OVAL, and RECTANGLE constants, which are also used by the
MyCanvas class. The type variable is used to record the type of object being drawn. The startX,
startY, endX, and endY variables identify the starting and ending coordinates of the object.
Three TwoPointObject constructors are declared. The first constructor takes as its parameters the type
of object being drawn and its starting and ending coordinates. The second constructor leaves out the
ending coordinates and sets them to be the same as the starting coordinates. The last constructor takes
no parameters and creates a line at the coordinates 0,0.
The draw() method checks the type variable to determine which type of object is to be drawn. If the
object is a line, it uses the drawLine() method of the Graphics class to draw a line from its starting to
ending coordinates. If the object is an oval or a line, the w and l variables are assigned the width and
length of the object to be drawn. The drawOval() and drawRect() methods are used to draw an oval or
rectangle, respectively.
Using Text and Fonts
The Font class of java.awt provides a platform-independent method of specifying and using fonts.
The Font class constructor constructs Font objects using the font's name, style (PLAIN, BOLD,
ITALIC, or BOLD + ITALIC), and point size. Java's fonts are named in a platform-independent
manner and then mapped to local fonts that are supported by the operating system on which it
executes. The getName() method returns the logical Java font name of a particular font, and the
getFamily()method returns the operating system-specific name of the font. You'll learn the name of
the standard Java fonts in the next programming example in this chapter.
The FontMetrics class is used to return the specific parameters for a particular Font object. An object
of this class is created using the getFontMetrics() methods supported by the Component class and
other classes, such as the Graphics and Toolkit classes. The FontMetrics methods provide access to
the details of the implementation of a Font object.
The bytesWidth(), charWidth(), charsWidth(), getWidths(), and stringWidth() methods are used to
determine the width of a text object in pixels. These methods are essential for determining the
horizontal position of text on the screen.
When text characters are displayed, they are displayed relative to a baseline. The baseline is the line
drawn through the bottom of nondescending characters. For example, if you drew a line at the bottom
of most text displayed on this line, you would get the text's baseline. Some characters, such as g and
y, descend below the baseline. The number of pixels that the characters of a font descend below the
baseline is known as the font's descent. The number of pixels that the characters of a font extend
above the baseline is known as the font's ascent.
In addition to a font's ascent and descent, a third parameter, referred to as the font's leading, is used to
describe the amount of vertical spacing, in pixels, used between the descent of a line of text and the
ascent of the line of text below it. The overall height of a font is the sum of its leading, ascent, and
descent, and is equal to the distance between baselines (in pixels) of vertically adjacent lines of text.
The getLeading(), getAscent(), getDescent(), and getHeight() methods of the FontMetrics class are
used to access these important font-related parameters. Figure 7.6 provides a graphical description of
these parameters.
FIGURE 7.6. Font parameters.
The getMaxAdvance(), getMaxAscent(), and getMaxDescent() methods are provided for backwardcompatibility with earlier Java versions.
Using the Toolkit Class
The Toolkit class provides a link between the platform-independent Java implementation and its
platform-specific characteristics. Among the many interesting methods implemented by this class are
the getFontList(), getFontMetrics(), getScreenSize(), and getScreenResolution() methods. The
getFontList()method returns a list of fonts that are accessible from Java. The getFontMetrics()
method identifies the font metrics for a particular font. The getScreenSize() method identifies the
screen dimension in terms of horizontal and vertical dots. The getScreenResolution() method
identifies the screen resolution in dots per inch.
The getFontList() is the method of interest for this chapter. You'll use it to get a list of the fonts
available to Java in the next section.
The getFontList() method is deprecated in JDK 1.2. With the advent of the Java 2D API (refer to
Chapter 20), the getFontFamilyNames() method of the GraphicsEnvironment class is now preferred.
The FontTest Applet
The FontTest applet illustrates the use of the Font, FontMetrics, and Toolkit classes and shows how
to draw text on a Graphics object. Its source code is shown in Listing 7.5. Listing 7.6 provides an
HTML file for displaying the applet.
LISTING 7.5. THE SOURCE CODE OF THE FontTest APPLET.
import java.applet.*;
import java.awt.*;
public class FontTest extends Applet {
Toolkit toolkit;
Font defaultFont;
String fontNames[];
int screenWidth = 400;
int screenHeight = 400;
public void init() {
setupFonts();
setSize(screenWidth,screenHeight);
}
void setupFonts() {
toolkit = getToolkit();
defaultFont = getFont();
fontNames = toolkit.getFontList();
}
public void paint(Graphics g) {
int styles[] = {Font.PLAIN,Font.BOLD,Font.ITALIC};
String styleNames[] = {"Plain","Bold","Italic"};
int size = 12;
int y=10;
for(int i=0;i<fontNames.length;++i) {
if(fontNames[i]!="ZapfDingbats") {
for(int j=0;j<styles.length;++j) {
Font newFont = new Font(fontNames[i],styles[j],size);
FontMetrics fm = g.getFontMetrics(newFont);
g.setFont(newFont);
String text = fontNames[i]+"-"+styleNames[j];
int x = (screenWidth - fm.stringWidth(text))/2;
g.drawString(text,x,y+fm.getLeading()+fm.getAscent());
y += fm.getHeight();
}
}
}
}
}
LISTING 7.6. THE FontTest.htm FILE.
<HTML>
<HEAD>
<TITLE>Using Fonts</TITLE>
</HEAD>
<BODY>
<APPLET CODE="FontTest.class" HEIGHT=400 WIDTH=400>
</APPLET>
</BODY>
</HTML>
The FontTest applet does not provide much functionality. Just run it and it will display a list of the
fonts that are currently available to Java, with each name written in its font. Figure 7.7 shows its
display. The applet's importance is not in what it does, but in how it does it. By closely examining
this applet, you'll be able to quickly come up to speed on working with Java fonts.
FIGURE 7.7. The FontTest output.
The FontTest class declares a number of field variables. The toolkit variable is used to refer to the
Toolkit object associated with the applet window. The defaultFont variable identifies the default font
used by the applet. The fontNames[] array is used to store the names of the fonts that are accessible to
Java.
The setupFonts() method obtains the Toolkit object associated with the applet's window, using the
getToolkit() method, and assigns this object to the toolkit variable. The current font used by the
applet is accessed by getFont() and assigned to the defaultFont variable. The Toolkit object is then
used to obtain the current list of font names via the getFontList() method of the Toolkit class. That's
all for the applet's setup.
The paint() method is where the primary processing of interest takes place. The styles[] and
styleNames[] arrays are used to identify the various text styles and their associated string
descriptions. The y variable identifies the vertical screen position where text is displayed. The size
variable identifies the point size used to display a font.
The paint() method uses two for statements. The outer statement iterates through the list of font
names, and the inner statement iterates through the font styles. The ZapfDingbats font, a symbol font,
is skipped. At each pass through the inner loop, a new font is created with the specified name, style,
and size. The getFontMetrics() method of the Graphics class is used to obtain the FontMetrics object
associated with the newly created font, and this object is assigned to the fm variable. The setFont()
method of the Graphics class is used to set the current font to the new font.
The next line of text to be displayed is created by concatenating the font name and its style name. The
horizontal position at which the text is to be displayed in order for it to be centered is calculated
based upon the width of the text (in pixels) returned by the stringWidth() method of the FontMetrics
class and the initial width of the applet window area. The vertical position where the text is to be
displayed is its baseline, and is determined by adding the leading and ascent values of the font with
the y variable. These values are obtained using the getLeading() and getAscent() methods of the
current FontMetrics object. The y variable identifies the point of maximum descent of the previously
displayed line of text. It is then updated for the current line of text by adding the height of the current
font returned by the getHeight() method of the FontMetrics class.
Fonts, Colors, and Text Components
The Font and FontMetrics classes are not confined to text that is drawn on Graphics objects. These
classes can also be used with the TextField and TextArea classes. These classes automatically
calculate the correct text-display locations using the native text objects supported by the local
operating-system platform. In addition to changing text fonts, the TextField and TextArea classes
also support the display of text using different foreground and background colors. The following
applet shows how fonts and colors can be quickly incorporated into a Java applet to implement
features associated with What-You-See-Is-What-You-Get (WYSIWYG) editors.
The Edit Applet
The Edit applet shows how the Font and Color classes can be used with a TextArea component. Its
source code is shown in Listing 7.7. Its HTML file is provided in Listing 7.8.
The Edit applet uses the FontDialog and ColorDialog classes that are introduced in subsequent
sections. In order to compile and run Edit.java, you will need the FontDialog.java and ColorDialog.
java files. Java will automatically compile the FontDialog.java and ColorDialog.java files when Edit.
java is compiled.
LISTING 7.7. THE SOURCE CODE OF THE Edit APPLET.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class Edit extends Applet {
Button clearButton = new Button("Clear");
Button fontButton = new Button("Font");
Button colorButton = new Button("Color");
TextArea text;
Frame frame;
FontDialog fd;
ColorDialog cd;
Font currentFont = new Font("Courier",Font.PLAIN,12);
Color currentColor = Color.black;
public void init() {
setBackground(Color.white);
setLayout(new BorderLayout());
text = new TextArea(25,80);
text.setFont(currentFont);
add("Center",text);
setupButtons();
}
void setupButtons() {
clearButton.addActionListener(new ButtonHandler());
fontButton.addActionListener(new ButtonHandler());
colorButton.addActionListener(new ButtonHandler());
Panel panel = new Panel();
panel.add(clearButton);
panel.add(fontButton);
panel.add(colorButton);
add("North",panel);
}
class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent ev){
String s=ev.getActionCommand();
if(s=="Clear"){
text.setText("");
}else if(s=="Font"){
frame = new Frame();
frame.show();
fd = new FontDialog(frame,currentFont,
new FontSelectHandler());
fd.show();
}else if(s=="Color"){
frame = new Frame();
frame.show();
cd = new ColorDialog(frame,currentColor,
new ColorSelectHandler());
cd.show();
}
}
}
class FontSelectHandler implements ActionListener {
public void actionPerformed(ActionEvent e){
currentFont = fd.getFont();
fd.dispose();
frame.dispose();
requestFocus();
text.setFont(currentFont);
}
}
class ColorSelectHandler implements ActionListener {
public void actionPerformed(ActionEvent e){
currentColor = cd.getColor();
cd.dispose();
frame.dispose();
requestFocus();
text.setForeground(currentColor);
text.setText(text.getText());
text.setVisible(true);
}
}
}
LISTING 7.8. THE Edit.htm FILE.
<HTML>
<HEAD>
<TITLE>Text Editing</TITLE>
</HEAD>
<BODY>
<APPLET CODE="Edit.class" HEIGHT=400 WIDTH=600>
</APPLET>
</BODY>
</HTML>
The Edit applet opening display is shown in Figure 7.8.
Type some text into the applet's text area. Click the Font button to launch the font dialog box, shown
in Figure 7.9. Use this dialog box to select a 24-point Bold Italic Helvetica font. The text's display is
updated, as shown in Figure 7.10.
FIGURE 7.8. The Edit applet opening display.
FIGURE 7.9. The font dialog box.
Select the Color menu item from the Format menu. The color dialog box is displayed, as shown in
Figure 7.11. Use this dialog box to change the color associated with the text's display. Try using
primary colors such as blue or green. Other colors might not display correctly, depending on the
number of colors supported by your video card and the current color map associated with the display.
The Edit applet makes use of the FontDialog and ColorDialog classes covered in the following
sections. It declares variables to implement the Clear, Font, and Color buttons, the text area, and a
frame window for displaying dialog boxes. It also declares variables for referencing the font and
color dialog boxes and the current font and color in use.
The init() method sets the background color and layout, creates the TextArea object, and sets the
current font. It then adds the TextArea object to the center of the applet's display and invokes
setupButtons().
FIGURE 7.10. Updated text.
FIGURE 7.11. The color dialog box.
The setupButtons() method sets up each button's event handler, organizes the buttons into a Panel
object, and adds the panel to the applet's display area.
The ButtonHandler class handles the clicking of the buttons. The Clear button is handled by invoking
the TextArea object's setText() method to clear its text. Clicking of the Font button results in a new
FontDialog object being created to solicit the user to change the current font. You'll learn about this
class in the next section. The clicking of the Color button results in a ColorDialog object being
created to provide the user with opportunity to change the color of the current text. The ColorDialog
class is covered later in the chapter. Note that a Frame object is created to provide a window in which
the FontDialog and ColorDialog boxes are displayed.
The FontSelectHandler class handles the event that occurs when the user closes the font dialog box.
You'll create this event in the FontDialog class. The actionPerformed() method invokes the getFont()
method of the FontDialog class to retrieve the font selected by the user. It then disposes of the dialog
box and its frame, and sets the current font of the TextArea object to the retrieved font.
The ColorSelectHandler class handles the event that occurs when the user closes a color dialog box.
You'll create this event in the ColorDialog class. The actionPerformed() method invokes the getColor
() method of the ColorDialog class to retrieve the color selected by the user. It then disposes of the
dialog box and its frame, and sets the current color of the TextArea object to the retrieved color. The
setText() and getText() methods are used to reset the text using the new color. The setVisible()
method causes the TextArea object to be redisplayed.
The FontDialog Class
The FontDialog class provides a handy encapsulation of the dialog boxes commonly used to select a
font from the list of available fonts provided by the system. The source code of the FontDialog class
is shown in Listing 7.9.
LISTING 7.9. THE SOURCE CODE OF THE FontDialog CLASS.
import java.awt.*;
import java.awt.event.*;
public class FontDialog extends Dialog {
String fontName;
int fontStyle;
int fontSize;
String fontNames[];
String styleNames[] = {"Plain","Bold","Italic","Bold Italic"};
String sizeNames[] = {"10","12","14","18","24","36","72"};
int styles[] = {Font.PLAIN,Font.BOLD,Font.ITALIC,Font.BOLD+Font.
ITALIC};
int sizes[] = {10,12,14,18,24,36,72};
MyList fontList;
MyList styleList = new MyList(5,false,styleNames);
MyList sizeList = new MyList(5,false,sizeNames);
Toolkit toolkit;
Font newFont;
boolean fontChanged;
ActionListener ah;
public FontDialog(Frame parent,Font currentFont,ActionListener ah)
{
super(parent,"Select a font:",true);
toolkit = parent.getToolkit();
newFont = currentFont;
setupFonts();
setupPanels();
setBackground(Color.lightGray);
setForeground(Color.black);
this.ah=ah;
pack();
addWindowListener(new WindowEventHandler());
}
void setupFonts() {
fontName=newFont.getName();
fontStyle=newFont.getStyle();
fontSize=newFont.getSize();
fontNames = toolkit.getFontList();
fontList = new MyList(5,false,fontNames);
}
void setupPanels() {
Panel mainPanel = new Panel();
mainPanel.setLayout(new GridLayout(1,3));
Panel fontPanel = new Panel();
fontPanel.setLayout(new BorderLayout());
Label fontLabel = new Label("Font:");
fontPanel.add("North",fontLabel);
fontPanel.add("Center",fontList);
Panel stylePanel = new Panel();
stylePanel.setLayout(new BorderLayout());
Label styleLabel = new Label("Style:");
stylePanel.add("North",styleLabel);
stylePanel.add("Center",styleList);
Panel sizePanel = new Panel();
sizePanel.setLayout(new BorderLayout());
Label sizeLabel = new Label("Size:");
sizePanel.add("North",sizeLabel);
sizePanel.add("Center",sizeList);
mainPanel.add(fontPanel);
mainPanel.add(stylePanel);
mainPanel.add(sizePanel);
Font plainFont = new Font("Helvetica",Font.PLAIN,12);
Font boldFont = new Font("Helvetica",Font.BOLD,12);
mainPanel.setFont(plainFont);
fontLabel.setFont(boldFont);
styleLabel.setFont(boldFont);
sizeLabel.setFont(boldFont);
Panel buttonPanel = new Panel();
buttonPanel.setLayout(new FlowLayout());
Button selectButton = new Button("Select");
Button cancelButton = new Button("Cancel");
ButtonHandler bh = new ButtonHandler();
selectButton.addActionListener(bh);
cancelButton.addActionListener(bh);
buttonPanel.add(selectButton);
buttonPanel.add(cancelButton);
buttonPanel.setFont(boldFont);
add("Center",mainPanel);
add("South",buttonPanel);
}
public boolean isChanged() {
return fontChanged;
}
public Font getFont() {
return newFont;
}
void updateNewFont() {
if(fontList.getSelectedIndex() != -1) fontName =
ÂfontList.
getSelectedItem();
if(styleList.getSelectedIndex() != -1)
fontStyle = styles[styleList.getSelectedIndex()];
if(sizeList.getSelectedIndex() != -1)
fontSize = sizes[sizeList.getSelectedIndex()];
newFont = new Font(fontName,fontStyle,fontSize);
fontChanged = true;
}
class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent e){
String s = e.getActionCommand();
if("Select".equals(s)) {
updateNewFont();
ah.actionPerformed(new ActionEvent(FontDialog.this,
ActionEvent.ACTION_PERFORMED,"Select"));
FontDialog.this.setVisible(false);
}else if("Cancel".equals(s)) {
FontDialog.this.dispose();
}
}
}
class WindowEventHandler extends WindowAdapter {
public void windowClosing(WindowEvent e){
FontDialog.this.dispose();
}
}
}
The FontDialog class creates the font dialog box, shown in Figure 7.9. This type of dialog box is used
in most text-processing applications. You can reuse the FontDialog class, as it is currently defined, in
your Java applets. You can also subclass FontDialog and add your own custom enhancements.
The FontDialog class declares a number of variables that are used in the generation and processing of
the font dialog box. The fontName, fontStyle, and fontSize variables are used to keep track of the
parameters of the currently selected font. The fontNames array identifies the names of the fonts that
are currently supported by the system. The styles, styleNames, sizes, and sizeNames arrays are used
to maintain int and String lists of the font styles and sizes that are displayed in the dialog box. The
fontList, styleList, and sizeList variables refer to the MyList objects displayed in the dialog box. The
MyList class is shown in Listing 7.10. The toolkit variable refers to the Toolkit object of the window
containing the font dialog box. The fontChanged variable keeps track of whether the user has selected
a new font, and the newFont variable maintains the Font object that is selected by the user.
The FontDialog constructor uses the superclass constructor call statement to create a modal dialog
box with the title Select a font:. The toolkit associated with the window containing the dialog box is
obtained using the getToolkit() method of the Window class. The newFont variable, representing the
user's font selection, is set to the default value of the currently selected font. This font is passed to the
FontDialog constructor using the currentFont parameter. The FontDialog constructor invokes the
setupFonts() and setupPanels() methods to perform the bulk of the dialog box setup. It then sets the
background and foreground colors and stores the ActionListener object passed via the ah variable.
This ActionListener object is used to handle an event generated by the FontDialog class. The
constructor then packs the dialog box window and assigns an event handler to it.
The setupFonts() method assigns default values to the fontName, fontStyle, and fontSize variables
based on the values of the current font stored in the newFont variable. The getFontList() method of
the Toolkit class is used to set the fontNames[] array to the list of fonts currently supported by the
system. These names are converted to a list using the MyList() constructor.
The setupPanels() method performs all of the grunt work, adding the lists to the dialog box and
rearranging them in an appealing fashion. The mainPanel variable is used to refer to the overall panel
into which the fontPanel, stylePanel, and sizePanel objects are inserted. The mainPanel is layed out
as a three-column set of subpanels. These sub-panels are identified by the fontPanel, stylePanel, and
sizePanel variables. Each of these subpanels is layed out using a BorderLayout object. The label
identifying the contents of the panel is added to the top of the panel. The center of each panel
contains the three MyList objects identified by the fontList, styleList, and sizeList variables.
The Helvetica font is used for the contents of the font dialog box. The labels at the top of each
column are set in a boldface style. A second panel, referred to by the buttonPanel variable, is created
with two buttons: Select and Cancel. These buttons provide the user with controls needed to accept or
abort a font selection. An object of the ButtonHandler class is used as the buttons' event handler. The
mainPanel is added to the center of the font dialog box, and the buttonPanel is added to the bottom.
Two access methods are provided with the FontDialog class. The isChanged() method is used to
query a FontDialog object to determine whether the user made a font selection. The getFont() method
returns the font selected by the user.
The ButtonHandler class handles the clicking of the Select and Cancel buttons. The Cancel button
results in the destruction of the FontDialog object. The object is destroyed using the dispose() method
of the Window class. The Select button invokes the updateNewFont() method to create a font based
on the user's current list selections and assign that font to the newFont variable. The actionPerformed
() method of the ActionListener object passed to the FontDialog constructor is invoked. This enables
additional event handling to be performed outside the FontDialog class. The font dialog box is then
hidden but not destroyed. Note that an ActionEvent object is passed as an argument to the
actionPerformed() method. The setVisible() method of the Component class is used to hide the dialog
box.
The updateNewFont() method checks the MyList objects referred to by the fontList, styleList, and
sizeList variables to update the fontName, fontStyle, and fontSize variables based on the user's
selection. These variables are then used to construct a new Font object, which is assigned to the
newFont variable. The fontChanged flag is then set to indicate that a user font selection has occurred.
LISTING 7.10. THE MyList CLASS.
import java.awt.*;
public class MyList extends List {
public MyList(int rows,boolean multiple,String labels[]) {
super(rows,multiple);
int length = labels.length;
for(int i=0;i<length;++i) {
try {
add(labels[i]);
}catch (NullPointerException ex) {
add("");
}
}
}
}
The MyList class, shown in Listing 7.10, provides a constructor that simplifies the construction of
List objects.
The ColorDialog Class
The ColorDialog class is very similar to, but simpler than, the FontDialog class. It allows the user to
select a color from the list of colors defined in the Color class. It provides a dialog box that is similar
to that of FontDialog, but is much simpler because only one list--the list of available colors--is
supported. The source code of the ColorDialog class is shown in Listing 7.11.
LISTING 7.11. THE SOURCE CODE OF THE ColorDialog CLASS.
import java.awt.*;
import java.awt.event.*;
public class ColorDialog extends Dialog {
Color colors[] = {Color.black,Color.blue,Color.cyan,Color.darkGray,
Color.gray,
Color.green,Color.lightGray,Color.magenta,Color.orange,Color.pink,
ÂColor.red,
Color.white,Color.yellow};
String colorNames[] =
{"black","blue","cyan","darkGray","gray","green",
"lightGray","magenta","orange","pink","red",
"white","yellow"};
MyList colorList = new MyList(5,false,colorNames);
Color newColor;
boolean colorChanged;
ActionListener ah;
public ColorDialog(Frame parent,Color currentColor,ActionListener
ah) {
super(parent,"Select a color:",true);
setupPanels();
setBackground(Color.lightGray);
setForeground(Color.black);
this.ah=ah;
pack();
addWindowListener(new WindowEventHandler());
}
void setupPanels() {
Panel colorPanel = new Panel();
colorPanel.setLayout(new BorderLayout());
Label colorLabel = new Label("Color:");
colorPanel.add("North",colorLabel);
colorPanel.add("Center",colorList);
Font plainFont = new Font("Helvetica",Font.PLAIN,12);
Font boldFont = new Font("Helvetica",Font.BOLD,12);
colorLabel.setFont(boldFont);
colorList.setFont(plainFont);
Panel buttonPanel = new Panel();
buttonPanel.setLayout(new FlowLayout());
Button selectButton = new Button("Select");
Button cancelButton = new Button("Cancel");
ButtonHandler bh = new ButtonHandler();
selectButton.addActionListener(bh);
cancelButton.addActionListener(bh);
buttonPanel.add(selectButton);
buttonPanel.add(cancelButton);
buttonPanel.setFont(boldFont);
add("Center",colorPanel);
add("South",buttonPanel);
}
public boolean isChanged() {
return colorChanged;
}
public Color getColor() {
return newColor;
}
class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent e){
String s = e.getActionCommand();
if("Select".equals(s)) {
if(colorList.getSelectedIndex() != -1)
newColor = colors[colorList.getSelectedIndex()];
colorChanged = true;
ah.actionPerformed(new ActionEvent(ColorDialog.this,
ActionEvent.ACTION_PERFORMED,"Select"));
ColorDialog.this.setVisible(false);
}else if("Cancel".equals(s)) {
ColorDialog.this.dispose();
}
}
}
class WindowEventHandler extends WindowAdapter {
public void windowClosing(WindowEvent e){
ColorDialog.this.dispose();
}
}
}
The ColorDialog class declares the colors array as an array of color constants and the colorNames
array as the names associated with these color constants. The colorList variable refers to the MyList
object that presents the colorNames array to the user. The newColor variable identifies the color
selected by the user, and the colorChanged variable indicates whether a user color selection has been
made.
The ColorDialog constructor invokes the Dialog constructor to set the title of the dialog box. It then
invokes the setupPanels() method to perform most of the setup of the dialog box's internal
components. The foreground and background colors are set and then the dialog box is packed and
resized.
The setupPanels() method creates and adds two panels to the dialog box. These panels are identified
by the colorPanel and buttonPanel variables. The panel identified by the colorPanel variable contains
the Color: label and the MyList object referred to by the colorList variable. The button panel is
implemented in the same manner as in the FontDialog class.
The isChanged() and getColor() methods are used to determine whether the user has selected a color
and, if so, to return the color selected.
The ButtonHandler class handles the clicking of the Select and Cancel buttons. The Select button is
handled by invoking the getSelectedIndex() method of the List class to see if a color was selected and
setting the newColor variable to the selected color. The colorChanged flag is updated to indicate that
a color has been selected. The actionPerformed() method of the ActionListener object passed to the
ColorDialog constructor is invoked in the same manner as in the FontDialog class. The setVisible()
method causes the dialog box to be hidden.
The Cancel button is handled by simply disposing of the dialog box.
Summary
This chapter covers the details of using the Canvas and Graphics classes. It also shows you how to
use the font-related classes of the java.awt package. The DisplayImage applet demonstrates Java's
support of bitmapped images. The Draw applet illustrates the drawing methods of the Graphics class,
and the FontTest applet shows you how to draw text on a Canvas object. The Edit applet shows how
fonts and colors are used with text components. Chapter 8, "Applet Security," shows you how to use
the applet security features of JDK 1.2.
© Copyright, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
-8Applet Security
●
●
●
●
●
Using JAR Files and Digital Signatures
❍ Using the JAR Tool
❍ Creating a JAR file
❍ Listing the Contents of a JAR File
❍ Viewing a JAR File
❍ Extracting the Contents of a JAR File
❍ Signing Applets
Specifying an Applet Security Policy
Working with Certificates
❍ Exporting Your Certificates
❍ Importing the Certificates of Others
❍ Other keytool Commands
The java.security Packages
Summary
Applet security is a major concern among Web users and applet developers. From a user's
perspective, an exploitable applet security flaw could result in sensitive data being modified or
disclosed, or their computer being rendered inoperable. From a developer's perspective, strong applet
security is necessary to make Web users comfortable with using applets. However, too high a level of
security limits their applets' capabilities.
The JDK 1.2 security model meets both user and developer needs. It allows users to maintain high
levels of security, by default, and also to relax these security controls to take advantage of additional
applet capabilities that are provided by developers they trust.
In this chapter, you'll learn how to use the JDK 1.2 security model to develop applets that extend the
bounds of the applet sandbox and use previously restricted capabilities. First, you'll learn how to
package your applets as Java Archive (JAR) files and how to digitally sign these files. You'll then
learn how the JDK 1.2 security model supports trusted applets and how users can configure their Java
Runtime Environment (JRE) to use trusted applets. You'll also learn about digital certificates and how
they are used to support applet security. You'll get hands-on experience using the JDK 1.2 security
tools and cover the JDK 1.2 Security API. When you finish this chapter, you'll be thoroughly
introduced to applet security.
Using JAR Files and Digital Signatures
A JAR file is a compressed archive file that is created using the Java archive tool (jar), which is
similar to the PKZIP program developed by Phil Katz. It combines multiple files into a single archive
file that is compressed using the ZLIB compression library. Although jar is a general-purpose file
archive and compression tool, its main purpose is to combine the files used by an applet into a single
compressed file for efficient loading by a Java-enabled Web browser.
NOTE: A description of the ZLIB compression format is available at the URL http://
www.cdrom.com/pub/infozip/zlib/.
Using jar with applets can greatly improve browser performance. Because all of the files used by an
applet are combined into a single file, a browser only needs to establish a single HTTP connection
with a Web server. This reduces the communication processing overhead on both the browser and the
server. File compression reduces the time re- quired to download an applet by 50% or more. This
benefits both the applet's user and publisher.
Another feature of JAR files is that they support the capability to sign archived files. This allows
browsers to differentiate between untrusted applets and those applets that may be trusted to perform
sensitive processing in a secure manner (because they are signed by a reputable identity). The
sensitive processing that is permitted of trusted applets is determined by the local Java security policy.
Using the JAR Tool
The jar tool is easy to use. You invoke it using the following command line:
jar [options] [manifest] jar-file input-file(s)
The jar-file is the file that is to be used as an archive. The .jar extension should be supplied in the
command line. The input-file(s) are written as a space-separated list of files to be placed in the
archive. Filename wildcard characters may be used (for example, *.class).
The manifest is a file that contains information about the archived files. It need not be supplied--jar
will create one automatically and store it as META-INF\MANIFEST.INF within the archive.
Information about the manifest file can be found in the file docs\guide\jar\manifest.html that is
included with the JDK 1.2 API documentation.
The jar options are used to control the input and output of the jar tool. They are described in Table
8.1.
TABLE 8.1. THE jar TOOL OPTIONS.
Option
Description
c
Creates a new (empty) archive file.
t
Displays the archive's table of contents.
x [file(s)]
Extracts the specified file(s). If no files are specified, all files are extracted.
f
Identifies the file to be created, listed, or extracted.
v
Generates verbose output.
u
Used to update an existing JAR file.
C
Used to change directories during execution of the jar command.
0
Stores files but does not compress them.
M
Skips creation of the manifest file.
m manifest Uses the supplied manifest file.
NOTE: The syntax of the jar tool is similar to the UNIX tar command.
NOTE: The @ character may be used in a jar command, followed by a file name.
When this occurs, command arguments are taken from the file (one argument per line)
and inserted into the command at the position of the @ character.
Examples of using the jar tool are provided in the following sections.
Creating a JAR file
If you have ever used the UNIX tar command or the DOS PKZIP program, you will find the jar tool
to be familiar and easy to use. In this section, you'll learn how to create a JAR file for the Edit applet
that you developed in Chapter 7, "Working with the Canvas."
We'll use the Edit applet because it uses several .class files, which makes it a good candidate for
archival and compression. Start by copying the Edit.java, MyList.java, FontDialog.java, and
ColorDialog.java files to your ch08 working directory and then recompile these files. The following
11 .class files are created in your ch08 directory:
ColorDialog.class
ColorDialog$ButtonHandler.class
ColorDialog$WindowEventHandler.class
Edit.class
Edit$ButtonHandler.class
Edit$FontSelectHandler.class
FontDialog.class
Edit$ColorSelectHandler.class
FontDialog$ButtonHandler.class
FontDialog$WindowEventHandler.class
MyList.class
Let's use jar to archive and compress them into a file named edit.jar:
jar cf edit.jar *.class
List your directory to verify that the JAR file was created:
Directory of C:\jdk1.2\ju\ch08
.
<DIR>
..
<DIR>
COLORD~1 JAV
2,448
EDIT~1
JAV
1,968
FONTDI~1 JAV
3,667
MYLIST~1 JAV
310
COLORD~1 CLA
2,908
COLORD~2 CLA
1,324
$ButtonHandler.class
COLORD~3 CLA
615
$WindowEventHandler.class
EDIT~1
CLA
1,914
EDIT$B~2 CLA
1,545
EDIT$F~2 CLA
1,016
class
FONTDI~1 CLA
3,880
EDIT$C~2 CLA
1,214
class
FONTDI~2 CLA
1,101
04-22-98
04-22-98
02-08-98
02-08-98
02-08-98
02-08-98
04-22-98
04-22-98
11:27a
11:27a
9:20a
10:50a
10:42a
9:19a
11:34a
11:34a
.
..
ColorDialog.java
Edit.java
FontDialog.java
MyList.java
ColorDialog.class
ÂColorDialog
04-22-98 11:34a ÂColorDialog
04-22-98 11:34a Edit.class
04-22-98 11:34a Edit$ButtonHandler.class
04-22-98 11:34a Edit$FontSelectHandler.
04-22-98 11:35a FontDialog.class
04-22-98 11:34a Edit$ColorSelectHandler.
04-22-98 11:35a FontDialog
$ButtonHandler.class
FONTDI~3 CLA
609 04-22-98 11:35a ÂFontDialog
$WindowEventHandler.class
MYLIST~1 CLA
431 04-22-98 11:35a MyList.class
EDIT
JAR
11,527 04-22-98 11:36a edit.jar
16 file(s)
36,477 bytes
2 dir(s)
197,722,112 bytes free
Note that bj.jar is only 11,527 bytes long. Because the 11 class files are 16,557 bytes, the jar tool
compressed them to 70% of their original size. Now that the .class files are archived, delete them
using del *.class.
Listing the Contents of a JAR File
Let's use the list option of the jar command to see what's inside the edit.jar file:
C:\jdk1.2\ju\ch08>jar tf edit.jar
META-INF/MANIFEST.MF
ColorDialog$ButtonHandler.class
ColorDialog$WindowEventHandler.class
ColorDialog.class
Edit$ButtonHandler.class
Edit$ColorSelectHandler.class
Edit$FontSelectHandler.class
Edit.class
FontDialog$ButtonHandler.class
FontDialog$WindowEventHandler.class
FontDialog.class
MyList.class
The only thing that looks out of place is the META-INF/MANIFEST.MF entry. That's the file used to
keep a manifest of the JAR file's contents.
Viewing a JAR File
You're probably wondering how you would include the edit.jar file in an applet. The answer is that
you add the ARCHIVE="edit.jar" attribute to the applet tag. This attribute tells the browser to load
the edit.jar archive file to find the Edit.class file and other related classes. Listing 8.1 shows the file
Edit.htm that is used to display the Edit applet.
LISTING 8.1. THE Edit.htm FILE.
<HTML>
<HEAD>
<TITLE>Text Editing</TITLE>
</HEAD>
<BODY>
<APPLET CODE="Edit.class" ARCHIVE="edit.jar" HEIGHT=400 WIDTH=600>
</APPLET>
</BODY>
</HTML>
You can view the Edit applet using the appletviewer tool, as follows (see Figure 8.1):
appletviewer Edit.htm
FIGURE 8.1. The Edit applet viewed by appletviewer.
Extracting the Contents of a JAR File
The x option of the jar tool lets you extract the file's contents. You can use it to re- create the .class
files that you deleted:
C:\jdk1.2\ju\ch08>jar xvf edit.jar
extracted:
extracted:
extracted:
extracted:
extracted:
extracted:
extracted:
extracted:
extracted:
extracted:
extracted:
extracted:
META-INF\MANIFEST.MF
ColorDialog$ButtonHandler.class
ColorDialog$WindowEventHandler.class
ColorDialog.class
Edit$ButtonHandler.class
Edit$ColorSelectHandler.class
Edit$FontSelectHandler.class
Edit.class
FontDialog$ButtonHandler.class
FontDialog$WindowEventHandler.class
FontDialog.class
MyList.class
You can list your directory to see exactly what came back:
C:\jdk1.2\ju\ch08>dir
Volume in drive C has no label
Volume Serial Number is 2747-15D2
Directory of C:\jdk1.2beta3\ju\ch08
.
<DIR>
04-22-98
..
<DIR>
04-22-98
COLORD~1 JAV
2,448 02-08-98
EDIT~1
JAV
1,968 02-08-98
FONTDI~1 JAV
3,667 02-08-98
MYLIST~1 JAV
310 02-08-98
11:27a
11:27a
9:20a
10:50a
10:42a
9:19a
.
..
ColorDialog.java
Edit.java
FontDialog.java
MyList.java
META-INF
<DIR>
04-22-98 12:05p META-INF
EDIT~1
CLA
1,914 04-22-98 12:05p Edit.class
EDIT
HTM
159 04-22-98 11:48a Edit.htm
COLORD~1 CLA
1,324 04-22-98 12:05p ÂColorDialog
$ButtonHandler.class
COLORD~2 CLA
615 04-22-98 12:05p ÂColorDialog
$WindowEventHandler.class
COLORD~3 CLA
2,908 04-22-98 12:05p ColorDialog.class
EDIT$B~1 CLA
1,545 04-22-98 12:05p Edit$ButtonHandler.class
EDIT$C~1 CLA
1,214 04-22-98 12:05p Edit$ColorSelectHandler.
class
EDIT$F~1 CLA
1,016 04-22-98 12:05p Edit$FontSelectHandler.
class
FONTDI~1 CLA
1,101 04-22-98 12:05p FontDialog
$ButtonHandler.class
FONTDI~2 CLA
609 04-22-98 12:05p ÂFontDialog
$WindowEventHandler.class
MYLIST~1 CLA
431 04-22-98 12:05p MyList.class
EDIT
JAR
11,527 04-22-98 11:36a edit.jar
FONTDI~3 CLA
3,880 04-22-98 12:05p FontDialog.class
17 file(s)
36,636 bytes
3 dir(s)
194,150,400 bytes free
Note that the META-INF directory is created. This directory contains a single manifest file named
MANIFEST.MF. The manifest file identifies each file in the JAR file, the digest algorithm used to
calculate a digest of the file, and the file's digest value. Listing 8.2 provides an example manifest file.
LISTING 8.2. AN EXAMPLE MANIFEST FILE.
Manifest-Version: 1.0
Created-By: Manifest JDK 1.2beta3
Name: ColorDialog$ButtonHandler.class
SHA-Digest: w1HOCEWkiOt+ui0IpayJLHasnHQ=
Name: ColorDialog$WindowEventHandler.class
SHA-Digest: G2HtKJluU0aiT/7tB6YqXaBQea0=
Name: ColorDialog.class
SHA-Digest: z4qdRsSiiLgDBUAjsAmx02TQzuw=
Name: Edit$ButtonHandler.class
SHA-Digest: Huerm63Agb8edXJJsafVA623MPs=
Name: Edit$ColorSelectHandler.class
SHA-Digest: IZTp5mlHM8ar5zMHQwzDcN+tkuo=
Name: Edit$FontSelectHandler.class
SHA-Digest: Ez6+lfCLTC6UvJW+0QIZo6uBkMc=
Name: Edit.class
SHA-Digest: v2/cnmrXXlH1LsOx4kcAB4BN0jE=
Name: FontDialog$ButtonHandler.class
SHA-Digest: FrMHhW4wSQeywVXTQ7CjOnIi+yk=
Name: FontDialog$WindowEventHandler.class
SHA-Digest: Z4mmLOnJcgS2+XA1CWx1ImYkYV8=
Name: FontDialog.class
SHA-Digest: urXQWWNi9bd842Wq3lMHFZKO+tQ=
Name: MyList.class
SHA-Digest: yH75rAxTz5Lbesv/g0Tqll5QKdU=
Delete the .class files and the META-INF directory before going on to the next section.
Signing Applets
The next thing that we're going to do is to digitally sign the edit.jar file. Chapter 3, "The Extended
Java Security Model," provides an introduction to digital signatures, but we'll briefly review their use
here.
A digital signature is a value that is computed from an object, such as an applet file, using a secret
key. It indicates that the person who holds the secret key has verified that the contents of the object
are correct and authentic.
Digital signatures often use public-key encryption algorithms--a private key is used for encryption,
and a public key is used for decryption. To sign an object, the signer first calculates a digest of the
object using a message digest algorithm, such as MD5. The digest serves as a fingerprint for the
object. The digest is then encrypted using the private key of a public/private key pair to produce the
object's digital signature.
The signature of a signed object is verified by decrypting the signature using the signer's public key.
This produces a digest value. The object's digest is then calculated and compared to the decrypted
digest value. If the calculated digest value and the decrypted digest values match, the signature is
verified. Refer to Figure 3.14 in Chapter 3 for an illustration of this process.
Creating a Keystore
Before we can sign an applet, we need to create a public/private key pair and make it available to the
jarsigner tool. We'll use the keytool to create a keystore with the public/private key pair. A keystore is
a database of keys and digital certificates that authenticate the values of the public keys. You'll learn
to use the keytool to work with digital certificates later in this chapter in the section "Working with
Certificates."
NOTE: The keytool and jarsigner tools of JDK 1.2 replace the javakey tool of JDK
1.1.
Keystore entries are associated with the identities of the subjects (people, organizations, software
processes, and so on) to which a particular key belongs. These identities are referenced using aliases.
For example, you might use the alias "John" to refer to John Doe's public key, "abc" to refer to the
public key of the ABC Corporation, or "Me" to your own public and private keys. Aliases are caseinsensitive. This means that "me", "Me", and "ME" are equivalent.
You generate a public/private key pair for yourself using the -genkey command of keytool. For
example, the following command generates a key pair for the alias "Me" in the keystore "MyStore":
keytool -genkey -alias "Me" -keystore "MyStore"
The keytool then prompts you to enter a password for the keystore:
Enter keystore password:
MyPassword
Enter a password, and then keytool prompts you for the following additional information:
What is your first and last name?
[Unknown]: Jamie Jaworski
What is the name of your organizational unit?
[Unknown]: Software Development
What is the name of your organization?
[Unknown]: Jaworski & Associates
What is the name of your City or Locality?
[Unknown]: San Diego
What is the name of your State or Province?
[Unknown]: California
What is the two-letter country code for this unit?
[Unknown]: US
Is <CN=Jamie Jaworski, OU=Just Me, O=Jaworski & Associates, L=San
Diego, S=California, C=US> correct?
[no]: yes
Finally, you are prompted to enter a password for your private key:
Enter key password for <Me>
(RETURN if same as keystore password):
I showed how I filled in this information. You would enter your own information, of course. This
information is used to associate an X.500 distinguished name with the alias. The distinguished name
is used as part of X.509 digital certificates. The following distinguished name subparts are supported:
●
Common Name (CN)--A person's name, such as Jamie Jaworski.
●
Organizational Unit (OU)--A part of an organization, such as software development.
●
Organization (O)--Company, institution, or other organization, such as Jaworski & Associates.
●
Locality name (L)--City.
●
State name (S).
●
Country (C)--Two-letter country code.
This information can be supplied directly with the -dname option.
The last password is separate from the keystore password and is used to access the private key of the
public key pair. This password can be specified directly using the -keypass option. If the password is
not specified, the keystore password is used. The -keypasswd command is used to change this
password.
The -keyalg option may be used to specify the algorithm used to generate the key pair.
NOTE: If the -keystore option is not supplied, keytool generates a keystore named .
keystore that is stored in the directory specified by the user.home system property.
Currently, only the National Institute of Standards and Technology (NIST) Digital Signature
Standard (DSA) key pair-generation algorithm is supported.
The -genkey command automatically generates a self-signed X.509 digital certificate for the key pair.
The -sigalg option may be used to specify a signature algorithm. Currently, only DSA is supported.
The -validity option may be used to specify the number of days for which the certificate associated
with the key pair is valid. If this option is not used, the certificate is valid for 90 days.
●
[begNOTE: Make sure that you create a keystore of your own before going on to the
next section.
Signing a JAR File
Now that you have created a keystore with your public and private keys, you can use the
jarsigner tool and your private key to sign a JAR file. The jarsigner tool is used for both
signature generation and signature verification. We'll cover signature generation in this section
and signature verification in the next section.
To sign a JAR file, you enter a jarsigner command in the following form:
jarsigner -keystore keystore -storepass storePassword -keypass
keyPassword JARFileName alias
The parameters to this command are as follows:
●
keystore--The name of the keystore to use, such as MyStore.
●
storePassword--The keystore password, such as MyPassword.
●
keyPassword--The private key password, such as MyPassword.
●
JARFileName--The name of the JAR file to be signed, such as edit.jar.
●
alias--The alias of the signer, such as Me.
Additional command parameters are available for the jarsigner command. Use jarsigner -help to
obtain a description of these parameters.
I used the following command to sign the edit.jar file:
jarsigner -keystore MyStore -storepass MyPassword -keypass
MyPassword edit.jar Me
If the -keystore option is not specified, the default (.keystore) keystore is used.
Signing a JAR file causes the file to be updated as follows:
●
●
A signature (.SF) file is added to the META-INF directory. The name of this signature file is
the first eight characters of the alias used to sign the file. This name may be changed using the
-sigFile option.
A signature block file (.DSA) file is added to the META-INF directory. The name of the
signature block file is generated in the same way as the signature file.
The signature file identifies each file in the JAR file, the digest algorithm used in the signing process,
and a digest value. The digest value is the digest computed from the file's entry in the manifest file.
Listing 8.3 provides an example signature file.
LISTING 8.3. AN EXAMPLE SIGNATURE FILE.
Signature-Version: 1.0
SHA1-Digest-Manifest: Tskq+b1DaL4RUZxFfDGGyNkTTSY=
Created-By: SignatureFile JDK 1.2beta3
Name: ColorDialog$ButtonHandler.class
SHA1-Digest: 81+YE73yybQfZLZVz4dZxERJNio=
Name: Edit$FontSelectHandler.class
SHA1-Digest: y1/rJWyOTC+joWOnJM6ZL9fYlnI=
Name: FontDialog$ButtonHandler.class
SHA1-Digest: IzZObN+lcU8F1UN0SE8M7PR9tP8=
Name: FontDialog$WindowEventHandler.class
SHA1-Digest: O2L7SWIGmBGqVcFXz6j/dSKg2pw=
Name: MyList.class
SHA1-Digest: IMKvGp/HqIdw/6jxjUd+CtLMAmA=
Name: Edit.class
SHA1-Digest: N3l2zs8HBLOmLkcIA5MAs/xXC4A=
Name: FontDialog.class
SHA1-Digest: AGiOIM3EjO0RxwY/NRVkUrn8RuM=
Name: ColorDialog$WindowEventHandler.class
SHA1-Digest: yGf1SzyPh/AKEozcQK60du0Auig=
Name: ColorDialog.class
SHA1-Digest: hOJAXgIblOMG0tREBAcmH4Aqe6s=
Name: Edit$ColorSelectHandler.class
SHA1-Digest: 5iY/2gP4j64FTrrlPm1KEWEW/Q8=
Name: Edit$ButtonHandler.class
SHA1-Digest: 1jKW3bcg9iz9j36ozAtq1WdpoDQ=
The signature block file contains the signature of the signature file and a certificate that authenticates
the public key corresponding to the private key used in the signature generation. The signature block
file is a binary file.
NOTE: By default, jarsigner uses the SHA-1 digest and DSA signature algorithms to
sign and verify JAR files. Other digest and signature algorithms may be installed and
used instead of SHA-1 and DSA.
NOTE:A JAR file may have multiple signers. Each signer signs the JAR file in
succession.
●
Verifying the Signature of a JAR File
The jarsigner tool is also used to verify the signature of a signed JAR file. This is accomplished using
the -verify option. The following jarsigner command form is used:
●
jarsigner -verify JARFileName
For example, the following command verifies the signature of edit.jar:
jarsigner -verify edit.jar
If the signature is valid, jarsigner produces the following output:
jar verified.
If the signature is invalid, jarsigner responds with an exception identifying why the failure occurred:
jarsigner: java.util.zip.ZipException: invalid entry size (expected
900 but got 876 bytes)
The jarsigner signature verification process is optimized for performance. This process consists of the
following:
●
●
●
1. Verifying that the signature block (.DSA) file contains a valid signature for the signature (.
SF) file.
2. Verifying that the signature file entries are valid digests for each of the corresponding
manifest (MANIFEST.MF) file entries.
3. Verifying that the digests in the MANIFEST.MF file are valid for each of the files in the
JAR file.
Any error encountered in the verification process results in the generation of a security exception.
Specifying an Applet Security Policy
The signing of JAR files provides the basis for developing an applet security policy. JAR files that
are received from trusted sources whose signatures can be verified may be given greater privileges
than JAR files that are unsigned or from an untrusted source. Chapter 3 covers the specification of a
custom security policy. In this section, we'll show how to develop an applet security policy based on
digital signatures.
Listing 3.1 in Chapter 3 shows the ReadFileApplet, which generates a security exception as the result
of the applet trying to read a user's AUTOEXEC.BAT file. In this section, we'll develop a trusted
version of ReadFileApplet that will successfully read your AUTOEXEC.BAT file without generating
a security exception.
Copy the ReadFileApplet.java and ReadFileApplet.htm files from your ch03 directory to your ch08
directory, and compile ReadFileApplet.java. This produces two class files: ReadFileApplet.class and
ReadFileApplet$ButtonHandler.class. Create a ReadFileApplet.jar file using the following command:
jar cf ReadFileApplet.jar ReadFile*.class
Now edit the ReadFileApplet.htm file to include the ReadFileApplet.jar file in an ARCHIVE
attribute, as shown in Listing 8.4.
LISTING 8.4. AN UPDATED ReadFileApplet.htm.
<HTML>
<HEAD>
<TITLE>An Applet that reads local files</TITLE>
</HEAD>
<BODY>
<H1>An Applet that reads local files.</H1>
<APPLET CODE="ReadFileApplet.class" ARCHIVE="ReadFileApplet.jar"
HEIGHT=300 WIDTH=600>
<PARAM NAME="fileName" VALUE="C:\AUTOEXEC.BAT">
Text displayed by browsers that are not Java-enabled.
</APPLET>
</BODY>
</HTML>
NOTE: You may need to create an AUTOEXEC.BAT file for use in the example, if
you don't have one already.
Now delete the ReadFileApplet.class and ReadFileApplet$ButtonHandler.class files and run the
ReadFileApplet in appletviewer as follows:
appletviewer ReadFileApplet.htm
When you click the Read Local File button, appletviewer will generate a security exception, as shown
in Figure 8.2.
FIGURE 8.2. Appletviewer generates a security exception when trying to run an untrusted applet.
Now we'll sign the applet and create a security policy that will trust the applet to read your
AUTOEXEC.BAT file. Sign the applet using the keystore that you generated earlier in this chapter:
jarsigner -keystore MyStore -storepass MyPassword -keypass
MyPassword ReadFileApplet.jar Me
Substitute your keystore, passwords, and alias, as necessary.
Next, create the policy file shown in Listing 8.5 and save it as my.policy in your ch08 directory. This
policy specifies that the keystore "MyStore" should be used for signature verification. It grants any
code signed by "Me" permission to read the AUTOEXEC.BAT file. Substitute your keystore and
alias for "MyStore" and "Me". For more information on security policy specification, refer to Chapter
3.
Now use appletviewer to run ReadFileApplet with the new policy:
●
appletviewer -J-Djava.policy=my.policy ReadFileApplet.htm
The -J option passes the -D option to the java interpreter. The -D option sets the java.policy property
to my.policy.
Now click the Read Local File button. The appletviewer displays your AUTOEXEC.BAT file, as
shown in Figure 8.3.
FIGURE 8.3. The ReadFileApplet is trusted to read your AUTOEXEC.BAT file.
Working with Certificates
In the previous example, you worked with JAR files that you signed yourself. You'll also create JAR
files that you'll distribute to your users. As a user, you'll use JAR files signed by other trusted
developers. In this section, you'll learn how to export digital certificates so that they can be used by
others to verify the signatures of your JAR files. You'll also learn how to import the digital
certificates of others.
A digital certificate is an object (file or message) signed by a certification authority that certifies the
value of an person's public key. The X.509 certificates of the International Standards Organization
are a popular digital certificate format. These are the certificates supported by the keytool.
NOTE: Digital certificates are introduced in Chapter 3.
The keytool allows you to import certificates that are created and signed by others. These certificates
verify the public keys of other individuals. The keytool also allows you to export certificates that can
be imported by others. We'll cover certificate exporting in the next section, and certificate importing
in the section after that.
Exporting Your Certificates
When you generate your public/private key pair, keytool generates a self-signed certificate for your
public key. You can export this certificate using the -export command. This command is of the
following form:
keytool -export -keystore keystore -alias alias -file fileName
You must substitute appropriate values for keystore, alias, and fileName.
For example, the following exports my self-signed certificate to the file MyCert:
keytool -export -keystore MyStore -alias Me -file MyCert
The command prompts me for a password and then tells me the status of the export:
Enter keystore password: MyPassword
Certificate stored in file <MyCert>
I can now give this certificate to others so that they can import it into their keystores.
The -csr command is used to create a certificate signing request (CSR). The output of this command
is a file containing certificate information that is to be provided by a certification authority. The
certification authority signs a certificate with its private key that attests to the validity of your public
key. A certification authority is a party that is trusted by the public to verify the public keys of others.
You can import the certificate received from the certification authority, and you can also distribute it
to others. The format of the -csr command is as follows:
keytool -csr -keystore keystore -alias alias -file fileName
For example, the following creates a CSR in the file MyCSR:
keytool -export -keystore MyStore -alias Me -file MyCSR
The command prompts you for a keystore password.
Importing the Certificates of Others
In order to use the certificates of others, you must import them into your keystore as follows:
keytool -import -keystore keystore -alias alias -file fileName
The file specified by fileName contains the certificate to be imported.
The following command imports the certificate contained in the MyCert file into the OtherStore
keystore, giving it the alias Jamie:
keytool -import -keystore OtherStore -alias Jamie -file MyCert
The command prompts you for a password:
Enter keystore password:
NewPassword
Then it generates the following type of output:
Owner: CN=Jamie Jaworski, OU=Software Development, O=Jaworski &
Associates, L=San Diego, S=California, C=US
Issuer: CN=Jamie Jaworski, OU=Software Development, O=Jaworski &
Associates, L=San Diego, S=California, C=US
Serial Number: 353e7a26
Valid from: Wed Apr 22 16:15:50 PDT 1998 until: Tue Jul 21 16:15:50
PDT Â1998
Certificate Fingerprints:
MD5: 70:BE:34:E8:D0:5A:A1:87:74:23:D4:81:0F:EC:AD:95
SHA1: D9:61:50:41:8C:47:75:35:D8:3A:C2:72:B1:44:
A1:64:18:85:63:AB
Trust this certificate? [no]:
Finally, keytool asks you whether or not to trust the certificate. You should only trust the certificates
of those individuals that you trust.
Other keytool Commands
The -list command lists the contents of the keystore or of a single entry.
For example, the following lists all entries in MyStore:
keytool -list -keystore MyStore
Enter keystore password: MyPassword
Your keystore contains 1 entry:
me, Wed Apr 22 16:15:59 PDT 1998, keyEntry,
Certificate MD5 Fingerprint: Â70:BE:34:E8:D0:5A:A1:87:74:23:
D4:81:0F:EC:AD:95
To list a single entry, use the -alias option.
The -delete command deletes an alias from a keystore. It is used as follows:
keytool -delete -keystore keystore -alias alias
The -printcert command displays a certificate that is stored in a file. The command
keytool -printcert -file MyCert
generates the following output:
Owner: CN=Jamie Jaworski, OU=Software Development, O=Jaworski
&
ÂAssociates, L=San Diego, S=California, C=US
Issuer: CN=Jamie Jaworski, OU=Software Development, O=Jaworski
&
ÂAssociates, L=San Diego, S=California, C=US
Serial Number: 353e7a26
Valid from: Wed Apr 22 16:15:50 PDT 1998 until: Tue Jul 21 16:15:50
PDT
Â1998
Certificate Fingerprints:
MD5: 70:BE:34:E8:D0:5A:A1:87:74:23:D4:81:0F:EC:AD:95
SHA1: D9:61:50:41:8C:47:75:35:D8:3A:C2:72:B1:44:
A1:64:18:85:63:AB
Finally, the -help command can be used to obtain a list of all the commands supported by keytool.
The command
keytool -help
generates the following output:
KeyTool usage:
-csr
[-v] [-alias <alias>] [-sigalg <sigalg>]
[-file <csr_file>] [-keypass <keypass>]
[-keystore <keystore>] [-storepass <storepass>]
-delete
[-v] -alias <alias>
[-keystore <keystore>] [-storepass <storepass>]
-export
[-v] [-alias <alias>] [-file <cert_file>]
[-keystore <keystore>] [-storepass <storepass>]
-genkey
[-v] [-alias <alias>] [-keyalg <keyalg>]
[-keysize <keysize>] [-sigalg <sigalg>]
[-dname <dname>] [-validity <valDays>]
[-keypass <keypass>] [-keystore <keystore>]
[-storepass <storepass>]
-help
-import
[-v] [-noprompt] [-alias <alias>]
[-file <cert_file>] [-keypass <keypass>]
-keyclone
-keypasswd
[-list]
[-keystore <keystore>] [-storepass <storepass>]
[-v] [-alias <alias>] -dest <dest_alias>
[-keypass <keypass>] [-new <new_keypass>]
[-keystore <keystore>] [-storepass <storepass>]
[-v] [-alias <alias>]
[-keypass <old_keypass>] [-new <new_keypass>]
[-keystore <keystore>] [-storepass <storepass>]
[-v | -rfc] [-alias <alias>]
[-keystore <keystore>] [-storepass <storepass>]
-printcert
-selfcert
[-v] [-file <cert_file>]
[-v] [-alias <alias>] [-sigalg <sigalg>]
[-dname <dname>] [-validity <valDays>]
[-keypass <keypass>] [-keystore <keystore>]
[-storepass <storepass>]
-storepasswd [-v] [-new <new_storepass>]
[-keystore <keystore>] [-storepass <storepass>]
The JDK 1.2 documentation describes all the commands and options of keytool.
The java.security Packages
The security tools covered in this chapter are implemented in terms of the Security API, which
consists of the following five packages:
●
java.security
●
java.security.acl
●
java.security.cert
●
java.security.interfaces
●
java.security.spec
The java.security package is the core Security API package. It provides the classes and interfaces that
support encryption and the computation of message digests and digital signatures. This package also
provides key generation and management support, and the classes used in security policy
implementation. The java.security.acl package consists of interfaces that can be used to implement
access control policies. The java. security.cert package provides support for X.509 certificates. The
java.security.interfaces package defines interfaces that are used to access the National Institute of
Standards and Technology (NIST) Digital Signature Algorithm. The java.security.spec package
provides algorithm-independent and algorithm-dependent classes that are used for keys and other
algorithm parameters. The java.security.cert and java.security.spec packages are new to JDK 1.2.
Summary
In this chapter, you learned how to develop applets that extend the bounds of the applet sandbox and
use new JDK 1.2 security features. You learned how to package your applets as Java Archive (JAR)
files and how to digitally sign these files. You learned how to configure your runtime environment to
use trusted applets. You also learned about digital certificates and how they are used to support applet
security. You were introduced to the JDK 1.2 security tools and learned about the JDK 1.2 Security
API. In the next chapter, you'll learn how to write window applications in Java.
© Copyright, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
-9Creating Window Applications
●
●
●
●
●
●
●
●
Differences Between Applications and Applets
Designing Window Programs
Window Classes
❍ Frame
❍ Dialog
❍ FileDialog
Opening and Closing Windows
❍ Hello Windows!
Constructing Menus
❍ The MyMenu Class
❍ The MenuApp Program
❍ Popup Menus
Using Dialog Boxes
❍ The MessageDialog Class
❍ The MessageApp Program
The Accessibility API
Summary
In Part II, "Applet Programming," you learned to write applets. While applets are Java's claim to
fame, they are only one aspect of Java's software development capabilities. In this chapter, you'll
learn to develop full-blown window applications using Java. You'll learn about the differences
between applications and applets, how to open and organize windows, and how to work with menus
and dialog boxes. You'll also learn how to use the new Accessibility API of JDK 1.2. When you have
finished this chapter, you will know how to write platform-independent window programs using Java.
Differences Between Applications and Applets
Applets are Java programs that execute within the context of a Web page. They interact with the user
while his Web page is active and stop their execution when his Web page is no longer active. Applets
are valuable because they are simple to use. A user only needs to open an applet's Web page to
download and execute an applet.
Most of the programs that we are accustomed to using are standalone or networked application
programs. A standalone application is a program that executes using the resources of a single
computer. A networked application is an application that uses resources that are available over a
network. A distributed application is an application that consists of objects that execute across
multiple computers. You'll learn how to develop networked applications in Part VIII, "Network
Programming," and distributed applications in Part IX, "Developing Distributed Applications."
Standalone applications consist of window applications and console applications. Window
applications are programs that make use of a windowing system, such as those supported by
Microsoft Windows, the Macintosh OS, Motif, and OS/2. Console programs are character-based
programs, such as those supported by DOS and UNIX shells.
Window applications are introduced in this chapter, and console applications are covered in the
following chapter. However, you'll see examples of both types of applications throughout the
remainder of this book. Window applications have an advantage over applets in that they are given
more security privileges by default. Among other things, they are allowed to read and write to the
local file system, establish network connections to multiple hosts, and launch other programs.
Applets have an advantage over applications in their ease of installation and use. The great thing
about both applications and applets is that they share the same GUI controls. This means that all the
GUI programming skills that you learned for applets carry over to applications.
Because window applications execute separately from a Web page, they must perform additional
functions like opening and closing windows, setting up and implementing menu bars, and working
with dialog boxes. These are the skills that you'll learn in this chapter.
NOTE: The JDK 1.2 security model allows applications to be restricted in their
behavior and applets to be given greater privileges. However, the model defaults to
giving applications more privileges than applets. Refer to Chapter 3, "The Extended
Java Security Model."
Designing Window Programs
The design of most window programs usually involves two basic steps: laying out the program's
graphical user interface, and providing the functionality that implements the interface.
The first step addresses one of the most important features of window programs--their look and feel.
Window programs are preferred to console programs when their look and feel are interesting,
innovative, and help the user to accomplish a particular purpose.
A program's look consists of all those characteristics that determine its appearance, such as window
size, layout, background and foreground colors, menus, and GUI controls. A program's feel is
determined by the availability of easy-to-use GUI controls and the contribution of these controls to
the program's ultimate intended use. It is the result of the designer's selection and implementation of
GUI controls that enhance a program's capability to satisfy user expectations.
The window's GUI design begins by creating an application window, using the Frame class, and
determining the basic characteristics of the window, such as its size, title, background and foreground
colors, and general layout. Next, a menu bar is added to the window and the program's menus and
menu items are added to the menu bar. The GUI controls that are to be used in the window are
determined, designed, and attached to the window's panels and frame.
At this point, you know what your program will look like and you can concentrate on what it will do.
The first step in bringing your program's user interface to life is to add the event-handling software
required to respond to events that are generated through user interaction. The event-handling software
will not immediately implement all user actions, but it should respond to them and provide hooks for
the eventual implementation of all user interface actions. The event-handling software is then fleshed
out to provide all the functionality required of the application program. The program's design and
implementation reaches an Alpha stage when all required user-interface functions have been
implemented.
The next stage of program development is to refine and test the program to make it more responsive
to its intended purpose. A series of Beta versions of the program are developed that implement user
feedback and fix any identified errors or deficiencies. Finally, the program is refined to handle
unusual user inputs and to process errors and exceptions.
Figure 9.1 provides an overview of the process of designing and implementing window programs.
FIGURE 9.1. The process for window design and implementation.
Window Classes
The Window class provides an encapsulation of a generic Window object. It is subclassed by Frame
and Dialog to provide the capabilities needed to support application main windows and dialog box
support.
The Window class contains a single constructor that creates a window that has a frame window as its
parent. The parent frame window is necessary because only objects of the Frame class or its
subclasses contain the functionality needed to implement an independent application window.
The Window class implements important methods that are used by its Frame and Dialog subclasses.
The pack() method is used to arrange the components contained in the window according to the
window layout style. The show() method is used to display a window. Windows are hidden
(invisible) by default, and are only displayed as a result of invoking their show() method. The toFront
() and toBack()methods are used to position windows relative to their frame window. The dispose()
method is used to release the resources associated with a window and delete the Window object. The
getWarningString() method is used to retrieve the warning message associated with untrusted
windows. Warning messages are associated with windows that are created by applets.
A Window object does not have a border or a menubar when it is created. In this state, it may be used
to implement a pop-up window. The default layout for a Window object is BorderLayout.
Frame
The Frame class is used to provide the main window of an application. It is a subclass of Window
that supports the capabilities to specify a window icon, cursor, menu bar, and title. Because it
implements the MenuContainer interface, it is capable of working with MenuBar objects. You'll learn
about menus later in this chapter in the section "Constructing Menus."
The Frame class defines several constants that are used to specify different types of cursors to be used
within the frame. As of JDK 1.1, a separate Cursor class is available for working with cursors.
Frame provides two constructors: a default parameterless constructor that creates an untitled frame
window, and a constructor that accepts a String argument to be used as the frame window's title. The
second constructor is typically used.
Frame extends the set of access methods that it inherits from Window by adding methods to get and
set the window title, icon image, and menu bar. Methods for removing the menu bar and specifying
whether the window is resizable are also provided.
Dialog
The Dialog class is a subclass of the Window class that is used to implement dialog box windows. A
dialog box is a window that takes input from the user. The Dialog class allows dialog boxes to be
constructed that are modal. Modal dialog boxes must be closed before control returns to the window
that launched them. The Dialog class also provides the capability to construct non-modal dialog
boxes that do not need to be closed before other program windows can be accessed.
The Dialog class provides four constructors. These constructors allow the Window object containing
the dialog box to be specified, as well as the modal flag and the dialog box's title.
The Dialog class provides only a handful of access methods. These methods are used to get and set
the dialog box's title, determine whether it is modal, and get and set its resizable properties.
FileDialog
The FileDialog class is used to construct dialog boxes that support the selection of files for input and
output operations. It is a subset of the Dialog class and provides three constructors. These
constructors take as arguments the Frame window that contains the dialog box, the title to be used at
the top of the dialog box, and a mode parameter that can be set to the LOAD or SAVE constants
defined by FileDialog.
FileDialog provides methods that are used to access the directory and filename of the user-selected
file and to specify an object that implements the FileNameFilter interface.
Opening and Closing Windows
The opening and closing of windows marks the beginning and end of any window program. The
Frame class enables these fundamental window operations to be accomplished. A Frame object
implements an application main window, inheriting many methods from the Window, Container, and
Component classes.
To open an application window, a Frame object is created and its show() method is invoked. The
show() method is inherited from the Window class. To close an application window, the window
closing event must be handled. The window is disposed of by using the dispose() method of the
Window class, or more commonly by invoking the System.exit() method after performing any
necessary program-termination processing.
The Frame class and its ancestors provide a number of methods that control the way in which a
window is displayed. The setBackground() and setForeground() methods inherited from the
Component class are used to specify a window's background and foreground colors. The setFont()
method, also inherited from Component, is used to specify the default font to be used with a window.
The Frame class itself provides a number of methods that control a window's appearance. The setTitle
() method allows a window's title to be changed, the setMenuBar() method enables a menu bar to be
attached to a window, and the setResizable() method toggles whether a window can or cannot be
resized. The setIconImage() method allows the window's minimized icon to be changed. This method
is not supported by all Java implementations, and therefore should be avoided if cross-platform
compatibility is a concern.
Hello Windows!
Now that you've covered the basic classes involved in opening and closing windows, we'll create a
simple window application that illustrates the use of these classes.
Traditionally, the first program that programmers write when learning a new programming language
is one that displays the text "Hello World!" to the console window. The main purpose of the program
is to show you how to develop a simple program that actually produces some noticeable effect. The
same rationale applies to the HelloWindows program, shown in Listing 9.1. This program shows you
how to open an application window and write the text "Hello Windows!" to the window.
LISTING 9.1. THE HelloWindows PROGRAM.
import java.awt.*;
import java.awt.event.*;
public class HelloWindows extends Frame {
public static void main(String args[]){
HelloWindows app = new HelloWindows();
}
public HelloWindows() {
super("Hello Windows!");
setSize(200,200);
addWindowListener(new HelloWindows.WindowEventHandler());
show();
}
public void paint(Graphics g) {
g.drawString("Hello Windows!",50,90);
}
class WindowEventHandler extends WindowAdapter {
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
When you compile and run the program, it opens a small window in the upper-left corner of your
desktop and displays the text "Hello Windows!" in the middle of the window. Figure 9.2 shows the
window displayed by the HelloWindows program.
FIGURE 9.2. The HelloWindows program display.
Let's take a look at HelloWindows to find out what makes it work. You should notice that we import
classes from the java.awt and java.awt.event packages. The Frame, Graphics, and WindowAdapter
classes are the primary classes that are imported. The Frame and Graphics classes are fundamental to
developing window programs. The Frame class is used to create Frame objects that implement
application main windows, and the Graphics class is used to update the screen display. The
WindowAdapter class is used to process user-generated window events, such as closing the window.
The HelloWindows class extends the Frame class. This is a typical approach to developing window
programs. By subclassing Frame, your application class implements a main application window. You
still use the same old main() method for implementing the entry point to your program. In
HelloWindows, the main() method simply creates an object of class HelloWindows.
The HelloWindows constructor uses the super() constructor call statement to invoke the Frame
constructor with the string "Hello Windows!". The Frame constructor creates a new application
window frame with the specified text as its title. The setSize() method sets the size of the window to
200¥200 pixels. The setSize() method is inherited from the Component class by way of the
Container, Window, and Frame classes. The addWindowListener() method is invoked to associate
window-related events with a newly created object of class WindowEventHandler. Finally, the show
() method causes the window to be displayed. It is inherited from the Window class.
When the window is initially displayed or redisplayed as the result of being uncovered or brought to
the foreground, the paint() method is invoked. It paints the window according to the current
application state.
The paint() method used by HelloWindows overrides the paint() method inherited from the
Component class. It uses the drawString() method to display the text "Hello Windows!" at the screen
coordinates (50,90) within the application window.
Window coordinates are organized in the same way they are for applets, with the upper-left corner of
the window being (0,0). The coordinates of the upper-right corner of the window are (width,0), where
width is the horizontal width of the window in pixels. The coordinates of the lower-left corner of the
window are (0,height), where height is the vertical height of the window in pixels. Finally, the
coordinates of the lower-right corner of the window are (width,height).
The WindowEventHandler class subclasses the WindowAdapter class of java.awt.event to handle the
event associated with the window's closing. This event occurs when the user closes the main
application window using the capabilities that are provided by the native windowing system. In
Microsoft Windows 95 and 98, this occurs when you click on the little "`x"' in the upper-right corner
of the window.
The window-closing event is handled by invoking the exit() method of the System class to terminate
the program. You might be wondering what would happen if the windowClosing() method did not
handle the window closing event. Try deleting the line with the System.exit(0) method invocation,
recompiling, and rerunning HelloWindows to see what happens when you try to terminate the
application. Your program will no longer terminate when you attempt to close it.
Constructing Menus
Java provides a rich set of menu-related classes for creating and interacting with pull-down menus.
The MenuComponent class is the superclass of all menu-related classes. It extends the Object class.
The getFont()and setFont()methods are the most useful methods provided by MenuComponent. Its
two direct superclasses, MenuBar and MenuItem, provide most of the methods for creating and using
menus. The CheckboxMenuItem class extends the MenuItem class and supports menu items that can
be checked on or off. The Menu class extends the MenuItem class and implements a collection of
MenuItem objects that can be assigned to a MenuBar object. The PopupMenu class extends the Menu
class to provide a menu that can be popped up inside a component to enable user menu selections.
Finally, the MenuShortcut class can be used to create a keyboard shortcut to a menu item.
A Frame object can have one and only one MenuBar object, which is set using the setMenuBar()
method. A menu bar is a collection of menus, each one represented as a separate pull-down menu.
Common examples are the File, Edit, and Help pull-down menus found in many window
applications. The MenuBar class allows a special menu to be designated as a Help menu, but this
feature is not implemented in Windows 95 or NT. It is implemented by Solaris and other flavors of
UNIX, however.
A Menu object contains one or more MenuItem objects, which can be a normal user- selectable
MenuItem object, a CheckboxMenuItem object, or another Menu object. Java supports tear-off
menus, which are menus that can be removed from a menu bar. A tear-off menu is constructed in the
same manner as a regular menu--you only need to set the Boolean tear-off value in the Menu()
constructor. Tear-off menus are not implemented within Windows 95 or NT, but they are
implemented in Solaris and other UNIX derivatives.
The MenuItem class is the superclass of the Menu class. This allows a menu to be a menu item and is
used to construct cascading, multilevel menus. MenuItem is also the superclass of the
CheckboxMenuItem class and provides the capability to implement menu items that can be checked
or unchecked. If a MenuItem object is constructed directly with the MenuItem constructor, it
becomes a normal menu item that is selected from a pull-down menu.
The MyMenu Class
The creation and organization of menu bars, menus, and menu items into a program's menu is a
straightforward but tedious process. You have to create a menu bar, create and add menus to the
menu bar, add menu items to the menus, and then add the menu bar to the program's application
window. This usually involves the use of a large number of constructors and access methods. To
illustrate the use of the menu-related classes and to simplify the menu-creation process, you'll create
two classes, MyMenu and MyMenuBar, that can be used to quickly construct menus for Java
programs. These classes implement multiple levels of menus, check box menu items, and menudisabling options. The special Help menu and tear-off menus are not implemented, however, because
they are transparent to Windows 95 and NT.
NOTE: In Chapter 13, "Working with Swing Components," you'll learn about the
menu classes provided by Swing. Swing's menu classes, unlike the AWT menu classes,
are subclasses of the java.awt.Component class. The MyMenu and MyMenuBar classes
can be easily tailored to support Swing.
The MyMenu class is used to construct menus using an array of objects consisting of String objects
that represent menu labels, or arrays of objects that represent submenus. Menu labels can be either
check box menu items or normal menu items, and can be either initially enabled or disabled (grayed
out). Check box menu items can be initially checked or unchecked. The first character of the label's
text string is used to indicate which type of label it is. The character conventions are as follows:
+ A check box menu item that is initially checked and enabled.
# A check box menu item that is initially checked and disabled.
-
A check box menu item that is initially unchecked and enabled. If the label consists of just -, it
indicates a separator.
= A check box menu item that is initially unchecked and disabled.
~ A normal menu item that is initially disabled.
Any other character indicates a normal, enabled menu item. If the first character is !, it is ignored.
This allows any menu item to begin with any character.
These conventions apply to menu options. Only the ~ and ! options are used with the menu's main
label. Using these options greatly simplifies the process of creating a menu. The source code for the
MyMenu class is shown in Listing 9.2.
LISTING 9.2. THE MyMenu CLASS.
package ju.ch09;
import java.awt.*;
import java.awt.event.*;
public class MyMenu extends Menu {
public MyMenu(Object labels[],ActionListener al,ItemListener il) {
super((String)labels[0]);
String menuName = (String) labels[0];
char firstMenuChar = menuName.charAt(0);
if(firstMenuChar == `~' || firstMenuChar =='!'){
setLabel(menuName.substring(1));
if(firstMenuChar == `~') setEnabled(false);
}
for(int i=1;i<labels.length;++i) {
if(labels[i] instanceof String){
if("-".equals(labels[i])) addSeparator();
else{
String label = (String)labels[i];
char firstChar = label.charAt(0);
switch(firstChar){
case `+':
CheckboxMenuItem checkboxItem = new CheckboxMenuItem(label.
substring(1));
checkboxItem.setState(true);
add(checkboxItem);
checkboxItem.addItemListener(il);
break;
case `#':
checkboxItem = new CheckboxMenuItem(label.substring(1));
checkboxItem.setState(true);
checkboxItem.setEnabled(false);
add(checkboxItem);
checkboxItem.addItemListener(il);
break;
case `-':
checkboxItem = new CheckboxMenuItem(label.substring(1));
checkboxItem.setState(false);
add(checkboxItem);
checkboxItem.addItemListener(il);
break;
case `=':
checkboxItem = new CheckboxMenuItem(label.substring(1));
checkboxItem.setState(false);
checkboxItem.setEnabled(false);
add(checkboxItem);
checkboxItem.addItemListener(il);
break;
case `~':
MenuItem menuItem = new MenuItem(label.substring(1));
menuItem.setEnabled(false);
add(menuItem);
menuItem.addActionListener(al);
break;
case `!':
menuItem = new MenuItem(label.substring(1));
add(menuItem);
menuItem.addActionListener(al);
break;
default:
menuItem = new MenuItem(label);
add(menuItem);
menuItem.addActionListener(al);
}
}
}else{
add(new MyMenu((Object[])labels[i],al,il));
}
}
}
public MenuItem getItem(String menuItem) {
int numItems = getItemCount();
for(int i=0;i<numItems;++i)
if(menuItem.equals(getItem(i).getLabel())) return getItem(i);
return null;
}
}
The MyMenu class specifies that it is in the package ju.ch09. Make sure that you place it in the ju/
ch09 directory and compile it. You'll be using it in subsequent chapters.
MyMenu contains no field variables. It consists of a single constructor and the getItem()access
method. The getItem() method retrieves a menu item that's contained in the menu and based on the
menu item's label. It uses the getItemCount() and getItem() methods of the Menu class to retrieve the
menu items contained in a menu, and the getLabel() method of the MenuItem class to match a menu
item with the search string.
The MyMenu constructor constructs a menu from an array of menu labels and nested menu arrays
(representing submenus). It also takes ActionListener and ItemListener objects as arguments. These
objects are set up as the event handlers for the regular and check box items of the menu. For example,
to construct a typical File menu, labeled File, with the New and Open menu items followed by a
separator and an Exit menu item, you would use the following MyMenu constructor:
String fileMenuLabels[] = {"File","New","Open","-","Exit"};
// EventHandler must implement the ActionListener and ItemListener
Âinterfaces.
EventHandler eh = new EventHandler();
MyMenu fileMenu = new MyMenu(fileLabelMenus,eh,eh);
The first object in the array must be a String object that is the main label associated with the menu.
The following objects are String objects identifying the labels of the menu items contained in the
menu, separators, or second-level arrays representing submenus. For example, the following creates a
multilevel menu:
String goMenuLabels[] = {"Go","Beginning","End","Previous","Next"};
String editMenuLabels[] = {"Edit","Copy","Cut","-","Paste","-",
ÂgoMenuLabels};
// EventHandler must implement the ActionListener and ItemListener
Âinterfaces.
EventHandler eh = new EventHandler();
MyMenu editLabel = new MyMenu(editMenuLabels,eh,eh);
Using the MyMenu class is much easier than constructing each of the individual menu items and
adding them to a menu.
Let's step through the MyMenu constructor to see how it works. It uses the super() class constructor
call statement to construct a Menu object using the first label in the labels array. This label may
contain either the ~ or ! character as the first character. MyMenu() checks for these characters and
readjusts the menu's label accordingly. If the first character of the menu's label is ~, MyMenu() will
disable the entire menu using the setEnabled() method of the MenuItem class.
After setting up the menu's main label, MyMenu() iterates through the list of objects contained in
labels. If the object is an instance of the String class and is therefore a label, MyMenu() checks the
first letter of the label and processes it accordingly. If the object is not an instance of the String class,
MyMenu() calls itself again, passing the object to itself as another array of objects. It then adds the
resulting MyMenu object to itself using the add() method of the Menu class. This allows submenus to
be processed in a recursive fashion.
MyMenu() processes the menu item labels by using a switch statement to check the first character of
the label to see if it matches the +, #, -, =, ~, or ! character. If it does not match any of these
characters, the label is added as a normal menu item. If the label equals -, a separator is added.
If the first character is +, an enabled and checked CheckboxMenuItem object is added to the menu.
The setState() method of the CheckboxMenuItem class is used to set the state of the menu item to be
checked. If the first character is #, a checked, but disabled, CheckboxMenuItem object is added. The
setEnabled() method of the MenuItem class is used to disable the menu item. The cases in which the
first character of the label is - or = are processed in a similar manner, except that the
CheckboxMenuItem object is initially unchecked.
When the first character of the label is ~, a normal MenuItem object is added to the menu. The menu
item is disabled.
The ! character is an escape character that is used to create a normal menu item beginning with any of
the special characters previously mentioned. When the first character of a label is !, the actual label
generated begins with the subsequent character.
The MyMenuBar Class
The MyMenuBar class uses the MyMenu class presented in the previous section to quickly create an
entire menu bar. Whereas the MyMenu class uses an array of labels and submenus to create a menu,
the MyMenuBar class uses an array of these arrays to create the entire menu bar. For example, the
following statements will construct a menu bar with File, Edit, and Help menus, each consisting of
individual menu items:
String menuBarLabels[] = {
{"File","New","Open","-","~Save As","-","Exit"};
{"Edit","Copy","Cut","-","~Paste"};
{"Help","Index"};
};
// EventHandler must implement the ActionListener and ItemListener
Âinterfaces.
EventHandler eh = new EventHandler();
MyMenuBar menuBar = new MyMenuBar(menuBarLabels,eh,eh);
Note that the Save As and Paste menu items are initially disabled.
The source code of the MyMenuBar class is shown in Listing 9.3.
LISTING 9.3. THE MyMenuBar CLASS.
package ju.ch09;
import java.awt.*;
import java.awt.event.*;
public class MyMenuBar extends MenuBar {
public MyMenuBar(Object labels[][],ActionListener al,
ItemListener il) {
super();
for(int i=0;i<labels.length;++i)
add(new MyMenu(labels[i],al,il));
}
public MyMenu getMenu(String menuName) {
int numMenus = getMenuCount();
for(int i=0;i<numMenus;++i)
if(menuName.equals(getMenu(i).getLabel())) return((MyMenu)getMenu
(i));
return null;
}
}
The MyMenuBar constructor simply iterates through the outer array and passes the first-level
elements (which are themselves Object arrays) to the MyMenu constructor. The MyMenu objects are
then added to the MyMenuBar object being constructed using the add() method inherited from the
MenuBar class.
The getMenu() method retrieves a MyMenu object from a MyMenuBar object based on the label
associated with the MyMenu object. It uses the getMenuCount() and getMenu() methods of the
MenuBar class to retrieve each MyMenu object contained in the menu bar. The getLabel() method of
the MenuItem class is used to check the labels of the MyMenu objects against the search string.
The MenuApp Program
The MenuApp program illustrates the use of the MyMenuBar and MyMenu classes. Its source code is
shown in Listing 9.4.
LISTING 9.4. THE MenuApp PROGRAM.
import java.awt.*;
import java.awt.event.*;
import ju.ch09.MyMenu;
import ju.ch09.MyMenuBar;
public class MenuApp extends Frame {
MyMenuBar menuBar;
MenuApp.EventHandler eh = new MenuApp.EventHandler();
public static void main(String args[]){
MenuApp app = new MenuApp();
}
public MenuApp() {
super("Menu Madness");
setup();
setSize(400,400);
addWindowListener(eh);
show();
}
void setup() {
setBackground(Color.white);
setupMenuBar();
}
void setupMenuBar(){
String gotoMenu[] = {"Go To","Beginning","End","-","Line Number"};
Object menuItems[][] = {
{"File","New","Open","-","~Save","~Save As","-","Exit"},
{"Edit","Copy","Cut","-","~Paste"},
{"Search","Find","~Find Next","~Find Previous","-", gotoMenu},
{"View","-Hex","+Line Number","+Column Number"},
{"Help","About Menu Madness"},
};
menuBar = new MyMenuBar(menuItems,eh,eh);
setMenuBar(menuBar);
}
class EventHandler extends WindowAdapter implements ActionListener,
ItemListener {
public void actionPerformed(ActionEvent e){
String selection=e.getActionCommand();
if("Exit".equals(selection)){
System.exit(0);
}else if("New".equals(selection) || "Open".equals(selection)){
menuBar.getMenu("File").getItem("Save").setEnabled(true);
menuBar.getMenu("File").getItem("Save As").setEnabled(true);
}else if("Copy".equals(selection) || "Cut".equals(selection)){
menuBar.getMenu("Edit").getItem("Paste").setEnabled(true);
}else if("Find".equals(selection)){
menuBar.getMenu("Search").getItem("Find Next").setEnabled(true);
menuBar.getMenu("Search").getItem("Find Previous").setEnabled
(true);
}else if("About Menu Madness".equals(selection)){
menuBar.getMenu("Help").setEnabled(false);
}
}
public void itemStateChanged(ItemEvent e){
}
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
MenuApp shows how the MyMenuBar and MyMenu classes are used to easily create a menu bar and
to support the processing of menu-related events. When the program is executed, it displays a blank
opening screen and a menu bar with five pull-down menus, as shown in Figure 9.3.
FIGURE 9.3. The MenuApp opening window.
Click on the File menu and select New, as shown in Figure 9.4. This will cause the Save and Save As
menu items to become enabled. You can verify this by clicking on the File menu once again.
Click on the Edit menu and select Copy, as shown in Figure 9.5. This results in the Paste menu item
becoming enabled.
Click on the Search menu and then on Go To, as shown in Figure 9.6. The Go To menu item is a
second-level menu that is attached to the Search menu.
FIGURE 9.4. The File menu.
FIGURE 9.5. The Edit menu.
FIGURE 9.6. The Search menu.
Click on the View menu and select Hex, as shown in Figure 9.7. Notice that the Hex check box
becomes checked, as shown in Figure 9.8.
FIGURE 9.7. The View menu.
FIGURE 9.8. The View menu after checking Hex.
Click on the Help menu and select About Menu Madness, as shown in Figure 9.9. This Help menu
isn't much help at all because it is programmed to disable itself, as shown in Figure 9.10.
FIGURE 9.9. The Help menu.
FIGURE 9.10. The Help menu disabled.
You've completed the tour of the MenuApp program. Select Exit from the File menu to terminate the
program's operation.
Inside MenuApp
The MenuApp class consists of two variables, menuBar and eh. The menuBar variable is an object of
class MyMenuBar that is used to hold the application's menu bar. The eh variable is assigned an
object of the EventHandler class. This object is used to handle both window- and menu-related
events. It is used to show how multiple event handlers can be combined into a single event handler.
The MenuApp constructor creates a 400¥400 frame window with the title "Menu Madness," and
invokes the setup() method to set up the background color and the menu bar. The setup() method
invokes setupMenuBar() to actually perform the menu bar setup.
The setupMenuBar() method creates a gotoMenu array as the labels of a submenu that will be
attached to the Search menu. The menuItems array is used to define the labels associated with the
menu bar and its first-level menus. The gotoMenu array is included as an object in this array. Notice
the use of the first-character conventions for disabling menu items and specifying menu items that are
check boxes. The menu bar is created, assigned to the menuBar variable, and set as the menu bar for
the MenuApp frame.
Creating the menu bar with the MyMenuBar class was a snap. However, creating the menu bar is
only half of the work. You also need to write event-handling code that acts on the menu items
selected by the user. The EventHandler inner class illustrates the use of a single event handler to
handle multiple types of events. EventHandler extends the WindowAdapter class. This allows it to
handle window events, such as the window closing event. It handles this event in the standard way,
by overriding the windowClosing()method.
EventHandler also implements the ActionListener and ItemListener interfaces, and therefore the
actionPerformed() and itemStateChanged() methods. The actionPerformed() method is used to handle
the events associated with the selection of normal menu items, and the itemStateChanged() method is
used to handle events associated with check box menu items.
The Exit menu item is handled by terminating the program's execution. The New and Open menu
items cause the Save and Save As menu items to be enabled. The getMenu() method of MyMenuBar
and the getItem() method of MyMenu are used to retrieve the Save and Save As MenuItem objects.
The setEnabled() method of the MenuItem class is used to enable these menu items. Note that the
Save and Save As menu items, as well as some other menu items, are not handled. Selecting these
menu items does not cause any action to be performed.
The Copy and Cut menu items are processed in a similar manner as the New and Open menu items.
Selecting Copy or Cut enables the Paste menu item.
The Find menu item enables the Find Next and Find Previous menu items.
The handling of the About Menu Madness menu item shows how an entire menu can be disabled.
Popup Menus
In addition to the traditional menus that are pulled down from a menu bar, Java provides support for
popup menus, which are menus that appear when you perform a mouse action that triggers them. In
Windows 95 platforms, this is the right-button click. Try right-clicking on your Windows 95 desktop.
This should cause a popup menu to be displayed.
Popup menus are supported via the PopupMenu class, which is a subclass of the Menu class. This
class provides two constructors--a default parameterless constructor, and a constructor that takes a
String parameter. The String parameter is used as the popup menu's title. In Windows 95, the title is
not displayed.
The show() method of the PopupMenu class causes a popup menu to be displayed. Its arguments are
the Component object in which the menu is to be popped up and the x- and y-coordinates where the
menu is to be placed (relative to the component).
Additional support for popup menus is provided in the MouseEvent and ComponentEvent classes of
the java.awt.event package. The isPopupTrigger() method of MouseEvent is used to determine
whether a mouse event is the native window event associated with popup menus. The getComponent
() method of ComponentEvent returns the component in which a mouse event takes place.
Using Dialog Boxes
The Dialog class is used to construct a window that is displayed separately from the application
menu. The window associated with a Dialog object is not allowed to contain a menu bar. It may be
specified as being modal, meaning that it is displayed on top of the main application window until it
is hidden or disposed of using the show()and dispose()methods. Most dialog boxes are used to
display information to the user and get the user's response via a button click.
The MessageDialog Class
The MessageDialog class provides a custom component that implements the most common types of
dialog boxes. Its source code is shown in Listing 9.5.
LISTING 9.5. THE MessageDialog CLASS.
package ju.ch09;
import java.awt.*;
import java.awt.event.*;
public class MessageDialog extends Dialog {
public MessageDialog(Frame parent,String title,boolean modal,
String text[],
String buttons[], WindowListener wh, ActionListener bh) {
super(parent,title,modal);
int textLines = text.length;
int numButtons = buttons.length;
Panel textPanel = new Panel();
Panel buttonPanel = new Panel();
textPanel.setLayout(new GridLayout(textLines,1));
for(int i=0;i<textLines;++i) textPanel.add(new Label(text[i]));
for(int i=0;i<numButtons;++i){
Button b = new Button(buttons[i]);
b.addActionListener(bh);
buttonPanel.add(b);
}
add("North",textPanel);
add("South",buttonPanel);
setBackground(Color.lightGray);
setForeground(Color.black);
pack();
addWindowListener(wh);
}
}
The MessageDialog constructor uses the parent, title, modal, text, buttons, wh, and bh parameters.
The parent, title, and modal parameters are passed to the Dialog constructor of its parent class. Two
Panel objects are created and assigned to textPanel and buttonPanel. The textPanel layout is specified
as a GridLayout object, and the buttonPanel layout is the default FlowLayout object. The text lines
are arranged in a vertical grid in the textPanel. The buttons are laid out in a centered horizontal
fashion within the buttonPanel. The layout for the MessageDialog object is BorderLayout by default.
The ActionListener object passed via bh is set up as the event handler for each button. The textPanel
is added to the top of the dialog box, and the buttonPanel is added to the bottom. The foreground and
background colors are set to light gray and black. The dialog box is packed, and the WindowListener
object passed via wh is set up as the event handler for the dialog box.
The MessageApp Program
The MessageApp program shows how the MessageDialog class can be used to implement traditional
dialog box functions found in typical window programs. Its source code is shown in Listing 9.6.
LISTING 9.6. THE MessageApp PROGRAM.
import java.awt.*;
import java.awt.event.*;
import ju.ch09.MyMenu;
import ju.ch09.MyMenuBar;
import ju.ch09.MessageDialog;
public class MessageApp extends Frame {
MyMenuBar menuBar;
MessageDialog dialog;
DialogHandler dh = new DialogHandler();
public static void main(String args[]){
MessageApp app = new MessageApp();
}
public MessageApp() {
super("MessageApp");
setup();
setSize(400,400);
addWindowListener(new WindowEventHandler());
show();
}
void setup() {
Object menuItems[][] = {
{"File","Exit"},
{"View","Information","Confirmation","Selection"},
};
MenuItemHandler mih = new MenuItemHandler();
menuBar = new MyMenuBar(menuItems,mih,mih);
setMenuBar(menuBar);
}
class MenuItemHandler implements ActionListener, ItemListener {
public void actionPerformed(ActionEvent ev){
String s=ev.getActionCommand();
if(s=="Exit"){
System.exit(0);
}else if(s=="Information"){
String text[] = {"Don't look now, but your shoelace is
untied."};
String buttons[] = {"OK"};
dialog = new MessageDialog(MessageApp.this,"Information",false,
text,buttons,dh,dh);
dialog.setLocation(75,75);
dialog.show();
}else if(s=="Confirmation"){
String text[] = {"Do you really want to do this?"};
String buttons[] = {"Yes","No","Cancel"};
dialog = new MessageDialog(MessageApp.this,"Confirmation",false,
text,buttons,dh,dh);
dialog.setLocation(75,75);
dialog.show();
}else if(s=="Selection"){
String text[] = {"What direction do you want to go?",
"North: cold", "South: warm", "East: humid", "West: arid"};
String buttons[] = {"North","South","East","West"};
dialog = new MessageDialog(MessageApp.this,"Selection",false,
text,buttons,dh,dh);
dialog.setLocation(75,75);
dialog.show();
}
}
public void itemStateChanged(ItemEvent e){
}
}
class WindowEventHandler extends WindowAdapter {
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
class DialogHandler extends WindowAdapter implements
ActionListener {
public void windowClosing(WindowEvent e){
MessageApp.this.show();
dialog.dispose();
}
public void actionPerformed(ActionEvent e){
MessageApp.this.show();
dialog.dispose();
}
}
}
The MessageApp opening window is shown in Figure 9.11. It supports the File and View pull-down
menus.
FIGURE 9.11. The MessageApp opening window.
Select the Information menu item from the View pull-down menu, as shown in Figure 9.12.
A helpful Information dialog box is displayed, as shown in Figure 9.13. This type of dialog box is
typically used to provide information to the user. When the dialog box is displayed, the user
acknowledges the information by clicking on the OK button.
FIGURE 9.12. Selecting Information from the View menu.
FIGURE 9.13. The Information dialog box.
Selecting Confirmation from the View menu results in a Confirmation dialog box being displayed to
the user, as shown in Figure 9.14. This type of dialog box requests confirmation from the user before
attempting to perform an operation that may require the user's approval. If the user clicks the Yes
button, the action is performed. If the user clicks No, the operation is not performed. If the user clicks
Cancel, an entire series of actions leading up to the confirmation dialog box is aborted.
FIGURE 9.14. The Confirmation dialog box.
Choosing the Selection menu item from the View menu results in a multiple-choice Selection dialog
box displayed to the user. The user is allowed to pick from one of several alternative paths of
program execution. (See Figure 9.15.)
FIGURE 9.15. The Selection dialog box.
The MessageApp constructor creates a 400¥400 window titled "MessageApp." It uses the
MyMenuBar class to construct the program's menu bar. No special processing of note is performed in
the application window's construction. The dialog boxes, previously shown, are created by the
program's event-handling software.
The MenuItemHandler class handles the events associated with the program's menu bar. The Exit
menu item is handled by terminating the program. If the Information menu item is selected, a new
MessageDialog object is created with the information shown in Figure 9.13, and the dialog box is
displayed to the user using the show() method. The setLocation() method is used to move the dialog
box to an offset within the main application window. The dialog box is not modal. The Confirmation
and Selection menu items are handled in a similar manner. They create the dialog boxes shown in
Figures 9.14 and 9.15 using the MessageDialog() constructor.
The event handling for each dialog box is performed by the methods of the DialogHandler class.
These methods display the main application window and then dispose of the dialog box.
The Accessibility API
The Accessibility API provides the capability to use assistive technologies, such as screen magnifiers
and speech recognition, within window applications and applets. These technologies can be used by
disabled and non-disabled users to simplify their interaction with GUI components. The Accessibility
API consists of the classes and interfaces of the com.sun.java.accessibility package. These classes
and interfaces provide "hooks" for the incorporation of assistive technologies.
●
Accessible--Defines general methods for incorporating accessibility features into an
application.
●
AccessibleAction--Used to define the actions that are supported by an assistive object.
●
AccessibleBundle--Superclass of AccessibleState and AccessibleRole.
●
AccessibleComponent--Interface implemented by visual components that support assistive
technologies.
●
AccessibleContext--Provides information about an assistive object.
●
AccessibleHyperlink--Provides the capability to add assistive services for hyperlinks.
●
AccessibleHypertext--Provides the capability to add assistive services for hypertext.
●
AccessibleResourceBundle--Provides localized accessibility properties for a particular locale.
●
AccessibleRole--Defines the roles for GUI components that support accessibility.
●
●
●
●
●
AccessibleSelection--Provides methods for an assistive object to identify child objects and
determine user selections.
AccessibleState--Provides methods for accessing the state of GUI components that support
accessibility.
AccessibleStateSet--Provides methods for accessing the set of states of GUI components that
support accessibility.
AccessibleText--Defines methods for assistive technologies that present text to the user.
AccessibleValue--An interface that is implemented by assistive objects (such as scrollbars)
that yield a value within a range of values.
Unfortunately, no assistive technologies are currently available to take advantage of the hooks
offered by the com.sun.java.accessibility package. However, it is anticipated that these technologies
will be available in the near future.
Summary
In this chapter, you learned how to develop window applications using Java. You learned about the
differences between applications and applets, how to open and organize windows, and how to work
with menus and dialog boxes. You also learned about the Accessibility API of JDK 1.2. In the next
chapter, you'll learn how to write console programs using Java.
© Copyright, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
- 10 Writing Console Applications
●
●
●
●
●
Differences Between Console and Window Applications
Keyboard Input and Console Output
BlackJackApp
❍ Overview of BlackJackApp
The java.lang Packages
❍ The Object, Class, and Package Classes
❍ The ClassLoader, SecurityManager, and Runtime Classes
❍ The System Class
❍ Wrapped Classes
❍ The Math Class and Comparable Interface
❍ The Compiler Class
❍ Exceptions and Errors
❍ The Void Class
❍ Reflection and the java.lang.reflect Package
❍ Reference Objects and the java.lang.ref Package
Summary
Before applets, the Web, Windows, and the Macintosh, most programs were text-based console
applications. These programs received user keyboard entries and displayed text output to the user.
Although most of the programs we use today are GUI-based, console programs still play a role in
some systems and applications. For example, I still use console programs with my Linux computer,
and I still run the Java compiler from a DOS shell.
In this chapter you'll learn to write console programs in Java. You'll learn to read user keyboard
input, process it, and display text output to the user's console. You'll also learn about some useful
classes and interfaces in the java.lang, java.lang.reflect, and java.lang.ref packages. When you finish
this chapter, you'll be able to write your own console programs.
Differences Between Console and Window Applications
In previous chapters you learned to use Java to write applets and window applications. You learned
how to open windows, display GUI components, and handle events associated with those
components. You don't need to do any of these things in console programs. There are no windows or
GUI components, and in simple programs, the only event that you usually need to handle is the
entering of keyboard data by the user.
Console programs are not limited to user interaction. They just minimize its complexities. Advanced
console programs access databases via JDBC, use TCP and UDP sockets for network
communication, and interface with distributed systems using RMI, CORBA, and DCOM. The
primary difference between console programs and window applications and applets is that console
programs lack a graphical user interface.
Console programs have the same entry point as window applications--a main() method with a String
[] argument. Like window applications, the following program template is shared by all console
programs:
class programClass {
public static void main(String[] args) {
.
.
.
}
}
Console programs start by reading the args array to see which parameters were passed to the program
at the command line. After reading these parameters and performing any necessary initialization, the
program then responds to input entered from the keyboard or received from a file, socket, remote
method invocation, or other input source.
Keyboard Input and Console Output
The most basic I/O performed by a console program is reading data entered at the user's keyboard and
writing data to the user's console. We'll cover keyboard input and console output in this chapter. Later
chapters of this book will show how to perform I/O via files, TCP/IP socket programming, JDBC,
remote method invocation, CORBA, and DCOM.
The System class of the java.lang package provides all that you need for your programs to
communicate with the user via the keyboard and console. The System.in variable provides access to
the standard input stream, which defaults to the keyboard. The System.out variable provides access to
the standard output stream, which is the console by default. The System.err variable provides access
to the standard error stream, which is also usually the user's console. These three variables refer to
stream objects of the java.io package. Each of these streams can be redirected to other inputs and
outputs, such as file I/O and socket I/O.
NOTE: Chapter 17, "Input/Output Streams," covers stream-based input and output in
great detail. This chapter provides you with just enough information on stream I/O to
allow you to write console programs.
The System.in variable refers to an object of the InputStream class. This class provides basic methods
for reading data, but is usually used to construct more powerful input classes, such as the
BufferedReader class. The BufferedReader class provides the readLine() method for reading an entire
line at a time from a stream. It returns the value null if the end of a stream has been encountered.
The following lines of code illustrate the use of these classes and methods:
BufferedReader keyboardInput;
keyboardInput = new BufferedReader(new InputStreamReader(System.
in));
String newLine;
while(((newLine = keyboardInput.readLine())!=null)) {
// Process each input line
}
The first line declares the keyboardInput variable to be of the BufferedReader class. The second line
uses the InputStream object referenced by System.in to construct a InputStreamReader object. The
InputStreamReader object is then used to construct an object of the BufferedReader class. This object
is assigned to the keyboardInput variable.
The while statement reads a line of input at a time by invoking the readLine() method of the
BufferedReader object assigned to the keyboardInput variable. It then assigns this input (as a String
object) to the newLine variable. The while statement checks to see if the input is null to determine
whether the end of the input stream was encountered. If not, it processes the new line within the body
of the while loop. In practice, readLine() will not return a null value when reading from the keyboard.
Instead, it blocks (waits) until the user enters a line of input. However, it is good practice to test for
end of input just in case the user redirects a file as input in place of the keyboard.
The System.out and System.err variables refer to objects of the PrintStream class that are directed to
the user's console. The PrintStream class provides the print() and println() methods for printing data
to an output stream.
BlackJackApp
In this section you'll learn to write a console program that illustrates keyboard input and console
output. The BlackJackApp program is a simplified, character-based version of the popular blackjack
card game. This example, while entertaining, also illustrates the basics of console application
programming. The source code for this program is shown in Listing 10.1.
LISTING 10.1. THE SOURCE CODE OF THE BlackJackApp PROGRAM.
// BlackJackApp.java
// Import all the Java API classes needed by this program.
import java.lang.System;
import java.lang.Integer;
import java.lang.NumberFormatException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Random;
class BlackJackApp {
public static void main (String args[]) throws IOException {
// Create a BlackJackGame object ...
BlackJackGame game = new BlackJackGame();
// and play it!
game.play();
}
}
class BlackJackGame {
// Variable declarations
int bet;
int money;
Deck deck;
Hand playersHand;
Hand dealersHand;
BufferedReader keyboardInput;
// Method declarations
public BlackJackGame() { // Constructor
bet = 0;
money = 1000;
deck = new Deck();
keyboardInput =
new BufferedReader(new InputStreamReader(System.in));
}
void play() throws IOException {
System.out.println("Welcome to Blackjack!");
System.out.println("You have $"+Integer.toString(money)+".");
do {
placeBet();
if(bet>0) {
initialDeal();
if(playersHand.blackjack()) playerWins();
else{
while(playersHand.under(22) && playerTakesAHit()) {
playersHand.addCard(deck.deal());
playersHand.show(false,false);
}
while(dealersHand.mustHit())
dealersHand.addCard(deck.deal());
dealersHand.show(true,false);
showResults();
}
}
} while (bet>0);
}
void placeBet() throws IOException, NumberFormatException {
do{
System.out.print("Enter bet: ");
System.out.flush();
bet = Integer.parseInt(keyboardInput.readLine());
} while(bet<0 || bet>money);
}
void initialDeal() {
System.out.println("New hand...");
playersHand = new Hand();
dealersHand = new Hand();
for(int i = 0;i<2;++i) {
playersHand.addCard(deck.deal());
dealersHand.addCard(deck.deal());
}
dealersHand.show(true,true);
playersHand.show(false,false);
}
void playerWins() {
money += bet;
System.out.println("Player wins $"+Integer.toString(bet)+".");
System.out.println("Player has $"+Integer.toString(money)+".");
}
void dealerWins() {
money -= bet;
System.out.println("Player loses $"+Integer.toString(bet)+".");
System.out.println("Player has $"+Integer.toString(money)+".");
}
void tie() {
System.out.println("Tie.");
System.out.println("Player has $"+Integer.toString(money)+".");
}
boolean playerTakesAHit() throws IOException {
char ch = ` `;
do{
System.out.print("Hit or Stay: ");
System.out.flush();
String playersDecision = keyboardInput.readLine();
try{
ch = playersDecision.charAt(0);
}catch (StringIndexOutOfBoundsException exception){
}
if(ch == `H' || ch == `h') return true;
if(ch == `S' || ch == `s') return false;
} while(true);
}
void showResults() {
if(playersHand.busted() && dealersHand.busted()) tie();
else if(playersHand.busted()) dealerWins();
else if(dealersHand.busted()) playerWins();
else if(playersHand.bestScore() > dealersHand.bestScore())
playerWins();
else if(playersHand.bestScore() < dealersHand.bestScore())
dealerWins();
else tie();
}
} // End of BlackJackGame class
class Deck {
// Variable declarations
int cards[];
// Array of 52 cards
int topCard;
// 0-51 (index of card in deck)
Random random;
// Method declarations
public Deck() { // Constructor
cards = new int[52];
for(int i = 0;i<52;++i) cards[i] = i;
topCard = 0;
random = new Random();
shuffle();
}
public void shuffle() {
// Repeat 52 times
for(int i = 0;i<52;++i) {
// Randomly exchange two cards in the deck.
int j = randomCard();
int k = randomCard();
int temp = cards[j];
cards[j] = cards[k];
cards[k] = temp;
}
}
int randomCard() {
int r = random.nextInt();
if(r<0) r = 0-r;
return r%52;
}
Card deal() {
if(topCard>51) {
shuffle();
topCard = 0;
}
Card card = new Card(cards[topCard]);
++topCard;
return card;
}
} // End of Deck class
class Hand {
// Variable declarations
int numCards;
Card cards[];
static int MaxCards = 12;
//Method declarations
public Hand() { // Constructor
numCards = 0;
cards = new Card[MaxCards];
}
void addCard(Card c) {
cards[numCards] = c;
++numCards;
}
void show(boolean isDealer,boolean hideFirstCard) {
if(isDealer) System.out.println("Dealer:");
else System.out.println("Player:");
for(int i = 0;i<numCards;++i) {
if(i == 0 && hideFirstCard) System.out.println(" Hidden");
else System.out.println(" "+cards[i].value+" of "+cards[i].
suit);
}
}
boolean blackjack() {
if(numCards == 2) {
if(cards[0].iValue == 1 && cards[1].iValue == 10) return true;
if(cards[1].iValue == 1 && cards[0].iValue == 10) return true;
}
return false;
}
boolean under(int n) {
int points = 0;
for(int i = 0;i<numCards;++i) points += cards[i].iValue;
if(points<n) return true;
else return false;
}
int bestScore() {
int points = 0;
boolean haveAce = false;
for(int i = 0;i<numCards;++i) {
points += cards[i].iValue;
if(cards[i].iValue == 1) haveAce = true;
}
if(haveAce) {
if(points+10 < 22) points += 10;
}
return points;
}
boolean mustHit() {
if(bestScore()<17) return true;
else return false;
}
boolean busted() {
if(!under(22)) return true;
else return false;
}
} // End of Hand class
class Card {
// Variable declarations
int iValue;
// Numeric value corresponding to card.
String value; // "A" "2" through "9" "T" "J" "Q" "K"
String suit; // "S" "H" "C" "D"
// Method declarations
public Card(int n) { // Constructor
int iSuit = n/13;
iValue = n%13+1;
switch(iSuit) {
case 0:
suit = "Spades";
break;
case 1:
suit = "Hearts";
break;
case 2:
suit = "Clubs";
break;
default:
suit = "Diamonds";
}
if(iValue == 1) value = "Ace";
else if(iValue == 10) value = "Ten";
else if(iValue == 11) value = "Jack";
else if(iValue == 12) value = "Queen";
else if(iValue == 13) value = "King";
else value = Integer.toString(iValue);
if(iValue>10) iValue = 10;
}
int getValue() {
return iValue;
}
} // End of Card class
When you run BlackJackApp, it produces the following output:
Welcome to Blackjack!
You have $1000.
Enter bet:
The BlackJackApp program will provide you with $1,000 with which to play blackjack. You can
place a bet between 0 and the amount of money you have. The program, acting as dealer, will deal
two cards to you and two to itself. For example, after I entered a bet of $10, I received the following
program output:
Welcome to Blackjack!
You have $1000.
Enter bet: 10
New hand...
Dealer:
Hidden
2 of Hearts
Player:
Queen of Clubs
3 of Spades
Hit or Stay:
I was dealt a queen of clubs and a three of spades. This gave me a total of 13 points. Points are
calculated as follows:
Card point
Value
Ace
1 or 11 (whichever is better)
2 through 10
Face value of card (that is, 2 through 10)
Jack, Queen, King 10
The objective of the game is to get as close to 21 as you can without going over. Whoever gets the
closest wins. If you go over 21 you lose, unless the dealer does also, in which case you tie.
When you are dealt your initial two cards, you are shown one of the dealer's cards. This helps you
determine whether you should take another card, referred to as hitting, or stay with the cards that you
have. You can enter h or s to inform the dealer of your decision. If you enter h, you will be dealt
another card. If you enter s, the dealer will begin to play its hand.
[begNOTE: If the point total of your first two cards is 21, you have blackjack and
immediately win.
The dealer must take a hit until the total points in its hand is 17 or over, at which point it must stay.
When both you and the dealer have finished playing your hand, the total number of points acquired
by each is used to determine the winner. Play is repeated until you enter a $0 bet.
The following program output shows a game played between myself and the BlackJackApp program:
Welcome to Blackjack!
You have $1000.
Enter bet: 10
New hand...
Dealer:
Hidden
2 of Hearts
Player:
Queen of Clubs
3 of Spades
Hit or Stay: h
Player:
Queen of Clubs
3 of Spades
7 of Spades
Hit or Stay: s
Dealer:
Queen of Spades
2 of Hearts
5 of Spades
Player wins $10.
Player has $1010.
Enter bet: 20
New hand...
Dealer:
Hidden
7 of Clubs
Player:
King of Clubs
9 of Spades
Hit or Stay: s
Dealer:
2 of Clubs
7 of Clubs
9 of Clubs
Player wins $20.
Player has $1030.
Enter bet: 0
On the initial deal, I bet 10 bucks. I was given a queen of clubs and a three of spades, for a total of 13
points. The dealer was given a two of hearts and another (hidden) card. I elected to take a hit and was
dealt a seven of spades, bringing the total in my hand up to 20 points--beginner's luck! The dealer
turned over the hidden card to reveal a queen of spades. He then drew a five of spades for a total of
17 points. Because the dealer reached 17, he was forced to stay, and I had won $10. Feeling a little
lightheaded, I proceeded to double my bet to $20. I was dealt a king of clubs and a nine of spades for
a total of 19 points. I decided to stay with that hand. The dealer's hand was revealed to be a two of
clubs and a seven of clubs. The dealer drew a nine of clubs for a total of 18 points. I had won again!
At that point I elected to take the money and continue writing this book. I entered a 0 bet to end the
game.
The point this is not to turn you into a blackjack gambler, but to serve as a more interesting example
of console programming.
Overview of BlackJackApp
The BlackJackApp.java file is long, but don't let that daunt you. I'm going to break it down, class by
class and method by method, to explain its operation.
The program begins by declaring the BlackJackApp class, the class that implements the blackjack
application. The main() method consists of two Java statements. The first declares the game variable
as having class type BlackJackGame and assigns it a new object of class BlackJackGame. The second
statement invokes the play() method of the object referenced by game. Because BlackJackApp does
not require any command-line arguments, the args array is not processed.
The BlackJackGame Class
The BlackJackGame class is rather long. It declares six variables and nine methods. The variables are
data structures that represent the state of a blackjack game. The bet variable identifies the amount bet
by the player. The money variable identifies how much money the player has left. The deck variable
references an object of class Deck that is used to represent a deck of cards. Two Hand variables are
declared, representing the player's hand and the dealer's hand. The keyboardInput variable refers to a
BufferedReader object that is used to read data entered at the user's keyboard.
The BlackJackGame() constructor initializes four of the six variables of the BlackJackGame class.
The player's bet is set to 0, and the player is given $1000. The playersHand and dealersHand
variables are not initialized until the cards are dealt. A new Deck object is created and assigned to the
deck variable. Finally, the keyboardInput variable is assigned a new object of class BufferedReader.
This object is created using the BufferedReader() and InputStreamReader() constructors with the
System.in variable as an argument.
The second method defined for BlackJackGame is the play() method. This method is invoked in the
main() method of BlackJackApp to cause the BlackJackGame object, referenced by game, to be
played.
The play() method begins by displaying the Welcome to Blackjack! text and the amount of money
available to the player. The second println() method takes three arguments. First it displays You have
$, then it displays the contents of the money variable, and then it displays a period (.). It converts the
integer value of money to a String value before printing it. The block of statements within the do
statement prompts the player to bet and then play a hand of blackjack.
If bet is greater than 0, the initialDeal() method is invoked. This method is used to deal a new hand to
the player and to the dealer. It causes the playersHand and dealersHand variables to each be
initialized with an object of class Hand. The blackjack() method is used to check whether the player
was dealt a blackjack (21 points). If so, the player wins the bet and the playerWins() method is
invoked.
If the player was not fortunate enough to have a blackjack, a while statement checks to see if the
player has 21 points or less in his hand and whether he wants to take another card. The
playerTakesAHit() method is invoked to prompt the player to hit or stay. The statements enclosed
within the first while statement invoke methods for the Hand object referenced by the playersHand
variable. The first method causes a card to be added to the player's hand by dealing it from the deck.
The second method determines if and how the player's hand should be displayed.
The second while statement is used to play the dealer's hand. It invokes the mustHit() method with
the object referenced by the dealersHand variable to determine whether the dealer has fewer than 17
points in his hand and, therefore, must take a hit. If the dealer must take a hit, the addCard() method
is invoked to deal a card to the dealer.
After the dealer's hand is played, the show() method is invoked to display it to the console. The
showResults() method is then invoked to show the results of the hand.
The placeBet() method is invoked by the play() method to prompt the player to enter a bet. It uses a
do statement to repeatedly prompt the user to enter a bet between 0 and the amount of money that he
has left. The statement block enclosed by the do statement displays the prompt, reads the line entered
by the user, converts it to an integer, and then assigns it to the bet variable.
The initialDeal() method is invoked by the play() method to deal a new hand to the player and the
dealer. It displays the New hand... text to the console window to inform the player that a new hand is
being dealt. It then creates two new objects of class Hand, initializes them with the Hand()
constructor, and assigns them to the playersHand and dealersHand variables.
After creating the two new hands, the initialDeal() method executes a for statement to sequentially
deal two cards to the player and two to the dealer via the addCard() method. After the player and
dealer have been dealt their hands, the show() method is invoked to display the new hands. (You'll
find out what the boolean values are used for when you study the show() method.)
The next three methods, playerWins(), dealerWins(), and tie(), are used to update the money variable
based on the bet variable and the outcome of the hand. These methods also display the results to the
player by converting the values of bet and money to String objects.
The playerTakesAHit() method prompts the user to hit or stay. The flush() method is used to flush all
output to the console in the absence of a new line character. The readLine() method is used to read
the line entered by the user.
The showResults() method is the last method declared for the BlackJackGame class. This method
uses a series of nested if statements. The first if statement checks to see if the player's hand and the
dealer's hand are both busted (over 21 points). If so, the tie() method is invoked to display the results
to the player.
The second if statement checks to see if the player's hand is busted. Because the else part of the first
if statement was executed, it is impossible for both the player and the dealer to be busted. So if the
player is busted, the dealer wins.
The third if statement is executed in the else parts of the first and second if statements. It uses the
same logic as the second if statement to determine whether the dealer busts and the player wins.
The fourth if statement is only executed if neither the player nor the dealer busts. It checks the points
in both of their hands to see if the player is higher than the dealer and, therefore, is the victor.
The fifth if statement is only executed if neither busts and the player is not higher than the dealer. If
the dealer is higher than the player, the dealer wins. If the dealer is not higher than the player, the
final else part is executed. At this point, neither has busted but neither is higher than the other, so
both must have the same number of points and a tie is declared.
The Deck Class
The Deck class declares three variables and four methods. The cards variable is used to simulate a
deck of cards. The topCard variable is an integer that identifies the next card to be dealt from the
deck. The random variable is used to generate random numbers.
The constructor for the Deck class allocates an array of 52 integers and assigns it to cards. A for
statement is used to assign 0 to cards[0], 1 to cards[1], 2 to cards[2], and so on, until 51 is assigned to
cards[51]. This creates a deck of cards in which all the cards are ordered by suit and by value. The
integers 0 through 51 are logically mapped to playing cards, as follows:
0 through 12 are mapped to the ace of spades through the king of spades.
13 through 25 are mapped to the ace of hearts through the king of hearts.
26 through 38 are mapped to the ace of clubs through the king of clubs.
39 through 51 are mapped to the ace of diamonds through the king of diamonds.
The topCard of the deck is set to 0. It is used as an index into the cards array. The random variable is
assigned a new object of class Random. Finally, the shuffle() method is invoked to shuffle the new
deck of cards.
The shuffle() method shuffles the deck of cards by randomly switching two cards in the deck 52
times. It does this by invoking the randomCard() method to generate a random integer between 0 and
51.
The randomCard() method returns an integer between 0 and 51, inclusive. It begins by declaring a
variable r and assigning it a random integer value generated by applying the nextInt() method to the
random variable. The nextInt() method is defined in the java.util.Random class. If the value assigned
to r is less than 0, it is changed to a positive integer. The randomCard() method then returns an
integer between 0 and 51 by returning the random integer modulus 52.
The deal() method is used to deal a card off the top of the deck. It does this by using the topCard
variable as an index into the cards array. It starts at 0 and is incremented until it is greater than 51,
indicating that all the cards in the deck have been dealt. In this case, the deck is reshuffled and
topCard is set to 0 once again. This creates the effect of another deck being used because the player
and dealer don't have to throw back any cards they're holding before the deck is shuffled.
The Card class is used to translate the integer card values to String values that can be displayed on the
console. A card is dealt by constructing a new instance of Card, using the value of cards indexed by
topCard as an argument. The topCard is then incremented to move to the next card in the deck. Note
that deal() returns the object of class Card that was created using the Card() constructor.
The Hand Class
The Hand class is used to implement a hand of cards as played by both the player and the dealer. It
declares three variables and eight methods.
The numCards variable identifies the number of cards contained in the hand. The cards array has the
same name as the cards array declared in the Deck class, but is logically and physically distinct.
Because it is declared in a separate class, it is contained in objects that are instances of the Hand class
and not of the Deck class. The MaxCards variable is declared to be static. It is used to identify the
number of components to be allocated within cards.
The constructor for the Hand class sets numCards to 0 to indicate an empty hand, and then creates a
MaxCards size array of Card objects and assigns it to cards.
Cards are added to a hand using the addCard() method. This method takes an object of class Card as
an argument and adds it to the first available position within the cards array. It then increments
numCards so that it will index the next available position within cards.
The show() method displays either the dealer's or the player's hand. It takes two boolean arguments
that specify whether the hand belongs to the dealer, and if so, whether the first card should be hidden
when the hand is displayed. The isDealer parameter is used in the initial if statement to determine
whether a dealer or a player heading should be displayed. A for statement is then used to iterate
numCards times in order to display each card of the hand. The statement block enclosed by the for
statement uses the hideFirstCard parameter to determine whether the first card should be hidden or
displayed.
The blackjack() method returns a boolean value indicating whether the hand is blackjack. If the
number of cards is exactly two, it uses the iValue variable of the Card objects contained in the cards
array to determine whether the current hand is blackjack. The iValue variable is discussed with the
Card class. It identifies the number of points associated with a card. A card with iValue = 1 is an ace.
Aces can be either 1 or 11 points.
The under() method returns a boolean value indicating whether the number of points in a hand is less
than the argument passed via the n parameter. It declares a points variable of type int and uses a for
statement to sum the points for all cards in the hand. It then checks to see if the number of points in
the hand is less than n and returns an appropriate value of true or false.
The bestScore() method returns an integer value identifying the best possible point score for the hand.
It adjusts the value associated with aces to either 1 or 11, depending upon whether it causes the hand
to go over 21 points.
The mustHit() method is used to play out the dealer's hand. If the bestScore of the dealer's hand is
lower than 17, the dealer must take a hit. If it is 17 or higher, the dealer must stay.
The busted() method determines whether the number of points in a hand is under 22.
The Card Class
The Card class is used to translate the integer value of cards, maintained by objects of the Deck class,
into objects of type String. It declares three variables and two methods.
The iValue variable is used to keep track of the number of points associated with a card. It is an
abbreviation for integer value and is used to differentiate it from the value variable, which references
a text string that is used to describe the face value of a playing card. The suit variable is used to
identify the suit of a playing card.
The Card() constructor takes an integer argument (0 through 51) that is a card value from the Deck
class. Card() first determines the suit of the card identified by the n parameter. It does this by dividing
n by 13 and assigning the result to an integer variable named iSuit. It determines the point value of
the card by calculating n modulus 13 and adding 1. It adjusts this value later in the method. Card()
then uses a switch statement to assign the correct text string to the suit variable.
The getValue() method is used to return the value of iValue, the point value of the card.
The java.lang Packages
In the BlackJackApp program, you learned to use the System class of java.lang to perform keyboard
input and console output. The java.lang package is one of the most important packages of the Core
Java API. It provides a number of classes and interfaces that are fundamental to Java programming.
This section covers the classes and interfaces of the java.lang, java.lang.reflect, and java.lang.ref
packages. It contains several console programs that illustrate the use of these classes and interfaces.
The Object, Class, and Package Classes
Object and Class are two of the most important classes in the Java API. The Object class is at the top
of the Java class hierarchy. All classes are subclasses of Object and therefore inherit its methods. The
Class class is used to provide class descriptors for all objects created during Java program execution.
The Package class is new to JDK 1.2. It is used to provide version information about a package.
Object
The Object class does not have any variables and has only one constructor. However, it provides 11
methods that are inherited by all Java classes and support general operations used by all objects. For
example, the equals() and hashCode()methods are used to construct hash tables of Java objects. Hash
tables are like arrays, but are indexed by key values and dynamically grow in size. They make use of
hash functions to quickly access the data that they contain. The hashCode() method creates a
hashcode for an object. Hashcodes are used to quickly determine whether two objects are different.
The clone() method creates an identical copy of an object. The object must implement the Cloneable
interface. This interface is defined within the java.lang package. It contains no methods and is used
only to differentiate clonable classes from nonclonable classes.
The getClass()method identifies the class of an object by returning an object of Class. You'll learn
how to use this method in the next programming example. (See the "A Touch of Class" section.)
The toString() method creates a String representation of the value of an object. This method is handy
for quickly displaying the contents of an object. When an object is displayed, using print() or println
(), the toString() method of its class is automatically called to convert the object into a string before
printing. Classes that override the toString() method can easily provide a custom display for their
objects.
The finalize() method of an object is executed when an object is garbage-collected. The method
performs no action, by default, and needs to be overridden by any class that requires specialized
finalization processing.
The Object class provides three wait() and two notify() methods that support thread control. These
methods are implemented by the Object class so that they can be made available to threads that are
not created from subclasses of class Thread. The wait() methods cause a thread to wait until it is
notified or until a specified amount of time has elapsed. The notify() methods are used to notify
waiting threads that their wait is over.
Class
The Class class provides over 30 methods that support the runtime processing of an object's class and
interface information. This class does not have a constructor. Objects of this class, referred to as class
descriptors, are automatically created and associated with the objects to which they refer. Despite
their name, class descriptors are used for interfaces as well as classes.
The getName()and toString()methods return the String containing the name of a class or interface.
The toString() method differs in that it prepends the string class or interface, depending on whether
the class descriptor is a class or an interface. The static forName() method loads the class specified by
a String object and returns a class descriptor for that class.
The getSuperclass() method returns the class descriptor of a class's superclass. The isInterface()
method identifies whether a class descriptor applies to a class or an interface. The getInterfaces()
method returns an array of Class objects that specify the interfaces of a class, if any.
The newInstance()method creates an object that is a new instance of the specified class. It can be
used in lieu of a class's constructor, although it is generally safer and clearer to use a constructor
rather than newInstance().
The getClassLoader()method returns the class loader of a class, if one exists. Classes are not usually
loaded by a class loader. However, if a class is loaded from outside the CLASSPATH, such as over a
network, a class loader is used to convert the class byte stream into a class descriptor. The
ClassLoader class is covered later in this chapter in the "ClassLoader" section.
The Class class contains a number of other methods that begin with get and is. These methods are as
follows:
●
getClasses()--Returns an array of all classes and interfaces that are members of the class.
●
getComponentType()--Returns the component type of an array.
●
getConstructor() and getConstructors()--Return Constructor objects for the class.
●
●
●
●
●
●
●
●
●
getDeclaredClasses(), getDeclaredConstructor(), getDeclaredConstructors(), getDeclaredField
(), getDeclaredFields(), getDeclaredMethod(), and getDeclaredMethods()--Return the classes,
constructors, fields, and methods that are declared for a class or interface.
getDeclaringClass()--Returns the class in which the referenced class is declared (if any).
getField() and getFields()--Returns a specific Field object or all Field objects of a class or
interface.
getMethod() and getMethods()--Returns a specific Method object or all Method objects of a
class or interface.
getModifiers()--Returns the class or interface modifiers as a coded integer.
getResource() and getResourceAsStream()--Locates system resources. System resources are
objects that are used by the runtime system or local Java implementation.
getSigners()--Returns the signers of a class. See Chapter 8, "Applet Security," for more
information about class signing.
isArray()--Returns true if the Class object represents an array.
isAssignableFrom()--Used to determine whether an object of one class can be assigned to an
object of another class.
●
isInstance()--Equivalent to the isinstanceof operator.
●
isPrimitive()--Returns true if the object represents a primitive type.
Package
Java software development is based upon the use and reuse of packages. Both Java 1.0 and Java 1.1
used packages. However, the Package class is new to JDK 1.2. It provides methods for obtaining
package version information stored in the manifest of .jar files. The Package class provides fourteen
methods that can be used to retrieve information about packages. The static getPackage() and
getAllPackages() methods provide Package objects that are known to the current class loader. The
getName(), getSpecificationTitle(), getImplementationTitle(), getSpecificationVersion(),
getImplementationVersion(), getSpecificationVendor(), and getImplementationVendor() methods
return name, title, version, and vendor information about the specification and implementation of
packages. The getSealBase() method returns the base URL of a signed package. The isSealed()
method is used to determine if a package is sealed. The isCompatibleWith() method is used to
determine whether a package is comparable with a particular version. The hashCode() and toString()
methods override those inherited from the Object class.
A Touch of Class
In order to give you a feel for how the Class methods can be used, let's create and run a small
program called ClassApp. The program's source code is shown in Listing 10.2.
LISTING 10.2. THE SOURCE CODE OF THE ClassApp PROGRAM.
import java.util.*;
public class ClassApp {
public static void main(String args[]) {
Vector v = new Vector();
Class cl = v.getClass();
do {
describeClass(cl);
cl = cl.getSuperclass();
}while(!cl.getName().equals("java.lang.Object"));
}
public static void describeClass(Class classDesc){
System.out.println("Class: "+classDesc.getName());
System.out.println("Superclass: "+classDesc.getSuperclass().
getName());
Class interfaces[] = classDesc.getInterfaces();
for(int i=0;i<interfaces.length;++i)
System.out.println("has interface: "+interfaces[i].getName());
System.out.println();
}
}
The program shows how the Class methods can be used to generate runtime class and interface
information about an arbitrary object. It creates an instance of the Vector class of the java.util
package and then uses the getClass(), getSuperclass(), and getName() methods of the Class class.
A do loop invokes the describeClass() method for the class identified by cl and then assigns cl to the
class's superclass. The loop repeats until cl becomes the class descriptor of the Object class.
The describeClass() method uses the getName() method to get the name of the class and its
superclass. The describeClass() method displays this information to the console. It uses the
getInterfaces() method to get all interfaces implemented by a class and the getName() method to get
and display the name of each interface.
Compile and run the ClassApp program. Its output is as follows:
Class: java.util.Vector
Superclass: java.util.AbstractList
has interface: java.util.List
has interface: java.lang.Cloneable
has interface: java.io.Serializable
Class: java.util.AbstractList
Superclass: java.util.AbstractCollection
has interface: java.util.List
Class: java.util.AbstractCollection
Superclass: java.lang.Object
has interface: java.util.Collection
It steps up the class hierarchy from Vector to CGObject to display information about each class. See
if you can modify the program to work with objects of other classes. You can do this by assigning the
class of these objects to the cl variable in the main() method.
The ClassLoader, SecurityManager, and Runtime Classes
The ClassLoader, SecurityManager, and Runtime classes provide a fine level of control over the
operation of the Java runtime system. However, most of the time you will not want or need to
exercise this control because Java is set up to perform optimally for a variety of applications. The
ClassLoader class allows you to define custom loaders for classes that you load outside of your
CLASSPATH--for example, over a network. The SecurityManager class allows you to define a
variety of security policies that govern the accesses that classes may make to threads, executable
programs, your network, and your file system. The Runtime class provides you with the capability to
control and monitor the Java runtime system. It also allows you to execute external programs.
ClassLoader
Classes that are loaded from outside the CLASSPATH require a class loader to convert the class byte
stream into a class descriptor. ClassLoader is an abstract class that is used to define class loaders. It
uses the defineClass() method to convert an array of bytes into a class descriptor. The definePackage
() method is used to define a package. The loadClass() method is used to load a class from its source,
usually a network. The resolveClass() method resolves all the classes referenced by a particular class
by loading and defining those classes. The findSystemClass()method is used to load classes that are
located within the CLASSPATH and, therefore, do not require a class loader. The findLoadedClass()
method is used to access a class that has been loaded. The findLocalClass() method is used to find a
class that is on the local system.
The checkPackageAccess() method is used to determine whether the invoking object's thread is
permitted to access a particular package. The static currentClassLoader() method returns a reference
to the ClassLoader that is currently in use. getParent() returns a class loader's parent.
The getResource(), getResourceAsStream(), getSystemResource(), and getSystemResourceAsStream
() methods are used to access application- or system-specific resources. Resources are additional files
or other objects that are associated with an application or the runtime system. The getPackage() and
getPackages() methods are used to access packages.
The setSigners() method is used to set the signers of a loaded class.
SecurityManager
The SecurityManager class is an abstract class that works with class loaders to implement a security
policy. It contains several methods that can be overridden to implement customized security policies.
These methods are of the form checkX(), where X is the access being checked. You can extend
SecurityManager and override these methods to implement custom security policies. As of JDK 1.2,
it is preferable to configure security policy using the security policy configuration methods described
in Chapter 3, "The Extended Java Security Model."
Runtime
The Runtime class provides access to the Java runtime system. It consists of a number of methods
that implement system-level services.
The getRuntime() method is a static method that is used to obtain access to an object of class
Runtime. The exec() methods are used to execute external programs from the Java runtime system.
The exec() methods provide a number of alternatives for passing parameters to the executed program.
These alternatives are similar to the standard C methods for passing command-line and environment
information. The exec() methods are subject to security checking to ensure that they are executed by
trusted code. The RuntimePermission class is used to implement permissions related to runtime
security checking.
The exit() method is used to exit the Java runtime system with an error code. It is similar to the exit
function found in standard C libraries.
The totalMemory(), freeMemory(), and gc() methods are used to obtain information about the
runtime system and control the memory used by it. The totalMemory() method identifies the total
memory available to the runtime system. The freeMemory() method identifies the amount of free
(unused) memory. The RuntimeMemoryAdvice interface is new to JDK 1.2. It provides constants for
determining the safety level associated with available memory. RuntimeMemoryAdvice is
implemented by the Runtime class. The waitForMemoryAdvice() and getMemoryAdvice() methods
are used to determine the current memory safety level.
The gc() method is used to run the garbage collector to free up memory allocated to objects that are
no longer being used. In general, you should not use the gc() method, but rather let Java perform its
own automated garbage collection.
The getLocalizedInputStream() and getLocalizedOutputStream() methods are used to convert local
(usually ASCII) input and output streams to Unicode-based streams.
The load()and loadLibrary() methods are used to load dynamic link libraries. This is usually
performed in conjunction with native methods, which are described in Chapter 53, "Native Methods."
The runFinalization() method causes the finalize() method of each object awaiting finalization to be
invoked. The runFinalizersOnExit() method can toggle on or off whether finalization occurs when the
runtime system exits. The traceInstructions() and traceMethodCalls() methods are used to enable or
disable instruction and method tracing. You will most likely never need to use any of these methods
in your programs. They are used in programs such as the debugger to trace through the execution of
Java methods and instructions.
Using Runtime
Most of the methods provided by Runtime are not typically used in application programs. However,
some methods are pretty useful. The program in Listing 10.3 shows how the Runtime methods can be
used to display memory status information.
LISTING 10.3. THE SOURCE CODE OF THE RuntimeMemApp PROGRAM.
import java.lang.System;
import java.lang.Runtime;
import java.io.IOException;
public class RuntimeMemApp {
public static void main(String args[]) throws IOException {
Runtime r = Runtime.getRuntime();
System.out.println(r.totalMemory());
System.out.println(r.freeMemory());
}
}
This program uses the static getRuntime() method to get an instance of Runtime that represents the
current Java runtime system. The totalMemory() method is used to display the total number of bytes
of runtime system memory. The freeMemory() method is used to display the number of bytes of
memory that are unallocated and currently available.
When you run the program, you should get results that are similar to the following:
1048568
845136
Listing 10.4 demonstrates how to use the Runtime exec() method to execute external programs. This
example assumes that you are using Windows 95 and may not work with other Java implementations.
However, it can be easily tailored to launch application programs on other operating systems.
LISTING 10.4. THE SOURCE CODE OF THE RuntimeExecApp PROGRAM.
import java.lang.System;
import java.lang.Runtime;
import java.io.IOException;
public class RuntimeExecApp {
public static void main(String args[]) throws IOException {
Runtime r = Runtime.getRuntime();
r.exec("C:\\Windows\\Explorer.exe");
}
}
This program uses getRuntime() to get the current instance of the runtime system and then uses exec
() to execute the Windows Explorer. The double backslashes (\\) are Java escape codes for a single
backslash (\). When you run this program, it should launch a copy of the Windows Explorer. Under
Windows 95, the exec() function works with true Win32 programs. It cannot be used to execute builtin DOS commands.
The System Class
You are no stranger to the System class because you have used it in several previous programming
examples. It is one of the most important and useful classes provided by java.lang. It provides a
standard interface to common system resources and functions. It implements the standard input,
output, and error streams, and supplies a set of methods that provide control over the Java runtime
system. Some of these methods duplicate those provided by the Runtime class.
Standard Streams
The in, out, and err variables are, by default, assigned to the standard input, output, and error streams.
The setIn(), setOut(), and setErr() methods can be used to reassign these variables to other streams.
Properties-Related Methods
The System class provides several properties-related methods. Properties are extensions of the
Dictionary and Hashtable classes and are defined in the java.util package. A set of system properties
is available through the System class that describes the general characteristics of the operating system
and runtime system you are using. The getProperties() method gets all of the system properties and
stores them in an object of class Properties. The getProperty() method gets a single property, as
specified by a key. The setProperties() method sets the system properties to the values of a Properties
object. The setProperty() method sets the value of a particular property. The identityHashCode()
method returns the hash code associated with an object. The sample program presented in Listing
10.4 introduces you to these system properties.
Security Manager-Related Methods
The getSecurityManager() and setSecurityManager() methods provide access to the security manager
that is currently in effect. The setSecurityManager() method can be used to implement a custom
security policy. However, as of JDK 1.2, the best way to implement a custom policy is via the policy
permissions covered in Chapter 3, "The Extended Java Security Model."
Runtime-Related Methods
Several of the methods defined for the Runtime class are made available through the System class.
These methods include exit(), gc(), load(), loadLibrary(), runFinalizersOnExit(), and runFinalization
().
Odds and Ends
The arraycopy() method is used to copy data from one array to another. This function provides the
opportunity for system-specific memory-copying operations to optimize memory-to-memory copies.
The currentTimeMillis() method returns the current time in milliseconds since January 1, 1970. If
you want more capable date and time methods, check out the Date class in java.util.
The getenv() method is used to obtain the value of an environment variable. However, this method is
identified as obsolete in the Java API documentation and can no longer be used.
Time and Properties
The short program in Listing 10.5 illustrates a few of the methods provided by the System class. If
your heyday was in the 1960s, it will allow you to keep track of the number of milliseconds that have
elapsed since the good old days. It also gets and displays the System properties. Take a look through
these properties to get a feel for the type of information that is provided. Finally, the exit() method is
used to terminate the program, returning a status code of 13.
LISTING 10.5. THE SOURCE CODE OF THE SystemApp PROGRAM.
import java.lang.System;
import java.util.Properties;
public class SystemApp {
public static void main(String args[]) {
long time = System.currentTimeMillis();
System.out.print("Milliseconds elapsed since January 1, 1970: ");
System.out.println(time);
Properties p=System.getProperties();
p.list(System.out);
System.exit(13);
}
}
The program generated the following output on my computer:
Milliseconds elapsed since January 1, 1970: 887133030120
-- listing properties -java.specification.name=Java Platform API Specification
awt.toolkit=sun.awt.windows.WToolkit
java.version=1.2beta2
java.awt.graphicsenv=sun.awt.Win32GraphicsEnvironment
java.tmpdir=c:\windows\TEMP\
user.timezone=PST
java.specification.version=1.2beta2
user.home=C:\JDK1.2BETA2\BIN\..
java-vm.name=non-JIT
os.arch=x86
java.awt.fonts=C:\WINDOWS\Fonts
java.vendor.url=http://www.sun.com/
user.region=US
file.encoding.pkg=sun.io
java.home=C:\JDK1.2BETA2\BIN\..
java-vm.specification.vendor=Sun Microsystems Inc.
java-vm.specification.version=1.0
java.class.path=.;C:\JavaWebServer1.0.3\public_html\c...
line.separator=
os.name=Windows 95
java.vendor=Sun Microsystems Inc.
java.library.path=C:\JDK1.2BETA2\BIN;.;C:\WINDOWS;c:\wi...
java-vm.version=1.2beta2
file.encoding=8859_1
java.specification.vendor=Sun Microsystems Inc.
user.name=Jamie
user.language=en
java.vendor.url.bug=http://java.sun.com/cgi-bin/bugreport...
java.class.version=45.3
os.version=4.0
path.separator=;
java-vm.specification.name=Java Virtual Machine Specification
file.separator=\
user.dir=C:\jdk1.2beta2\ju\ch10
java-vm.vendor=Sun Microsystems Inc.
Wrapped Classes
Variables that are declared using the primitive Java types are not objects and cannot be created and
accessed using methods. Primitive types also cannot be subclassed. To get around the limitations of
primitive types, the java.lang package defines class wrappers for these types. These class wrappers
furnish methods that provide basic capabilities such as class conversion, value testing, hash codes,
and equality checks. The constructors for the wrapped classes allow objects to be created and
converted from primitive values and strings. Be sure to browse the API pages for each of these
classes to familiarize yourself with the methods they provide.
The Boolean Class
The Boolean class is a wrapper for the boolean primitive type. It provides the getBoolean(), toString
(), valueOf(), and booleanValue() methods to support type and class conversion. The toString(),
equals(), and hashCode() methods override those of class Object.
The Character Class
The Character class is a wrapper for the char primitive type. It provides several methods that support
case, type, and class testing and conversion. Check out the API pages on these methods. We'll use
some of them in the upcoming example.
The Byte, Short, Integer, and Long Classes
These classes wrap the byte, short, int, and long primitive types. They provide the MIN_VALUE and
MAX_VALUE constants, as well as a number of type and class testing and conversion methods. The
parseInt() and parseLong() methods are used to parse String objects and convert them to Byte, Short,
Integer, and Long objects.
The Double and Float Classes
The Double and Float classes wrap the double and float primitive types. They provide the
MIN_VALUE, MAX_VALUE, POSITIVE_INFINITY, and NEGATIVE_INFINITY constants, as
well as the NaN (not-a-number) constant. NaN is used as a value that is not equal to any value,
including itself. These classes provide a number of type and class testing and conversion methods,
including methods that support conversion to and from integer bit representations.
The Number Class
The Number class is an abstract numeric class that is subclassed by Byte, Short, Integer, Long, Float,
and Double. It provides six methods that support conversion of objects from one class to another.
All Wrapped Up
The program in Listing 10.6 shows some of the methods that can be used with the primitive types
when they are wrapped as objects. Look up these methods in the API pages for each class and try to
figure out how they work before moving on to their explanations.
LISTING 10.6. THE SOURCE CODE OF THE WrappedClassApp PROGRAM.
import java.lang.System;
import java.lang.Boolean;
import java.lang.Character;
import java.lang.Integer;
import java.lang.Long;
import java.lang.Float;
import java.lang.Double;
public class WrappedClassApp {
public static void main(String args[]) {
Boolean b1 = new Boolean("TRUE");
Boolean b2 = new Boolean("FALSE");
System.out.println(b1.toString()+" or "+b2.toString());
for(int j=0;j<16;++j)
System.out.print(Character.forDigit(j,16));
System.out.println();
Integer i = new Integer(Integer.parseInt("ef",16));
Long l = new Long(Long.parseLong("abcd",16));
long m=l.longValue()*i.longValue();
System.out.println(Long.toString(m,8));
System.out.println(Float.MIN_VALUE);
System.out.println(Double.MAX_VALUE);
}
}
The program examines some of the more useful methods provided by the wrapped classes. It creates
two objects of class Boolean from string arguments passed to their constructors. It assigns these
objects to b1 and b2 and then converts them back to String objects when it displays them. They are
displayed in lowercase, as boolean values are traditionally represented.
The program then executes a for loop that prints out the character corresponding to each of the
hexadecimal digits. The static forDigit() method of the Character class is used to generate the
character values of digits in a number system of a different radix.
The static parseInt() and parseLong() methods are used to parse strings according to different radices.
In the example, they are used to convert strings representing hexadecimal numbers into Integer and
Long values. These values are then multiplied together and converted to a string that represents the
resulting value in base 8. This is accomplished using an overloaded version of the toString() method.
The sample program concludes by displaying the minimum float value and the maximum double
value using the predefined class constants of the Float and Double classes.
The program's output is as follows:
true or false
0123456789abcdef
50062143
1.4E-45
1.7976931348623157E308
The Math Class and Comparable Interface
The Math class provides an extensive set of mathematical methods in the form of a static class
library. It also defines the mathematical constants E and PI. The supported methods include
arithmetic, trigonometric, exponential, logarithmic, random number, and conversion routines. You
should browse the API page of this class to get a feel for the methods it provides. The example in
Listing 10.7 only touches on a few of these methods.
LISTING 10.7. THE SOURCE CODE OF THE MathApp PROGRAM.
import java.lang.System;
import java.lang.Math;
public class MathApp {
public static void main(String args[]) {
System.out.println(Math.E);
System.out.println(Math.PI);
System.out.println(Math.abs(-1234));
System.out.println(Math.cos(Math.PI/4));
System.out.println(Math.sin(Math.PI/2));
System.out.println(Math.tan(Math.PI/4));
System.out.println(Math.log(1));
System.out.println(Math.exp(Math.PI));
for(int i=0;i<3;++i)
System.out.print(Math.random()+" ");
System.out.println();
}
}
This program prints the constants e and p, |-1234|, cos(p/4), sin(p/2), tan(p/4), ln(1), ep, and then three
random double numbers between 0.0 and 1.1. Its output is as follows:
2.718281828459045
3.141592653589793
1234
0.7071067811865476
1.0
0.9999999999999999
0.0
23.14069263277926
0.5214844573332809 0.7036104523989761 0.15555052349418896
The random numbers you generate will almost certainly differ from those shown here.
The Comparable interface is a new interface that was added with JDK 1.2. This interface defines the
compareTo() method. Objects of classes that implement the Comparable interface can be compared
to each other and sorted.
The String and StringBuffer Classes
The String and StringBuffer classes are used to support operations on strings of characters. The
String class supports constant (unchanging) strings, whereas the StringBuffer class supports
growable, modifiable strings. String objects are more compact than StringBuffer objects, but
StringBuffer objects are more flexible.
String Literals
String literals are strings that are specified using double quotes. "This is a string" and "xyz" are
examples of string literals. String literals are different than the literal values used with primitive
types. When the javac compiler encounters a String literal, it converts it to a String constructor. For
example, this:
String str = "text";
is equivalent to this:
String str = new String("text");
The fact that the compiler automatically supplies String constructors allows you to use String literals
everywhere that you could use objects of the String class.
The + Operator and StringBuffer
If String objects are constant, how can they be concatenated with the + operator and be assigned to
existing String objects? In the following example, the code will result in the string "ab" being
assigned to the s object:
String s = "";
s = s + "a" + "b";
How can this be possible if Strings are constant? The answer lies in the fact that the Java compiler
uses StringBuffer objects to accomplish the string manipulations. This code would be rendered as
something similar to the following by the Java compiler:
String s = "";
s = new StringBuffer("").append("a").append("b").toString();
A new object of class StringBuffer is created with the "" argument. The StringBuffer append()
method is used to append the strings "a" and "b" to the new object, and then the object is converted to
an object of class String via the toString() method. The toString() method creates a new object of
class String before it is assigned to the s variable. In this way, the s variable always refers to a
constant (although new) String object.
String Constructors
The String class provides several constructors for the creation and initialization of String objects.
These constructors allow strings to be created from other strings, string literals, arrays of characters,
arrays of bytes, and StringBuffer objects. Browse through the API page for the String class to become
familiar with these constructors.
String Access Methods
The String class provides a very powerful set of methods for working with String objects. These
methods allow you to access individual characters and substrings; test and compare strings; copy,
concatenate, and replace parts of strings; convert and create strings; and perform other useful string
operations.
The most important String methods are the length() method, which returns an integer value
identifying the length of a string; the charAt() method, which allows the individual characters of a
string to be accessed; the substring() method, which allows substrings of a string to be accessed; and
the valueOf() method, which allows primitive data types to be converted into strings.
In addition to these methods, the Object class provides a toString() method for converting other
objects to String objects. This method is often overridden by subclasses to provide a more appropriate
object-to-string conversion.
Character and Substring Methods
Several String methods allow you to access individual characters and substrings of a string. These
include charAt(), getBytes(), getChars(), indexOf(), lastIndexOf(), and substring(). Whenever you
need to perform string manipulations, be sure to check the API documentation to make sure that you
don't overlook an easy-to-use, predefined String method.
String Comparison and Test Methods
Several String methods allow you to compare strings, substrings, byte arrays, and other objects with a
given string. Some of these methods are compareTo(), endsWith(), equals(), equalsIgnoreCase(),
regionMatches(), and startsWith().
Copy, Concatenation, and Replace Methods
The following methods are useful for copying, concatenating, and manipulating strings: concat(),
copyValueOf(), replace(), and trim().
String Conversion and Generation
A number of string methods support String conversion. These are intern(), toCharArray(),
toLowerCase(), toString(), toUpperCase(), and valueOf(). You'll explore the use of some of these
methods in the following example.
Stringing Along
The program in Listing 10.8 provides a glimpse at the operation of some of the methods identified in
the previous subsections. Because strings are frequently used in application programs, learning to use
the available methods is essential to being able to use the String class most effectively.
LISTING 10.8. THE SOURCE CODE OF THE StringApp PROGRAM.
import java.lang.System;
import java.lang.String;
public class StringApp {
public static void main(String args[]) {
String s = " Java Unleashed 1.2 ";
System.out.println(s);
System.out.println(s.toUpperCase());
System.out.println(s.toLowerCase());
System.out.println("["+s+"]");
s=s.trim();
System.out.println("["+s+"]");
s=s.replace(`J','X');
s=s.replace(`U','Y');
s=s.replace(`2','Z');
System.out.println(s);
int i1 = s.indexOf(`X');
int i2 = s.indexOf(`Y');
int i3 = s.indexOf(`Z');
char ch[] = s.toCharArray();
ch[i1]='J';
ch[i2]='U';
ch[i3]='2';
s = new String(ch);
System.out.println(s);
}
}
This program performs several manipulations of a string s, which is initially set to "Java Unleashed
1.2 ". It prints the original string and then prints upper- and lowercase versions of it, illustrating the
use of the toUpperCase() and toLowerCase() methods. It prints the string enclosed between two
braces to show that it contains leading and trailing spaces. It then trims away these spaces using the
trim() method and reprints the string to show that these spaces were removed.
The program uses the replace() method to replace `J', `U', and `2' with `X', `Y', and `Z', and prints out
the string to show the changes. The replace() method is case sensitive. It uses the indexOf() method
to get the indices of `X', `Y', and `Z' within s. It uses the toCharArray() to convert the string to a char
array. It then uses the indices to put `J', `U', and `2' back in their proper locations within the character
array. The String() constructor is used to construct a new string from the character array. The new
string is assigned to s and is printed.
The program's output is as follows:
Java Unleashed 1.2
JAVA UNLEASHED 1.2
java unleashed 1.2
[ Java Unleashed 1.2 ]
[Java Unleashed 1.2]
Xava Ynleashed 1.Z
Java Unleashed 1.2
The StringBuffer Class
The StringBuffer class is the force behind the scenes for most complex string manipulations. The
compiler automatically declares and manipulates objects of this class to implement common string
operations.
The StringBuffer class provides three constructors: an empty constructor, a constructor with a
specified initial buffer length, and a constructor that creates a StringBuffer object from a String
object. In general, you will find yourself constructing StringBuffer objects from String objects, and
the last constructor will be the one you use most often.
The StringBuffer class provides several versions of the append() method to convert and append other
objects and primitive data types to StringBuffer objects. It provides a similar set of insert() methods
for inserting objects and primitive data types into StringBuffer objects. It also provides methods to
access the character-buffering capacity of StringBuffer and methods for accessing the characters
contained in a string. It is well worth a visit to the StringBuffer API pages to take a look at the
methods that it has to offer.
Strung Out
The program in Listing 10.9 shows how StringBuffer objects can be manipulated using the append(),
insert(), and setCharAt() methods.
LISTING 10.9. THE SOURCE CODE OF THE StringBufferApp PROGRAM.
import java.lang.System;
import java.lang.String;
import java.lang.StringBuffer;
public class StringBufferApp {
public static void main(String args[]) {
StringBuffer sb = new StringBuffer(" is ");
sb.append("Hot");
sb.append(`!');
sb.insert(0,"Java");
sb.append(`\n');
sb.append("This is ");
sb.append(true);
sb.setCharAt(21,'T');
sb.append(`\n');
sb.append("Java is #");
sb.append(1);
String s = sb.toString();
System.out.println(s);
}
}
The program creates a StringBuffer object using the string " is ". It appends the string "Hot" using the
append() method and the character `!' using an overloaded version of the same method. The insert()
method is used to insert the string "Java" at the beginning of the string buffer.
Three appends are used to tack on a newline character (\n), the string "This is ", and the boolean
value true. The append() method is overloaded to support the appending of the primitive data types as
well as arbitrary Java objects.
The setCharAt() method is used to replace the letter `t' at index 21 with the letter `T'. The charAt()
and setCharAt() methods allow StringBuffer objects to be treated as arrays of characters.
Finally, another newline character is appended to sb, followed by the string "Java is #" and the int
value 1. The StringBuffer object is then converted to a string and displayed to the console window.
The output of the program is as follows:
Java is Hot!
This is True
Java is #1
Threads and Processes
This section describes the classes of java.lang that support multithreading. It also covers the Process
class, which is used to manipulate processes that are executed using the System.exec() methods.
Runnable
The Runnable interface provides a common approach to identifying the code to be executed as part of
an active thread. It consists of a single method, run(), which is executed when a thread is activated.
The Runnable interface is implemented by the Thread class and by other classes that support threaded
execution.
Thread
The Thread class is used to construct and access individual threads of execution that are executed as
part of a multithreaded program. It defines the priority constants that are used to control task
scheduling: MIN_PRIORITY, MAX_PRIORITY, and NORM_PRIORITY. It provides seven
constructors for creating instances of class Thread. The four constructors with the Runnable
parameters are used to construct threads for classes that do not subclass the Thread class. The other
constructors are used for the construction of Thread objects from Thread subclasses.
Thread supports many methods for accessing Thread objects. These methods provide the capabilities
to work with a thread's group; obtain detailed information about a thread's activities; set and test a
thread's properties; and cause a thread to wait, be interrupted, or be destroyed.
ThreadGroup
The ThreadGroup class is used to encapsulate a group of threads as a single object so that they can be
accessed as a single unit. A number of access methods are provided for manipulating ThreadGroup
objects. These methods keep track of the threads and thread groups contained in a thread group and
perform global operations on all threads in the group. The global operations are group versions of the
operations that are provided by the Thread class.
ThreadLocal
The ThreadLocal class is used to implement variables that are local to a thread. The get(), set(), and
initialize() methods are used to set and retrieve the values of these variables.
Process
The Process class is used to encapsulate processes that are executed with the System.exec() methods.
An instance of class Process is returned by the Runtime class exec() method when it executes a
process that is external to the Java runtime system. This Process object can be destroyed using the
destroy() method and waited on using the waitFor() method. The exitValue() method returns the
system exit value of the process. The getInputStream(), getOutputStream(), and getErrorStream()
methods are used to access the standard input, output, and error streams of the process.
ProcessApp
The simple program in Listing 10.10 actually performs some pretty complex processing. It is
provided as an example of some of the powerful things that can be accomplished using the Process
class.
LISTING 10.10. THE SOURCE CODE OF THE ProcessApp PROGRAM.
import java.lang.System;
import java.lang.Runtime;
import java.lang.Process;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.IOException;
public class ProcessApp {
public static void main(String args[]) throws IOException {
Runtime r = Runtime.getRuntime();
Process p = r.exec("java SystemApp");
BufferedReader kbdInput =
new BufferedReader(new InputStreamReader(p.getInputStream()));
String line;
while((line = kbdInput.readLine())!=null)
System.out.println(line);
}
}
The program uses the static getRuntime() method to get the current instance of the Java runtime
system. It then uses the exec() method to execute another separate copy of the Java interpreter with
the SystemApp program that was developed earlier in this chapter. It creates a BufferedReader
object, kbdInput, that is connected to the output stream of the SystemApp program. It then uses
kbdInput to read the output of the SystemApp program and display it on the console window.
The exec() methods combined with the Process class provide a powerful set of tools by which Java
programs can be used to launch and control the execution of other programs.
The Compiler Class
The Compiler class consists of static methods that are used to compile Java classes in the rare event
that you want to compile classes directly from a program or applet. These methods allow you to build
your own customized Java development environment.
Exceptions and Errors
The java.lang package establishes the Java exception hierarchy and declares numerous exceptions
and errors. Errors are used to indicate the occurrence of abnormal and fatal events that should not be
handled within application programs.
The Throwable Class
The Throwable class is at the top of the Java error-and-exception hierarchy. It is extended by the
Error and Exception classes and provides methods that are common to both classes. These methods
consist of stack tracing methods, the getMessage() method, and the toString() method, which is an
override of the method inherited from the Object class. The getMessage() method is used to retrieve
any messages that are supplied in the creation of Throwable objects.
The fillInStackTrace() and printStackTrace() methods supply and print information that is used to
trace the propagation of exceptions and errors throughout a program's execution.
The Error Class
The Error class is used to provide a common superclass to define abnormal and fatal events that
should not occur. It provides two constructors and no other methods. Four major classes of errors
extend the Error class: AWTError, LinkageError, ThreadDeath, and VirtualMachineError.
The AWTError class identifies fatal errors that occur in the Abstract Window Toolkit packages. It is
a single identifier for all AWT errors and is not subclassed.
The LinkageError class is used to define errors that occur as the result of incompatibilities between
dependent classes. These incompatibilities result when class Y depends on class X, which is changed
before class Y can be recompiled. The LinkageError class is extensively subclassed to identify
specific manifestations of this type of error.
The ThreadDeath error class is used to indicate that a thread has been stopped. Instances of this class
can be caught and then rethrown to ensure that a thread is gracefully terminated, although this is not
recommended. The ThreadDeath class is not subclassed.
The VirtualMachineError class is used to identify fatal errors occurring in the operation of the Java
Virtual Machine. It has four subclasses: InternalError, OutOfMemoryError, StackOverflowError, and
UnknownError.
The Exception Class
The Exception class provides a common superclass for the exceptions that can be defined for Java
programs and applets.
The Void Class
The Void class is used to reference the Class object representing the void type. It is provided for
completeness. It has no constructors or methods.
Reflection and the java.lang.reflect Package
The classes and interfaces of the java.lang.reflect package enable classes, interfaces, and objects to be
examined, and their public fields, constructors, and methods to be discovered and used at runtime.
These capabilities are used by JavaBeans, object inspection tools, Java runtime tools such as the
debugger, and other Java applications and applets.
The java.lang.reflect package consists of the Member interface and seven classes: AccessibleObject,
Array, Constructor, Field, Method, Modifier, and ReflectPermission.
The Member Interface
The Member interface is used to provide information about a Field, Constructor, or Method. It
defines two constant variables and three methods. The DECLARED constant identifies the class
members (fields, constructors, and methods) that are declared for a class. The PUBLIC constant
identifies all members of a class or interface, including those that are inherited. The getName()
method returns the name of the referenced Member. The getModifiers() method returns the modifiers
of the referenced Member encoded as an integer. The Modifier class is used to decode this integer.
The getDeclaringClass() method returns the class in which the Member is declared.
The AccessibleObject Class
The AccessibleObject class is introduced with JDK 1.2. It is the superclass of the Constructor, Field,
and Method classes. It was added to the class hierarchy to provide the capability to specify whether
an object suppresses reflection access control checks. The isAccessible() method identifies whether
the object suppresses access control checks. The setAccessible() method is used to set the
accessibility of an object or array of objects.
The Array Class
The Array class is used to obtain information about, create, and manipulate arrays. It consists of 21
static methods. The getLength() method is used to access the length of an array.
The get() method is used to access an indexed element of an array. The getBoolean(), getByte(),
getChar(), getDouble(), getFloat(), getInt(), getLong(), and getShort() methods are used to access an
indexed element of an array as a particular primitive type.
The set() method is used to set an indexed element of an array. The setBoolean(), setByte(), setChar
(), setDouble(), setFloat(), setInt(), setLong(), and setShort() methods are used to set an indexed
element of an array to a value of a particular primitive type.
The newInstance() method is used to create new arrays of a specified size.
The Constructor Class
The Constructor class is used to obtain information about and access the constructors of a class. It
consists of nine methods.
The getName() method returns the name of the constructor. The getDeclaringClass() method
identifies the class to which the constructor applies.
The newInstance() method is used to create a new instance of the class to which the constructor
applies. The getParameterTypes() method provides access to the parameters used by the constructor.
The getModifiers() method encodes the constructor's modifiers as an integer that can be decoded by
the Modifier class. The getExceptionTypes() method identifies the exceptions that are thrown by the
constructor.
The equals(), hashCode(), and toString() methods override those of the Object class.
The Field Class
The Field class is used to obtain information about and access the field variables of a class. It consists
of 25 methods.
The getName() method returns the name of the variable. The getDeclaringClass() method identifies
the class in which the variable is declared. The getType() method provides access to the data type of
the variable. The getModifiers() method encodes the variable's modifiers as an integer that can be
decoded by the Modifier class.
The get() method is used to access the value of the variable. The getBoolean(), getByte(), getChar(),
getDouble(), getFloat(), getInt(), getLong(), and getShort() methods are used to access the value as a
particular primitive type.
The set() method is used to set the value of the variable. The setBoolean(), setByte(), setChar(),
setDouble(), setFloat(), setInt(), setLong(), and setShort() methods are used to set the value to a
particular primitive type.
The equals(), hashCode(), and toString() methods override those of the Object class.
The Method Class
The Method class is used to obtain information about and access the methods of a class. It consists of
10 methods.
The getName() method returns the name of the method. The getDeclaringClass() method identifies
the class in which the method is declared.
The invoke() method is used to invoke the method for a particular object and list of parameters. The
getParameterTypes() method provides access to the parameters used by the method. The getModifiers
() method encodes the method's modifiers as an integer that can be decoded by the Modifier class.
The getExceptionTypes() method identifies the exceptions that are thrown by the method. The
getReturnType() method identifies the type of object returned by the method.
The equals(), hashCode(), and toString() methods override those of the Object class.
The Modifier Class
The Modifier class is used to decode integers that represent the modifiers of classes, interfaces, field
variables, constructors, and methods. It consists of 11 constants, a single parameterless constructor,
and 12 static access methods.
The 11 constants are used to represent all possible modifiers. They are ABSTRACT, FINAL,
INTERFACE, NATIVE, PRIVATE, PROTECTED, PUBLIC, STATIC, SYNCHRONIZED,
TRANSIENT, and VOLATILE.
The toString() method returns a string containing the modifiers encoded in an integer. The isAbstract
(), isFinal(), isInterface(), isNative(), isPrivate(), isProtected(), isPublic(), isStatic(), isSynchronized(),
isTransient(), and isVolatile() methods return a boolean value indicating whether the respective
modifier is encoded in an integer.
The ReflectPermission Class
The ReflectPermission class is a permission class introduced with JDK 1.2. It is used to specify
whether the default language access checks should be suppressed for reflected objects. Chapter 3
covers the use of permissions in setting up a security policy.
A Reflection Example
The java.lang.reflect provides a number of useful methods for discovering information about the
members of a class or interface. In most cases, you will use it with the Class class of java.lang. The
example in Listing 10.11 shows how Class and the classes of java.lang.reflect can be used together to
create a program that discovers and displays information about classes and interfaces.
LISTING 10.11. THE SOURCE CODE OF THE ReflectApp PROGRAM.
import java.lang.reflect.*;
public class ReflectApp {
public static void main(String args[]) {
String parm = args[0];
Class className = void.class;
try {
className= Class.forName(parm);
}catch (ClassNotFoundException ex){
System.out.println("Not a class or interface.");
System.exit(0);
}
describeClassOrInterface(className,parm);
}
static void describeClassOrInterface(Class className,String name){
if(className.isInterface()){
System.out.println("Interface: "+name);
displayModifiers(className.getModifiers());
displayFields(className.getDeclaredFields());
displayMethods(className.getDeclaredMethods());
}else{
System.out.println("Class: "+name);
displayModifiers(className.getModifiers());
displayInterfaces(className.getInterfaces());
displayFields(className.getDeclaredFields());
displayConstructors(className.getDeclaredConstructors());
displayMethods(className.getDeclaredMethods());
}
}
static void displayModifiers(int m){
System.out.println("Modifiers: "+Modifier.toString(m));
}
static void displayInterfaces(Class[] interfaces){
if(interfaces.length>0){
System.out.println("Interfaces: ");
for(int i=0;i<interfaces.length;++i)
System.out.println(interfaces[i].getName());
}
}
static void displayFields(Field[] fields){
if(fields.length>0){
System.out.println("Fields: ");
for(int i=0;i<fields.length;++i)
System.out.println(fields[i].toString());
}
}
static void displayConstructors(Constructor[] constructors){
if(constructors.length>0){
System.out.println("Constructors: ");
for(int i=0;i<constructors.length;++i)
System.out.println(constructors[i].toString());
}
}
static void displayMethods(Method[] methods){
if(methods.length>0){
System.out.println("Methods: ");
for(int i=0;i<methods.length;++i)
System.out.println(methods[i].toString());
}
}
}
Compile the program and run it as follows. It takes the fully qualified name of a class or interface as a
command-line argument. The following output shows the information that it generates when the java.
lang.reflect.AccessibleObject class is used as an argument. It identifies the class modifiers as public
and synchronized and identifies ACCESS_PERMISSION and override as field variables. It also
shows that AccessibleObject has a single parameterless constructor and three methods.
java ReflectApp java.lang.reflect.AccessibleObject
Class: java.lang.reflect.AccessibleObject
Modifiers: public synchronized
Fields:
private static final java.security.Permission Âjava.lang.reflect.
AccessibleObject
.ACCESS_PERMISSION
private boolean java.lang.reflect.AccessibleObject.override
Constructors:
protected java.lang.reflect.AccessibleObject()
Methods:
public static void java.lang.reflect.AccessibleObject.setAccessible
Â(java.lang.reflect.AccessibleObject[],boolean) throws Âjava.lang.
SecurityException
public void java.lang.reflect.AccessibleObject.setAccessible
(boolean) Âthrows java.lang.SecurityException public boolean java.
lang.reflect.AccessibleObject.isAccessible()
Try running ReflectApp with other classes and interfaces. It's a great way to learn about the definition
of classes and interfaces.
ReflectApp takes the first command-line argument and uses the forName() method of Class to create
a Class object representing the class or interface identified by the argument. This Class object is
assigned to the className variable. The describeClassOrInterface() method is invoked to display
information about the class or interface.
The describeClassOrInterface() method uses the isInterface() method of Class to determine whether
the Class object refers to an interface or class. It uses getInterfaces() to retrieve all of the interfaces of
a class and invokes displayInterfaces() to display those interfaces.
The describeClassOrInterface() method uses getModifiers(), getDeclaredFields(),
getDeclaredConstructors(), and getDeclaredMethods() to retrieve the Modifier, Field, Constructor,
and Method objects associated with a class or interface. It invokes displayModifiers(), displayFields
(), displayConstructors(), and displayMethods() to display information about these objects. These
display methods use the toString() method to convert the objects into a useful display string.
Reference Objects and the java.lang.ref Package
JDK 1.2 introduces reference objects, which are objects that store references to other objects. The
java.lang.ref package provides five classes that implement reference objects. These classes also
provide the capability to notify a program when a referenced object is subject to garbage collection.
This capability allows reference objects to be used to implement object caching mechanisms.
The Reference class is the top-level class of the reference class hierarchy. It provides the capability to
store a reference to another object. The object being referenced is referred to as the referent. The
Reference class provides the following methods for getting and setting references to the referents:
●
●
●
●
get() and set()--Used to retrieve and set the referent.
register() and unregister()--Used to register and unregister the reference object with a
ReferenceQueue object.
clear()--Clears the reference to the referent.
isEnqueued()--Reports on whether a reference object has been queued with a ReferenceQueue
object.
The classes of the reference object hierarchy are used to work with referents of varying degrees of
reachability. Reachability refers to the ease with which an object can be referenced. The following
degrees of reachability are defined:
●
Strongly reachable--An object can be reached without the use of reference objects.
●
●
Weakly reachable--An object that is not strongly reachable, but can be reached via a
WeakReference object. An object becomes eligible for finalization when all of its weak
references are cleared.
Phantomly reachable--An object that is not strongly or weakly reachable, but can be reached
via a PhantomReference object. If an object is phantomly reachable, it has been finalized. An
object becomes unreachable when all of its phantom references are cleared or unreachable.
Reference objects can be registered with a reference queue. When the garbage collector determines
that a referent has a change in reachability, the reference object is added to the queue. A program can
be notified of the queuing of a reference. The program can then remove the reference from the queue
in order to access the referent. When a reference object is removed from a queue, it becomes
unregistered. A reference object can only be registered with a single reference queue. The
ReferenceQueue class implements reference queues. It provides the remove() method for removing
an object from the queue. The register() and unregister() methods of the Reference class are used to
register and unregister objects with a ReferenceQueue object.
The subclasses of Reference are used to implement the reachability levels. These classes are as
follows:
●
●
WeakReference--When the referent of a registered WeakReference object is no longer
strongly reachable, the WeakReference object is cleared and added to the ReferenceQueue to
which it is registered. The referent is then subject to finalization.
PhantomReference--When the referent of a registered PhantomReference object is no longer
strongly or weakly reachable, the PhantomReference object is cleared and added to the
ReferenceQueue to which it is registered. Because PhantomReference objects refer to objects
that have been finalized, its get() method always returns null.
The ReferenceApp Program
Although the reference classes are intended to be used to build caching systems, reference objects can
be used in other ways. The ReferenceApp program (Listing 10.12) provides an example of the use of
reference objects. It creates two String objects and assigns them to s1 and s2. It then creates two
WeakReference objects that refer to the String objects, and assigns the reference objects to g1 and g2.
It shows that g1 and g2 reference the original String objects by displaying the values returned by the
get() method. The WeakReference object referenced by g2 is assigned to g1. The value of the referent
of g1 is then displayed to show that it is now the second String object.
The output of ReferenceApp is as follows:
g1 = The value of a String object 1
g2 = The value of a String object 2
g1 = The value of a String object 2
LISTING 10.12. THE ReferenceApp PROGRAM.
import java.lang.ref.*;
public class ReferenceApp {
public static void main(String args[]) {
String s1 = "The value of a String object 1";
String s2 = "The value of a String object 2";
GuardedReference g1 = new WeakReference(s1);
GuardedReference g2 = new WeakReference(s2);
System.out.println("g1 = "+(String) g1.get());
System.out.println("g2 = "+(String) g2.get());
g1=g2;
System.out.println("g1 = "+(String) g1.get());
}
}
Summary
In this chapter you learned to write console programs in Java. You learned how to read user keyboard
input, process the input, and display text output to the user's console. You also learned about some
useful classes and interfaces in the java.lang, java.lang.reflect, and java.lang.ref packages. In the next
chapter you'll learn how to use the classes and interfaces of the java.util and java.math packages.
© Copyright, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
- 11 Using the Utility and Math Packages
●
●
●
The java.util Package
❍ The Collections API
❍ Date and Calendar-Related Classes
❍ Internationalization Classes
❍ Other java.util Classes and Interfaces
The java.util.zip Package
❍ Adler32
❍ CRC32
❍ CheckedInputStream
❍ CheckedOutputStream
❍ Deflater
❍ Inflater
❍ DeflaterOutputStream
❍ InflaterInputStream
❍ GZIPOutputStream
❍ GZIPInputStream
❍ ZipFile
❍ ZipEntry
❍ ZipOutputStream
❍ ZipInputStream
❍ The UnzipApp Program
❍ rfc1951.txt
The java.util.jar Package
❍ The JarFile Class
The JarEntry Class
❍ The Manifest Class
❍ The Attributes Class
❍ The Attributes.Name Class
❍ The JarInputStream Class
❍ The JarOutputStream Class
❍ The JarApp Program
The java.util.mime Package
The java.math Package
❍ BigDecimal
❍ BigInteger
❍ The BigNumApp Program
Summary
❍
●
●
●
The java.util family of packages and the java.math package provide a number of classes and
interfaces that can be used to simplify the development of window and console applications, applets,
or just about any Java code that you write. These utility classes include the new JDK 1.2 Collections
API, as well as Java Archive (JAR), ZIP file, and MIME type support. The math classes provide
support for large-number arithmetic. In this chapter you'll learn how to work with all the useful utility
classes contained in the java.util, java.util.mime, java.util.zip, java.util.jar, and java.math packages.
When you finish this chapter, you'll be able to make productive use of these classes in your own
programs.
The java.util Package
The java.util package provides 34 classes and 13 interfaces that support the new Collections API,
date/calendar operations, internationalization, change observation, parsing, random number
generation, and basic event processing. These classes and interfaces are covered in the following
subsections.
The Collections API
The most notable change to the java.util package in JDK 1.2 is the introduction of the classes and
interfaces of the Collections API. These classes and interfaces provide an implementationindependent framework for manipulating collections of objects. We'll first review the pre-JDK 1.2
collections classes and interfaces. Then we'll cover the new classes and interfaces introduced with
JDK 1.2.
Pre-JDK 1.2 Collections Classes and Interfaces
JDK 1.1 provided the Enumeration interface and the following six classes for working with
collections of objects:
●
Vector--An expandable array of objects.
●
Stack--A last-in-first-out stack of objects.
●
BitSet--A growable bit vector.
●
Dictionary--A list of key-value pairs.
●
Hashtable--A dictionary that implements a hash table.
●
Properties--A hash table that provides the capability to associate a list of properties with their
values.
The Enumeration interface and the preceding six classes proved to be very valuable in working with
different types of object collections. Their success inspired the JDK 1.2 Collections API. The
following subsections cover the Enumeration interface and the six classes in the preceding list.
The Enumeration Interface
The Enumeration interface provides two methods for stepping through an indexed set of objects or
values: hasMoreElements() and nextElement(). The hasMoreElements() method enables you to
determine whether more elements are contained in an Enumeration object. The nextElement() method
returns the nextElement() contained by an object.
Enumeration-implementing objects are said to be consumed by their use. This means that the
Enumeration objects cannot be restarted to reaccess through the elements they contain. Their
elements may be accessed only once.
NOTE: The Enumeration interface has been replaced by the Iterator interface in the
JDK 1.2 Collections API. You can still use Enumeration, but it is being phased out.
The Vector Class
The Vector class provides the capability to implement a growable array. The array grows larger as
more elements are added to it. The array may also be reduced in size after some of its elements have
been deleted. This is accomplished using the trimToSize() method.
Vector operates by creating an initial storage capacity and then adding to this capacity as needed. It
grows by an increment defined by the capacityIncrement variable. The initial storage capacity and
capacityIncrement can be specified in Vector's constructor. A second constructor is used when you
want to specify only the initial storage capacity. A third, default constructor specifies neither the
initial capacity nor the capacityIncrement. This constructor lets Java figure out the best parameters to
use for Vector objects. Finally, a fourth constructor was added with JDK 1.2 to create a Vector out of
a Collection object.
The access methods provided by the Vector class support array-like operations and operations related
to the size of Vector objects. The array-like operations allow elements to be added, deleted, and
inserted into vectors. They also allow tests to be performed on the contents of vectors and specific
elements to be retrieved. The size-related operations allow the byte size and number of elements of
the vector to be determined, and the vector size to be increased to a certain capacity or trimmed to the
minimum capacity needed. Consult the Vector API page for a complete description of these methods.
NOTE: The Vector class has been retrofitted in JDK 1.2 to extend the AbstractList
class and implement the List interface.
VectorApp
The VectorApp program illustrates the use of vectors and the Enumeration interface. (See Listing
11.1.)
LISTING 11.1. THE SOURCE CODE OF THE VectorApp PROGRAM.
import java.lang.System;
import java.util.Vector;
import java.util.Enumeration;
public class VectorApp {
public static void main(String args[]){
Vector v = new Vector();
v.addElement("one");
v.addElement("two");
v.addElement("three");
v.insertElementAt("zero",0);
v.insertElementAt("oops",3);
v.insertElementAt("four",5);
System.out.println("Size: "+v.size());
Enumeration enum = v.elements();
while (enum.hasMoreElements())
System.out.print(enum.nextElement()+" ");
System.out.println();
v.removeElement("oops");
System.out.println("Size: "+v.size());
for(int i=0;i<v.size();++i)
System.out.print(v.elementAt(i)+" ");
System.out.println();
}
}
The program creates a Vector object using the default constructor, and uses the addElement()
method to add the strings "one", "two", and "three" to the vector. It then uses the insertElementAt()
method to insert the strings "zero", "oops", and "four" at locations 0, 3, and 5 within the vector. The
size() method is used to retrieve the vector size for display to the console window.
The elements() method of the Vector class is used to retrieve an enumeration of the elements that
were added to the vector. A while loop is then used to cycle through and print the elements contained
in the enumeration. The hasMoreElements() method is used to determine whether the enumeration
contains more elements. If it does, the nextElement() method is used to retrieve the object for printing.
The removeElement() of the Vector class is used to remove the vector element containing the string
"oops". The new size of the vector is displayed and the elements of the vector are redisplayed. The
for loop indexes each element in the vector using the elementAt() method.
The output of the VectorApp program is as follows:
Size: 6
zero one two oops three four
Size: 5
zero one two three four
The Stack Class
The Stack class provides the capability to create and use storage objects called stacks within your
Java programs. You store information by pushing it onto a stack, and remove and retrieve
information by popping it off the stack. Stacks implement a last-in-first-out storage capability. The
last object pushed onto a stack is the first object that can be retrieved from the stack. The Stack class
extends the Vector class.
The Stack class provides a single default constructor, Stack(), that is used to create an empty stack.
Objects are placed on the stack using the push() method and retrieved from the stack using the pop()
method. The search() method allows you to search through a stack to see if a particular object is
contained on the stack. The peek() method returns the top element of the stack without popping it off.
The empty() method is used to determine whether a stack is empty. The pop() and peek() methods
both throw the EmptyStackException if the stack is empty. Use of the empty() method can help to
avoid the generation of this exception.
StackApp
The StackApp program demonstrates the operation of a stack (see Listing 11.2). It creates a Stack
object and then uses the push() method to push the strings "one", "two", and "three" onto the stack.
Because the stack operates in last-in-first-out fashion, the top of the stack is the string "three". This is
verified by using the peek() method. The contents of the stack are then popped off and printed using a
while loop. The empty() method is used to determine when the loop should terminate. The pop()
method is used to pop objects off the top of the stack.
LISTING 11.2. THE SOURCE CODE OF THE StackApp PROGRAM.
import java.lang.System;
import java.util.Stack;
public class StackApp {
public static void main(String args[]){
Stack s = new Stack();
s.push("one");
s.push("two");
s.push("three");
System.out.println("Top of stack: "+s.peek());
while (!s.empty())
System.out.println(s.pop());
}
}
The output of the StackApp program is as follows:
Top of stack: three
three
two
one
The BitSet Class
The BitSet class is used to create objects that maintain a set of bits. The bits are maintained as a
growable set. The capacity of the bit set is increased as needed. Bit sets are used to maintain a list of
flags that indicate the state of each element of a set of conditions. Flags are boolean values that are
used to represent the state of an object.
Two BitSet constructors are provided. One allows the initial capacity of a BitSet object to be
specified. The other is a default constructor that initializes a BitSet to a default size.
The BitSet access methods provide and, or, and exclusive or logical operations on bit sets, enable
specific bits to be set and cleared, and override general methods declared for the Object class.
BitSetApp
The BitSetApp program demonstrates the operation of bit sets. See Listing 11.3.
LISTING 11.3. THE SOURCE CODE OF THE BitSetApp PROGRAM.
import java.lang.System;
import java.util.BitSet;
public class BitSetApp {
public static void main(String args[]){
int size = 8;
BitSet b1 = new BitSet(size);
for(int i=0;i<size;++i) b1.set(i);
BitSet b2 = (BitSet) b1.clone();
for(int i=0;i<size;i=i+2) b2.clear(i);
System.out.print("b1: ");
for(int i=0;i<size;++i) System.out.print(b1.get(i)+" ");
System.out.print("\nb2: ");
for(int i=0;i<size;++i) System.out.print(b2.get(i)+" ");
System.out.println();
System.out.println("b1: "+b1);
System.out.println("b2: "+b2);
b1.xor(b2);
System.out.println("b1 xor b2 = "+b1);
b1.and(b2);
System.out.println("b1 and b2 = "+b1);
b1.or(b2);
System.out.println("b1 or b2 = "+b1);
}
}
The program begins by creating a BitSet object, b1, of size 8. It executes a for statement to index
through b1 and set each bit in the bit set. It then uses the clone() method to create an identical copy of
b1 and assign it to b2. Another for statement is executed to clear every even-numbered bit in b2. The
values of the b1 and b2 bit sets are then printed. This results in the display of two lists of boolean
values. The bit sets are printed as objects, resulting in a set-oriented display. Only the bits with true
boolean values are identified as members of the displayed bit sets.
The xor() method is used to compute the exclusive or of b1 and b2, updating b1 with the result. The
new value of b1 is then displayed.
The and() method is used to calculate the logical and of b1 and b2, again, updating b1 with the result
and displaying b1's new value.
Finally, the logical or of b1 and b2 is computed, using the or() method. The result is used to update
b1, and b1's value is displayed.
The output of BitSetApp is as follows:
b1: true true true true true true true true
b2: false true false true false true false true
b1: {0, 1, 2, 3, 4, 5, 6, 7}
b2: {1, 3, 5, 7}
b1 xor b2 = {0, 2, 4, 6}
b1 and b2 = {}
b1 or b2 = {1, 3, 5, 7}
The Dictionary, Hashtable, and Properties Classes
The Dictionary, Hashtable, and Properties classes are three generations of classes that implement the
capability to provide key-based data storage and retrieval. The Dictionary class is the abstract
superclass of Hashtable, which is, in turn, the superclass of Properties.
Dictionary
Dictionary provides the abstract functions used to store and retrieve objects by key-value
associations. The class allows any object to be used as a key or value. This provides great flexibility
in the design of key-based storage and retrieval classes. Hashtable and Properties are two examples of
these classes.
The Dictionary class can be understood using its namesake abstraction. A hard-copy dictionary maps
words to their definitions. The words can be considered the keys of the dictionary, and the definitions
are the values of the keys. Java dictionaries operate in the same fashion. One object is used as the key
to access another object. This abstraction will become clearer as you investigate the Hashtable and
Properties classes.
The Dictionary class defines several methods that are inherited by its subclasses. The elements()
method is used to return an Enumeration object containing the values of the key-value pairs stored
within the dictionary. The keys() method returns an enumeration of the dictionary keys. The get()
method is used to retrieve an object from the dictionary based on its key. The put() method puts a
Value object in the dictionary and indexes it using a Key object. The isEmpty() method determines
whether a dictionary contains any elements, and the size() method identifies the dictionary's size in
terms of the number of elements it contains. The remove() method deletes a key-value pair from the
dictionary, based on the object's key.
NOTE: The Dictionary class has been rendered obsolete by the Map interface, as of
JDK 1.2. However, its Hashtable and Properties subclasses are still in use.
Hashtable
The Hashtable class implements a hash table data structure. A hash table indexes and stores objects in
a dictionary using hash codes as the objects' keys. Hash codes are integer values that identify objects.
They are computed in such a manner that different objects are very likely to have different hash
values and therefore different dictionary keys.
The Object class implements the hashCode() method. This method allows the hash code of an
arbitrary Java object to be calculated. All Java classes and objects inherit this method from Object.
The hashCode() method is used to compute the hash code key for storing objects within a hash table.
Object also implements the equals() method. This method is used to determine whether two objects
with the same hash code are, in fact, equal.
The Java Hashtable class is very similar to the Dictionary class from which it is derived. Objects are
added to a hash table as key-value pairs. The object used as the key is hashed, using its hashCode()
method, and the hash code is used as the actual key for the value object. When an object is to be
retrieved from a hash table, using a key, the key's hash code is computed and used to find the object.
The Hashtable class provides three constructors. The first constructor allows a hash table to be
created with a specific initial capacity and load factor. The load factor is a float value between 0.0
and 1.0 that identifies the percentage of hash table usage that causes the hash table to be rehashed into
a larger table. For example, suppose a hash table is created with a capacity of 100 entries and a 0.70
load factor. When the hash table is 70 percent full, a new, larger hash table will be created, and the
current hash table entries will have their hash values recalculated for the larger table.
The second Hashtable constructor just specifies the table's initial capacity and ignores the load factor.
The default hash table constructor does not specify either hash table parameter.
The access methods defined for the Hashtable class allow key-value pairs to be added to and removed
from a hash table, to search the hash table for a particular key or object value, to create an
enumeration of the table's keys and values, to determine the size of the hash table, and to recalculate
the hash table as needed. Many of these methods are inherited or overridden from the Dictionary
class.
HashApp
The HashApp program illustrates the operation and use of hash tables. See Listing 11.4.
LISTING 11.4. THE SOURCE CODE OF THE HashApp PROGRAM.
import java.lang.System;
import java.util.Hashtable;
import java.util.Enumeration;
public class HashApp {
public static void main(String args[]){
Hashtable h = new Hashtable();
h.put("height","6 feet");
h.put("weight","200 pounds");
h.put("eye color","blue");
h.put("hair color","brown");
System.out.println("h: "+h);
Enumeration enum = h.keys();
System.out.print("keys: ");
while (enum.hasMoreElements()) System.out.print(enum.nextElement()
+", Â");
System.out.print("\nelements: ");
enum = h.elements();
while (enum.hasMoreElements()) System.out.print(enum.nextElement()
+", Â");
System.out.println();
System.out.println("height: "+h.get("height"));
System.out.println("weight: "+h.get("weight"));
System.out.println("eyes: "+h.get("eye color"));
System.out.println("hair: "+h.get("hair color"));
h.remove("weight");
System.out.println("h: "+h);
}
}
The program begins by creating a Hashtable object using the default constructor. It then adds four
key-value pairs to the hash table using the put() method. The hash table is then printed using the
default print method for objects of class Hashtable.
The keys() method is used to create an enumeration of the hash table's keys. These keys are then
printed one at a time by indexing through the enumeration object.
The elements() method is used to create an enumeration of the hash table's values. This enumeration
is printed in the same way as the key enumeration.
The values of the hash table are again displayed by using the get() method to get the values
corresponding to specific key values.
Finally, the remove() method is used to remove the key-value pair associated with the weight key,
and the hash table is reprinted using the default print convention.
The program output is as follows:
h: {height=6 feet, weight=200 pounds, eye color=blue, hair
color=brown}
keys: height, weight, eye color, hair color,
elements: 6 feet, 200 pounds, blue, brown,
height: 6 feet
weight: 200 pounds
eyes: blue
hair: brown
h: {height=6 feet, eye color=blue, hair color=brown}
The Properties Class
The Properties class is a subclass of Hashtable that can be read from or written to a stream. It also
provides the capability to specify a set of default values to be used if a specified key is not found in
the table. The default values themselves are specified as an object of class Properties. This allows an
object of class Properties to have a default Properties object, which in turn has its own default
properties, and so on.
Properties supports two constructors: a default constructor with no parameters, and a constructor that
accepts the default properties to be associated with the Properties object being constructed.
The Properties class declares several new access methods. The getProperty() method allows a
property to be retrieved using a String object as a key. A second overloaded getProperty() method
allows a value string to be used as the default in case the key is not contained in the Properties object.
The load() and save() methods are used to load a Properties object from an input stream and save it to
an output stream. The save() method allows an optional header comment to be saved at the beginning
of the saved object's position in the output stream.
The propertyNames() method provides an enumeration of all the property keys, and the list() method
provides a convenient way to print a Properties object on a PrintStream object.
PropApp
The PropApp program illustrates the use of the Properties class by retrieving the System properties
and displaying them to the console (see Listing 11.5). This program is similar to the SystemApp
program of Chapter 10, "Writing Console Applications."
LISTING 11.5. THE SOURCE CODE OF THE PropApp PROGRAM.
import java.lang.System;
import java.util.Properties;
public class PropApp {
public static void main(String args[]){
Properties sysProp = System.getProperties();
sysProp.list(System.out);
}
}
The program uses the getProperties() method of the System class to retrieve the system properties and
assign them to the sysProp variable. The system properties are then listed on the console window
using the list() method.
The program's output will vary from machine to machine. Its output, when run from my computer, is
as follows:
-- listing properties -java.specification.name=Java Platform API Specification
awt.toolkit=sun.awt.windows.WToolkit
java.version=1.2beta2
java.awt.graphicsenv=sun.awt.Win32GraphicsEnvironment
java.tmpdir=c:\windows\TEMP\
user.timezone=PST
java.specification.version=1.2beta2
user.home=C:\JDK1.2BETA2\BIN\..
java-vm.name=non-JIT
os.arch=x86
java.awt.fonts=C:\WINDOWS\Fonts
java.vendor.url=http://www.sun.com/
user.region=US
file.encoding.pkg=sun.io
java.home=C:\JDK1.2BETA2\BIN\..
java-vm.specification.vendor=Sun Microsystems Inc.
java-vm.specification.version=1.0
java.class.path=.;C:\JavaWebServer1.0.3\public_html\c...
line.separator=
os.name=Windows 95
java.vendor=Sun Microsystems Inc.
java.library.path=C:\JDK1.2BETA2\BIN;.;C:\WINDOWS;c:\wi...
java-vm.version=1.2beta2
file.encoding=8859_1
java.specification.vendor=Sun Microsystems Inc.
user.name=jaworskij
user.language=en
java.vendor.url.bug=http://java.sun.com/cgi-bin/bugreport...
java.class.version=45.3
os.version=4.0
path.separator=;
java-vm.specification.name=Java Virtual Machine Specification
file.separator=\
user.dir=C:\jdk1.2beta2\ju\ch11
java-vm.vendor=Sun Microsystems Inc.
JDK 1.2 Collections Classes and Interfaces
The Collections API of JDK 1.2 added 10 new interfaces and 13 new classes to those that you studied
in the previous section. These additional classes and interfaces provide a powerful API for working
with different types of object collections.
The new collections interfaces introduced with JDK 1.2 are as follows:
●
●
●
Collection--Defines methods that implement the concept of a group of objects, referred to as
elements. The Collection interface corresponds to a mathematical bag, which is a collection
that allows duplicate objects. It defines a full spectrum of methods for adding, removing, and
retrieving objects from the collection, as well as methods that operate on the collection itself.
List--Extends the Collection interface to implement an ordered collection of objects. Because
lists are ordered, List's objects can be indexed. The ListIterator interface provides methods for
iterating through the elements of a list.
Set--Extends the Collection interface to implement a finite mathematical set. Sets differ from
lists in that they do not allow duplicate elements.
●
SortedSet--A Set whose elements are sorted in ascending order.
●
Comparator--Provides the compare() method for comparing the elements of a collection.
●
●
●
●
●
Iterator--Provides methods for iterating through the elements of a collection. In JDK 1.2, the
Iterator interface replaces the Enumeration interface.
ListIterator--Extends the Iterator interface to support bidirectional iteration of lists.
Map--Replaces the Dictionary class as a means to associate keys with values. The Map
interface provides similar methods for performing operations on the map and its elements.
SortedMap--A Map whose elements are sorted in ascending order.
Map.Entry--An inner interface of the Map interface that defines methods for working with a
single key-value pair.
Figure 11.1 shows the hierarchical relationships between the classes and interfaces of the Collections
API.
FIGURE 11.1. The Collections API class and interface hier-archy.
The new collections classes introduced with JDK 1.2 are as follows:
●
●
AbstractCollection--The AbstractCollection class provides a basic implementation of the
Collection interface. It is extended by other classes that tailor AbstractCollection to more
specific implementations.
AbstractList--The AbstractList class extends the AbstractCollection class to provide a basic
implementation of the List interface.
●
●
●
●
●
●
●
●
●
●
●
●
AbstractSequentialList--The AbstractSequentialList class extends the AbstractList class to
provide a list that is tailored to sequential access, as opposed to random access.
LinkedList--The LinkedList class extends the AbstractSequentialList class to provide an
implementation of a doubly linked list. A linked list is a list in which each element references
the next element in the list. A doubly linked list is a list in which each element references both
the previous and next elements in the list.
ArrayList--The ArrayList class extends AbstractList to implement a resizable array.
AbstractSet--The AbstractSet class extends the AbstractCollection class to provide a basic
implementation of the Set interface.
HashSet--The HashSet class extends AbstractSet to implement a set of key-value pairs. It does
not allow the use of the null element.
TreeSet--The TreeSet class extends AbstractSet to implement the Set interface using a
TreeMap.
AbstractMap--The AbstractMap class provides a basic implementation of the Map interface.
HashMap--The HashMap class extends AbstractMap to implement a hash table that supports
the Map interface.
WeakHashMap--The WeakHashMap class extends AbstractMap to implement a hash table
that supports the Map interface and allows its keys to be garbage collected when no longer in
ordinary use.
TreeMap--The TreeMap class extends AbstractMap to implement a sorted binary tree that
supports the Map interface.
Arrays--The Arrays class provides static methods for searching and sorting arrays and
converting them to lists.
Collections--The Collections class provides static methods for searching, sorting, and
performing other operations on objects that implement the Collection interface.
The right half of Figure 11.1 shows the Collections API class hierarchy. The following subsections
show how to work with the new Collections classes and interfaces. Four examples are provided that
show you how to work with lists, sets, maps, and the conversion capabilities of the Arrays class.
Working with Lists
Lists are collections whose objects are ordered. Because lists are ordered, their elements can be
indexed. Lists allow duplicate elements. Most lists allow the null value to be an element.
The ListApp program of Listing 11.6 shows how to create and use lists. This program creates a
LinkedList object that is referenced by the list variable. The add() method if used to add the strings
"is", "is", "a", and "a" to the LinkedList object. The add() method is then used to add the null value to
the list. The addLast() method is used to add "test" as the last element of the list. The addFirst()
method is used to add "This" as the first element of the list. The displayList() method is then invoked
to display the elements of the list.
The displayList() method displays the following results:
The size of the list is: 7
This
is
is
a
a
null
test
The displayList() method uses the size() method to determine the number of elements in the list. It
invokes the listIterator() method to return an object that implements the ListIterator interface. The
argument to the listIterator() method is the index of the first element of the list to return in the
ListIterator object. In this case, we used 0 so that the whole list would be returned.
The hasNext() method of the ListIterator interface is used to iterate through the list, and the next()
method is used to retrieve the next element of the list. Note that the list can contain the null value,
and special provisions are made for printing this value.
LISTING 11.6. THE ListApp PROGRAM.
import java.util.*;
public class ListApp {
public static void main(String args[]){
LinkedList list = new LinkedList();
list.add("is");
list.add("is");
list.add("a");
list.add("a");
list.add(null);
list.addLast("test");
list.addFirst("This");
displayList(list);
}
static void displayList(LinkedList list) {
System.out.println("The size of the list is: "+list.size());
ListIterator i = list.listIterator(0);
while(i.hasNext()){
Object o = i.next();
if(o == null) System.out.println("null");
else System.out.println(o.toString());
}
}
}
Working with Sets
Sets differ from lists in that they are unordered and cannot contain duplicates of the same element.
The SetApp program, shown in Listing 11.7, illustrates the use of sets. It performs the same type of
processing as ListApp, but it does so using sets instead of lists.
LISTING 11.7. THE SetApp PROGRAM.
import java.util.*;
public class SetApp {
public static void main(String args[]){
HashSet set = new HashSet();
set.add("This");
set.add("is");
set.add("is");
set.add("a");
set.add("a");
set.add(null);
set.add("test");
displaySet(set);
}
static void displaySet(HashSet set) {
System.out.println("The size of the set is: "+set.size());
Iterator i = set.iterator();
while(i.hasNext()){
Object o = i.next();
if(o == null) System.out.println("null");
else System.out.println(o.toString());
}
}
}
SetApp begins by creating an HashSet object and assigning it to the set variable. It then adds the
same elements to the set as ListApp did to its list. Note that because sets are not ordered, there are no
addFirst() and addLast() methods. The displaySet() method is invoked to display the set. It displays
the following results:
The size of the set is: 5
This
is
a
null
test
Note that the set did not allow duplicate elements, but did allow the null value as an element. The
displaySet() method uses the size() method to determine the number of elements in the set. It uses the
iterator() method to create an Iterator object. The Iterator object is used to step through and display
the elements of the set.
Working with Maps
Maps differ from lists and sets in that they are ordered collections of key-value pairs. Maps are a
generalization of the Dictionary, Hashtable, and Properties classes that you studied earlier in this
chapter. The MapApp program of Listing 11.8 uses an object of the TreeMap class to create a sorted
list of key-value pairs. The TreeMap class implements a sorted binary tree.
LISTING 11.8. THE MapApp PROGRAM.
import java.util.*;
public class MapApp {
public static void main(String args[]){
TreeMap map = new TreeMap();
map.put("one","1");
map.put("two","2");
map.put("three","3");
map.put("four","4");
map.put("five","5");
map.put("six","6");
displayMap(map);
}
static void displayMap(TreeMap map) {
System.out.println("The size of the map is: "+map.size());
Collection c = map.entrySet();
Iterator i = c.iterator();
while(i.hasNext()){
Object o = i.next();
if(o == null) System.out.println("null");
else System.out.println(o.toString());
}
}
}
The MapApp program begins by creating a TreeMap object and assigning it to the map variable. It
then adds six key-value pairs to the map. These key-value pairs associate the names of the numbers
from 1 through 6 with their values. The displayMap() method is then invoked to display the
program's results:
The size of the map is: 6
five=5
four=4
one=1
six=6
three=3
two=2
The displayMap() method uses the size() method to determine the number of elements (key-value
pairs) in the map. It invokes the entrySet() method to create a Collection object containing the values
of the map. The iterator() method of the Collection object is used to obtain an Iterator object for the
collection. The Iterator object is used to step through and display the elements of the collection. You
should note that the TreeMap object uses the key to sort its key-value pairs.
Sorting and Converting
The Arrays and Collections classes provide a number of static methods for searching, sorting, and
converting arrays and Collection objects. The ConvertApp program of Listing 11.9 provides an
example of these capabilities. This program creates an array of names, sorts the array, converts it to a
list, and then displays the values of the list.
LISTING 11.9. THE ConvertApp PROGRAM.
import java.util.*;
public class ConvertApp {
public static void main(String args[]){
String strings[] = {"Jason","Emily","Lisa","Jamie","Pierre",
"Stanley","Gloria","Ben","Ken","Lela"};
Arrays.sort(strings);
List list = Arrays.asList(strings);
displayList(list);
}
static void displayList(List list) {
System.out.println("The size of the list is: "+list.size());
ListIterator i = list.listIterator(0);
while(i.hasNext()){
Object o = i.next();
if(o == null) System.out.println("null");
else System.out.println(o.toString());
}
}
}
ConvertApp begins by creating an array of first names. It then uses the static sort() method of the
Arrays class to sort the array. The asList() method of Arrays is invoked to convert the array to a List
object. The displayList() method is then invoked to display the list. Its output follows:
The size of the list is: 10
Ben
Emily
Gloria
Jamie
Jason
Ken
Lela
Lisa
Pierre
Stanley
The displayList() method uses the method of the List interface to determine the size of the list and
step through the elements of the list.
Date and Calendar-Related Classes
Another major set of classes supported by the java.util package are classes for working with dates and
calendars. The original JDK 1.0 provided the Date class to encapsulate date and time as an object. In
JDK 1.1, many of the functions of the Date class were deprecated in favor of more international
handling of date and time. The Calendar, GregorianCalendar, SimpleTimeZone, and TimeZone
classes were added to provide more comprehensive and international support of date and time. The
DateFormat class of the java.text package was also added to support international date formatting.
NOTE: A deprecated API element is one that has been replaced by an improved
alternative. In most cases, the deprecated element may still be used. However, compiler
warnings are generated to inform you that an improved alternative exists.
Date
The Date class encapsulates date and time information and allows date objects to be accessed in a
system-independent manner.
Four of the six Date JDK 1.0 constructors have been deprecated. Only the default constructor that
creates a Date object with the current system date and time, and a constructor that creates a Date
object from a long value, are not deprecated in JDK 1.2.
The access methods defined by the Date class support comparisons between dates and provide access
to specific date information, including the time zone offset. However, many of the JDK 1.0 methods
have been deprecated in favor of methods provided by the Calendar, DateFormat, and TimeZone
classes.
Calendar
The Calendar class provides support for date conversions that were previously implemented by the
Date class. The support provided by Calendar is more comprehensive and international. The Calendar
class is an abstract class that can be extended to provide conversions for specific calendar systems.
The GregorianCalendar subclass supports the predominant calendar system used by many countries.
The Calendar class provides two constructors--a default parameterless constructor that constructs a
calendar with the default TimeZone and Locale objects, and a constructor that allows the TimeZone
and Locale objects to be specified. It supplies many constants for accessing days of the week, months
of the year, hours, minutes, seconds, milliseconds, and other values.
The Calendar class provides a number of methods for performing data comparisons, arithmetic, and
conversions. The getInstance() method returns a locale-specific calendar that is a GregorianCalendar
object, by default.
GregorianCalendar
The GregorianCalendar class is a subclass of the Calendar class that supports calendar operations for
most of the world. It supports the eras B.C. and A.D. by defining them as class constants. It provides
seven constructors that allow GregorianCalendar objects to be created using a combination of
different date, time, time zone, and locale values. Its methods override those provided by the
Calendar class.
TimeZone
The TimeZone class is used to encapsulate the notion of a time zone. It allows you to work in the
local time zone, as well as time zones that are selected by a time zone ID. The TimeZone class keeps
track of daylight savings time.
The TimeZone class provides a single, parameterless constructor that creates a TimeZone object
corresponding to the local time zone. The TimeZone class does not define any field variables.
The access methods of TimeZone allow you to get a list of available time zone IDs, retrieve the local
time zone (from the operating system), get the local time zone offset (and adjust it for daylight
savings time), and create TimeZone objects for other time zone IDs.
SimpleTimeZone
The SimpleTimeZone class extends TimeZone to provide support for GregorianCalendar objects. It
creates SimpleTimeZone objects using the time zone IDs and offsets defined in the TimeZone class.
It provides methods for changing the way daylight savings time is calculated.
DateApp
The DateApp program illustrates the use of the date-related classes covered in the previous sections.
It shows how Date, GregorianCalendar, and TimeZone objects are created and how to use their
methods to access date/time information. The DateApp program is presented in Listing 11.10.
LISTING 11.10. THE SOURCE CODE OF THE DateApp PROGRAM.
import java.lang.System;
import java.util.Date;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.TimeZone;
public class DateApp {
public static void main(String args[]){
Date today = new Date();
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(today);
System.out.println("Today: ");
displayDateInfo(cal);
cal.clear();
cal.set(2000,0,1);
System.out.println("\nNew Years Day 2000: ");
displayDateInfo(cal);
}
static void displayDateInfo(GregorianCalendar cal){
String days[] = {"","Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
String months[] = {"January","February","March","April","May",
"June","July","August","September","October","November",
"December"};
String am_pm[] = {"AM","PM"};
System.out.println("Year: "+cal.get(Calendar.YEAR));
System.out.println("Month: "+months[cal.get(Calendar.MONTH)]);
System.out.println("Date: "+cal.get(Calendar.DATE));
System.out.println("Day: "+days[cal.get(Calendar.DAY_OF_WEEK)]);
System.out.println("Hour: "+(cal.get(Calendar.HOUR)+12)%13);
System.out.println("Minute: "+cal.get(Calendar.MINUTE));
System.out.println("Second: "+cal.get(Calendar.SECOND));
System.out.println(am_pm[cal.get(Calendar.AM_PM)]);
TimeZone tz=cal.getTimeZone();
System.out.println("Time Zone: "+tz.getID());
}
}
The program creates a Date object and a GregorianCalendar object using the default Date() and
GregorianCalendar() constructors. The Date object is assigned to the today variable, and the
GregorianCalendar object is assigned to the cal variable. The cal variable is updated with the current
date by invoking its setTime() method with the Date object stored in today. The displayDateInfo()
method is then invoked to display date and time information about the cal variable.
The clear() method of the Calendar class is invoked to reset the date of the GregorianCalendar object
stored in cal. The set() method is used to set its date to New Year's 2000. There are several versions
of the set() method, each of which takes a different set of parameters. The version used in DateApp
takes the year, month, and date as parameters. Note that the month value ranges from 0 to 12, where
the year and date values begin at 1. The displayDateInfo() method is invoked again to display
information about the new calendar date.
The displayDateInfo() method creates the days, months, and am_pm arrays to define string values
corresponding to the days of the week, months of the year, and a.m./p.m. It then prints a line
corresponding to date and time values. These values are retrieved using the get() method of the
Calendar class and the Calendar constants corresponding to date/time values. The getTimeZone()
method of Calendar is invoked to retrieve the local TimeZone object. The getID() method of the
TimeZone class is used to retrieve the local time zone ID string.
The output of the DateApp program follows. When you run the program, you will obviously get a
different date for the first part of the program's processing. The following are the results that were
displayed when I ran the program:
Today:
Year: 1998
Month: July
Date: 28
Day: Tue
Hour: 10
Minute: 57
Second: 6
AM
Time Zone: America/Los Angeles
New Years Day 2000:
Year: 2000
Month: January
Date: 1
Day: Sat
Hour: 12
Minute: 0
Second: 0
AM
Time Zone: America/Los Angeles
Internationalization Classes
The java.util package provides a number of classes that support internationalization. These classes are
described in this section. Examples of their use are provided in Chapter 19, "Internationalization."
The Locale Class
The Locale class supports internationalization by describing geographic, political, or cultural regions.
Locale objects are used to tailor program output to the conventions of that region. They are created
using the Locale() constructors, which take language and country arguments and an optional variant
argument. The variant argument is used to specify software-specific characteristics, such as operating
system or browser. The Locale class defines constants for the most popular languages and countries.
The access methods of Locale support the setting and retrieving of language, country, and variantrelated values. Examples of using the Locale class are provided in Chapter 19.
The ResourceBundle Class
The ResourceBundle class also supports internationalization. ResourceBundle subclasses are used to
store locale-specific resources that can be loaded by a program to tailor the program's appearance to
the particular locale in which it is being run. Resource bundles provide the capability to isolate a
program's locale-specific resources in a standard and modular manner.
The ResourceBundle class provides a single parameterless constructor. The parent field variable is
used to identify the ResourceBundle class that is the parent of a particular class. This parent can be
set using the setParent() method. The parent is used to find resources that are not available in a
particular class.
The ResouceBundle access methods are used to retrieve the resources that are specific to a particular
locale. The ResourceBundle class and its subclasses are covered in Chapter 19.
The ListResourceBundle Class
The ListResourceBundle class extends the ResourceBundle class to simplify access to locale-specific
resources. It organizes resources in terms of an array of object pairs, where the first object is a String
key and the second object is the key's value. The getContents() method returns the key-value array.
The PropertyResourceBundle Class
The PropertyResourceBundle class extends the ResourceBundle class to organize locale-specific
resources using a property file. An InputStream object is supplied to the PropertyResourceBundle()
constructor to enable reading of the property file.
Other java.util Classes and Interfaces
The java.util package provides a number of other classes and interfaces that provide capabilities that
can be used in many of your programs. These remaining classes and interfaces are covered in the
following subsections.
The Random Class
The Random class provides a template for the creation of random number generators. It differs from
the random() method of the java.lang.Math class in that it allows any number of random number
generators to be created as separate objects. The Math.random() method provides a static function for
the generation of random double values. This static method is shared by all program code.
Objects of the Random class generate random numbers using a linear congruential formula. Two
constructors are provided for creating Random objects. The default constructor initializes the seed of
the random number generator using the current system time. The other constructor allows the seed to
be set to an initial long value.
The Random class provides eight access methods, seven of which are used to generate random
values. The next(), nextInt(), nextLong(), nextFloat(), and nextDouble() methods generate values for
the numeric data types. The values generated by nextFloat() and nextDouble() are between 0.0 and
1.0. The nextGaussian() method generates a Gaussian distribution of double values with mean 0.0
and standard deviation 1.0. The nextBytes() method generates a random byte array.
The setSeed() method is used to reset the seed of the random number generator.
RandomApp
The RandomApp program demonstrates the use of the Random class (see Listing 11.11). It creates an
object of class Random using the default constructor and assigns it to r. This causes the random
number generator to be seeded using the current system time. Three for loops are used to print
random int, double, and Gaussian-distributed double values. Each loop prints four values.
LISTING 11.11. THE SOURCE CODE OF THE RandomApp PROGRAM.
import java.lang.System;
import java.util.Random;
public class RandomApp {
public static void main(String args[]){
Random r = new Random();
for(int i=0;i<4;++i) System.out.print(r.nextInt()+" ");
System.out.println();
r = new Random(123456789);
for(int i=0;i<4;++i) System.out.print(r.nextDouble()+" ");
System.out.println();
r.setSeed(234567890);
for(int i=0;i<4;++i) System.out.print(r.nextGaussian()+" ");
System.out.println();
}
}
The following is the output generated by the program when it was run on my computer:
-854287801 -2056322098 1372478715 1217144804
0.664038103272266 0.45695178590520646 0.39050647939140426
0.8933411602003871
0.11378145160284903 0.4122962630933344 -1.5726230841498485
0.07568285309772235
It will produce different results when it is run on your computer because the first line that is printed
uses the Random() constructor to generate the output data.
The StringTokenizer Class
The StringTokenizer class is used to create a parser for String objects. It parses strings according to a
set of delimiter characters. It implements the Enumeration interface in order to provide access to the
tokens contained within a string. The StringTokenizer class is similar to the StreamTokenizer class
covered in Chapter 17, "Input/Output Streams."
StringTokenizer provides three constructors. All three have the input string as a parameter. The first
constructor includes two other parameters: a set of delimiters to be used in the string parsing, and a
boolean value used to specify whether the delimiter characters should be returned as tokens. The
second constructor accepts the delimiter string, but not the return token's toggle. The last constructor
uses the default delimiter set consisting of the space, tab, newline, and carriage-return characters.
The access methods provided by StringTokenizer include the Enumeration methods,
hasMoreElements() and nextElement(), hasMoreTokens() and nextToken(), and countTokens(). The
countTokens() method returns the number of tokens in the string being parsed.
TokenApp
The TokenApp program prompts the user to enter a line of keyboard input and then parses the line,
identifying the number and value of the tokens that it found (see Listing 11.12).
LISTING 11.12. THE SOURCE CODE OF THE TokenApp PROGRAM.
import java.lang.System;
import java.io.*;
import java.util.StringTokenizer;
public class TokenApp {
public static void main(String args[]) throws IOException {
BufferedReader keyboardInput = new BufferedReader(
new InputStreamReader(System.in));
int numTokens;
do {
System.out.print("=> ");
System.out.flush();
StringTokenizer st = new StringTokenizer(keyboardInput.readLine
());
numTokens = st.countTokens();
System.out.println(numTokens+" tokens");
while (st.hasMoreTokens())
System.out.println(" "+st.nextToken());
} while(numTokens!=0);
}
}
The program begins by creating a BufferedReader object using the System.in stream as an argument
to its constructor. A do loop is used to read a line of input from the user, construct a StringTokenizer
object on the input line, display the number of tokens in the line, and display each token as parsed
using the standard delimiter set. The loop continues until a line with no tokens is entered.
The program's output is as follows:
=> this is a test
4 tokens
this
is
a
test
=> 1 2 3 4.5 6
5 tokens
1
2
3
4.5
6
=> @ # $ % ^
5 tokens
@
#
$
%
^
=>
0 tokens
Observer and Observable
The Observer interface and Observable class are used to implement an abstract system by which
observable objects can be observed by objects that implement the Observer interface. Observable
objects are objects that subclass the abstract Observable class. These objects maintain a list of
observers. When an observable object is updated, it invokes the update() method of its observers to
notify the observers that it has changed state.
The update() method is the only method that is specified in the Observer interface. The update()
method is used to notify an observer that an Observable object has changed. The method takes the
Observable object and a second notification message Object as its parameters.
The Observable class is an abstract class that must be subclassed by Observable objects. It provides
several methods for adding, deleting, and notifying observers and for manipulating change status.
These methods are described in the class's API page.
The EventObject Class and the EventListener Interface
The EventObject class is the top-level class of the Java event hierarchy. Events represent actions that
occur during the course of program execution. Most events are generated as the result of user actions,
such as mouse clicks and keyboard actions. The java.awt.event package declares event classes that
are subclasses of EventObject. The EventObject class contains a single constructor that identifies the
object that is the source of the event. This object is accessible through the source field variable. The
EventObject class also provides the getSource() method for accessing the event source.
Events are handled by responding to their occurrence and providing feedback to the user. Java 1.1
provided the capability to deliver events to specific objects--a capability that was lacking in Java 1.0.
It makes use of special classes, called adapter classes, whose objects listen for the occurrence of
events on behalf of objects of other classes. These classes implement event listener interfaces that
specify methods for identifying and responding to the occurrence of related events. The
EventListener interface is the top-level interface that all listener interfaces must implement. It is an
empty interface and does not declare any methods.
The PropertyPermission Class
The PropertyPermission class is used to create permissions to access specific system properties. You
should not use this class yourself. Instead, specify property permissions in your local security policy.
Chapter 3, "The Extended Java Security Model," covers the development of a JDK 1.2 security policy.
The java.util.zip Package
The java.util.zip package provides 1 interface and 14 classes to support the compression and
decompression of files and streams and to support checksum calculation. These classes are described
in the following sections.
Checksum
The Checksum interface provides four methods that support checksum calculation. The getValue()
method returns the current value of a checksum. The reset() method resets a checksum to its initial
value. The two update() methods update a checksum based on a single byte or an array of bytes.
Adler32
The Adler32 class implements the Checksum interface to compute an Adler-32 checksum. The Adler32 checksum is computed quickly, but is less reliable than the CRC32 checksum.
CRC32
The CRC32 class implements the Checksum interface to calculate a standard 32-bit cyclic
redundancy code.
CheckedInputStream
The CheckedInputStream class extends the FilterInputStream class of java.io to include a checksum
calculation for data read from the stream. The checksum is used to verify the integrity of the stream's
data. The CheckedInputStream() constructor creates a CheckedInputStream object from an
InputStream object and an object that implements the Checksum interface. The getChecksum()
method returns the Checksum object associated with the stream. Other methods support low-level
input.
CheckedOutputStream
The CheckedOutputStream class extends the FilterOutputStream class of java.io to include a
checksum calculation for data written to the stream. The checksum is used to verify the integrity of
the stream's data. The CheckedOutputStream() constructor creates a CheckedOutputStream object
from an OutputStream object and an object that implements the Checksum interface. The
getChecksum() method returns the Checksum object associated with the stream. Other methods
support low-level output.
Deflater
The Deflater class supports compression using the compression approaches described in Request For
Comments (RFCs) 1950, 1951, and 1952. RFCs are publicly available Internet standards that can be
found at ftp://ds.internic.net/rfc/. The Deflater class supports the following compression levels and
strategies, as defined by its field constants:
●
BEST_COMPRESSION--Most compression
●
BEST_SPEED--Fastest compression
●
DEFAULT_COMPRESSION--Default trade-off between compression and speed
●
DEFAULT_STRATEGY--Default compression strategy
●
DEFLATED--Simple deflation
●
FILTERED--Emphasizes Huffman coding over string matching
●
HUFFMAN_ONLY--Uses Huffman coding and not string matching
●
NO_COMPRESSION--Turns compression off
The compression level can be selected when constructing a Deflater object.
The methods of the Deflater class support data compression, the selection of a compression level and
strategy, and the use of preset data dictionaries. These methods perform block-oriented compression
on byte arrays.
Inflater
The Inflater class is used to decompress data that is compressed by the Deflater class. This
decompression is also covered in RFCs 1950, 1951, and 1952. The Inflater() constructor provides the
nowrap parameter to support GZIP- and PKZIP-compatible compression. GZIP compression is the
Gnu public version of the commercial PKZIP compression algorithm developed by Phil Katz.
The methods of the Inflater class support decompression and the use of preset data dictionaries.
These methods perform block-oriented decompression on byte arrays.
DeflaterOutputStream
The DeflaterOutputStream class extends the FilterOutputStream class to provide support for streamoriented compression. Its two field variables, buf and def, identify the output buffer used to write
compressed data and the type of compressor in use. The DeflaterOutputStream() constructors allow
the OutputStream and Deflater objects to be specified, as well as the output buffer size.
The deflate() method writes the next block of compressed data to the output stream. The finish()
method completes the compression of the output stream by writing all compressed data to the stream.
Other methods support low-level data output.
InflaterInputStream
The InflaterInputStream class is the input analog of the DeflaterOutputStream class.
InflaterInputStream reads and decompresses data that is written to a compressed output stream using
a DeflaterOutputStream object. It extends the FilterInputStream class of java.io.
InflaterInputStream defines three field variables: buf, inf, and len. These variables identify the input
buffer used for decompression, the type of decompressor to be used, and the length of the input
buffer. The InflaterInputStream() constructors allow InputStream and Inflater objects to be specified,
as well as the input buffer size.
The fill() method is used to fill the input buffer with compressed data. Other methods are used to read
uncompressed data from the stream.
GZIPOutputStream
The GZIPOutputStream class extends DeflaterOutputStream to support GZIP compression. It adds
the crc field variable to calculate a CRC-32 checksum on the compressed data. The
GZIPOutputStream() constructors allow the OutputStream object and the output buffer size to be
specified.
GZIPInputStream
The GZIPInputStream class is the input analog of the GZIPOutputStream class. It extends
InflaterInputStream and defines two additional variables and a constant. The crc variable identifies
the CRC-32 checksum of the compressed data. The eos variable identifies the end of the output
stream. The GZIP_MAGIC constant identifies the magic number of the GZIP header. Magic numbers
are used to uniquely identify files of a given format. The GZIPInputStream() constructors allow the
InputStream object and the input buffer size to be specified.
ZipFile
The ZipFile class is used to read .zip compressed files. The ZipFile() constructor opens a ZIP file for
reading. A File object or a String object containing a file name may be provided to the ZipFile()
constructor.
The methods of the ZipFile class support the reading and examination of .zip files. They are as
follows:
●
entries()--Returns an Enumeration object containing the .zip file entries.
●
●
getEntry()--Returns a ZipEntry object corresponding to the pathname passed as a string
argument.
getInputStream()--Returns an InputStream object corresponding to the ZipEntry object passed
as an argument to the method. The InputStream object is used to read the contents of the
ZipEntry object.
●
getName()--Returns the pathname of the .zip file.
●
close()--Closes the .zip file.
ZipEntry
The ZipEntry class encapsulates a .zip file entry. It represents a compressed file that is stored within
the .zip file. The DEFLATED and STORED constants are used to identify whether a .zip entry is
compressed or merely stored as uncompressed data within the .zip file. The ZipEntry() constructor is
used to create a named .zip file entry. Several methods are provided to read the following aspects of a
ZipEntry object:
●
Name of the entry
●
Comment string
●
Size of the compressed and uncompressed data
●
CRC-32 checksum of the compressed data
●
Extra field data
●
Compression method
●
Modification time of the entry
●
Whether the entry is a directory
Other methods are provided to set the comment string, CRC, extra field data, entry size, and time of
modification. The toString() method is overridden to convert a ZipEntry object to a String object.
ZipOutputStream
The ZipOutputStream class extends the DeflaterOutputStream class to support the writing of file
streams that are compressed in the .zip file format. The DEFLATED and STORED constants are used
to identify whether data should be compressed (DEFLATED) or stored as uncompressed data
(STORED). The ZipOutputStream() constructor creates a ZipOutputStream object from an
OutputStream object.
In addition to low-level output methods, the ZipOutputStream class provides the following methods:
●
putNextEntry()--Starts the writing of a new ZIP entry.
●
closeEntry()--Closes the current entry and positions the stream for writing the next entry.
●
setMethod()--Sets the compression method.
●
setLevel()--Sets the compression level.
●
setComment()--Sets the .zip file comment.
●
finish()--Completes the writing of the zipped output stream.
ZipInputStream
The ZipInputStream class is the input analog to the ZipOutputStream class. It is used to read a
compressed .zip format file. The ZipInputStream class extends the InflaterInputStream class.
The ZipInputStream() constructor creates a ZipInputStream object from an InputStream object. In
addition to low-level input methods, it provides the getNextEntry() method for reading the next .zip
file entry and the closeEntry() method for closing a .zip file entry.
The UnzipApp Program
The UnzipApp program, shown in Listing 11.13, illustrates the power of the java.util.zip in working
with compressed files. This short program can be used to unzip files in the .zip format.
LISTING 11.13. THE SOURCE CODE OF THE UnzipApp PROGRAM.
import java.lang.System;
import java.util.*;
import java.util.zip.*;
import java.io.*;
public class UnzipApp {
public static void main(String args[]) throws IOException {
if(args.length==0) System.exit(0);
ZipFile f = new ZipFile(args[0]);
Enumeration entries = f.entries();
System.out.println("Decompressing "+args[0]+" ...");
while(entries.hasMoreElements()){
ZipEntry entry = (ZipEntry) entries.nextElement();
System.out.println(" "+entry.getName());
InputStream in = f.getInputStream(entry);
FileOutputStream out = new FileOutputStream(entry.getName());
for(int ch=in.read();ch!=-1;ch=in.read()) out.write(ch);
out.close();
in.close();
}
f.close();
}
}
To show how the program works, I've included the file rfcs.zip on the CD-ROM included with this
book. This file contains the files rfc1950.txt, rfc1951.txt, and rfc1952.txt in compressed form. These
files document the conventions and formats used for ZLIB, DEFLATE, and GZIP.
The UnzipApp program takes a single argument--the name of the file that you want to unzip. To
unzip rfcs.zip, use:
java UnzipApp rfcs.zip
The program's output is as follows:
Decompressing rfcs.zip ...
rfc1950.txt
rfc1952.txt
rfc1951.txt
The files rfc1950.txt, rfc1951.txt, and rfc1952.txt are created and placed in your current working
directory.
The program makes use of the ZipFile and ZipEntry classes of java.util.zip and the Enumeration
interface of java.util. It creates a new ZipFile object from the filename that you pass to the program
as a command-line argument. It then invokes the entries() method of ZipFile to create an
Enumeration object of ZipEntry objects corresponding to the entries into the ZipFile object.
A while statement is used to loop through the Enumeration object and process each entry. The
hasMoreElements() method of the Enumeration interface is used to determine whether all entries
have been processed. The individual ZipEntry objects are extracted from the Enumeration object via
the nextElement() method and assigned to the entry variable. The getName() method of the ZipEntry
class is used to retrieve the filename associated with each ZipEntry object.
The ZipEntry objects are extracted to individual files by using the getInputStream() method of
ZipFile to read the contents of the ZipEntry object and write this data to files that are created using
the FileOutputStream class of java.io.
The java.util.jar Package
The java.util.jar package provides classes and methods for working with .jar files. The .jar files are
archive files used to combine all of the resources used by an applet into a single file. You learned
about .jar files in Chapter 8, "Applet Security." The java.util.jar package is new to JDK 1.2. It
provides seven new classes that are covered in the following subsections.
The JarFile Class
The JarFile class extends the ZipFile class to provide support for .jar files. It provides the capability
to add and work with the .jar file manifest. The JarFile constructors are used to create JarFile objects
that take their input from an input stream. The getManifest() method returns the file's manifest. The
getJarEntry() returns a named .jar file entry as an JarEntry object. The createZipEntry() method is
used to create a JarEntry object. The getInputStream() method returns an input stream for reading the .
jar file.
The JarEntry Class
The JarEntry class extends the ZipEntry class to provide support for .jar file entries. It provides a
single constructor for creating a named .jar file entry. The getAttributes() method returns an
Attributes object that specifies the manifest attributes for the entry. The getIdentities() method returns
an array of Identity objects that identifies the identities of the signers of the .jar file entry.
The Manifest Class
The Manifest class provides the capability to work with manifest entries and their attributes. It
provides methods for reading and manipulating manifest entries, main attributes, and per-entry
attributes.
The Attributes Class
The Attributes class implements the Map interface and provides a mapping between attribute names
and their values. It provides methods for reading and modifying the attribute names and values.
The Attributes.Name Class
The Attributes.Name class is an inner class of the Attributes class that is used to encapsulate an
attribute name. It provides a number of constants that represent commonly used manifest attributes.
The JarInputStream Class
The JarInputStream class is a subclass of the ZipInputStream class that supports the reading of .jar
files. It provides methods for reading JarEntry and Manifest objects.
The JarOutputStream Class
The JarOutputStream class is a subclass of the ZipOutputStream class that supports the writing of .jar
files. It provides the capability to specify a Manifest object in one of its constructors.
The JarApp Program
The JarApp program illustrates the use of the JarFile, JarEntry, Manifest, and Attributes classes. It
reads a .jar file and displays the JAR entries, main attributes, and manifest entries of the .jar file.
I've added the file TCanv.jar to the files contained on the CD-ROM for this chapter. You can use
JarApp to display the contents of the TCanv.jar file, as follows:
java JarApp TCanv.jar
Entries:
tcanv16m.gif
TCanvBeanInfo.class
tcanv32c.gif
META-INF/MANIFEST.MF
TCanv.class
tcanv32m.gif
tcanv16c.gif
Main attributes:
Manifest-Version 1.0
Manifest entries:
tcanv16m.gif [email protected]
TCanvBeanInfo.class [email protected]
TCanv.class [email protected]
tcanv32c.gif [email protected]
tcanv16c.gif [email protected]
tcanv32m.gif [email protected]
JarApp begins by creating a JarFile object from the name of the .jar file passed as an argument to the
program. It uses the entries() method to retrieve an Enumeration of the JarEntry objects contained in
the .jar file. It invokes getManifest() to retrieve a Manifest object for the .jar file.
The JarApp program iterates through the Enumeration of JarEntry objects and uses the getName()
method to display the names of the files that are contained in TCanv.jar:
tcanv16m.gif
TCanvBeanInfo.class
tcanv32c.gif
META-INF/MANIFEST.MF
TCanv.class
tcanv32m.gif
tcanv16c.gif
It invokes the getMainAttributes() method of the Manifest object to retrieve an Attributes object that
describes the main attributes of the .jar file. It invokes displayCollection() to display the single
attribute (Manifest-Version) and its value (1.0).
Next, JarApp invokes the getEntries() method of the Manifest object to return a Map object
containing the manifest entries and their values. It invokes displayCollection() to display these values:
tcanv16m.gif [email protected]
TCanvBeanInfo.class [email protected]
TCanv.class [email protected]
tcanv32c.gif [email protected]
tcanv16c.gif [email protected]
tcanv32m.gif [email protected]
The displayCollection() method displays a collection of key-value pairs. It invokes the iterator()
method of the Collection object to obtain an Iterator object. It then uses the Iterator object to step
through the collection and display each key name and its corresponding value.
LISTING 11.14. THE JarApp PROGRAM.
import java.util.*;
import java.util.jar.*;
import java.io.*;
public class JarApp {
public static void main(String args[]) throws IOException {
// Create JarFile object
JarFile f = new JarFile(args[0]);
// Get JarEntry objects
Enumeration entries = f.entries();
// Get Manifest
Manifest manifest = f.getManifest();
// Display the names of the entries
System.out.println("Entries:");
while(entries.hasMoreElements()){
JarEntry entry = (JarEntry) entries.nextElement();
System.out.println(" "+entry.getName());
}
// Display the names of the main attributes
System.out.println("Main attributes:");
Attributes attributes = manifest.getMainAttributes();
displayCollection(attributes.entrySet());
// Display the manifest entries and their attributes
System.out.println("Manifest entries:");
Map manifestEntries = manifest.getEntries();
displayCollection(manifestEntries.entrySet());
f.close();
}
static void displayCollection(Collection collection) {
if(collection.size()==0) System.out.println(" None");
else{
Iterator iterator = collection.iterator();
while(iterator.hasNext()){
Map.Entry entry = (Map.Entry) iterator.next();
String desc = entry.getKey().toString()+" ";
desc+=entry.getValue().toString();
System.out.println(" "+desc);
}
}
}
}
The java.util.mime Package
The java.util.mime package is new to JDK 1.2. It is a very small package consisting of the MimeType
and MimeTypeParameterList classes. These classes are used to provide support for Multipurpose
Internet Mail Extensions (MIME) types (refer to RFCs 2045 and 2046). Chapter 33, "Content and
Protocol Handlers," provides an introduction to MIME types.
The MimeType class provides methods for constructing MimeType objects that represent different
MIME types, for accessing the primary and subtypes of a MIME type, for working with MIME type
parameters, and for comparing MIME types. It also provides methods for supporting stream-based I/
O for different MIME types.
The MimeTypeParameterList class is used to encapsulate the parameter list of a MIME type. It
provides methods for getting and setting the parameters that are in the MIME type parameter list.
The java.math Package
The java.math package includes two classes, BigDecimal and BigNumber, that can be used to
perform arbitrary precision mathematical calculations. The BigDecimal class supports decimal
arithmetic, and the BigInteger class supports integer arithmetic. Both of these classes extend the
Number class.
BigDecimal
The BigDecimal class is implemented as an arbitrary precision integer number and a non-negative
scale value that identifies the number of digits to the right of the decimal point. BigDecimal provides
eight modes for rounding support. These modes are defined using class constants:
●
●
●
●
●
●
ROUND_CEILING--Use ROUND_UP for positive numbers and ROUND_DOWN for
negative numbers.
ROUND_DOWN--Round toward zero.
ROUND_FLOOR--Use ROUND_DOWN for positive numbers and ROUND_UP for negative
numbers.
ROUND_HALF_DOWN--Use ROUND_UP if the discarded fraction is greater than .5. Use
ROUND_DOWN otherwise.
ROUND_HALF_EVEN--Use ROUND_HALF_UP if the digit to the left of the discarded
fraction is odd. Use ROUND_HALF_DOWN if the digit to the left of the discarded fraction is
even.
ROUND_HALF_UP--Use ROUND_UP if the discarded fraction is greater than or equal to .5.
Otherwise, use ROUND_DOWN.
●
ROUND_UNNECESSARY--An exception is thrown if rounding is required.
●
ROUND_UP--Round away from zero.
These modes provide a great deal of flexibility in the rounding policy used by the BigDecimal class.
The BigDecimal class provides constructors that allow BigDecimal objects to be created from String,
double, and BigInteger objects. The methods of BigDecimal support arithmetic operations,
comparisons, rounding and scaling, and conversions to other types and classes.
BigInteger
The BigInteger class is similar to BigDecimal, but it is limited to integer operations. It does not have
any public field values, like BigDecimal, because it does not deal with rounding. Its constructors
allow BigInteger objects to be constructed from strings, byte arrays, and randomly within a specified
range. Its methods support arithmetic, logical, bitwise, and comparison operations. Its methods also
support modular arithmetic, greatest common divisor calculation, and prime number generation and
testing.
The BigNumApp Program
The BigNumApp program illustrates the ease by which large number computations can be
performed. It calculates the first number greater than a trillion (10 to the 12 power) that is probably
prime. Listing 11.15 contains the source code of the BigNumApp program.
LISTING 11.15. THE SOURCE CODE OF THE BigNumApp PROGRAM.
import java.lang.System;
import java.math.BigInteger;
public class BigNumApp {
public static void main(String args[]){
BigInteger n=new BigInteger("1000000000000");
BigInteger one=new BigInteger("1");
while(!n.isProbablePrime(7)) n=n.add(one);
System.out.println(n.toString(10)+" is probably prime.");
System.out.println("It is "+n.bitLength()+" bits in length.");
}
}
The BigNumApp program creates a BigInteger equal to one trillion and assigns it to n. It then creates
a BigInteger equal to 1 and assigns it to the one variable. It uses a while loop to test numbers greater
than a trillion until it finds one that is probably prime with a certainty of 7. This certainty value
means that the probability of the number being prime is (1 - (1/2**7)), which is greater than 99%.
The bitLength() method is to determine the length of the prime number in bits.
The program's output is as follows:
1000000000039 is probably prime.
It is 40 bits in length.
Summary
In this chapter you learned about the classes and interfaces of the java.util family of packages and the
java.math package. You learned how to use the new JDK 1.2 Collections API, work with dates and
calendars, work with .zip and .jar files, and perform large number arithmetic. In the next chapter
you'll learn how to use the new Java Swing API to enhance the look and feel of your applets' and
applications' user interfaces.
© Copyright, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
- 12 Introducing Swing
●
●
●
●
●
●
What Is Swing?
Swing, AWT, and the JFC
The Swing Component Hierarchy
Swing Package Overview
Developing a Swing-Based GUI
❍ How SwingStart Works
Summary
Swing is one of the major improvements in the JDK between versions 1.1 and 1.2. It is also one of
the key APIs of the Java Foundations Classes (JFC). What makes Swing so important is the power
that it provides in developing GUIs for applets and applications. The number and quality of the GUI
controls provided by Swing is unrivaled by any other GUI toolkit.
Up until now, you have been developing your applet and application GUIs using the traditional GUI
controls of the AWT. In this chapter, you'll be introduced to the GUI controls of Swing. You'll learn
what Swing is, where it comes from, and its relationship to the AWT and the JFC as a whole. You'll
cover the Swing component hierarchy and learn about the Swing packages. You'll then develop an
example Swing-based GUI. When you finish this chapter, you will be thoroughly introduced to
Swing. The following chapter will then expand upon your Swing programming skills.
What Is Swing?
Swing is a major component of the JFC, which is the result of a large collaborative effort between
Sun, Netscape, IBM, and other companies. Swing provides a large number of useful GUI controls
that originated with Netscape's Internet Foundations Classes (IFC). The Swing components go far
beyond the IFC, to the point where there is no visible resemblance between Swing components and
those of the IFC. Swing also provides the capability to quickly and easily change the look and feel
(L&F) of a single component or group of components. This capability, known as pluggable look and
feel (PL&F), is a hallmark feature of Swing. Chapter 14, "Changing the Look and Feel of Your
Swing Components," focuses on Swing's PL&F features.
NOTE: To make optimal use of Swing, your video card should be set to 16-bit or
higher color. This setting supports 65,536 color combinations.
Swing, AWT, and the JFC
Figure 12.1 shows the relationship between Swing, the AWT, and the JFC. The JFC subsumes and
extends the original AWT and consists of the following major APIs:
●
AWT
●
Swing
●
Java 2D
●
Drag-and-Drop
●
Accessibility
Although Swing is separate from the AWT, it is implemented in terms of basic AWT classes. The
AWT provides the interface between the underlying native windowing system and the Java GUI
components. Swing uses this interface, but does not rely on AWT components that make use of
native windowing system objects. Instead, Swing components are written in pure Java. This provides
significant advantages. It allows Swing components to be independent of the native windowing
system, which means they can run on any windowing system that supports the AWT. It also allows
Swing components to be independent of any limitations of the native windowing systems. This
independence allows Swing to control and tailor its look and feel--hence the emergence of PL&F.
FIGURE 12.1. Swing, IFC, JFC, and AWT.
Swing also provides a pure Java implementation of many of the traditional AWT components. These
components have the same functionality as the AWT components and all of the advantages of Swing.
Swing is compatible with the AWT, and Swing components can be used interchangeably with AWT
components. However, Swing components can only be used with the JDK 1.1 event model. They do
not support the JDK 1.0 event model.
NOTE: The latest version of Swing can be found at http://www.javasoft.com/products/
jfc/index.html. Swing is packaged as part of the JFC.
The Swing Component Hierarchy
Swing consists of 9 packages, and hundreds of classes and interfaces. However, the JComponent
class of com.sun.java.swing is the top-level class of the Swing component hierarchy. As such, it is a
good starting point for learning about Swing components. The JComponent class is a subclass of the
java.awt.container class, and is therefore both a component and container in the AWT sense. Because
JComponent is the superclass of all Swing components, all Swing components descend from java.awt.
Container and java.awt.Component.
Figure 12.2 shows the Swing component hierarchy. The first thing that you should notice is that all
components begin with the letter J, followed by the type of component supported by the class.
JComponent has the following direct subclasses:
●
●
●
●
●
●
●
●
●
AbstractButton--The top-level button class. It is subclassed by JButton (traditional and
enhanced GUI buttons), JToggleButton (checkboxes and radio buttons), and JMenuItem
(menus and menu items).
JComboBox--A combination of a text field and drop-down list.
JInternalFrame--A frame that supports all standard frame operations and can be used as an
internal GUI component. The JDesktopIcon inner class is used to implement an iconified form
of an internal frame.
JLabel--A label that may contain text, an image, or both. It is extended by the
DefaultTableCellRenderer class, which is used to display the cells of a table.
JLayeredPane--A panel that supports several layers. It is extended by JDesktopPane, which
provides the capability to manage layered frames as a desktop.
JList--A list component that can be tailored in a variety of ways.
JMenuBar--A menu bar that can be added to any container. It displays a pop-up menu of menu
items.
JOptionPane--A single class that supports a number of common dialog boxes.
JPanel--The Swing analog of the AWT Panel class. It is extended by the ColorChooserPanel,
which provides support for color selection.
●
JPopupMenu--A pop-up menu that supports text and graphical menu items.
●
JProgressBar--A configurable bar that displays progress as a percentage of the bar's length.
●
●
JRootPane--Uses a layered pane and a see-through plane to allow objects to be overlaid on the
layered plane.
JScrollBar--The Swing scrollbar implementation, typically used with objects of the JViewPort
class.
●
JScrollPane--The combination of a scrollbar and a viewport.
●
JSeparator--Used to separate menu items.
●
●
●
JSlider--Provides a slider GUI control that is analogous to the sliders found on audio
equalizers.
JSplitPane--A panel that is used to separate exactly two components.
JTabbedPane--A panel that organizes components into tabs. The user clicks on the tabs to
view the component groups.
●
JTable--A very flexible table component that displays both text and graphic cells.
●
JTableHeader--Column header for JTable objects.
●
JTextComponent--Superclass of the Swing text fields.
●
JToolBar--A draggable, floating toolbar container.
●
JToolTip--A pop-up component that displays useful information about other components.
●
JTree--A component that displays hierarchical data in a tree-like (outline) fashion.
●
JViewport--A panel for holding information that is scrolled by a scrollbar.
FIGURE 12.2. Swing component hierarchy.
You'll see visual examples of many of these components later in this chapter and in the following
chapter.
Swing Package Overview
Swing is a large API consisting of 9 packages and numerous classes and interfaces. Most of the
Swing components are contained in the com.sun.java.swing package, which also provides classes and
interfaces that support and manage the GUI components. The com.sun.java.swing.border package
provides a number of interesting borders that can be used with Swing components. These borders
help to tailor the look and feel of component sets.
The com.sun.java.swing.event package defines the events and event listeners used by Swing
components. It is a good idea to look over the list of events and event listeners to get a feel for the
types of user interactions supported by Swing.
The com.sun.java.swing.table package provides classes and interfaces that support the feature rich
and flexible JTable object. You use these classes and interfaces to tailor a table's display features.
The com.sun.java.swing.text packages provides several classes and interfaces that support text
components. These classes and interfaces control the caret, highlighting, formatting, and other
aspects of text that is entered and edited within text components.
The com.sun.java.swing.text.html package contains the single HTMLEditorKit class. This class
supports the implementation of a simple but powerful HTML editor. The com.sun.java.swing.text.rtf
package is similar to the com.sun.java.swing.text.html package. It contains the single RTFEditorKit
class, which provides the capability to edit Rich Text Format (RTF) text.
The com.sun.java.swing.tree package provides classes and interfaces that support the use of the JTree
component.
The com.sun.java.swing.undo package provides support for undo and redo operations.
The com.sun.java.swing.plaf provides support for Swing's pluggable look-and-feel features.
Developing a Swing-Based GUI
Now that we've covered the components and packages that compose the Swing API, you'll develop a
sample program that shows off some of Swing's features. You'll run the program first, to get an idea
of what it does, and then you'll examine the Swing code used in its implementation.
Listing 12.1 shows the source code of the SwingStart program. Compile this program and run it. It
displays the GUI shown in Figure 12.3. You'll notice four tabs labeled Buttons, Bars, Lists, and
Table. You'll also notice two graphical buttons. Move your mouse over any of the tabs. After a
second or two, an information tip is displayed, as shown in Figure 12.4. Move your mouse over each
tab to see the tip associated with that tab.
FIGURE 12.3. The initial display of the SwingStart program.
FIGURE 12.4. Tips are displayed when you move your mouse over a tab.
The Buttons tab shows two buttons. The button on the left is a standard button, but it is enhanced
with a printer image. Wouldn't a button like this be more informative to a program user than a simple
text button? The button on the right provides an extra capability--the button retains its state. When
you click the button, it sticks in the in position. When you click it again, the button moves back out.
Click on the Bars tab. A slider and a progress bar are displayed, as shown in Figure 12.5. Use your
mouse to move the slider, and the progress bar is updated to reflect the new slider position. Sliders
and progress bars provide users with a fine level of control over a program parameter and display
progress toward the completion of a task.
FIGURE 12.5. The Bars tab shows examples of Swing's slider and progress bar controls.
FIGURE 12.6. A Swing list can contain icons.
Click on the Lists tab. The icon list, shown in Figure 12.6, is displayed. Click on any of the images to
select it from the list. As you can see, Swing provides excellent integration of images into GUI
controls.
FIGURE 12.7. Swing makes it easy to create advanced tables.
Click on the Table tab. The cost table, shown in Figure 12.7, is displayed. Swing tables not only
provide the capability to display tabular information, but they can also be used to create tables that
can be edited by users.
The GUI controls shown in the SwingStart program are just a small sample of the GUI capabilities of
Swing. However, they are enough to introduce you to Swing programming, as discussed in the next
section.
LISTING 12.1. THE SwingStart PROGRAM.
import java.awt.*;
import java.awt.event.*;
import com.sun.java.swing.*;
import com.sun.java.swing.event.*;
import com.sun.java.swing.border.*;
public class SwingStart extends Frame {
public static int WIDTH = 450;
public static int HEIGHT = 450;
public static String TITLE = "SwingStart";
// Swing components
JTabbedPane tabbedPane = new JTabbedPane();
JPanel buttonPanel = new JPanel();
JPanel barPanel = new JPanel();
JPanel listPanel = new JPanel();
JPanel tablePanel = new JPanel();
JPanel[] panels = {buttonPanel,barPanel,listPanel,tablePanel};
Icon worldIcon = new ImageIcon("world.gif");
Icon printerIcon = new ImageIcon("printer.gif");
Icon leaf1Icon = new ImageIcon("leaf1.gif");
Icon leaf2Icon = new ImageIcon("leaf2.gif");
Icon leaf3Icon = new ImageIcon("leaf3.gif");
Icon[] leaves = {leaf1Icon, leaf2Icon, leaf3Icon};
JButton printerButton = new JButton("Print",printerIcon);
JToggleButton worldButton = new JToggleButton("Connect",worldIcon,
true);
JList leafList = new JList(leaves);
JSlider slider = new JSlider(JSlider.VERTICAL, 0, 100, 60);
JProgressBar progressBar = new JProgressBar();
String[] columns = {"Product ID","Description","Price"};
Object[][] cells = {columns,{"zvga-1234","Video Card","$50"},
{"56m-11","56K Modem","$315"},
{"dc-10","Net Card","$499"}};
JTable table = new JTable(cells,columns);
{
super(TITLE);
addWindowListener(new WindowHandler());
buildGUI();
setSize(WIDTH,HEIGHT);
setBackground(Color.darkGray);
show();
}
void buildGUI() {
// Set up tabbed pane
String[] tabs = {"Buttons","Bars","Lists","Table"};
String[] tabTips = {"A Button and a Toggle Button",
"A Slider and a Progress Bar",
"An Icon List",
"A Cost Table"};
for(int i=0;i<tabs.length;++i) {
panels[i].setBackground(Color.lightGray);
panels[i].setBorder(new TitledBorder(tabTips[i]));
tabbedPane.addTab(tabs[i],null,panels[i],tabTips[i]);
}
addComponentsToTabs();
add("Center",tabbedPane);
}
void addComponentsToTabs() {
setupButtonPanel();
setupBarPanel();
setupListPanel();
setupTablePanel();
}
void setupButtonPanel() {
printerButton.setBackground(Color.white);
worldButton.setBackground(Color.white);
buttonPanel.add(printerButton);
buttonPanel.add(worldButton);
}
void setupBarPanel() {
slider.setMajorTickSpacing(10);
slider.setMinorTickSpacing(5);
slider.setPaintTicks(true);
slider.addChangeListener(new SliderHandler());
progressBar.setOrientation(JProgressBar.HORIZONTAL);
progressBar.setMinimum(0);
progressBar.setMaximum(100);
progressBar.setValue(60);
progressBar.setBorderPainted(true);
barPanel.add(new JLabel("Slider"));
barPanel.add(slider);
barPanel.add(new JLabel("Progress Bar"));
barPanel.add(progressBar);
}
void setupListPanel() {
leafList.setFixedCellHeight(123);
listPanel.add(leafList);
}
void setupTablePanel() {
tablePanel.add(table);
}
public static void main(String[] args) {
SwingStart app = new SwingStart();
}
public class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
public class SliderHandler implements ChangeListener {
public void stateChanged(ChangeEvent e) {
progressBar.setValue(slider.getValue());
}
}
}
How SwingStart Works
The first thing that you should notice about SwingStart is that it imports the com.sun.java.swing
(Swing components), com.sun.java.swing.event (Swing event handling), and com.sun.java.swing.
border (custom borders) packages. The SwingStart program extends the Frame class of java.awt.
Swing provides its own window classes that extend java.awt. You'll learn about these classes in the
following chapter. SwingStart uses the Frame class to show how Swing and AWT components can be
used interchangeably.
The SwingStart class begins by declaring a few constants used to define the window size and title.
After that, it declares and initializes a number of variables used to implement Swing components.
These variables are used as follows:
●
●
●
●
●
●
●
tabbedPane--References a JTabbedPane object that provides the four tabs of the SwingStart
GUI.
buttonPanel, barPanel, listPanel, and tablePanel--Reference JPanel objects that serve as
containers for the objects added to the Buttons, Bars, Lists, and Table tabs.
panels--An array of JPanel objects used to access each of the preceding four panels.
worldIcon, printerIcon, leaf1Icon, leaf2Icon, and leaf3Icon--Reference objects of the
ImageIcon class that are used in the Buttons and Lists tabs.
leaves--An ImageIcon array consisting of the preceding three leaf icons. These objects are
used in the Lists tab.
printerButton--References the JButton object used in the Buttons tab. The button is created
with the Print label and the ImageIcon object referenced by printerIcon.
worldButton--References the JToggleButton object used in the Buttons tab. The button is
created with the Connect label and the ImageIcon object referenced by worldIcon. Objects of
the JToggleButton class are buttons that implement an on/off state. The button state is
identified by whether or not the button is pushed in.
●
●
leafList--References a JList object that is constructed from an ImageIcon array. The JList class
provides the capability to construct lists from arbitrary GUI objects.
slider--References the JSlider object used in the Bars tab. The object is a vertical slider with a
range of 0 to 100 and a starting value of 60.
●
progressBar--References the JProgressBar object used in the Bars tab.
●
columns--An array of column headings used to construct a table.
●
cells--The contents of the table's cells.
●
table--References the JTable object used in the Table tab. The table is constructed from its
column headings and cell values.
The SwingStart constructor invokes the superclass constructor to set the window's title, adds a
window event handler, and invokes the buildGUI() method to build the program's graphical user
interface. The setSize() method is used to set the window's size, and the setBackground() method sets
the window's background color to dark gray. Finally, the show() method is invoked to cause the
window to be displayed.
The buildGUI() method sets up the tabbed pane that controls the program's display. It creates an array
of tab labels and tips associated with those labels. It then uses a for statement to set the background
color and border of each panel. The border used is a TitleBorder object. This border constructs an
etched box around the panel's contents and displays a title in the upper-left corner of the pane. Refer
to Figures 12.3 through 12.7 for examples of how the border is displayed. Each of the panels is then
added to a tab via the addTab() method, which takes the names of the tabs, an icon, the objects to be
added to each tab, and the tab tips as parameters. The addComponentsToTabs() method is invoked to
add components to the panels of each tab. The tabbed pane is then added to the center of SwingStart's
frame.
The addComponentsToTabs()method simply invokes other methods to set up the Buttons, Bars, Lists,
and Table panes.
The setupButtonPanel() method adds the printer and world buttons to the Buttons tab. It sets the
background color of the buttons to white and then adds the buttons to the pane. No event handling is
provided for the buttons.
The setupBarPanel() method sets parameters for the slider and progress bar, adds an event handler for
the slider, and then adds the slider and progress bar to the Bars tab. The setMajorTickSpacing() and
setMinorTickSpacing() methods are used to add tick marks to the slider. The setPaintTicks() method
is invoked to cause the ticks to be displayed. The addChangeListener() method sets up an event
handler for the slider.
The setOrientation(), setMinimum(), setMaximum(), and setValue() methods set up the progress bar's
orientation, range, and initial value. The setBorderPainted() method controls the display of the
progress bar's border. The slider, progress bar, and two labels are added to the Bars tab via the JPanel
object referenced by barPanel.
The setupListPanel() method sets the cell height of the icon list to 123 pixels. (I arrived at this value
through trial and error. It seemed to be the most pleasing height for the icons.) The list (referenced by
the leafList variable) is then added to the tab.
The setupTablePanel() method sets up the JTable object's parameters and then adds the table to the
Table tab. It sets the intercell spacing to a 20 pixel border. The sizeColumnsToFit() method causes
table columns to be automatically resized to fit in the space allocated to the table.
The main() method simply creates a SwingStart object. The WindowHandler inner class handles the
window closing event by exiting the JVM.
The SliderHandler class implements the ChangeListener interface of com.sun.java.swing.event. The
stateChanged() method handles changes to the slider position by getting the value of the slider and
setting the value of the progress bar to the slider value.
Summary
In this chapter, you were introduced to the GUI controls of Swing. You learned what Swing is, where
it comes from, and its relationship to the AWT and the JFC as a whole. You learned about the Swing
component hierarchy and about the Swing packages. You then developed an example Swing-based
GUI. In the next chapter, you'll encounter more examples that will expand upon your Swing
programming skills.
© Copyright 1998, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
- 13 Working with Swing Components
●
●
●
●
●
Swing GUI Building
❍ Windows
❍ Menus
❍ Panels
❍ Layouts
❍ Icons
❍ Borders
❍ Tool Tips
❍ Toolbars
❍ Labels and Buttons
❍ Text Components
❍ Lists and Combo Boxes
❍ Sliders and Progress Bars
❍ Scrollbars
❍ Tables
❍ Trees
Swing Event Handling
Swing Applets
❍ CalendarApplet
Converting to Swing
Summary
In the previous chapter, you were introduced to Swing and learned about some of the Swing
components. This chapter takes the introduction to the next level. You'll learn about Swing windows,
menus, toolbars, tables, trees, and other GUI components. You'll learn how Swing events are handled
and how the JApplet class supports the development of applets that use Swing components. You'll
also learn how to convert your existing applications and applets to Swing. When you finish this
chapter, you'll be able to begin writing your own Swing-based applets and applications.
Swing GUI Building
Chapter 6, "GUI Building," covered GUI building using the component and container classes of the
AWT. Swing GUI building is very similar to AWT GUI building, except that you have many more
component classes with which to work. For the most part, everything you learned in Chapter 6 carries
over to Swing. However, Swing provides a number of enhancements you'll need to know about in
order to maximize Swing's potential. The following subsections describe the classes used for Swing
GUI building and point out the enhancements provided by Swing.
Windows
Just as AWT provides a Window class hierarchy, so does Swing. Swing's window classes are
extensions of the AWT Window class hierarchy. The JWindow class extends the AWT Window
class. The JFrame class extends the AWT Frame class and the JDialog class extends the AWT Dialog
class.
The JWindow, JFrame, and JDialog classes differ from their AWT counterparts in that they use a
separate content pane for adding and laying out GUI components. This content pane is a Container
object that is accessed via the getContentPane() method. The content pane is part of a JRootPane
object that contains other panes used for overlaying components and intercepting mouse and
keyboard events. You'll learn how to use the content pane to build a Swing GUI in the examples of
this chapter.
Menus
Swing menus, like Swing windows, are analogous to their AWT counterparts. The JMenuBar,
JMenu, JMenuItem, JCheckBoxMenuItem, and JRadioButtonMenuItem classes are used in the same
manner as the AWT MenuBar, Menu, MenuItem, and CheckboxMenuItem classes but with one very
important difference. The Swing menu classes are all subclasses of the JComponent class, and
therefore, of the Component class. This means that Swing menus, unlike their AWT counterparts, are
first-class components and can be used with any Container classes. The JPopupMenu class is
analogous to the AWT PopupMenu class. Another nice feature provided by Swing menus is the
capability to use icon images in menus. An image can be added to a menu item via its constructor.
SwingWin
The SwingWin program, shown in Listing 13.1, demonstrates the use of Swing's menus. The
program's opening display is shown in Figure 13.1. Select the New menu item from the File menu, as
shown in Figure 13.2. The menu item's label is displayed in the text field, as shown in Figure 13.3.
Try experimenting with the menu items of the File and Edit menus.
FIGURE 13.1. The SwingWin opening window.
FIGURE 13.2. Selecting the New menu item from the File menu.
FIGURE 13.3. The name of the menu item is displayed in the text field.
The Special menu is shown in Figure 13.4. Note that it contains two checkboxes and two menu items.
The second checkbox is already checked. Check the first checkbox and then pull down the menu to
see its effect. As you can see in Figure 13.5, multiple checkboxes may be checked.
FIGURE 13.4. The Special menu.
FIGURE 13.5. Multiple checkboxes can be checked.
Check the first radio button and then pull down the Special menu to verify that it has been checked.
Now check the second radio button. Only one radio button can be checked at a time. Figure 13.6
shows that the checking of the second radio button causes the first radio button to become unchecked.
FIGURE 13.6. Only a single radio button may be checked.
Listing 13.1. The SwingWin program.
import java.awt.*;
import java.awt.event.*;
import com.sun.java.swing.*;
import com.sun.java.swing.event.*;
public class SwingWin extends JFrame {
public static int WIDTH = 300;
public static int HEIGHT = 300;
public static String TITLE = "SwingWin";
Container frameContainer;
// Swing components
JTextField textField = new JTextField(50);
JMenuBar menuBar = new JMenuBar();
JMenu fileMenu = new JMenu("File");
JMenuItem fileNew = new JMenuItem("New");
JMenuItem fileOpen = new JMenuItem("Open");
JMenuItem fileSave = new JMenuItem("Save");
JMenuItem fileExit = new JMenuItem("Exit");
JMenu editMenu = new JMenu("Edit");
JMenuItem editCut = new JMenuItem("Cut");
JMenuItem editCopy = new JMenuItem("Copy");
JMenuItem editPaste = new JMenuItem("Paste");
JMenu specialMenu = new JMenu("Special");
JCheckBoxMenuItem specialCheck1 = new JCheckBoxMenuItem("Check 1");
JCheckBoxMenuItem specialCheck2 = new JCheckBoxMenuItem("Check 2",
true);
JSeparator separator = new JSeparator();
JRadioButtonMenuItem specialRadio1 = new JRadioButtonMenuItem
("Radio 1");
JRadioButtonMenuItem specialRadio2 = new JRadioButtonMenuItem
("Radio 2");
ButtonGroup buttonGroup = new ButtonGroup();
public SwingWin() {
super(TITLE);
buildGUI();
setupEventHandlers();
setSize(WIDTH,HEIGHT);
show();
}
void buildGUI() {
setupMenuBar();
layoutComponents();
}
void setupMenuBar() {
fileMenu.add(fileNew);
fileMenu.add(fileOpen);
fileMenu.add(fileSave);
fileMenu.add(fileExit);
editMenu.add(editCut);
editMenu.add(editCopy);
editMenu.add(editPaste);
specialMenu.add(specialCheck1);
specialMenu.add(specialCheck2);
specialMenu.add(separator);
buttonGroup.add(specialRadio1);
buttonGroup.add(specialRadio2);
specialMenu.add(specialRadio1);
specialMenu.add(specialRadio2);
menuBar.add(fileMenu);
menuBar.add(editMenu);
menuBar.add(specialMenu);
setJMenuBar(menuBar);
}
public void layoutComponents() {
frameContainer = getContentPane();
frameContainer.setLayout(null);
textField.setBounds(100,100,100,20);
frameContainer.add(textField);
}
void setupEventHandlers() {
addWindowListener(new WindowHandler());
fileNew.addActionListener(new MenuItemHandler());
fileOpen.addActionListener(new MenuItemHandler());
fileSave.addActionListener(new MenuItemHandler());
fileExit.addActionListener(new MenuItemHandler());
editCut.addActionListener(new MenuItemHandler());
editCopy.addActionListener(new MenuItemHandler());
editPaste.addActionListener(new MenuItemHandler());
specialCheck1.addItemListener(new ItemHandler());
specialCheck2.addItemListener(new ItemHandler());
specialRadio1.addItemListener(new ItemHandler());
specialRadio2.addItemListener(new ItemHandler());
}
public static void main(String[] args) {
SwingWin app = new SwingWin();
}
public class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
public class MenuItemHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
String cmd = e.getActionCommand();
if(cmd.equals("Exit")) System.exit(0);
else textField.setText(cmd);
}
}
public class ItemHandler implements ItemListener {
public void itemStateChanged(ItemEvent e) {
AbstractButton button = (AbstractButton) e.getItem();
String label = button.getText();
if(button.isSelected()) label += " true";
else label += " false";
textField.setText(label);
}
}
}
The first thing you should notice about SwingWin is that it extends the JFrame class instead of the
Frame class of java.awt. It then declares constants and variables for use in the program. Objects of
classes JMenuBar, JMenu, JMenuItem, JCheckBoxMenuItem, and JRadioButtonMenuItem are
declared in a manner similar to their AWT counterparts. Note that the JSeparator class is used to
implement menu separators. For objects of the JRadioButtonMenuItem class to implement mutually
exclusive button selection, they are added to an object of the ButtonGroup class.
The SwingWin() constructor invokes buildGUI() to build the program's GUI and setupEventHandlers
() to connect events to their event handling code.
The setupMenuBar() method is invoked by buildGUI() to set up the program's menu bar. Menu items
are added to menus and the menus are then added to the menu bar. In addition, radio buttons are
added to their button group. Finally, the menu bar is set using the setJMenuBar() method of the
JFrame class.
NOTE: You can use the Swing menu classes to rewrite the MyMenu class of Chapter
9, "Creating Window Applications."
The layoutComponents() method invokes the getContentPane() method of the JFrame class to get the
frame's container. Unlike AWT frames, Swing frames have a container that is separate from the
frame itself. The container's layout is set to a null layout and the text field is centered within the
container.
The setupEventHandlers() method sets up event handlers for the window and each of the menu items.
Note that a separate menu handler is used for the checkbox and radio button menu items. The
actionPerformed() method of the MenuItemHandler class handles the selection of a menu item by
displaying the menu item's label in the text field. The itemStateChanged() method of the ItemHandler
class handles the selection of a checkbox or radio button by displaying the checkbox or button's label
and selection state in the text field.
Panels
The JPanel class is the Swing analog of the AWT Panel class. It, like all other subclasses of
JComponent, provides the capability to add a border. You'll learn how to use borders with a panel in
the upcoming SwingBorder program of Listing 13.2.
Layouts
Swing containers support all of the AWT layouts, including the null layout. In addition, the following
layouts are supported by Swing:
●
BoxLayout Lays out components in a box-like fashion along the x-axis or y-axis
●
JRootPane.RootLayout Used to layout JRootPane objects
●
OverlayLayout Allows components to be laid out in an overlapping fashion
●
ScrollPaneLayout Automatically created, managed, and used by ScrollPane objects
●
●
SpringLayout Used to lay out components in terms of relative positions, without determining
component sizes
ViewportLayout Defines the layout used by a JViewport object
With the exception of BoxLayout and OverlayLayout, you'll probably use the layouts of the AWT.
Icons
One of the most useful features provided by Swing is the capability to add icons to components, such
as labels, buttons, menu items, and so on. The Icon interface defines the methods that must be
implemented by icon classes. The ImageIcon class provides a default implementation of this
interface. ImageIcon objects can be constructed from image files, URLs that point to image files, or
AWT Image objects. You'll define a border from an Image object in the SwingBorder program of
Listing 13.2.
Borders
The com.sun.java.swing.border package provides the Border interface, which defines the methods
that need to be implemented by all border classes. The AbstractBorder class implements the Border
interface and is the superclass of the Swing border classes. Its subclasses include:
●
BevelBorder A border that is beveled and raised or lowered
●
CompoundBorder A border consisting of multiple other borders
●
EmptyBorder An empty border used to provide margins
●
EtchedBorder A border that is etched with highlight and shadow colors
●
LineBorder A border that draws a line around a component
●
MatteBorder A border that is comprised of an image or color
●
SoftBevelBorder A beveled border with softened corners
●
TitledBorder A boxed border with a title
The use of these classes is covered in the next example.
SwingBorder
The SwingBorder program, shown in Listing 13.2, illustrates the use of Swing's pre-defined borders.
The opening window of SwingBorder is shown in Figure 13.7. Select Bevel from the Border menu
and the window's border changes to a beveled border as shown in Figure 13.8. Note that the beveling
can be changed from a lowered bevel to a raised bevel.
FIGURE 13.7. The SwingBorder opening display.
Select Compound from the Border menu and a compound blue and red border is displayed, as shown
in Figure 13.9. The compound border consists of two line borders, one of each color. Figure 13.10
shows an the empty border that is displayed when you select Empty from the Border menu. An empty
border is used to provide vertical and horizontal margins, without displaying anything in those
margins.
FIGURE 13.8. A beveled border.
FIGURE 13.9. A compound border.
FIGURE 13.10. An empty border.
Selecting Etched from the Border menu results in the Etched border shown in Figure 13.11. Figure
13.12 shows the lined border that results from selecting Line from the border menu.
Probably the most interesting border is the matte border, shown in Figure 13.13. This border results
from selecting matte from the Border menu. The border was created using a phone icon.
Figure 13.14 shows the raised soft beveled border that results from selecting Soft Bevel from the
Border menu. Figure 13.15 provides an example of a titled border.
FIGURE 13.11. An etched border.
FIGURE 13.12. A lined border.
FIGURE 13.13. A matte border.
FIGURE 13.14. A soft beveled border.
FIGURE 13.15. A titled border.
Listing 13.2. The SwingBorder program.
import java.awt.*;
import java.awt.event.*;
import com.sun.java.swing.*;
import com.sun.java.swing.event.*;
import com.sun.java.swing.border.*;
public class SwingBorder extends JFrame {
public static int WIDTH = 300;
public static int HEIGHT = 300;
public static String TITLE = "SwingBorder";
Container frameContainer;
// Swing components
JPanel panel = new JPanel();
JMenuBar menuBar = new JMenuBar();
JMenu fileMenu = new JMenu("File");
JMenuItem fileExit = new JMenuItem("Exit");
JMenu borderMenu = new JMenu("Border");
String[] borderTypes = {"Bevel","Compound","Empty","Etched",
"Line","Matte","SoftBevel","Titled"};
JRadioButtonMenuItem[] borders =
new JRadioButtonMenuItem[borderTypes.length];
AbstractBorder[] border = {new BevelBorder(BevelBorder.LOWERED),
new CompoundBorder(new LineBorder(Color.blue,10),
new LineBorder(Color.red,5)), new EmptyBorder(10,10,10,10),
new EtchedBorder(), new LineBorder(Color.blue,10),
new MatteBorder(new ImageIcon("phone.gif")),
new SoftBevelBorder(BevelBorder.RAISED),
new TitledBorder("TitledBorder")};
ButtonGroup buttonGroup = new ButtonGroup();
public SwingBorder() {
super(TITLE);
buildGUI();
setupEventHandlers();
setSize(WIDTH,HEIGHT);
show();
}
void buildGUI() {
setupMenuBar();
layoutComponents();
}
void setupMenuBar() {
fileMenu.add(fileExit);
for(int i=0;i<borderTypes.length;++i) {
borders[i] = new JRadioButtonMenuItem(borderTypes[i]);
buttonGroup.add(borders[i]);
borderMenu.add(borders[i]);
}
menuBar.add(fileMenu);
menuBar.add(borderMenu);
setJMenuBar(menuBar);
}
public void layoutComponents() {
frameContainer = getContentPane();
frameContainer.setLayout(new BorderLayout());
frameContainer.add("Center",panel);
}
void setupEventHandlers() {
addWindowListener(new WindowHandler());
fileExit.addActionListener(new MenuItemHandler());
for(int i=0;i<borders.length;++i)
borders[i].addItemListener(new ItemHandler());
}
public static void main(String[] args) {
SwingBorder app = new SwingBorder();
}
public class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
public class MenuItemHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
String cmd = e.getActionCommand();
if(cmd.equals("Exit")) System.exit(0);
}
}
public class ItemHandler implements ItemListener {
public void itemStateChanged(ItemEvent e) {
JRadioButtonMenuItem button = (JRadioButtonMenuItem) e.getItem();
String label = button.getText();
for(int i=0;i<borderTypes.length;++i) {
if(label.equals(borderTypes[i])) {
panel.setBorder(border[i]);
repaint();
}
}
}
}
}
SwingBorder begins by declaring the constants and variables used to implement the borders. It uses
an object of the JPanel class to display the border. This object is assigned to the panel variable. The
borderTypes array is used to create the menu items of the Border menu. These menu items are
implemented as objects of the JRadioButtonMenuItem class. An array of AbstractBorder objects is
created to provide examples of each border type. These borders are implemented by the following
objects:
●
●
A BevelBorder object with a lowered bevel
A CompoundBorder object consisting of a blue 10-pixel-wide LineBorder object and a red 5pixel-wide LineBorder object
●
An EmptyBorder object with 10-pixel margins
●
An EtchedBorder object
●
A blue 10-pixel-wide LineBorder object
●
A MatteBorder object that displays the image contained in the phone.gif file on the border
●
A SoftBevelBorder object that has a raised bevel
●
A TitledBorder object with the TitledBorder title
The setupMenuBar() method creates each of the JRadioButtonMenuItem objects from the
borderTypes array, adds the buttons to their button group, and then adds them to the Border menu.
The setupEventHandlers() method sets up the event handlers for the window and menu items. The
Border menu items are assigned objects of the ItemHandler class.
The itemStateChanged() method of the ItemHandler class retrieves the label of the
JRadioButtonMenuItem that is selected. The border of the JPanel object referenced by panel is set to
the selected border object and the repaint() method is invoked to bring the border into effect.
Tool Tips
The JToolTip class provides the capability to add popup text boxes that are displayed when the
mouse is held over a component. Those components that support tool tips allow tool tips to be
specified in their constructors. The setToolTipText() method of the JComponent class can also be
used to specify a component's tool tip.
Toolbars
The JToolBar class provides the capability to use moveable and dockable toolbars with Swing.
Objects of this class are containers for other Swing or AWT components. Typical JToolBar objects
contain JButton objects that are constructed with image icons. The addSeparator() method is used to
add a separator to a toolbar.
SwingBar
The SwingBar program, shown in Listing 13.3, illustrates Swing's toolbar and tool tip capabilities.
The program's opening display is shown in Figure 13.16. A toolbar is positioned at the top of the
window, underneath the menu bar. Position your mouse over the first button and the New tool tip is
displayed, as shown in Figure 13.17. The toolbar is moveable. Drag it by the left side to another
position within the SwingBar window as shown in Figure 13.18.
FIGURE 13.16. The SwingBar opening window.
FIGURE 13.17. Tool tips are assigned to the toolbar's buttons.
FIGURE 13.18. The toolbar can be moved around the SwingBar window.
Listing 13.3. The SwingBar program.
import java.awt.*;
import java.awt.event.*;
import com.sun.java.swing.*;
import com.sun.java.swing.event.*;
public class SwingBar extends JFrame {
public static int WIDTH = 400;
public static int HEIGHT = 400;
public static String TITLE = "SwingBar";
Container frameContainer;
// Swing components
JToolBar toolBar = new JToolBar();
String[] iconFiles = {"new.gif","open.gif","save.gif","cut.gif",
"copy.gif","paste.gif"};
String[] buttonLabels = {"New","Open","Save","Cut","Copy","Paste"};
ImageIcon[] icons = new ImageIcon[iconFiles.length];
JButton[] buttons = new JButton[buttonLabels.length];
JMenuBar menuBar = new JMenuBar();
JMenu fileMenu = new JMenu("File");
JMenuItem fileExit = new JMenuItem("Exit");
public SwingBar() {
super(TITLE);
buildGUI();
setupEventHandlers();
setSize(WIDTH,HEIGHT);
show();
}
void buildGUI() {
setupMenuBar();
layoutComponents();
}
void setupMenuBar() {
fileMenu.add(fileExit);
menuBar.add(fileMenu);
setJMenuBar(menuBar);
}
public void layoutComponents() {
frameContainer = getContentPane();
frameContainer.setLayout(new BorderLayout());
for(int i=0;i<buttonLabels.length;++i) {
icons[i] = new ImageIcon(iconFiles[i]);
buttons[i] = new JButton(icons[i]);
buttons[i].setToolTipText(buttonLabels[i]);
if(i==3) toolBar.addSeparator();
toolBar.add(buttons[i]);
}
frameContainer.add("North",toolBar);
}
void setupEventHandlers() {
addWindowListener(new WindowHandler());
fileExit.addActionListener(new MenuItemHandler());
}
public static void main(String[] args) {
SwingBar app = new SwingBar();
}
public class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
public class MenuItemHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
String cmd = e.getActionCommand();
if(cmd.equals("Exit")) System.exit(0);
}
}
}
The SwingBar program creates a JToolBar object and assigns it to the toolBar variable. The iconFiles
array identifies the filenames of the toolbar's button icons. The buttonLabels array identifies the tool
tips of the toolbar's buttons. The icons array is used to hold the images of the toolbar's buttons. The
buttons array contains the actual buttons.
The layoutComponents() method creates the image icons from their image files, creates the buttons
from their icons, and sets the tool tips of each button. A separator is added between the third and
fourth buttons. The buttons are then added to the JToolBar object.
Labels and Buttons
The JLabel and JButton classes provide Swing analogs to the AWT Label and Button classes. The
Swing implementation provides the advantage of being able to use icons along with text. The JLabel
() and JButton() constructors allow an icon to be specified. In addition, both classes support the
setIcon() method for setting an icon after the object has been constructed.
Text Components
The JTextComponent, JTextField, and JTextArea classes are the Swing analogs of the AWT
TextComponent, TextField, and TextArea classes. In addition, Swing provides the TextPane class for
working with text documents that can be marked up with different text styles.
Lists and Combo Boxes
The JComboBox and JList classes provide the capability to present the user with a list of text or
graphic selections. The JComboBox class implements a drop-down list, similar to a Motif option list.
The JList class is a single or multiple selection list with a multi- element view. JList objects are
typically added to a JScrollPane object so the list can be scrolled. You'll see examples of JComboBox
and JList objects in the Calendar example of Listing 13.4.
Sliders and Progress Bars
You were introduced to sliders and progress bars in Chapter 12, "Introducing Swing." The JSlider
and JProgressBar classes do not have AWT analogs. Both classes support horizontal and vertical
orientations. The JProgressBar class is typically used to display the progress of a task, such as the
loading of an image. The JSlider class is used to adjust or monitor the value of a variable within its
allowed interval.
Scrollbars
The JScrollPane greatly simplifies the use of scrollbars. The getViewport() method returns a
JViewport object to which components may be added. In most cases, you simply need to add
components to the JViewport object and they are automatically scrolled. You'll see an example of this
in the Calendar program of Listing 13.4.
Tables
The JTable class is another Swing component that does not have an AWT analog. JTable provides a
very flexible capability for creating and displaying tables. It allows tables to be constructed from
arrays, vectors of objects, or from objects that implement the TableModel interface.
The JTableModel interface defines methods for objects that specify a table's contents. The
AbstractTableModel class provides a default implementation of the JTableModel interface. This class
is typically extended to provide a custom table model implementation. You'll see an example of using
the AbstractTableModel class in the Calendar program of Listing 13.4.
The JTable class provides the capability to edit tables. The setCellEditor() method allows an object of
the TableCellEditor interface to be identified as a table's cell editor.
Calendar
The Calendar program, shown in Listing 13.4, illustrates the use of Swing tables. The program's
opening display is shown in Figure 13.19. It consists of a combo box, list, and a table. When you
select a year from the combo box, the calendar displayed by the table is updated. Select 1999 from
the combo box and the calendar is updated, as shown in Figure 13.20. The selection of a month from
the list also results in the calendar table being updated. Select December from the list to view the
calendar for the end of this millennium, as shown in Figure 13.21.
FIGURE 13.19. The Calendar opening display.
FIGURE 13.20. Selecting a year from the combo box results in a new calendar.
FIGURE 13.21. Selecting a month from the list also results in a new calendar.
Listing 13.4. The Calendar program.
import java.awt.*;
import java.awt.event.*;
import com.sun.java.swing.*;
import com.sun.java.swing.event.*;
import com.sun.java.swing.table.*;
import java.util.Date;
public class Calendar extends JFrame {
public static int WIDTH = 600;
public static int HEIGHT = 400;
public static String TITLE = "Calendar";
Container frameContainer;
// Swing components
String[] years = {"1998","1999","2000","2001",
"2002","2003","2004","2005"};
JComboBox comboBox = new JComboBox(years);
String[] months = {"January","February","March","April","May",
"June","July","August","September","October","November",
"December"};
JList list = new JList(months);
JScrollPane scrollPane = new JScrollPane(list);
CalendarModel model = new CalendarModel();
JTable table = new JTable(model);
JMenuBar menuBar = new JMenuBar();
JMenu fileMenu = new JMenu("File");
JMenuItem fileExit = new JMenuItem("Exit");
public Calendar() {
super(TITLE);
buildGUI();
setupEventHandlers();
setSize(WIDTH,HEIGHT);
show();
}
void buildGUI() {
setupMenuBar();
layoutComponents();
}
void setupMenuBar() {
fileMenu.add(fileExit);
menuBar.add(fileMenu);
setJMenuBar(menuBar);
}
public void layoutComponents() {
frameContainer = getContentPane();
frameContainer.setLayout(null);
comboBox.setBounds(10,10,100,30);
comboBox.setSelectedIndex(0);
comboBox.addItemListener(new ComboHandler());
scrollPane.setBounds(200,10,150,100);
list.setSelectedIndex(3);
list.addListSelectionListener(new ListHandler());
table.setBounds(10,150,550,200);
model.setMonth(comboBox.getSelectedIndex()+1998,
list.getSelectedIndex());
frameContainer.add(comboBox);
frameContainer.add(scrollPane);
table.setGridColor(Color.black);
table.setShowGrid(true);
frameContainer.add(table);
}
void setupEventHandlers() {
addWindowListener(new WindowHandler());
fileExit.addActionListener(new MenuItemHandler());
}
public static void main(String[] args) {
Calendar app = new Calendar();
}
class CalendarModel extends AbstractTableModel {
String[] days = {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
int[] numDays = {31,28,31,30,31,30,31,31,30,31,30,31};
String[][] calendar = new String[7][7];
public CalendarModel() {
for(int i=0;i<days.length;++i)
calendar[0][i]=days[i];
for(int i=1;i<7;++i)
for(int j=0;j<7;++j)
calendar[i][j]=" ";
}
public int getRowCount() {
return 7;
}
public int getColumnCount() {
return 7;
}
public Object getValueAt(int row, int column) {
return calendar[row][column];
}
public void setValueAt(Object value,int row, int column) {
calendar[row][column] = (String) value;
}
public void setMonth(int year,int month) {
for(int i=1;i<7;++i)
for(int j=0;j<7;++j)
calendar[i][j]=" ";
java.util.GregorianCalendar cal =
new java.util.GregorianCalendar();
cal.set(year,month,1);
int offset = cal.get(java.util.GregorianCalendar.DAY_OF_WEEK)-1;
offset += 7;
int num = daysInMonth(year,month);
for(int i=0;i<num;++i) {
calendar[offset/7][offset%7]=Integer.toString(i+1);
++offset;
}
}
public boolean isLeapYear(int year) {
if(year % 4 ==0) return true;
return false;
}
public int daysInMonth(int year,int month) {
int days = numDays[month];
if(month==1 && isLeapYear(year)) ++days;
return days;
}
}
public class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
public class ComboHandler implements ItemListener {
public void itemStateChanged(ItemEvent e) {
model.setMonth(comboBox.getSelectedIndex()+1998,
list.getSelectedIndex());
table.repaint();
}
}
public class ListHandler implements ListSelectionListener {
public void valueChanged(ListSelectionEvent e) {
model.setMonth(comboBox.getSelectedIndex()+1998,
list.getSelectedIndex());
table.repaint();
}
}
public class MenuItemHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
String cmd = e.getActionCommand();
if(cmd.equals("Exit")) System.exit(0);
}
}
}
}
The Calendar program uses the years and months arrays to identify the years and months supported
by the calendar. A JComboBox object is created from the years array and a JList object is created
from the months array. The JList object is used to create a ScrollPane object that supports list
scrolling. The CalendarModel class is an inner class that is used to implement the table's model. An
object of this class is created and assigned to the model variable. A JTable object is created from the
CalendarModel object and assigned to the table variable.
The layoutComponents() method sets the layout of the frame's container to a null layout. It then sets
the bounds, selected index, and event handlers for the combo box and list. The table's bounds are set
and then the table's model is updated based on the year selected in the combo box and month selected
in the list. This is accomplished using the setMonth() method of the CalendarModel class.
The CalendarModel class is used as the table's model. It extends the AbstractTableModel class. It
declares the days array for use in the table's column headings and the numDays array to keep track of
the number of days in each month. The calendar array is set to a seven-row by seven-column array. It
is used to keep track of the table's contents. The CalendarModel() constructor sets the column
headings and then blanks the table's contents.
The getRowCount(), getColumnCount(), getValueAt(), and setValueAt() methods override those of
the AbstractTableModel class.
The setMonth() method updates the calendar array with the contents of the calendar for the specified
year and month. It blanks out the array's contents and creates a GregorianCalendar object for the first
day of the month. It then uses the get() method to determine the day of the week associated with the
first day of the month. The daysInMonth() method returns the number of days in the specified month.
Using this information, setMonth() is able to fill in the array's contents.
The isLeapYear() method is used to identify leap years and the daysInMonth() method returns the
number of days in a month adjusted for leap years.
Trees
One of the most interesting new classes provided by Swing is the JTree class. This class implements
a tree structure that can be used to display hierarchical data. The TreeNode interface defines methods
that are to be implemented by the nodes of a JTree object. The DefaultMutableTreeNode class
provides a default implementation of the TreeNode interface. Trees are created by creating objects of
the TreeNode interface and then adding them together (via the add() method). When all of the
TreeNode objects have been added together, the resulting TreeNode object is passed to the JTree
constructor.
The default rendering of a JTree object uses a folder icon to identify tree nodes that have child nodes
and a file icon to identify tree leaves. The setCellRenderer() method of the JTree class is used to
identify an alternative tree rendering. The setCellRenderer() method takes an object of the
TreeCellRenderer interface as a parameter. The following example shows how to use a custom tree
rendering object.
SwingTree
The SwingTree program, shown in Listing 13.5, illustrates the use of Swing trees. Its opening
window is shown in Figure 13.22. A JTree object is used to display the teams of the National
Basketball association, arranged by conference and division. Click the circles before the conferences
and divisions to expand the tree, as shown in Figure 13.23. Note that scrollbars appear when you
expand the tree to the bottom of its display area. Click any team and the team's win/loss record is
displayed in the text field at the bottom of the window as shown in Figure 13.24.
FIGURE 13.22. The SwingTree initial display.
FIGURE 13.23. Expand the tree and scrollbars are displayed.
FIGURE 13.24. Click a team and the team's record is displayed.
Listing 13.5. The SwingTree program.
import java.awt.*;
import java.awt.event.*;
import com.sun.java.swing.*;
import com.sun.java.swing.event.*;
import com.sun.java.swing.tree.*;
public class SwingTree extends JFrame {
public static int WIDTH = 400;
public static int HEIGHT = 400;
public static String TITLE = "SwingTree";
Container frameContainer;
// Swing components
JTextField textField = new JTextField();
JScrollPane scrollPane = new JScrollPane();
JTree tree;
Renderer renderer = new Renderer();
DefaultMutableTreeNode nba =
new DefaultMutableTreeNode("National Basketball Association");
DefaultMutableTreeNode western =
new DefaultMutableTreeNode("Western Conference");
DefaultMutableTreeNode pacific =
new DefaultMutableTreeNode("Pacific Division Teams");
DefaultMutableTreeNode lalakers =
new DefaultMutableTreeNode("Los Angeles (Lakers)");
DefaultMutableTreeNode seattle =
new DefaultMutableTreeNode("Seattle");
DefaultMutableTreeNode phoenix =
new DefaultMutableTreeNode("Phoenix");
DefaultMutableTreeNode portland =
new DefaultMutableTreeNode("Portland");
DefaultMutableTreeNode sacramento =
new DefaultMutableTreeNode("Sacramento");
DefaultMutableTreeNode goldengate =
new DefaultMutableTreeNode("San Francisco");
DefaultMutableTreeNode laclippers =
new DefaultMutableTreeNode("Los Angeles (Clippers)");
DefaultMutableTreeNode midwest =
new DefaultMutableTreeNode("Midwest Division Teams");
DefaultMutableTreeNode utah =
new DefaultMutableTreeNode("Utah");
DefaultMutableTreeNode sanantonio =
new DefaultMutableTreeNode("San Antonio");
DefaultMutableTreeNode houston =
new DefaultMutableTreeNode("Houston");
DefaultMutableTreeNode minnesota =
new DefaultMutableTreeNode("Minnesota");
DefaultMutableTreeNode vancouver =
new DefaultMutableTreeNode("Vancouver");
DefaultMutableTreeNode dallas =
new DefaultMutableTreeNode("Dallas");
DefaultMutableTreeNode denver =
new DefaultMutableTreeNode("Denver");
DefaultMutableTreeNode eastern =
new DefaultMutableTreeNode("Eastern Conference");
DefaultMutableTreeNode atlantic =
new DefaultMutableTreeNode("Atlantic Division Teams");
DefaultMutableTreeNode miami =
new DefaultMutableTreeNode("Miami");
DefaultMutableTreeNode ny =
new DefaultMutableTreeNode("New York");
DefaultMutableTreeNode nj =
new DefaultMutableTreeNode("New Jersey");
DefaultMutableTreeNode washington =
new DefaultMutableTreeNode("Washington");
DefaultMutableTreeNode orlando =
new DefaultMutableTreeNode("Orlando");
DefaultMutableTreeNode boston =
new DefaultMutableTreeNode("Boston");
DefaultMutableTreeNode philadelphia =
new DefaultMutableTreeNode("Philadelphia");
DefaultMutableTreeNode central =
new DefaultMutableTreeNode("Central Division Teams");
DefaultMutableTreeNode chicago =
new DefaultMutableTreeNode("Chicago");
DefaultMutableTreeNode indiana =
new DefaultMutableTreeNode("Indiana");
DefaultMutableTreeNode charlotte =
new DefaultMutableTreeNode("Charlotte");
DefaultMutableTreeNode atlanta =
new DefaultMutableTreeNode("Atlanta");
DefaultMutableTreeNode cleveland =
new DefaultMutableTreeNode("Cleveland");
DefaultMutableTreeNode detroit =
new DefaultMutableTreeNode("Detroit");
DefaultMutableTreeNode milwaukee =
new DefaultMutableTreeNode("Milwaukee");
DefaultMutableTreeNode toronto =
new DefaultMutableTreeNode("Toronto");
JMenuBar menuBar = new JMenuBar();
JMenu fileMenu = new JMenu("File");
JMenuItem fileExit = new JMenuItem("Exit");
public SwingTree() {
super(TITLE);
buildGUI();
setupEventHandlers();
setSize(WIDTH,HEIGHT);
show();
}
void buildGUI() {
setupMenuBar();
setupTree();
layoutComponents();
}
void setupMenuBar() {
fileMenu.add(fileExit);
menuBar.add(fileMenu);
setJMenuBar(menuBar);
}
void setupTree() {
nba.add(western);
nba.add(eastern);
western.add(pacific);
western.add(midwest);
eastern.add(atlantic);
eastern.add(central);
pacific.add(lalakers);
pacific.add(laclippers);
pacific.add(goldengate);
pacific.add(seattle);
pacific.add(phoenix);
pacific.add(portland);
pacific.add(sacramento);
midwest.add(utah);
midwest.add(sanantonio);
midwest.add(houston);
midwest.add(minnesota);
midwest.add(vancouver);
midwest.add(dallas);
midwest.add(denver);
atlantic.add(miami);
atlantic.add(ny);
atlantic.add(nj);
atlantic.add(washington);
atlantic.add(orlando);
atlantic.add(boston);
atlantic.add(philadelphia);
central.add(chicago);
central.add(indiana);
central.add(charlotte);
central.add(atlanta);
central.add(cleveland);
central.add(detroit);
central.add(milwaukee);
central.add(toronto);
tree = new JTree(nba);
}
public void layoutComponents() {
frameContainer = getContentPane();
frameContainer.setLayout(new BorderLayout());
tree.setCellRenderer(renderer);
tree.addTreeSelectionListener(new TreeHandler());
scrollPane.getViewport().add(tree);
frameContainer.add("Center",scrollPane);
frameContainer.add("South",textField);
}
void setupEventHandlers() {
addWindowListener(new WindowHandler());
fileExit.addActionListener(new MenuItemHandler());
}
public static void main(String[] args) {
SwingTree app = new SwingTree();
}
public class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
public class MenuItemHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
String cmd = e.getActionCommand();
if(cmd.equals("Exit")) System.exit(0);
}
}
public class TreeHandler implements TreeSelectionListener {
public void valueChanged(TreeSelectionEvent e) {
TreePath path = e.getPath();
String text = path.getPathComponent(
path.getPathCount()-1).toString();
if(path.getPathCount()>3) {
text += ": ";
text += Integer.toString((int)(Math.random()*50))+" Wins ";
text += Integer.toString((int)(Math.random()*50))+" Losses";
}
textField.setText(text);
}
}
class Renderer extends JLabel implements TreeCellRenderer {
public Component getTreeCellRendererComponent(JTree tree,
Object value, boolean selected, boolean expanded,
boolean leaf, int row, boolean hasFocus) {
setText(value.toString()+"
");
return this;
}
}
}
The SwingTree program uses a TextField object to display team selections, a ScrollPane object to
support scrolling for the tree, a JTree object to implement the tree, and a Renderer object to control
the way the tree is rendered. The Renderer class is declared as an inner class.
The nodes and leaves of the tree are implemented as DefaultMutableTreeNode objects. These objects
are created with the names of NBA teams and organizational groupings. The setupTree() method
connects the DefaultMutableTreeNode objects into the nodes of the tree. A new JTree object is
created at the end of setupTree() method. This object is created from the tree's root node and assigned
to the tree variable.
The layoutComponents() method lays out the frame's container using a BorderLayout object. The
setCellRenderer() method sets the rendering object of the tree to the Renderer object referenced by
the renderer variable. An object of the TreeHandler class is used to handle the selection of elements
of the tree. The tree is then added to the view port of a scroll pane.
The valueChanged() method of the TreeHandler class handles the selection of elements of the tree by
using the getPathComponent() method to get the path selected by the user and the getPathCount()
method to identify the length of this path. The last element of the path is set as the text of the text
field. If the element is a team (in other words, at the fourth level of the tree), random win/loss
statistics are displayed along with the team's name.
Swing Event Handling
Swing events are handled using the event delegation model introduced by JDK 1.1. The event
inheritance model of JDK 1.0 cannot be used with Swing. The com.sun.java.swing.event package
defines a number of event listening interfaces and event classes for use with Swing components. In
addition, many Swing components also use AWT events. The Swing events defined in the com.sun.
java.swing.event package are the following:
●
AncestorEvent Generated when an ancestors of a JComponent is added, removed, or moved
●
ChangeEvent Generated when an object's state is changed
●
DragEvent Generated as the result of the dragging of an object
●
ListDataEvent Generated as the result of changes to list data
●
ListSelectionEvent Generated as the result of a change in a list selection
●
MenuEvent Generated as the result of the posting, selection, or canceling of a menu
●
TableColumnModelEvent Generated as the result of a change in a table column model
●
TableModelEvent Generated as the result of a change in a table model
●
TreeExpansionEvent Generated as the result of a change in a tree's expansion
●
TreeModelEvent Generated as the result of a change in a tree model
●
TreeSelectionEvent Generated as the result of a change in a tree selection
The com.sun.java.swing.event package defines event listener interfaces for the above events. The
next chapter covers the Model View Controller (MVC) used by Swing components.
Swing Applets
The JApplet class is the Swing analog of the Applet class. JApplet is similar to JFrame in that it
supports a separate content pane. This container is accessed via the getContentPane() method. If you
ever wished you could use menus in an applet, you'll love the JApplet class. It provides the capability
to use a menu bar with an applet via the setJMenuBar method. The menu bar must be an object of the
JMenuBar class.
CalendarApplet
The CalendarApplet applet, shown in Listing 13.6, is an applet conversion of the Calendar
application of Listing 13.4. CalendarApplet illustrates the menu feature of the JApplet class. The
calendar.htm file of Listing 13.7 is used to display CalendarApplet using the appletviewer.
Figure 13.25 shows the opening display of CalendarApplet. Note the addition of the Year and Month
menus at the top of the applet display area. The inability to include menus in applets was a
shortcoming of the Applet class. This shortcoming is removed by JApplet. Select the year 2002 from
the Year pull-down menu. The calendar is updated to display a calendar for April 2002, as shown in
Figure 13.26. Note that the year displayed by the combo box is also updated.
FIGURE 13.25. The CalendarApplet initial display.
FIGURE 13.26. Selecting a menu item from the Year menu causes the calendar and combo box to be
updated.
Select March from the Month menu. The calendar is updated to display March 2002, as shown in
Figure 13.27. Also note that the list identifies the month of March as being selected.
FIGURE 13.27. Selecting a menu item from the Month menu causes the calendar and list to be
updated.
Listing 13.6. The CalendarApplet applet.
import java.awt.*;
import java.awt.event.*;
import com.sun.java.swing.*;
import com.sun.java.swing.event.*;
import com.sun.java.swing.table.*;
import java.util.Date;
public class CalendarApplet extends JApplet {
public static int WIDTH = 600;
public static int HEIGHT = 400;
Container frameContainer;
// Swing components
String[] years = {"1998","1999","2000","2001",
"2002","2003","2004","2005"};
JComboBox comboBox = new JComboBox(years);
String[] months = {"January","February","March","April","May",
"June","July","August","September","October","November",
"December"};
JList list = new JList(months);
JScrollPane scrollPane = new JScrollPane(list);
CalendarModel model = new CalendarModel();
JTable table = new JTable(model);
JMenuBar menuBar = new JMenuBar();
JMenu yearMenu = new JMenu("Year");
JMenu monthMenu = new JMenu("Month");
JMenuItem[] yearMenuItems = new JMenuItem[years.length];
JMenuItem[] monthMenuItems = new JMenuItem[months.length];
public CalendarApplet() {
buildGUI();
setupEventHandlers();
setSize(WIDTH,HEIGHT);
}
void buildGUI() {
setupMenuBar();
layoutComponents();
}
void setupMenuBar() {
for(int i=0;i<years.length;++i) {
yearMenuItems[i] = new JMenuItem(years[i]);
yearMenu.add(yearMenuItems[i]);
}
for(int i=0;i<months.length;++i) {
monthMenuItems[i] = new JMenuItem(months[i]);
monthMenu.add(monthMenuItems[i]);
}
menuBar.add(yearMenu);
menuBar.add(monthMenu);
setJMenuBar(menuBar);
}
public void layoutComponents() {
frameContainer = getContentPane();
frameContainer.setLayout(null);
comboBox.setBounds(10,10,100,30);
comboBox.setSelectedIndex(0);
comboBox.addItemListener(new ComboHandler());
scrollPane.setBounds(200,10,150,100);
list.setSelectedIndex(3);
list.addListSelectionListener(new ListHandler());
table.setBounds(10,150,550,200);
model.setMonth(comboBox.getSelectedIndex()+1998,
list.getSelectedIndex());
frameContainer.add(comboBox);
frameContainer.add(scrollPane);
table.setGridColor(Color.black);
table.setShowGrid(true);
frameContainer.add(table);
}
void setupEventHandlers() {
for(int i=0;i<yearMenuItems.length;++i)
yearMenuItems[i].addActionListener(new YearMenuItemHandler());
for(int i=0;i<monthMenuItems.length;++i)
monthMenuItems[i].addActionListener(new MonthMenuItemHandler());
}
class CalendarModel extends AbstractTableModel {
String[] days = {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
int[] numDays = {31,28,31,30,31,30,31,31,30,31,30,31};
String[][] calendar = new String[7][7];
public CalendarModel() {
for(int i=0;i<days.length;++i)
calendar[0][i]=days[i];
for(int i=1;i<7;++i)
for(int j=0;j<7;++j)
calendar[i][j]=" ";
}
public int getRowCount() {
return 7;
}
public int getColumnCount() {
return 7;
}
public Object getValueAt(int row, int column) {
return calendar[row][column];
}
public void setValueAt(Object value,int row, int column) {
calendar[row][column] = (String) value;
}
public void setMonth(int year,int month) {
for(int i=1;i<7;++i)
for(int j=0;j<7;++j)
calendar[i][j]=" ";
java.util.GregorianCalendar cal =
new java.util.GregorianCalendar();
cal.set(year,month,1);
int offset = cal.get(java.util.GregorianCalendar.DAY_OF_WEEK)-1;
offset += 7;
int num = daysInMonth(year,month);
for(int i=0;i<num;++i) {
calendar[offset/7][offset%7]=Integer.toString(i+1);
++offset;
}
}
public boolean isLeapYear(int year) {
if(year % 4 ==0) return true;
return false;
}
public int daysInMonth(int year,int month) {
int days = numDays[month];
if(month==1 && isLeapYear(year)) ++days;
return days;
}
}
public class ComboHandler implements ItemListener {
public void itemStateChanged(ItemEvent e) {
model.setMonth(comboBox.getSelectedIndex()+1998,
list.getSelectedIndex());
table.repaint();
}
}
public class ListHandler implements ListSelectionListener {
public void valueChanged(ListSelectionEvent e) {
model.setMonth(comboBox.getSelectedIndex()+1998,
list.getSelectedIndex());
table.repaint();
}
}
public class YearMenuItemHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
String cmd = e.getActionCommand();
int year = (new Integer(cmd)).intValue() - 1998;
comboBox.setSelectedIndex(year);
model.setMonth(comboBox.getSelectedIndex()+1998,
list.getSelectedIndex());
table.repaint();
}
}
public class MonthMenuItemHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
String cmd = e.getActionCommand();
int month = 0;
for(int i=0;i<months.length;++i) {
if(cmd.equals(months[i])) {
month = i;
break;
}
}
list.setSelectedIndex(month);
model.setMonth(comboBox.getSelectedIndex()+1998,
list.getSelectedIndex());
table.repaint();
}
}
}
The CalendarApplet class is based on the Calendar class of Listing 13.4. Instead of extending
JFrame, CalendarApplet extends JApplet. The only other significant difference between
CalendarApplet and Calendar is the use of the Year and Month menus. These menus are set up in the
setupMenuBar() and setupEventHandlers() methods. Note that separate classes are used to handle the
Year and Month menu items.
The actionPerformed() method of the YearMenuItemHandler class determines the year that was
selected and sets the corresponding index in the combo box. The table's model is updated based upon
the indexes of the combo box and list. The repaint() method is invoked to cause the table to be
redisplayed.
The actionPerformed() method of the MonthMenuItemHandler class is similar to that of the
YearMenuItemHandler class. The month that was selected is determined and the corresponding index
in the list is set. The table's model is then updated and the repaint() method is invoked.
LISTING 13.7. THE calendar.htm FILE.
<HTML>
<HEAD>
<TITLE>Calendar Applet</TITLE>
</HEAD>
<BODY>
<APPLET CODE="CalendarApplet.class" HEIGHT=400 WIDTH=600>
</APPLET>
</BODY>
</HTML>
Converting to Swing
Because Swing provides GUI components that are analogous to AWT components, it is easy to
convert applications and applets to Swing. Applications are converted to Swing by replacing the
Frame class with the JFrame class and using getContentPane() to access the frame's container. GUI
components that were added to the Frame are added to the frame container. Applets are converted in
a similar manner with the JApplet class replacing the Applet class. Most AWT GUI components can
be converted to Swing by simply preceding the AWT class name with the letter `J'.
Once you convert your AWT components to Swing components you may want to substitute new
Swing components, such as sliders, trees, and tables to reduce the complexity of your user interface.
You may also want to use icons with buttons, labels, and other components to make the interface
more attractive and usable. Finally, you should experiment with borders and other Swing features that
contribute to your application's or applet's look and feel.
Summary
In this chapter you learned about Swing windows, menus, toolbars, tables, trees, and other GUI
components. You learned about Swing events and how the JApplet class supports the development of
applets that use Swing components. You also learned how to convert your existing applications and
applets to Swing. In the next chapter, Chapter 14, "Changing the Look and Feel of Your Swing
Components" you'll learn about Swing's pluggable look and feel capabilities.
© Copyright, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
- 14 Changing the Look and Feel of Your Swing
Components
●
●
●
●
●
●
Look and Feel Explained
The Model-View-Controller Architecture
❍ Combining the View and the Controller
Changing Look and Feel
❍ The SwingLF Application
Changing the Model
Look and Feel Programming
❍ The RedButtonUI Class
❍ Testing the Look and Feel
Summary
Swing is a powerful enhancement to the AWT because it provides a rich set of platform independent
GUI components. Platform independence ensures that Swing components are supported in the same
manner across all Java ports. Platform independence also enables the look-and-feel (L&F) of Swing
components to be easily tailored. This feature, referred to as Pluggable Look and Feel (PL&F), lets
you create applets and applications that use a look and feel that is independent of the windowing
platform in which the applets and applications are executed. For example, you can create applications
that use a Macintosh look and feel when they are executed on a Windows platform, and you can
create applets that use a Motif look and feel no matter what browsers or windowing systems are used
to run them.
This chapter covers PL&F. It explains what look and feel is and how the model-view-controller
(MVC) architecture is used to achieve PL&F. It introduces you to the Swing classes and interfaces
that implement PL&F and shows you how to change an applet or application's look and feel. It also
shows you how to develop your own look and feel. When you finish this chapter, you'll be able to use
PL&F to enhance the style and consistency of the applets and applications you develop.
Look and Feel Explained
The look and feel of a program consists of the way the program presents itself to the user (its look)
and the way the user interacts with it (its feel). Most programs display their output to the user's
console and receive input from a keyboard and pointer device (mouse or equivalent). However, look
and feel is subtler than raw input and output.
Many operating systems, such as Microsoft Windows, Macintosh OS, and UNIX, support windowing
systems, which allow windows to be opened, closed, moved, and sized based on keyboard and mouse
operations. They also support GUI components, such as labels, buttons, text fields, and menus.
However, look and feel is subtler still.
Look and feel is determined by how a window or other GUI component is displayed and how it
responds to user input. The GUI components of Microsoft Windows share a display style and
operational behavior that set them apart from the equivalent components of the Macintosh. We can
look at a screen capture and determine whether it came from Microsoft Windows or Macintosh based
on its look. We can interact with a GUI and identify it as Motif based upon its feel. We notice slight
differences in the controls used with windows, the way menus are displayed, and the way buttons
behave when clicked that enable us to make these decisions. These differences are what constitute
look and feel.
The Model-View-Controller Architecture
Swing provides the capability to change the look and feel of an applet or application. This capability
stems from the fact that Swing components (unlike AWT components) are not tied to the GUI
components of the native windowing system. This capability allows you to create applets or
applications that will use a specific look and feel (such as Motif) no matter whether the applet or
application executes on a Macintosh, a UNIX system, or a PC. Figure 14.1 provides an example of a
Java program that uses the Motif look and feel but executes under Windows 95. Figure 14.2 shows
the very same program but with a Windows look and feel. The capability to easily change look and
feel, referred to as pluggable look and feel (PL&F), also allows custom look and feel to be developed.
For example, Swing defines the Metal look and feel as the standard look and feel for Java applets and
applications that use Swing components. The Metal look and feel is named for the shiny sharp
characteristics of its GUI components. Figure 14.3 provides an example of the Metal look and feel.
FIGURE 14.1. The Motif look and feel.
FIGURE 14.2. The Windows look and feel.
Figure 14.3. The Metal look and feel.
PL&F is implemented in terms of the model-view-controller (MVC) architecture. MVC is a software
architecture that separates the state of an object (the model), the way the object is displayed to the
user (the view), and the way that the object's state is updated (the controller). By separating these
three perspectives, it is possible to define GUI components that are equivalent in terms of information
state (model), but are displayed (view) and respond to the user (controller) in different ways. For
example, a button's state may be defined in terms of a text label, an icon graphic, and whether the
button is being clicked. The button's view can allow the button's label and icon to be displayed in a
great variety of ways: square button, round button, etched button, label-only, text-only, different
colors, and so on. The button's controller can cause the clicking of the button to be clicked in
different ways: single-click, double-click, right-click, left-click, and so on.
By separating the model from its view and controller, Swing allows logically equivalent buttons to be
implemented but rendered with different look and feels. MVC provides other advantages. For
example, you can define a single GUI component with multiple simultaneous views. As another
example, you can define a component that provides a separate controller for disabled users.
Combining the View and the Controller
In implementing PL&F, Swing allows GUI components to be tailored in terms of their model and
L&F. L&F is a function of view and controller. The L&F of a component is implemented in terms of
a delegate, which is the object that is used to display the component and interact with the user. The
delegate encapsulates view and controller as a single object. This eliminates the need for all views to
support all controllers, allowing L&F to exhibit richer, more varied behavior.
Each Swing component (subclass of JComponent) is defined in terms of a unique model and
delegate. For example, the models of JButton components must implement the ButtonModel
interface. However, this interface may be implemented in different ways by different classes. The
model of a component is accessed via the getModel() and setModel() methods. Similarly, the
delegates of JButton components must implement the ButtonUI interface. This interface can be
implemented in different ways by different classes, thereby making PL&F possible for the JButton
class. The delegate of a component is accessed via the getUI() and setUI() methods.
Changing Look and Feel
Delegates provide the basis for changing look and feel. In order to change the look and feel of a
component, all you need to do is change the component's delegate. You change the component's
delegate via the setUI() method. Consider the following example:
JButton button = new JButton("My Button");
button.setUI(new MotifButtonUI());
The button's delegate is changed to an object of the MotifButtonUI object.
The question naturally arises, "What delegates are available for a particular component?" The answer
to this question lies in the PL&F packages that come with JDK 1.2 and the PL&F packages that you
install. We'll cover the development and installation of custom PL&F packages later in this chapter in
the section, "Look and Feel Programming." The PL&F packages that come with JDK 1.2 are as
follows:
●
com.sun.java.swing.plaf.basic The Basic look and feel
●
com.sun.java.swing.plaf.mac The Macintosh look and feel
●
com.sun.java.swing.plaf.motif The Motif look and feel
●
com.sun.java.swing.plaf.windows The Windows look and feel
●
com.sun.java.swing.plaf.organic The Organic look and feel
●
com.sun.java.swing.plaf.metal The Metal look and feel
The Macintosh, Motif, and Windows looks and feels are modeled after the looks and feels of popular
windowing systems. The Basic, Organic, and Metal looks and feels are Java-specific. Each look and
feel package provides classes that implement the delegate interfaces of Swing components. For
example, the com.sun.java.swing.plaf.motif package provides the MotifButtonUI class and the com.
sun.java.swing.plaf.metal package provides the MetalButtonUI class.
Delegate classes allow you to change the look and feel of a single component or a group of
components (one component at a time). But what if you want to change the look and feel for all of
your components? The UIManager class of com.sun.java.swing provides the solution. The static
setLookAndFeel() method of UIManager lets you set the look and feel of all of the components used
by an applet or application. For example, the following statement sets the look and feel to the Motif
look and feel.
try {
UIManager.setLookAndFeel("com.sun.java.swing.plaf.Motif");
}catch(Exception ex){
System.out.println(ex);
}
There are two versions of setLookAndFeel(). One version takes the name of a look and feel package
as a parameter. The other version takes the name of an object of the LookAndFeel class as a
parameter. The first version throws the LookAndFeelException and the second version throws the
ClassNotFound exception. After setting the look and feel, your GUI components must update their
delegates to the new look and feel. The easiest way to do this is to invoke the static
updateComponentTreeUI() method of the SwingUtilities class. This method asks each component
that is contained in the component (or its subcomponents) passed as a parameter to update its
delegate. For example, if this refers to a JFrame or JApplet object, all components contained in the
application or applet will update their delegate to the new look and feel.
SwingUtilities.updateComponentTreeUI(this);
The next section provides an example application that changes its look and feel under user control.
The SwingLF Application
The SwingLF application, shown in Listing 14.1, shows how look and feel can be dynamically
changed during program execution. When you run the program, it uses the default Metal look and
feel, as shown in Figure 14.4. Play around with the menus and GUI controls to familiarize yourself
with the Metal L&F. When you are finished, click the Motif button, and the program changes its look
and feel to the Motif L&F, as shown in Figure 14.5. If you are not already familiar with Motif, you
may want to take the time to familiarize yourself at this time. Finally, click the Windows button, and
the program changes its look and feel to the Windows look and feel, as shown in Figure 14.6. Which
L&F do you prefer? I find the Metal L&F to be very appealing. Compared to Metal, the Windows
L&F appears pretty boring.
FIGURE 14.4. The Metal L&F is the program's default L&F.
FIGURE 14.5. The Motif L&F as displayed by SwingLF.
FIGURE 14.6. SwingLF also displays the Windows L&F.
Listing 14.1. The SwingLF application.
import java.awt.*;
import java.awt.event.*;
import com.sun.java.awt.swing.*;
import com.sun.java.awt.swing.event.*;
import com.sun.java.awt.swing.border.*;
import com.sun.java.awt.swing.plaf.motif.*;
import com.sun.java.awt.swing.plaf.metal.*;
import com.sun.java.awt.swing.plaf.windows.*;
public class SwingLF extends JFrame {
public static int WIDTH = 450;
public static int HEIGHT = 450;
public static String TITLE = "SwingLF";
Container frameContainer;
// Swing components
JPanel[] panels = new JPanel[6];
JCheckBox checkbox1 = new JCheckBox("Check 1");
JCheckBox checkbox2 = new JCheckBox("Check 2");
JCheckBox checkbox3 = new JCheckBox("Check 3");
ButtonGroup buttonGroup = new ButtonGroup();
JRadioButton radioButton1 = new JRadioButton("Radio 1");
JRadioButton radioButton2 = new JRadioButton("Radio 2");
JRadioButton radioButton3 = new JRadioButton("Radio 3");
JTextField textField1 = new JTextField("Text field 1",15);
JTextField textField2 = new JTextField("Text field 2",15);
JSlider slider1 = new JSlider(0,0,100,25);
JSlider slider2 = new JSlider(0,0,100,75);
JButton metalButton = new JButton("Metal");
JButton motifButton = new JButton("Motif");
JButton windowsButton = new JButton("Windows");
JMenuBar menuBar = new JMenuBar();
JMenu fileMenu = new JMenu("File");
JMenuItem fileNew = new JMenuItem("New");
JMenuItem fileOpen = new JMenuItem("Open");
JMenuItem fileSave = new JMenuItem("Save");
JMenuItem fileExit = new JMenuItem("Exit");
JMenu editMenu = new JMenu("Edit");
JMenuItem editCut = new JMenuItem("Cut");
JMenuItem editCopy = new JMenuItem("Copy");
JMenuItem editPaste = new JMenuItem("Paste");
//Look and Feel Classes
MetalLookAndFeel metalLF = new MetalLookAndFeel();
MotifLookAndFeel motifLF = new MotifLookAndFeel();
WindowsLookAndFeel windowsLF = new WindowsLookAndFeel();
public SwingLF() {
super(TITLE);
buildGUI();
setupEventHandlers();
setSize(WIDTH,HEIGHT);
show();
}
void buildGUI() {
setupMenuBar();
layoutComponents();
}
void setupMenuBar() {
fileMenu.add(fileNew);
fileMenu.add(fileOpen);
fileMenu.add(fileSave);
fileMenu.add(fileExit);
editMenu.add(editCut);
editMenu.add(editCopy);
editMenu.add(editPaste);
menuBar.add(fileMenu);
menuBar.add(editMenu);
setJMenuBar(menuBar);
}
public void layoutComponents() {
for(int i=0;i<panels.length;++i)
panels[i] = new JPanel();
panels[0].setBorder(new TitledBorder("Checkboxes"));
panels[0].setLayout(new GridLayout(3,1));
panels[0].add(checkbox1);
panels[0].add(checkbox2);
panels[0].add(checkbox3);
panels[1].setBorder(new TitledBorder("Radio Buttons"));
panels[1].setLayout(new GridLayout(3,1));
panels[1].add(radioButton1);
panels[1].add(radioButton2);
panels[1].add(radioButton3);
panels[2].setBorder(new TitledBorder("Text Fields"));
panels[2].add(textField1);
panels[2].add(textField2);
panels[3].setBorder(new TitledBorder("Sliders"));
panels[3].add(slider1);
panels[3].add(slider2);
panels[4].setLayout(new GridLayout(3,1));
panels[4].add(metalButton);
panels[4].add(motifButton);
panels[4].add(windowsButton);
frameContainer = getContentPane();
frameContainer.setLayout(new GridLayout(3,2));
for(int i=0;i<panels.length;++i) frameContainer.add(panels[i]);
}
void setupEventHandlers() {
addWindowListener(new WindowHandler());
fileExit.addActionListener(new MenuItemHandler());
metalButton.addActionListener(new ButtonHandler());
motifButton.addActionListener(new ButtonHandler());
windowsButton.addActionListener(new ButtonHandler());
}
public static void main(String[] args) {
SwingLF app = new SwingLF();
}
public class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
public class MenuItemHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
}
public class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
String cmd = e.getActionCommand();
if(cmd.equals("Motif")) {
try {
UIManager.setLookAndFeel(motifLF);
SwingUtilities.updateComponentTreeUI(SwingLF.this);
}catch(Exception ex){
System.out.println(ex);
}
}else if(cmd.equals("Metal")) {
try {
UIManager.setLookAndFeel(metalLF);
SwingUtilities.updateComponentTreeUI(SwingLF.this);
}catch(Exception ex){
System.out.println(ex);
}
}else if(cmd.equals("Windows")) {
try {
UIManager.setLookAndFeel(windowsLF);
SwingUtilities.updateComponentTreeUI(SwingLF.this);
}catch(Exception ex){
System.out.println(ex);
}
}
}
}
}
SwingLF begins by importing the packages that are used to implement the various L&Fs. It then
declares the class constants and the Swing components to be displayed in the application window.
You should be familiar with these components from Chapter 12, "Introducing Swing," and Chapter
13, "Working with Swing Components." Three look and feel variables are declared and used to refer
to objects of the MetalLookAndFeel, MotifLookAndFeel, and WindowsLookAndFeel classes.
The SwingLF constructor sets its title, invokes buildGUI() to build the application's GUI and
setupEventHandlers() to set up event handling, and then sizes and displays the window.
The buildGUI() method simply invokes setupMenuBar() and layoutComponents(). The setupMenuBar
() method sets up the application's menu bar and the layoutComponents() method adds and arranges
the previously declared Swing components to the application's GUI.
The setupEventHandlers()method sets up the event handling for the window's closing, the Exit menu
item, and the three buttons. Only the ButtonHandler is of interest. The clicking of a button is handled
by invoking getActionCommand() to get the label of the button that was clicked. The program's look
and feel is then changed based on the button. The static setLookAndFeel() method of UIManager is
used to change the look and feel. The static updateComponentTreeUI() method of SwingUtilities is
used to notify the program's GUI controls to update their L&F to the new delegates.
Changing the Model
Changing the delegate of a component results in a change in the component's look and feel. You can
also change a component's model. However, this is rarely done because the state of a label, button,
text field and other GUI components tends to be the same from platform-to-platform and across
various look and feels. However, there are times when you may want to add state information to a
component's model. As a hypothetical example, suppose you want to develop an animated button. In
this case, you may want to store the button's animation frames as part of its model. Any new
implementation of a component's model must implement the interface associated with that model. For
example, the hypothetical AnimatedButton model would need to implement the ButtonModel
interface. You could then change a button's model to AnimatedButton using the setModel() method,
as follows:
JButton myCoolButton = new JButton("Cool Button");
myCoolButton.setModel(new AnimatedButton("frames.zip"));
The model of myCoolButton is set to an object of the AnimatedButton class. This object is created
using the frames.zip file as an argument. This file would contain the frames of the animation
sequence.
Look and Feel Programming
Now that you know what look and feel is, how it is implemented in terms of the MVC architecture,
and how to use different looks and feels, you're probably wondering how you would go about
developing your own look and feel. The answer is to create delegate classes for the components of
your look and feel. The easiest way to do this is to extend an existing look and feel, such as the Basic
L&F. You can then change selected GUI components and leave the others as they are. You would
need to override some methods of the BasicLookAndFeel class and use the initClassDefaults()
method to map component classes to your look and feel delegates.
Listing 14.2 shows the RedLookAndFeel class, which extends the BasicLookAndFeel class. This
class overrides most of the methods inherited from BasicLookAndFeel.
●
getName() Returns the name of the L&F
●
getDescription() Returns a description of the L&F
●
getID() Returns an identifier for the L&F
●
isNativeLookAndFeel() Identifies the L&F as non-native
●
isSupportedLookAndFeel() Identifies the L&F as supported
●
initClassDefaults() Identifies that the RedButtonUI class is to be used where objects of the
ButtonUI are required
The initClassDefaults() method is used to modify the default mapping between delegate interfaces
and the L&F classes that implement those interfaces. The only change to the delegate mapping is the
RedButtonUI class used to implement the look and feel for buttons. Whenever an object of the
ButtonUI is required, an object of the RedButtonUI is used.
LISTING 14.2. THE RedLookAndFeel CLASS.
import java.awt.*;
import java.awt.event.*;
import com.sun.java.awt.swing.*;
import com.sun.java.awt.swing.event.*;
import com.sun.java.awt.swing.plaf.*;
import com.sun.java.awt.swing.plaf.basic.*;
public class RedLookAndFeel extends BasicLookAndFeel {
public RedLookAndFeel() {
super();
}
public String getName() {
return "Red Look and Feel";
}
public String getDescription() {
return "The Red Look and Feel";
}
public String getID() {
return "RedLookAndFeel";
}
public boolean isNativeLookAndFeel() {
return false;
}
public boolean isSupportedLookAndFeel() {
return true;
}
protected void initClassDefaults(UIDefaults table) {
super.initClassDefaults(table);
table.put("ButtonUI", "RedButtonUI");
}
}
The RedButtonUI Class
The RedButtonUI class (Listing 14.3) implements the button delegate for the RedLookAndFeel. All
other delegates are inherited from BasicLookAndFeel. The RedButtonUI class extends the
BasicButtonUI class of com.sun.java.swing. plaf.basic.
The static createUI() method is overridden to return an object of the RedButtonUI class.
The paintFocus() method is overridden to paint a red square around the perimeter of the button. The
thickness of the red square is 5% of the button's height and 10% of the button's width.
Listing 14.3. The REDBUTTONUI class.
import java.awt.*;
import java.awt.event.*;
import com.sun.java.awt.swing.*;
import com.sun.java.awt.swing.event.*;
import com.sun.java.awt.swing.plaf.*;
import com.sun.java.awt.swing.plaf.basic.*;
public class RedButtonUI extends BasicButtonUI {
public RedButtonUI() {
super();
}
public static ComponentUI createUI(JComponent c) {
return new RedButtonUI();
}
public void paintFocus(Graphics g, Dimension size) {
Color color = g.getColor();
g.setColor(Color.red);
int hpercentage = 5;
int wpercentage = 10;
int w = size.width;
int h = size.height;
int sw = w/wpercentage;
int sh = h/hpercentage;
g.fillRect(0,0,w,sh);
g.fillRect(0,0,sw,h);
g.fillRect(w-sw,0,sw,h);
g.fillRect(0,h-sh,w,sh);
g.setColor(color);
}
}
Testing the Look and Feel
The MyLF program, shown in Listing 14.4, extends the SwingLF program of Listing 14.1 to use the
RedLookAndFeel. When you run the program, it displays the opening window shown in Figure 14.7.
Note the additional Red button. Click the Red button to use the Red look and feel. The Red look and
feel uses the basic look and feel, except that it displays a red square around a button when it has the
input focus, as shown in Figure 14.8.
FIGURE 14.7. The opening display of the MyLF program.
FIGURE 14.8. Switching to the RedLookAndFeel.
Press the Tab key to move the input focus to the Windows button.
Only a few changes are required to upgrade SwingLF to MyLF. The Red button is created, assigned
an event handler, and displayed. The actionPerformed() method of ButtonHandler is updated to
process the handling of the Red button and change the look and feel to the RedLookAndFeel class.
LISTING 14.4. THE MyLF PROGRAM.
import java.awt.*;
import java.awt.event.*;
import com.sun.java.awt.swing.*;
import com.sun.java.awt.swing.event.*;
import com.sun.java.awt.swing.border.*;
import com.sun.java.awt.swing.plaf.motif.*;
import com.sun.java.awt.swing.plaf.metal.*;
import com.sun.java.awt.swing.plaf.windows.*;
public class MyLF extends JFrame {
public static int WIDTH = 450;
public static int HEIGHT = 450;
public static String TITLE = "MyLF";
Container frameContainer;
// Swing components
JPanel[] panels = new JPanel[6];
JCheckBox checkbox1 = new JCheckBox("Check 1");
JCheckBox checkbox2 = new JCheckBox("Check 2");
JCheckBox checkbox3 = new JCheckBox("Check 3");
ButtonGroup buttonGroup = new ButtonGroup();
JRadioButton radioButton1 = new JRadioButton("Radio 1");
JRadioButton radioButton2 = new JRadioButton("Radio 2");
JRadioButton radioButton3 = new JRadioButton("Radio 3");
JTextField textField1 = new JTextField("Text field 1",15);
JTextField textField2 = new JTextField("Text field 2",15);
JSlider slider1 = new JSlider(0,0,100,25);
JSlider slider2 = new JSlider(0,0,100,75);
JButton metalButton = new JButton("Metal");
JButton motifButton = new JButton("Motif");
JButton windowsButton = new JButton("Windows");
JButton redButton = new JButton("Red");
JMenuBar menuBar = new JMenuBar();
JMenu fileMenu = new JMenu("File");
JMenuItem fileNew = new JMenuItem("New");
JMenuItem fileOpen = new JMenuItem("Open");
JMenuItem fileSave = new JMenuItem("Save");
JMenuItem fileExit = new JMenuItem("Exit");
JMenu editMenu = new JMenu("Edit");
JMenuItem editCut = new JMenuItem("Cut");
JMenuItem editCopy = new JMenuItem("Copy");
JMenuItem editPaste = new JMenuItem("Paste");
//Look and Feel Classes
MetalLookAndFeel metalLF = new MetalLookAndFeel();
MotifLookAndFeel motifLF = new MotifLookAndFeel();
WindowsLookAndFeel windowsLF = new WindowsLookAndFeel();
RedLookAndFeel redLF = new RedLookAndFeel();
public MyLF() {
super(TITLE);
buildGUI();
setupEventHandlers();
setSize(WIDTH,HEIGHT);
show();
}
void buildGUI() {
setupMenuBar();
layoutComponents();
}
void setupMenuBar() {
fileMenu.add(fileNew);
fileMenu.add(fileOpen);
fileMenu.add(fileSave);
fileMenu.add(fileExit);
editMenu.add(editCut);
editMenu.add(editCopy);
editMenu.add(editPaste);
menuBar.add(fileMenu);
menuBar.add(editMenu);
setJMenuBar(menuBar);
}
public void layoutComponents() {
for(int i=0;i<panels.length;++i)
panels[i] = new JPanel();
panels[0].setBorder(new TitledBorder("Checkboxes"));
panels[0].setLayout(new GridLayout(3,1));
panels[0].add(checkbox1);
panels[0].add(checkbox2);
panels[0].add(checkbox3);
panels[1].setBorder(new TitledBorder("Radio Buttons"));
panels[1].setLayout(new GridLayout(3,1));
panels[1].add(radioButton1);
panels[1].add(radioButton2);
panels[1].add(radioButton3);
panels[2].setBorder(new TitledBorder("Text Fields"));
panels[2].add(textField1);
panels[2].add(textField2);
panels[3].setBorder(new TitledBorder("Sliders"));
panels[3].add(slider1);
panels[3].add(slider2);
panels[4].setLayout(new GridLayout(2,1));
panels[4].add(metalButton);
panels[4].add(motifButton);
panels[5].setLayout(new GridLayout(2,1));
panels[5].add(redButton);
panels[5].add(windowsButton);
frameContainer = getContentPane();
frameContainer.setLayout(new GridLayout(3,2));
for(int i=0;i<panels.length;++i) frameContainer.add(panels[i]);
}
void setupEventHandlers() {
addWindowListener(new WindowHandler());
fileExit.addActionListener(new MenuItemHandler());
metalButton.addActionListener(new ButtonHandler());
motifButton.addActionListener(new ButtonHandler());
windowsButton.addActionListener(new ButtonHandler());
redButton.addActionListener(new ButtonHandler());
}
public static void main(String[] args) {
MyLF app = new MyLF();
}
public class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
public class MenuItemHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
}
public class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
String cmd = e.getActionCommand();
if(cmd.equals("Motif")) {
try {
UIManager.setLookAndFeel(motifLF);
SwingUtilities.updateComponentTreeUI(MyLF.this);
}catch(Exception ex){
System.out.println(ex);
}
}else if(cmd.equals("Metal")) {
try {
UIManager.setLookAndFeel(metalLF);
SwingUtilities.updateComponentTreeUI(MyLF.this);
}catch(Exception ex){
System.out.println(ex);
}
}else if(cmd.equals("Windows")) {
try {
UIManager.setLookAndFeel(windowsLF);
SwingUtilities.updateComponentTreeUI(MyLF.this);
}catch(Exception ex){
System.out.println(ex);
}
}else{
try {
UIManager.setLookAndFeel(redLF);
SwingUtilities.updateComponentTreeUI(MyLF.this);
}catch(Exception ex){
System.out.println(ex);
}
}
}
}
}
Summary
This chapter covers Swing's PL&F capabilities. It explains what look and feel is and how the modelview-controller (MVC) architecture is used to achieve PL&F. It introduces you to the Swing classes
and interfaces that implement PL&F and shows you how to change an applet and application's look
and feel. It also shows you how to develop your own look and feel. In the next chapter, you'll learn
how to perform clipboard cut and paste operations using Java.
© Copyright 1998, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
- 15 Using the Clipboard
●
●
●
Clipboard Basics
❍ The Clipboard Class
❍ The Transferable Interface
❍ The DataFlavor Class
❍ The FlavorMap Interface and SystemFlavorMap Class
❍ The ReadClipApp Program
❍ Clipboard Ownership
❍ The StringSelection Class
Copying and Pasting Text
❍ editMenu.add(editCopy);
Summary
Copying and pasting data to and from the clipboard is a fundamental capability that is expected by
users of all windowing systems. The JDK provides the basis for full support of clipboard operations
through the Clipboard class and other classes and interfaces of the java.awt.transfer package. This
chapter introduces you to the classes of java.awt.transfer. You'll learn how to copy Java objects to the
clipboard and paste them into other windows or programs. When you finish this chapter, you'll be
able to implement clipboard support in your Java applications.
Clipboard Basics
The java.awt.datatransfer class was created to support platform-independent clipboard operations. It
consists of three interfaces (ClipboardOwner, FlavorMap, and Transferable) and four classes
(Clipboard, DataFlavor, SystemFlavorMap, and StringSelection). Each of these classes and interfaces
is covered in the following sections.
The Clipboard Class
The Clipboard class, as you would expect, is the core class for implementing clipboard operations. It
provides access to the system clipboard as well as to Java-internal clipboard objects. The system
clipboard can be used to copy and paste data between Java and non-Java programs. The Clipboard
object is returned by the getSystemClipboard() method of the Toolkit class. Other Java-internal
Clipboard objects can be created using the Clipboard() constructor, which takes a String object (the
name of the clipboard) as an argument.
The Clipboard class has two field variables: owner and contents. The owner variable refers to an
object that implements the ClipboardOwner interface and identifies the process that owns the
clipboard. The contents variable refers to an object that is placed on the clipboard. This object
implements the Transferable interface.
The three clipboard access methods, getName(), getContents(), and setContents(), are used to identify
a Clipboard object, get the contents of the clipboard, and put new data on the clipboard.
The getContents()method takes a single argument--the object requesting the clipboard's contents. It
returns an object that implements the Transferable interface. This object is used to access the
clipboard's contents.
The setContents()method takes two arguments: an object that implements the Transferable interface
and an object that implements the Clipboard owner interface. The first object contains the data that is
to be placed on the clipboard. The second object identifies the object that has placed the data on the
clipboard.
The Transferable Interface
Objects that implement the Transferable interface are copied to and from Clipboard objects via the
setContents() and getContents() method of the Clipboard class. The Transferable interface has three
methods that allow the clipboard data to be read:
●
●
●
getTransferDataFlavors()--Returns an array of DataFlavor objects that describe the type of
data that is on the clipboard and the various format options in which the data can be accessed.
isDataFlavorSupported()--Returns a boolean value indicating whether a particular DataFlavor
object is supported. The DataFlavor object of interest is passed as an argument to this method.
getTransferData()--Returns an object that identifies the actual data to be retrieved from the
clipboard. The object returned depends on the DataFlavor object that is passed as an argument.
This object must be cast to a class that is appropriate for the DataFlavor object.
The key to reading data from the clipboard is to read the data using the most appropriate data flavor
(for example, PostScript, HTML, plain text, and so on). At present, choosing the correct flavor is
easy because the java.awt.datatransfer package only provides useful support for simple text transfers.
However, the classes and interfaces of java.awt.datatransfer provide a foundation from which more
complex data flavors can be created.
The DataFlavor Class
The DataFlavor class encapsulates data types used to pass data to and from the clipboard. A
DataFlavor object consists of the following information:
●
A human-readable name
●
A MIME type
●
The Java class of the object to be returned (referred to as its representation class)
The naming scheme of the DataFlavor class bridges the gap between humans, MIME types, and Java.
It provides a sound foundation from which complex clipboard operations can be supported.
NOTE: MIME types are covered in Chapter 11, "Using the Utility and Math
Packages," and Chapter 33, "Content and Protocol Handlers."
The DataFlavor class provides several constructors that allow a DataFlavor object to be created for a
particular Java class or for a specified MIME type. In the first case, a Class object (representing the
class of the data to be sent to the keyboard) and a String that provides a human-readable name for the
data are provided as arguments to the constructor. The MIME type associated with the DataFlavor
object defaults to application/x-java-serialized-object.
In the second case, the MIME type and human-readable name are provided as arguments to the
constructor, and the Java class name of the object defaults to either InputStream or null.
Several access methods of DataFlavor are used to get and set the human-readable name, MIME type,
and Java class associated with DataFlavor objects:
●
●
The getHumanPresentableName() and setHumanPresentableName() methods provide access
to the human-readable name of a DataFlavor object.
The getMimeType(), normalizeMimeType(), normalizeMimeTypeParameter(), and the two
versions of the isMimeTypeEqual() method provide access to the MIME type of a DataFlavor
object.
●
●
The getRepresentationClass() method returns the Java class that is associated with a
DataFlavor object.
The equals() method is used to compare DataFlavor objects.
The DataFlavor class defines two constants, plainTextFlavor and stringFlavor, that are used to
identify specific data flavors. The plainTextFlavor constant identifies data that is of the text/plain
MIME type and that is associated with an InputStream class or with no class (null). The stringFlavor
constant identifies an object of the java.lang.String class that has the application/x-java-serializedobject MIME type.
The FlavorMap Interface and SystemFlavorMap Class
The FlavorMap interface maps native type strings to their associated MIME types and data flavors. It
consists of two methods, getFlavorsForNatives() and getNativesForFlavors(). The SystemFlavorMap
class provides an implementation of the FlavorMap interface that also provides support for working
with MIME types.
The ReadClipApp Program
The ReadClipApp program in Listing 15.1 shows how the Clipboard class, Transferable interface,
and DataFlavor class are used to obtain information about data that is contained on the clipboard.
Figure 15.1 shows the program's opening display. Copy some text to the clipboard using a text editor
such as Notepad. When you switch to ReadClipApp and select Clipboard from the Read menu,
ReadClipApp displays information about the flavor of the data contained on the clipboard, as shown
in Figure 15.2. Try copying nontext objects to the clipboard, such as an image that you create using
the Paint program. When you try to read information about these objects, the ReadClipApp program
displays the information shown in Figure 15.3. The reason the program does not see the image data is
because the DataFlavor class for the image data is not available.
FIGURE 15.1. The opening window of the Readclipapp program.
FIGURE 15.2. Displaying information about the clipboard's contents.
FIGURE 15.3. How unknown data flavors are handled.
LISTING 15.1. THE SOURCE CODE OF THE ReadClipApp PROGRAM.
import java.awt.*;
import java.awt.event.*;
import java.awt.datatransfer.*;
public class ReadClipApp extends Frame {
TextArea textArea = new TextArea();
Toolkit toolkit;
int screenWidth = 500;
int screenHeight = 500;
public static void main(String args[]){
ReadClipApp app = new ReadClipApp();
}
public ReadClipApp() {
super("ReadClipApp");
setup();
setSize(screenWidth,screenHeight);
addWindowListener(new WindowEventHandler());
show();
}
void setup() {
setupMenuBar();
toolkit=getToolkit();
add("Center",textArea);
}
void setupMenuBar() {
MenuBar menuBar = new MenuBar();
Menu fileMenu = new Menu("File");
Menu readMenu = new Menu("Read");
MenuItem fileExit = new MenuItem("Exit");
MenuItem readClipboard = new MenuItem("Clipboard");
fileExit.addActionListener(new MenuItemHandler());
readClipboard.addActionListener(new MenuItemHandler());
fileMenu.add(fileExit);
readMenu.add(readClipboard);
menuBar.add(fileMenu);
menuBar.add(readMenu);
setMenuBar(menuBar);
}
class MenuItemHandler implements ActionListener {
public void actionPerformed(ActionEvent ev){
String s=ev.getActionCommand();
if(s=="Exit"){
System.exit(0);
}else if(s=="Clipboard"){
// Use the Toolkit object to obtain access to the system
clipboard
Clipboard clip=toolkit.getSystemClipboard();
String text="Object Name: ";
// Get the name of the clipboard
text+=clip.getName();
text+="\n\nData Flavors:";
// Get the clipboard contents
Transferable contents=clip.getContents(ReadClipApp.this);
if(contents==null) text+="\n\nThe clipboard is empty.";
else{
// Get the data flavors associated with the clipboard contents
DataFlavor flavors[]=contents.getTransferDataFlavors();
for(int i=0;i<flavors.length;++i){
// Get the name, MIME type, and class associated with each
flavor
text+="\n\n Name: "+flavors[i].getHumanPresentableName();
text+="\n MIME Type: "+flavors[i].getMimeType();
text+="\n Class: ";
Class cl = flavors[i].getRepresentationClass();
if(cl==null) text+="null";
else text+=cl.getName();
}
}
textArea.setText(text);
}
}
}
class WindowEventHandler extends WindowAdapter {
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
The code that implements clipboard operations is contained in the actionPerfomed() method of the
MenuItemHandler class. When the Clipboard menu item is selected, the getSystemClipboard()
method of the Toolkit class is invoked to gain access to the system clipboard. This object is assigned
to the clip variable. The getName() method of the Clipboard class is used to get the name of the
Clipboard object that is returned.
A Transferable object representing the contents of the clipboard is returned by invoking the
getContents() method of the Clipboard class. This object is assigned to the contents variable.
If a null value is returned by getContents(), the clipboard is identified as empty. Otherwise, the
getTransferDataFlavors() method of the Transferable interface is invoked to obtain an array of data
flavors corresponding to the clipboard data. The getHumanPresentableName(), getMimeType(), and
getRepresentationClass() methods are used to obtain information about each of the supported
DataFlavor objects. This information is then displayed to the user.
Clipboard Ownership
The ClipboardOwner interface of java.awt.datatransfer is used to provide a callback method,
lostOwnership(), that notifies the current clipboard owner that it has lost ownership of the clipboard.
The ClipboardOwner object can then take whatever action is necessary as the result of lost
ownership. In most cases, no action is required at all.
The StringSelection Class
The StringSelection class implements both the Transferable and ClipboardOwner interfaces to
support the transfer of String objects to and from the clipboard. This is a useful class that simplifies
the copying and pasting of text.
The StringSelection class has a single constructor that takes a String object as an argument. This
object is the data that is to be transferred via the clipboard. StringSelection implements the
getTransferData(), getTransferDataFlavors(), and isDataFlavorSupported() methods of the
Transferable interface and the lostOwnership() method of the ClipboardOwner interface. These
methods provide all that is needed to copy and paste String objects, as you'll learn in the next section.
Copying and Pasting Text
The ClipTextApp program of Listing 15.2 shows how text can be copied to or pasted from the
clipboard. Figure 15.4 shows the ClipTextApp opening window. Copy some text to the clipboard
using a text editor and then switch back to the ClipTextApp program. Select Paste from the Edit
menu. The text that you copied to the clipboard is pasted to the ClipTextApp window, as shown in
Figure 15.5.
You have seen how ClipTextApp supports pasting from the system clipboard. It is also designed to
copy the text Hello from Java! to the system clipboard. Select Copy from the Edit menu to copy text
from ClipTextApp to the clipboard. Then select Paste to see which text was copied, as shown in
Figure 15.6. ClipTextApp copied the text Hello from Java! to the clipboard. You can verify this by
pasting the clipboard's contents using another program, such as Notepad, as shown in Figure 15.7.
FIGURE 15.4. The opening window of the ClipTextApp program.
FIGURE 15.5. Pasting text to the ClipTextApp window.
FIGURE 15.6. The result of copying and pasting.
FIGURE 15.7. The text copied by ClipTextApp can be retrieved by other programs.
LISTING 15.2. THE SOURCE CODE OF THE ClipTextApp PROGRAM.
import java.awt.*;
import java.awt.event.*;
import java.awt.*;
import java.awt.datatransfer.*;
import java.util.*;
import java.io.*;
public class ClipTextApp extends Frame {
Font defaultFont = new Font("default",Font.PLAIN,12);
int screenWidth = 400;
int screenHeight = 400;
Toolkit toolkit;
int baseline;
int lineSize;
FontMetrics fm;
Canvas canvas = new MyCanvas();
Vector text = new Vector();
int topLine;
public static void main(String args[]){
ClipTextApp app = new ClipTextApp();
}
public ClipTextApp() {
super("ClipTextApp");
setup();
setSize(screenWidth,screenHeight);
addWindowListener(new WindowEventHandler());
show();
}
void setup() {
setupMenuBar();
setupFontData();
text.addElement("");
add("Center",canvas);
}
void setupMenuBar() {
MenuBar menuBar = new MenuBar();
Menu fileMenu = new Menu("File");
Menu editMenu = new Menu("Edit");
MenuItem fileExit = new MenuItem("Exit");
MenuItem editCopy = new MenuItem("Copy");
MenuItem editPaste = new MenuItem("Paste");
fileExit.addActionListener(new MenuItemHandler());
editCopy.addActionListener(new MenuItemHandler());
editPaste.addActionListener(new MenuItemHandler());
fileMenu.add(fileExit);
editMenu.add(editCopy);
editMenu.add(editPaste);
menuBar.add(fileMenu);
menuBar.add(editMenu);
setMenuBar(menuBar);
}
void setupFontData() {
setFont(defaultFont);
toolkit = getToolkit();
fm = toolkit.getFontMetrics(defaultFont);
baseline = fm.getLeading()+fm.getAscent();
lineSize = fm.getHeight();
}
public void paint(Graphics g) {
canvas.repaint();
}
void copyToClipboard() {
// Copy the string, "Hello from Java!" to the clipboard
String toClipboard="Hello from Java!";
StringSelection ss = new StringSelection(toClipboard);
Clipboard clip=toolkit.getSystemClipboard();
clip.setContents(ss,ss);
}
void pasteFromClipboard() {
// Get the system clipboard using the toolkit
Clipboard clip=toolkit.getSystemClipboard();
// Get the clipboard contents
Transferable contents=clip.getContents(ClipTextApp.this);
text.removeAllElements();
if(contents==null) text.addElement("The clipboard is empty.");
else{
// If the contents support the string data flavor then retrieve
and Âparse the data contained
// on the clipboard
if(contents.isDataFlavorSupported(DataFlavor.stringFlavor)){
try{
String data = (String) contents.getTransferData(
DataFlavor.stringFlavor);
if(data==null) text.addElement("null");
else{
StringTokenizer st = new StringTokenizer(data,"\n");
while(st.hasMoreElements()) text.addElement(st.nextToken());
}
} catch(IOException ex){
text.addElement("IOException");
} catch(UnsupportedFlavorException ex){
text.addElement("UnsupportedFlavorException");
}
}else text.addElement("Wrong flavor.");
}
repaint();
}
class MenuItemHandler implements ActionListener {
public void actionPerformed(ActionEvent ev){
String s=ev.getActionCommand();
if(s=="Exit"){
System.exit(0);
}else if(s=="Copy") copyToClipboard();
else if(s=="Paste") pasteFromClipboard();
}
}
class WindowEventHandler extends WindowAdapter {
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
class MyCanvas extends Canvas {
public void paint(Graphics g) {
topLine = 0;
int numLines = text.size();
screenHeight = getSize().height;
int y = baseline*2;
int x = y;
for(int i = topLine;(i < numLines) && (y < screenHeight +
ÂlineSize);++i) {
g.drawString((String) text.elementAt(i),x,y);
y += lineSize;
}
}
}
}
The copying of text to the clipboard is implemented by the copyToClipboard() method of
ClipTextApp. This method creates a StringSelection object with the text Hello from Java!. It invokes
the getSystemClipboard() method of the Toolkit class to access the system clipboard and the
setContents() method of the Clipboard class to set the StringSelection object as the clipboard's
contents.
The pasting of text from the clipboard is performed by the pasteFromClipboard() method. This
method invokes getSystemClipboard() to access the system clipboard and getContents() to retrieve
the clipboard contents as a Transferable object. If the Transferable object is null, a Clipboard empty.
message is displayed to the user. Otherwise, the isDataFlavorSupported() method of the Transferable
interface is used to determine whether an object that is compatible with the StringSelection class is
contained on the clipboard. If not, a Wrong flavor. message is displayed to the user.
If the data on the clipboard can be accessed as a StringSelection object, the data is retrieved using the
getTransferData() method of the Transferable interface and assigned to the data variable. A
StringTokenizer object is constructed to parse the data into separate lines and assign them to the
Vector object referenced by the text variable. The contents of text are then displayed to the screen via
the paint() method of the MyCanvas class.
Summary
In this chapter you were introduced to the classes of java.awt.transfer. You learned how to copy data
to and from the clipboard using the Clipboard API. In the next chapter, you'll learn how to use the
new drag-and-drop capabilities of JDK 1.2.
© Copyright, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
- 16 Working with Drag and Drop
●
●
●
The Drag and Drop API
Using Drag and Drop in Your Programs
Summary
Drag and drop is a capability that allows users to perform operations on objects by dragging files'
GUI components to the GUI components of objects that represent the operations. Most windowing
systems provide desktops that display icons representing programs, files, printers, and storage
devices. You drag a file's icon to a program icon to have the file opened by the program, to a printer
icon to send the file to the printer, or to a storage device to have the file copied to that device.
Drag-and-drop capabilities are introduced to the Core API with JDK 1.2. These capabilities allow
you to use drag and drop within Java applications, between Java applications, and between Java
applications and native applications. This chapter shows you how to use drag and drop in your Java
programs. It covers the basic mechanics of drag and drop, describes the Drag and Drop API, and
provides examples of Java programs that implement drag and drop. When you finish this chapter,
you'll be able to use drag and drop in your Java applications.
Drag and drop consists of the following three levels of abstraction:
●
The actual files, programs, devices, and other objects upon which operations are performed
●
GUI components that represent the files, programs, and devices
●
The drag-and-drop gesture, which associates the GUI component of the source object being
dragged with the GUI component of the target upon which the source is dropped
Drag and drop is implemented using special objects, referred to as the drag source and drop target
(see Figure 16.1). A GUI component that receives drops is associated with a drop target object that is
activated and waits for drop events. The GUI creates the drag source at the beginning of the drag
gesture. The drag source monitors the progress of the drag operation by handling events from the
GUI. When the drag-and-drop operation is completed (the user drops the source component on the
target component), the drop target coordinates with the drag source to transfer information from the
source component to the target component. If the source and target components are associated with
other objects (such as files or devices), these components effect data transfers between these other
objects.
The Drag and Drop API
The Drag and Drop API consists of the java.awt.dnd package. However, it is implemented using
other packages, most notably the java.awt.datatransfer package. The java.awt.dnd package consists of
4 interfaces and 15 classes. These interfaces and classes are summarized as follows:
FIGURE 16.1. How drag and drop works.
●
●
●
●
●
●
●
DnDConstants--Defines constants used in drag-and-drop operations.
DragSource--Provides field variables and methods that are used to originate a drag-and-drop
operation.
DragSourceContext--Implements the DragSourceListener interface and provides methods for
managing the initiation of a drag-and-drop operation.
DropTarget--A class that is associated with a component that acts as a target for drag-and-drop
operations. The DropTargetAutoScroller inner class implements auto scrolling.
DropTargetContext--The class of an object that is created as the result of a drag to a
component that is associated with a DropTarget. DragTargetContext provides methods for
providing feedback and completing the drag operation.
DropTargetContext.TransferableProxy--An inner class of DropTargetContext that supports
data transfer to the target.
Autoscroll--An interface that defines methods that support the dropping of objects in a
scrollable GUI area that is not currently visible.
●
DragSourceEvent--Superclass of all drag-and-drop events that are provided to the drag source.
●
DragSourceDragEvent-- Provides feedback to the drag source about the drag state of a drag-
and-drop operation.
●
●
●
●
●
●
●
●
●
●
DragSourceDropEvent--Provides feedback to the drag source about the drop state of a dragand-drop operation.
DragGestureEvent--An event that is generated as the result of a platform dependent drag-anddrop action initiating gesture.
DragGestureListener--Defines methods for handling the DragGestureEven event.
DragGestureRecognizer--An abstract class for handling platform dependent drag-and-drop
operations.
MouseDragGestureRecognizer--Extends DragGestureRecognizer to support mouse-based
gestures.
DragSourceListener--An interface that defines methods for source objects to handle state
changes associated with drag-and-drop events.
DropTargetEvent--Superclass of all drag-and-drop events that are provided to the drag target.
DropTargetDragEvent--Provides feedback to the drag target about the drag state of a drag-anddrop operation.
DropTargetDropEvent--Provides feedback to the drag target about the drop state of a drag-anddrop operation.
DropTargetListener--An interface that defines methods for target objects to handle state
changes associated with drag-and-drop events.
Drag and drop is implemented by setting up DragSource and DropTarget objects for those GUI
components that you want to use as a source or destination of drag-and-drop operations. You can
implement only sources, only targets, or both sources and targets, depending on the requirements of
your application. A DragSource object is associated with a GUI component from which you want to
have data transferred, and a DropTarget component is associated with a GUI component that is to
receive transferred data. Once these components are set up, the bulk of the drag-and-drop processing
consists of handling events associated with the sources and targets.
A DragSource object is associated with a GUI component by specifying the component as an
argument to the object's start() method. A DropTarget object is associated with a GUI component by
passing the component as an argument to the object's constructor. Information is transferred from the
source component to the target component via an object of the Transferable interface. You declare a
class that implements this interface to effect the data transfer. The example in the following section
illustrates the use of the DragSource, DropTarget, and Transferable objects.
Using Drag and Drop in Your Programs
Now that you've been introduced to the Drag and Drop API, we'll create an example application that
implements both the source and target aspects of drag and drop. Listing 16.1 presents the DragNDrop
application. This program displays the opening window, shown in Figure 16.2. Its GUI uses two text
boxes to implement drag and drop. Type some text in the upper text box and then drag the text to the
lower text box, as shown in Figure 16.3. Note how the cursor changes shape during the drag-and-drop
operation. The program also displays text to the console window that identifies the drag-and-drop
events that are handled.
FIGURE 16.2. The DragNDrop application opening window.
FIGURE 16.3. Dragging text from one text area to another.
The DragNDrop application illustrates both source and target event-handling in support of drag and
drop. The program declares the needed GUI components and then declares variables that are used to
implement drag and drop. The source variable is assigned an object of the DragSource class, and the
target variable is assigned an object of the DropTarget class. The DropTarget()constructor takes the
following four arguments:
●
The component that the target is associated with
●
The type of drag-and-drop operation supported
●
An event handler for target-related events
●
A Boolean value indicating whether or not the target accepts drops
The transferable variable is assigned an object of the TextTransfer class, which is an inner class that
implements the Transferable interface of java.awt.datatransfer.
The sourceHandler variable is assigned a DragSourceHandler object that is used to handle sourcerelated events.
The setup() method sets the DropTarget object referenced by target to actively receive drops via the
setActive()method. A DragGestureRecognizer is created with respect to the first TextArea object so
that drag opertations can be detected and processed. The rest of the program (with the exception of
TextTransfer) consists of event handlers.
The DragSourceHandler class implements the DragSourceListener interface to handle source-related
events. The dropActionChanged(), dragEnter(), and dragDropEnd() methods just display notices
about the occurrence of events. The dragOver() method doesn't display anything because it may be
invoked many times during a drag-and-drop operation.
The DropTargetHandler class implements the DropTargetListener interface to handle target-related
events. The dragEnter() method handles the event that occurs when a drag operation enters the
component (the second TextArea object) associated with the DropTarget. This method checks if the
data flavors of the object being dragged to the target support any of the standard text data flavors. If
so, the drag is accepted. Other-wise, it is rejected. The dragOver(), dragExit(), and dropAction()
methods are placeholders used to implement the DropTargetListener interface.
The drop() method implements the actual data transfer. It accepts the drop action and gets a
Transferable object that contains the data being transferred. It retrieves the data flavors associated
with the Transferable object and checks to see whether these flavors coincide with the target's flavors.
If a match occurs, the associated TextArea object is updated with the transferred data. The successful
completion of the drop is signaled by the dropComplete() method of the DropTargetContext class.
The TextTransfer class implements the Transferable interface and is used to transfer information
from the DragSource object. The getTransferDataFlavors() method returns the flavors supported by
the source. The isDataFlavorSupported() method reports information on a single data flavor. The
getTransferData() method returns the data to be transferred.
The DragHandler class implements DragGestureListener to start the drag operation when a drag
operation is initiated in the first text area. It handles this event by invoking the event's startDrag()
method. This method takes the following arguments:
●
●
●
The cursor to be used for dragging.
An object that implements the Transferable interface that is used to accomplish the actual
transfer.
An event handler for source-related events.
The WindowEventHandler class handles the closing of the application window.
LISTING 16.1. THE DragNDrop APPLICATION.
import java.awt.*;
import java.awt.event.*;
import java.awt.dnd.*;
import java.awt.datatransfer.*;
import java.io.*;
public class DragNDrop extends Frame {
int screenWidth = 400;
int screenHeight = 400;
Panel panel = new Panel();
Label topLabel = new Label("Enter text in this text area:");
Label bottomLabel = new Label("And then drag it to this text
area:");
TextArea textArea1 = new TextArea();
TextArea textArea2 = new TextArea();
//Drag and drop variables
DragSource source = new DragSource();
DropTarget target = new DropTarget(textArea2,
DnDConstants.ACTION_COPY,new DropTargetHandler(),true);
TextTransfer transferable = new TextTransfer();
DragSourceHandler sourceHandler = new DragSourceHandler();
public static void main(String[] args) {
DragNDrop app = new DragNDrop();
}
public DragNDrop() {
super("DragNDrop");
setup();
setSize(screenWidth,screenHeight);
addWindowListener(new WindowEventHandler());
show();
}
void setup() {
target.setActive(true);
panel.setLayout(new GridLayout(4,1));
panel.add(topLabel);
panel.add(textArea1);
Toolkit toolkit=Toolkit.getDefaultToolkit();
try{
toolkit.createDragGestureRecognizer(Class.forName(
"java.awt.dnd.MouseDragGestureRecognizer"),source,textArea1,
DnDConstants.ACTION COPY,new DragHandler());
}catch(ClassNotFoundException ex){
System.out.println("Recognizer class not found.");
System.exit(o);
}
panel.add(bottomLabel);
panel.add(textArea2);
add("Center",panel);
}
class DragSourceHandler implements DragSourceListener {
public void dropActionChanged(DragSourceDragEvent ev) {
System.out.println("Source: Drop action changed");
}
public void dragEnter(DragSourceDragEvent ev) {
System.out.println("Source: Drag enter");
}
public void dragOver(DragSourceDragEvent ev) {
}
public void dragExit(DragSourceEvent ev) {
System.out.println("Source: Drag exit");
}
public void dragDropEnd(DragSourceDropEvent ev) {
System.out.println("Source: Drag drop end");
}
}
class DropTargetHandler implements DropTargetListener {
public void dragEnter(DropTargetDragEvent ev) {
System.out.println ("Target: Drag enter");
DataFlavor df[] = ev.getCurrentDataFlavors();
for (int i = 0; i < df.length; i++) {
if (df[i].equals (DataFlavor.plainTextFlavor) ||
df[i].equals (DataFlavor.stringFlavor)) {
ev.acceptDrag(DnDConstants.ACTION_COPY);
return;
}
}
ev.rejectDrag();
}
public void dragOver(DropTargetDragEvent ev) {
}
public void dragExit(DropTargetEvent ev) {
System.out.println ("Target: Drag exit");
}
public void dropActionChanged(DropTargetDragEvent ev) {
System.out.println("Target: Drop action changed");
}
public void drop(DropTargetDropEvent ev) {
System.out.println ("Target: Dropped");
ev.acceptDrop (DnDConstants.ACTION_COPY);
Transferable transfer = ev.getTransferable();
DataFlavor df[] = ev.getCurrentDataFlavors();
String input = "";
try {
for (int i=0;i<df.length;i++) {
if (df[i].equals(DataFlavor.stringFlavor) ||
df[i].equals(DataFlavor.plainTextFlavor)) {
input = (String) transfer.getTransferData(df[i]);
}
}
textArea2.setText(input);
}catch (Exception e) {
System.out.println(e.toString());
}
try {
target.getDropTargetContext().dropComplete(true);
}catch (Exception e) {
}
}
}
class TextTransfer implements Transferable {
public DataFlavor[] getTransferDataFlavors() {
DataFlavor[] flavors = new DataFlavor[1];
flavors[0] = DataFlavor.plainTextFlavor;
return flavors;
}
public boolean isDataFlavorSupported(DataFlavor flavor) {
return (flavor.equals(DataFlavor.plainTextFlavor));
}
public Object getTransferData(DataFlavor flavor)
throws UnsupportedFlavorException, IOException {
return textArea1.getText();
}
}
class DragHandler implements DragGestureListener {
public void dragGestureRecognized(DragGestureEvent e) {
e.startDrag (new Cursor(Cursor.HANDCURSOR),
transferable,sourceHandler);
}
}
class WindowEventHandler extends WindowAdapter {
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
Summary
This chapter showed you how to use the drag-and-drop capabilities of JDK 1.2. It covered the basic
mechanics of drag and drop, described the Drag and Drop API, and provided examples of Java
programs that implement drag and drop. In the next chapter you'll learn how to use the sophisticated
input/output capabilities of the java.io package.
© Copyright, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
- 17 Input/Output Streams
●
●
●
●
●
●
●
●
Streams
The java.io Class Hierarchy
The java.io Interfaces
The InputStream Class
❍ The available() Method
❍ The close() Method
❍ Markable Streams
❍ The skip() Method
The OutputStream Class
❍ The write() Method
❍ The flush() Method
❍ The close() Method
Byte Array I/O
❍ The ByteArrayInputStream Class
❍ The ByteArrayOutputStream Class
❍ The ByteArrayIOApp Program
❍ The StringBufferInputStream Class
File I/O
❍ The File Class
❍ The FileDescriptor Class
❍ The FileInputStream Class
❍ The FileOutputStream Class
❍ The FileIOApp Program
The SequenceInputStream Class
The SequenceIOApp Program
Filtered I/O
❍ The FilterInputStream Class
❍ The FilterOutputStream Class
❍ Buffered I/O
❍ PushbackInputStream
❍ The LineNumberInputStream Class
❍ Data I/O
❍ The PrintStream Class
Piped I/O
❍ The PipedIOApp Program
Object I/O
❍ The ObjectIOApp Program
The Reader and Writer Classes
❍ The Reader Class
❍ The Writer Class
Character Array and String I/O
❍ The CharArrayIOApp and StringIOApp Programs
The InputStreamReader and OutputStreamWriter Classes
❍ The InputStreamReader Class
❍ The OutputStreamWriter Class
The FileReader and FileWriter Classes
❍ The CharFileIOApp Program
❍ The LineNumberReader Class
Filtered Character I/O
❍ The PushbackReader Class
The PipedReader and PipedWriter Classes
The PrintWriter Class
The RandomAccessFile Class
❍ The RandomIOApp Program
The StreamTokenizer Class
❍ The StreamTokenApp Program
❍
●
●
●
●
●
●
●
●
●
●
●
●
In this chapter you'll learn to use Java streams to perform sophisticated input and output using
standard I/O, memory buffers, and files. You'll explore the input and output stream class hierarchy
and learn to use stream filters to simplify I/O processing. You'll also learn how to perform randomaccess I/O and how to use the StreamTokenizer class to construct input parsers. When you finish this
chapter, you'll be able to add sophisticated I/O processing to your Java programs.
Streams
Java input and output is based on the use of streams, or sequences of bytes that travel from a source
to a destination over a communication path. If your program is writing to a stream, it is the stream's
source. If it is reading from a stream, it is the stream's destination. The communication path is
dependent on the type of I/O being performed. It can consist of memory-to-memory transfers, a file
system, a network, and other forms of I/O.
Streams are not complicated. They are powerful because they abstract away the details of the
communication path from input and output operations. This allows all I/O to be performed using a
common set of methods. These methods can be tailored and extended to provide higher-level custom
I/O capabilities.
Java defines two major classes of byte streams: InputStream and OutputStream. These streams are
subclassed to provide a variety of I/O capabilities. Java 1.1 introduced the Reader and Writer classes
to provide the foundation for 16-bit Unicode character- oriented I/O. These classes support
internationalization of Java I/O. The Reader and Writer classes, such as InputStream and
OutputStream, are subclassed to support additional capabilities. Unicode is covered in Chapter 19,
"Internationalization."
The java.io Class Hierarchy
Figure 17.1 identifies the java.io class hierarchy. As described in the previous section, the
InputStream, OutputStream, Reader, and Writer classes are the major components of this hierarchy.
Other high-level classes include the File, FileDescriptor, RandomAccessFile, ObjectStreamClass, and
StreamTokenizer classes.
The InputStream and OutputStream classes have complementary subclasses. For example, both have
subclasses for performing I/O via memory buffers, files, and pipes. The InputStream subclasses
perform the input and the OutputStream classes perform the output.
FIGURE 17.1. The classes of the java.io hierarchy.
The InputStream class has seven direct subclasses. The ByteArrayInputStream class is used to
convert an array into an input stream. The StreamBufferInputStream class uses a StreamBuffer as an
input stream. The FileInputStream class allows files to be used as input streams. The
ObjectInputStream class is used to read primitive types and objects that have been previously written
to a stream. The PipedInputStream class allows a pipe to be constructed between two threads and
supports input through the pipe. The SequenceInputStream class allows two or more streams to be
concatenated into a single stream. The FilterInputStream class is an abstract class from which other
input-filtering classes are constructed.
NOTE: The process of preparing objects for stream input and output is referred to as
serialization. In order for an object to be serialized, it must implement the java.io.
Serializable interface.
Filters are objects that read from one stream and write to another, usually altering the data in some
way as they pass it from one stream to another. Filters can be used to buffer data, read and write
objects, keep track of line numbers, and perform other operations on the data they move. Filters can
be combined, with one filter using the output of another as its input. You can create custom filters by
combining existing filters.
FilterInputStream has four filtering subclasses. The BufferedInputStream class maintains a buffer of
the input data that it receives. This eliminates the need to read from the stream's source every time an
input byte is needed. The DataInputStream class implements the DataInput interface, a set of methods
that allow objects and primitive data types to be read from a stream. The LineNumberInputStream is
used to keep track of input line numbers. The PushbackInputStream provides the capability to push
data back onto the stream that it is read from so that it can be read again.
NOTE: Other Java API packages, such as java.util, contain classes and interfaces that
extend those of java.io. In particular, the java.util package defines input and output
stream classes that can be used to support file and stream compression.
The OutputStream class hierarchy consists of five direct subclasses. The ByteArrayOutputStream,
FileOutputStream, ObjectOutputStream, and PipedOutputStream classes are the output complements
to the ByteArrayInputStream, FileInputStream, ObjectInputStream, and PipedInputStream classes.
The FilterOutputStream class provides subclasses that complement the FilterInputStream classes.
The BufferedOutputStream class is the output analog to the BufferedInputStream class. It buffers
output so that output bytes can be written to devices in larger groups. The DataOutputStream class
implements the DataOutput interface. This interface complements the DataInput interface. It provides
methods that write objects and primitive data types to streams so that they can be read by the
DataInput interface methods. The PrintStream class provides the familiar print() and println()
methods used in most of the sample programs that you've developed so far in this book. It provides a
number of overloaded methods that simplify data output.
NOTE: The PrintStream class is not necessarily used to print to a printer. Chapter 18,
"Printing," covers printing to a printer.
The Reader class is similar to the InputStream class in that it is the root of an input class hierarchy.
Reader supports 16-bit Unicode character input, while InputStream supports 8-bit byte input. The
Reader class has six direct subclasses:
●
The BufferedReader class supports buffered character input. Its LineNumberReader subclass
supports buffered input and keeps track of line numbers.
●
●
●
The CharArrayReader class provides the capability to read a character input stream from a
character buffer.
The FilterReader class is an abstract class that provides the basis for filtering character input
streams. Its PushbackReader subclass provides a filter that allows characters to be pushed
back onto the input stream.
The InputStreamReader class is used to convert byte input streams to character input streams.
Its FileReader subclass is used to read character files.
●
The PipedReader class is used to read characters from a pipe.
●
The StringReader class is used to read characters from a String.
The Writer class is the output analog of the Reader class. It supports 16-bit Unicode character output.
It has seven direct subclasses:
●
The BufferedWriter class supports buffered character output.
●
The CharArrayWriter class supports output to a character array.
●
The FilterWriter class is an abstract class that supports character output filtering.
●
The OutputStreamWriter class allows a character stream to be converted to a byte stream. Its
FileWriter subclass is used to perform character output to files.
●
The PipedWriter class supports character output to pipes.
●
The PrintWriter class supports platform-independent character printing.
●
The StringWriter class supports character output to String objects.
The File class is used to access the files and directories of the local file system. The FileDescriptor
class is an encapsulation of the information used by the host system to track files that are being
accessed. The RandomAccessFile class provides the capabilities needed to directly access data
contained in a file. The ObjectStreamClass class is used to describe classes whose objects can be
written (serialized) to a stream. The StreamTokenizer class is used to create parsers that operate on
stream data.
New classes introduced with JDK 1.2 include the ObjectInputStream.GetField, ObjectOutputStream.
PutField, and ObjectStreamField classes, which support object stream I/O. The FilePermission and
SerializablePermission classes support I/O access controls (refer to Chapter 3, "The Extended Java
Security Model").
NOTE: Other packages, such as java.util.zip, provide classes that extend the java.io
class hierarchy shown in Figure 17.1.
The java.io Interfaces
The java.io package declares 10 interfaces. The DataInput and DataOutput interfaces provide
methods that support machine-independent I/O. The ObjectInput and ObjectOutput interfaces extend
DataInput and DataOutput to work with objects. The ObjectInputValidation interface supports the
validation of objects that are read from a stream. The ObjectStreamConstants interface defines
constants that are used to work with object streams. The Serializable, Externalizable, Replaceable,
and Resolvable interfaces support the serialized writing of objects to streams. The FileFilter and
FilenameFilter interfaces are used to select filenames from a list.
The InputStream Class
The InputStream class is an abstract class that lays the foundation for the Java Input class hierarchy.
As such, it provides methods that are inherited by all InputStream classes.
THE READ() METHOD
The read() method is the most important method of the InputStream class hierarchy. It reads a byte of
data from an input stream and blocks if no data is available. When a method blocks, it causes the
thread in which it is executing to wait until data becomes available. This is not a problem in
multithreaded programs. The read() method takes on several overloaded forms. It can read a single
byte or an array of bytes, depending upon what form is used. It returns the number of bytes read, or -1
if an end of file is encountered with no bytes read.
The read() method is overridden and overloaded by subclasses to provide custom read capabilities.
The available() Method
The available()method returns the number of bytes that are available to be read without blocking. It is
used to peek into the input stream to see how much data is available. However, depending on the
input stream, it might not be accurate or useful. Some input streams on some operating systems may
always report 0 available bytes. In general, it is not a good idea to blindly rely on this method to
perform input processing.
The close() Method
The close() method closes an input stream and releases resources associated with the stream. It is
always a good idea to close a stream to ensure that the stream processing is correctly terminated.
Markable Streams
Java supports markable streams. These are streams that provide the capability to mark a position in
the stream and then later reset the stream so that it can be reread from the marked position. If a stream
can be marked, it must contain some memory associated with it to keep track of the data between the
mark and the current position of the stream. When this buffering capability is exceeded, the mark
becomes invalidated.
The markSupported() method returns a boolean value that identifies whether a stream supports mark
and reset capabilities. The mark() method marks a position in the stream. It takes an integer
parameter that identifies the number of bytes that can be read before the mark becomes invalid. This
is used to set the buffering capacity of the stream. The reset()method simply repositions the stream to
its last marked position.
The skip() Method
The skip() method skips over a specified number of input bytes. It takes a long value as a parameter.
You can use the skip() method to move to a specific position within an input stream.
The OutputStream Class
The OutputStream class is an abstract class that lays the foundation for the output stream hierarchy. It
provides a set of methods that are the output analog to the InputStream methods.
The write() Method
The write() method allows bytes to be written to the output stream. It provides three overloaded
forms to write a single byte, an array of bytes, or a segment of an array. The write() method, like the
read() method, may block when it tries to write to a stream. The blocking causes the thread executing
the write() method to wait until the write operation has been completed.
NOTE: The OutputStream class defines three overloaded forms for the write() method.
These forms allow you to write an integer, an array of bytes, or a subarray of bytes to
an OutputStream object. You will often see several overloaded forms for methods that
perform the same operation using different types of data.
The flush() Method
The flush() method causes any buffered data to be immediately written to the output stream. Some
subclasses of OutputStream support buffering and override this method to clean out their buffers and
write all buffered data to the output stream. They must override the OutputStream flush() method
because, by default, it does not perform any operations and is used as a placeholder.
The close() Method
It is generally more important to close() output streams than input streams, so that any data written to
the stream is stored before the stream is deallocated and lost. The close() method of OutputStream is
used in the same manner as that of InputStream.
Byte Array I/O
Java supports byte array input and output via the ByteArrayInputStream and ByteArrayOutputStream
classes. These classes use memory buffers as the source and destination of the input and output
streams. These streams do not have to be used together. They are covered in the same section here
because they provide similar and complementary methods. The StringBufferInputStream class is
similar to the ByteArrayInput class and is also covered in this section.
The CharArrayReader, CharArrayWriter, StringReader, and StringWriter classes support characterbased I/O in a similar manner to the ByteArrayInputStream, ByteArrayOutputStream, and
StringBufferInputStream classes. They are covered later in this chapter.
The ByteArrayInputStream Class
The ByteArrayInputStream class creates an input stream from a memory buffer. The buffer is an
array of bytes. It provides two constructors that use a byte array argument to create the input stream.
The class does not support any new methods, but overrides the read(), skip(), available(), and reset()
methods of InputStream.
The read() and skip() methods are implemented as specified for InputStream. The available() method
is reliable and can be used to check on the number of available bytes in the buffer. The reset() method
resets the stream to the marked position.
The ByteArrayOutputStream Class
The ByteArrayOutputStream class is a little more sophisticated than its input complement. It creates
an output stream on a byte array, but provides additional capabilities to allow the output array to
grow to accommodate new data that is written to it. It also provides the toByteArray() and toString()
methods for converting the stream to a byte array or String object.
ByteArrayOutputStream provides two constructors. One takes an integer argument that is used to set
the output byte array to an initial size. The other constructor does not take an argument and sets the
output buffer to a default size.
ByteArrayOutputStream provides some additional methods not declared for OutputStream. The reset
() method resets the output buffer to allow writing to restart at the beginning of the buffer. The size()
method returns the current number of bytes that have been written to the buffer. The writeTo()
method is new. It takes an object of class OutputStream as an argument and writes the contents of the
output buffer to the specified output stream. The write() methods override those of OutputStream to
support array output.
The ByteArrayIOApp Program
Having learned about both sides of the byte array I/O classes, you now have a base from which to
create a sample program. The source code of the ByteArrayIOApp program is provided in Listing
17.1.
LISTING 17.1. THE SOURCE CODE OF THE ByteArrayIOApp PROGRAM.
import java.lang.System;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class ByteArrayIOApp {
public static void main(String args[]) throws IOException {
// Create ByteArrayOutputStream object
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
String s = "This is a test.";
// Write output to stream
for(int i=0;i<s.length();++i)
outStream.write(s.charAt(i));
System.out.println("outstream: "+outStream);
System.out.println("size: "+outStream.size());
ByteArrayInputStream inStream;
inStream = new ByteArrayInputStream(outStream.toByteArray());
// Determine how many input bytes are available
int inBytes = inStream.available();
System.out.println("inStream has "+inBytes+" available bytes");
byte inBuf[] = new byte[inBytes];
// Read input into a byte array
int bytesRead = inStream.read(inBuf,0,inBytes);
System.out.println(bytesRead+" bytes were read");
System.out.println("They are: "+new String(inBuf));
}
}
The program creates a ByteArrayOutputStream object, outStream, and an array, s, that contains the
text "This is a test." to be written to the stream. Each s character is written, one at a time, to
outStream. The contents of outstream are then printed, along with the number of bytes written.
A ByteArrayInputStream object, inStream, is created by invoking the toByteArray() method of
outStream to create a byte array that is used as an argument to the ByteArrayInputStream constructor.
The available() method is used to determine the number of available input bytes stored in the buffer.
This number is stored as inBytes and is used to allocate a byte array to store the data that is read. The
read() method is invoked for inStream to read inBytes worth of data. The actual number of bytes read
is stored in bytesRead. This number is displayed, followed on the next line by the bytes that were
read from inStream, as follows:
outstream: This is a test.
size: 15
inStream has 15 available bytes
15 bytes were read
They are: This is a test.
The StringBufferInputStream Class
StringBufferInputStream is similar to ByteArrayInputStream except that it uses a StringBuffer to
store input data. The input stream is constructed using a String argument. Its methods are identical to
those provided by ByteArrayInputStream. The StringBufferInputStream was deprecated in Java 1.1.
This means that it has been superceded. The StringReader class is now the preferred class for Stringbased input.
File I/O
Java supports stream-based file input and output through the File, FileDescriptor, FileInputStream,
and FileOutputStream classes. It supports direct or random access I/O using the File, FileDescriptor,
and RandomAccessFile classes. Random access I/O is covered later in this chapter. The FileReader
and FileWriter classes support Unicode-based file I/O. These classes are also covered later in this
chapter.
The File class provides access to file and directory objects and supports a number of operations on
files and directories. The FileDescriptor class encapsulates the information used by the host system to
track files that are being accessed. The FileInputStream and FileOutputStream classes provide the
capability to read and write to file streams.
The File Class
The File class is used to access file and directory objects. It uses the file-naming conventions of the
host operating system. The File class encapsulates these conventions using the File class constants.
File provides constructors for creating files and directories. These constructors take absolute and
relative file paths and file and directory names.
The File class provides numerous access methods that can be used to perform all common file and
directory operations. It is important for you to review the API page for this class because file I/O and
file and directory operations are common to most programs.
File methods allow files to be created, deleted, and renamed. They provide access to a file's path/
name and determine whether a File object is a file or directory. These methods also check read and
write access permissions.
Directory methods allow directories to be created, deleted, renamed, and listed. Direct-ory methods
also allow directory trees to be traversed by providing access to the parent and sibling directories.
The FileDescriptor Class
The FileDescriptor class provides access to the file descriptors maintained by operating systems when
files and directories are being accessed. This class is opaque in that it does not provide visibility into
the specific information maintained by the operating system. It provides only one method, the valid()
method, which is used to determine whether a file descriptor object is currently valid.
The FileInputStream Class
The FileInputStream class allows input to be read from a file in the form of a stream. Objects of class
FileInputStream are created using a filename string or a File or FileDescriptor object as an argument.
FileInputStream overrides the methods of the InputStream class and provides two new methods,
finalize() and getFD(). The finalize() method is used to close a stream when it is processed by the
Java garbage collector. The getFD() method is used to obtain access to the FileDescriptor associated
with the input stream.
The FileOutputStream Class
The FileOutputStream class allows output to be written to a file stream. Objects of class
FileOutputStream are created in the same way as those of class FileInputStream, using a filename
string, File object, or FileDescriptor object as an argument. FileOutputStream overrides the methods
of the OutputStream class and supports the finalize() and getFD() methods described for the
FileInputStream class.
The FileIOApp Program
The program in Listing 17.2 illustrates the use of the FileInputStream, FileOutputStream, and File
classes. It writes a string to an output file and then reads the file to verify that the output was written
correctly. The file used for the I/O is then deleted.
LISTING 17.2. THE SOURCE CODE OF THE FileIOApp PROGRAM.
import java.lang.System;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.File;
import java.io.IOException;
public class FileIOApp {
public static void main(String args[]) throws IOException {
// Create output file test.txt
FileOutputStream outStream = new FileOutputStream("test.txt");
String s = "This is a test.";
for(int i=0;i<s.length();++i)
outStream.write(s.charAt(i));
outStream.close();
// Open test.txt for input
FileInputStream inStream = new FileInputStream("test.txt");
int inBytes = inStream.available();
System.out.println("inStream has "+inBytes+" available bytes");
byte inBuf[] = new byte[inBytes];
int bytesRead = inStream.read(inBuf,0,inBytes);
System.out.println(bytesRead+" bytes were read");
System.out.println("They are: "+new String(inBuf));
inStream.close();
File f = new File("test.txt");
f.delete();
}
}
The FileOutputStream constructor creates an output stream on the file test.txt. The file is
automatically created in the current working directory. It then writes the string "This is a test." to the
output file stream. Note the similarity between this program and the previous one. The power of
streams is that the same methods can be used no matter what type of stream is being used.
The output stream is closed to make sure that all the data is written to the file. The file is then
reopened as an input file by creating an object of class FileInputStream. The same methods used in
the ByteArrayIOApp program are used to determine the number of available bytes in the file and read
these bytes into a byte array. The number of bytes read is displayed along with the characters
corresponding to those bytes.
The input stream is closed and then a File object is created to provide access to the file. The File
object is used to delete the file using the delete() method. The program's output follows:
inStream has 15 available bytes
15 bytes were read
They are: This is a test.
The SequenceInputStream Class
The SequenceInputStream class is used to combine two or more input streams into a single input
stream. The input streams are concatenated, which allows the individual streams to be treated as a
single, logical stream. The SequenceInputStream class does not introduce any new access methods.
Its power is derived from the two constructors that it provides. One constructor takes two
InputStream objects as arguments. The other takes an Enumeration of InputStream objects. The
Enumeration interface is described in Chapter 10, "Writing Console Applications." It provides
methods for dealing with a sequence of related objects.
The SequenceIOApp Program
The program in Listing 17.3 reads the two Java source files, ByteArrayIOApp.java and FileIOApp.
java, as a single file courtesy of the SequenceInputStream class.
LISTING 17.3. THE SOURCE CODE OF THE SequenceIOApp PROGRAM.
import java.lang.System;
import java.io.FileInputStream;
import java.io.SequenceInputStream;
import java.io.IOException;
public class SequenceIOApp {
public static void main(String args[]) throws IOException {
SequenceInputStream inStream;
FileInputStream f1 = new FileInputStream("ByteArrayIOApp.java");
FileInputStream f2 = new FileInputStream("FileIOApp.java");
// Concatentate two files into a single input stream
inStream = new SequenceInputStream(f1,f2);
boolean eof = false;
int byteCount = 0;
while (!eof) {
int c = inStream.read();
if(c == -1) eof = true;
else{
System.out.print((char) c);
++byteCount;
}
}
System.out.println(byteCount+" bytes were read");
inStream.close();
f1.close();
f2.close();
}
}
The program creates two objects of class FileInputStream for the files ByteArrayIOApp.java and
FileIOApp.java. The SequenceInputClass constructor is used to construct a single input stream from
the two FileInputStream objects. The program then uses a while loop to read all bytes in the
combined file and display them to the console window. The loop stops when the end of the combined
file is encountered. This is signaled when the read() method returns -1. The streams are closed after
the combined files have been read. The program's output is as follows:
import java.lang.System;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class ByteArrayIOApp {
public static void main(String args[]) throws IOException {
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
String s = "This is a test.";
for(int i=0;i<s.length();++i)
outStream.write(s.charAt(i));
System.out.println("outstream: "+outStream);
System.out.println("size: "+outStream.size());
ByteArrayInputStream inStream;
inStream = new ByteArrayInputStream(outStream.toByteArray());
int inBytes = inStream.available();
System.out.println("inStream has "+inBytes+" available bytes");
byte inBuf[] = new byte[inBytes];
int bytesRead = inStream.read(inBuf,0,inBytes);
System.out.println(bytesRead+" bytes were read");
System.out.println("They are: "+new String(inBuf));
}
}
import java.lang.System;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.File;
import java.io.IOException;
public class FileIOApp {
public static void main(String args[]) throws IOException {
FileOutputStream outStream = new FileOutputStream("test.txt");
String s = "This is a test.";
for(int i=0;i<s.length();++i)
outStream.write(s.charAt(i));
outStream.close();
FileInputStream inStream = new FileInputStream("test.txt");
int inBytes = inStream.available();
System.out.println("inStream has "+inBytes+" available bytes");
byte inBuf[] = new byte[inBytes];
int bytesRead = inStream.read(inBuf,0,inBytes);
System.out.println(bytesRead+" bytes were read");
System.out.println("They are: "+new String(inBuf));
inStream.close();
File f = new File("test.txt");
f.delete();
}
}
1763 bytes were read
The SequenceIOApp program displays the combined contents of the two source files, followed by a
line identifying the number of bytes that were read.
Filtered I/O
The filtered input and output stream classes provide the capability to filter I/O in a number of useful
ways. I/O filters are used to adapt streams to specific program needs. These filters sit between an
input stream and an output stream and perform special processing on the bytes they transfer from
input to output. You can combine filters to perform a sequence of filtering operations where one filter
acts on the output of another, as shown in Figure 17.2.
FIGURE 17.2. Combining filters.
The FilterInputStream Class
The FilterInputStream class is an abstract class that is the parent of all filtered input stream classes.
The FilterInputStream class provides the basic capability to create one stream from another. It allows
one stream to be read and provided as output as another stream. This is accomplished through the use
of the in variable, which is used to maintain a separate object of class InputStream. The design of the
FilterInputStream class allows multiple chained filters to be created using several layers of nesting.
Each subsequent class accesses the output of the previous class through the in variable. Because the
in variable is an object of class InputStream, arbitrary InputStream objects can be filtered.
The FilterOutputStream Class
The FilterOutputStream class is the complement to the FilterInputStream class. It is an abstract class
that is the parent of all filtered output stream classes. It is similar to the FilterInputStream class in that
it maintains an object of class OutputStream as an out variable. Data written to an object of
FilterOutputStream can be modified as needed to perform filtering operations and then forwarded to
the out OutputStream object. Because out is declared to be of class OutputStream, arbitrary output
streams can be filtered. Multiple FilterOutputStream objects can be combined in a manner that is
analogous to FilterInputStream objects. The input of subsequent FilterOutputStream objects is linked
to the output of preceding objects.
Buffered I/O
Buffered input and output is used to temporarily cache data that is read from or written to a stream.
This allows programs to read and write small amounts of data without adversely affecting system
performance. When buffered input is performed, a large number of bytes are read at a single time and
stored in an input buffer. When a program reads from the input stream, the input bytes are read from
the input buffer. Several reads may be performed before the buffer needs to be refilled. Input
buffering is used to speed up overall stream input processing.
Output buffering is performed in a similar manner to input buffering. When a program writes to a
stream, the output data is stored in an output buffer until the buffer becomes full or the output stream
is flushed. Only then is the buffered output actually forwarded to the output stream's destination.
Java implements buffered I/O as filters. The filters maintain and operate the buffer that sits between
the program and the source or destination of a buffered stream.
The BufferedInputStream Class
The BufferedInputStream class supports input buffering by automatically creating and maintaining a
buffer for a designated input stream. This allows programs to read data from the stream one byte at a
time without degrading system performance. Because the BufferedInputStream class is a filter, it can
be applied to arbitrary objects of class InputStream and combined with other input filters.
The BufferedInputStream class uses several variables to implement input buffering. These variables
are described in the Java API page for this class. However, because these variables are declared as
protected, they cannot be directly accessed by your program.
BufferedInputStream defines two constructors. One allows the size of an input buffer to be specified
and the other does not. Both constructors take an object of class InputStream as an argument. It is
usually better to let BufferedInputStream select the best size for the input buffer than to specify one
yourself, unless you have specific knowledge that one buffer size is better than another.
BufferedInputStream overrides the access methods provided by InputStream and does not introduce
any new methods of its own.
The BufferedOutputStream Class
The BufferedOutputStream class performs output buffering in a manner that is analogous to
BufferedInputStream. It allows the size of the output buffer to be specified in a constructor as well as
providing for a default buffer size. It overrides the methods of the OutputStream class and does not
introduce any new methods of its own.
The BufferedIOApp Program
The BufferedIOApp program (see Listing 17.4) builds on the SequenceIOApp example that was
previously presented. It performs buffering on the SequenceInputStream object used to combine the
input from two separate files. It also performs buffering on program output so that characters do not
need to be displayed to the console window a single character at a time.
LISTING 17.4. THE SOURCE CODE OF THE BufferedIOApp PROGRAM.
import java.lang.System;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.SequenceInputStream;
import java.io.IOException;
public class BufferedIOApp {
public static void main(String args[]) throws IOException {
SequenceInputStream f3;
FileInputStream f1 = new FileInputStream("ByteArrayIOApp.java");
FileInputStream f2 = new FileInputStream("FileIOApp.java");
f3 = new SequenceInputStream(f1,f2);
// Create the buffered input and output streams
BufferedInputStream inStream = new BufferedInputStream(f3);
BufferedOutputStream outStream = new BufferedOutputStream(System.
out);
inStream.skip(500);
boolean eof = false;
int byteCount = 0;
while (!eof) {
int c = inStream.read();
if(c == -1) eof = true;
else{
outStream.write((char) c);
++byteCount;
}
}
String bytesRead = String.valueOf(byteCount);
bytesRead+=" bytes were read\n";
outStream.write(bytesRead.getBytes(),0,bytesRead.length());
inStream.close();
outStream.close();
f1.close();
f2.close();
}
}
The program begins by creating two objects of FileInputStream and combining them into a single
input stream using the SequenceInputStream constructor. It then uses this stream to create an object
of BufferedInputStream using the default buffer size.
A BufferedOutputStream object is created using the System.out output stream and a default buffer
size. The skip() method is used to skip over 500 bytes of the input stream. This is done for two
reasons: to illustrate the use of the skip() method and to cut down on the size of the program output.
The rest of the input is read and printed, as in the previous example.
The program output is similar to that of the preceding example. You should execute BufferedIOApp
from the \ch17 directory. The skip() method was used to skip over 500 bytes of input. These bytes are
also absent from the program's output, which is as follows:
rrayInputStream inStream;
inStream = new ByteArrayInputStream(outStream.toByteArray());
int inBytes = inStream.available();
System.out.println("inStream has "+inBytes+" available bytes");
byte inBuf[] = new byte[inBytes];
int bytesRead = inStream.read(inBuf,0,inBytes);
System.out.println(bytesRead+" bytes were read");
System.out.println("They are: "+new String(inBuf));
}
}
import java.lang.System;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.File;
import java.io.IOException;
public class FileIOApp {
public static void main(String args[]) throws IOException {
FileOutputStream outStream = new FileOutputStream("test.txt");
String s = "This is a test.";
for(int i=0;i<s.length();++i)
outStream.write(s.charAt(i));
outStream.close();
FileInputStream inStream = new FileInputStream("test.txt");
int inBytes = inStream.available();
System.out.println("inStream has "+inBytes+" available bytes");
byte inBuf[] = new byte[inBytes];
int bytesRead = inStream.read(inBuf,0,inBytes);
System.out.println(bytesRead+" bytes were read");
System.out.println("They are: "+new String(inBuf));
inStream.close();
File f = new File("test.txt");
f.delete();
}
}
1263 bytes were read
PushbackInputStream
PushbackInputStream is a filter that lets you push a byte that was previously read back onto the input
stream so that it can be reread. This type of filter is commonly used with parsers. When a character
indicating a new input token is read, it is pushed back onto the input stream until the current input
token is processed. It is then reread when processing of the next input token is initiated.
PushbackInputStream allows only a single byte to be pushed back. This is generally enough for most
applications.
The pushback character is stored in a variable named pushBack.
The unread() method is the only new method introduced by this class. It is used to push a specified
character back onto the input stream.
The PushbackIOApp Program
The PushbackIOApp program illustrates the use of the PushbackInputStream class (see Listing 17.5).
It adds a pushback filter to the ByteArrayIOApp program shown earlier in this chapter.
LISTING 17.5. THE SOURCE CODE OF THE PushbackIOApp PROGRAM.
import java.lang.System;
import java.io.PushbackInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class PushbackIOApp {
public static void main(String args[]) throws IOException {
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
String s = "This is a test.";
for(int i=0;i<s.length();++i)
outStream.write(s.charAt(i));
System.out.println("outstream: "+outStream);
System.out.println("size: "+outStream.size());
ByteArrayInputStream inByteArray;
inByteArray = new ByteArrayInputStream(outStream.toByteArray());
PushbackInputStream inStream;
inStream = new PushbackInputStream(inByteArray);
char ch = (char) inStream.read();
System.out.println("First character of inStream is "+ch);
// Push `t' back onto stream
inStream.unread((int) `t');
int inBytes = inStream.available();
System.out.println("inStream has "+inBytes+" available bytes");
byte inBuf[] = new byte[inBytes];
for(int i=0;i<inBytes;++i) inBuf[i]=(byte) inStream.read();
System.out.println("They are: "+new String(inBuf));
}
}
PushbackIOApp creates a stream to be used for byte array input using the code of the
ByteArrayIOApp program. It applies a pushback filter to this stream by using the
PushbackInputStream filter to create an object of class PushbackInputStream. It reads the first
character of the input stream and displays it. It then pushes back a t onto the input stream. Note that
any character could have been pushed back upon the input stream. The new input stream is then read
and displayed.
The program output shows how the pushback filter was used to change the first character of the input
stream from an uppercase T to a lowercase t. The program output consists of the following:
outstream: This is a test.
size: 15
First character of inStream is T
inStream has 15 available bytes
They are: this is a test.
The LineNumberInputStream Class
The LineNumberInputStream class provides a handy capability for keeping track of input line
numbers. It is also a subclass of FilterInputStream. This class provides two new methods to support
line number processing. The setLineNumber() method is used to set the current line number to a
particular value. The getLineNumber() method is used to obtain the value of the current line number.
Up until Java 1.1, the LineNumberInputStream class was the preferred class for tracking input line
numbers. In Java 1.1, significant support was added for internationalization. As a result, the
LineNumberInputStream class has been deprecated. The LineNumberReader class (covered later in
this chapter) is now the preferred class for tracking input line numbers.
Data I/O
The DataInputStream and DataOutputStream classes implement the DataInput and DataOutput
interfaces. These interfaces identify methods that allow primitive data types to be read from and
written to a stream. By implementing these interfaces, the DataInputStream and DataOutputStream
classes provide the basis for implementing portable input and output streams.
The DataInputStream Class
The DataInputStream class provides the capability to read arbitrary objects and primitive types from
an input stream. It implements the methods of the DataInput interface. These methods provide a full
range of input capabilities:
●
readBoolean()--Reads a boolean value.
●
readByte()--Reads a byte as an 8-bit signed value.
●
readChar()--Reads a Unicode character.
●
readDouble()--Reads a double value.
●
readFloat()--Reads a float value.
●
readFully()--Reads an array of bytes.
●
readInt()--Reads an int value.
●
readLine()--Reads a line of text (deprecated).
●
readLong()--Reads a long value.
●
readShort()--Reads a short value.
●
readUnsignedByte()--Reads a byte as an 8-bit unsigned value.
●
readUnsignedShort()--Reads an unsigned 16-bit value.
●
readUTF()--Reads a string that is in the UTF-8 format.
●
skipBytes()--Skips over a specified number of input bytes.
Note that most, but not all, of these methods raise the EOFException when an end of file is
encountered. The readLine() method returns a null value to signify a read past the end of a file. This
method was deprecated in Java 1.1. The readLine() method of the BufferedReader class should be
used instead. BufferedReader provides better support for internationalization. Its readLine() method
corrects errors that exist in the readLine() method of DataInputStream.
The DataOutputStream Class
The DataOutputStream class provides an output complement to DataInputStream. It allows arbitrary
objects and primitive data types to be written to an output stream. It also keeps track of the number of
bytes written to the output stream. It is an output filter and can be combined with any output-filtering
streams.
The DataIOApp Program
The program in Listing 17.6 shows how DataInputStream and DataOutputStream can be used to
easily read and write a variety of values using streams.
LISTING 17.6. THE SOURCE CODE OF THE DataIOApp PROGRAM.
import java.lang.System;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.File;
import java.io.IOException;
public class DataIOApp {
public static void main(String args[]) throws IOException {
File file = new File("test.txt");
FileOutputStream outFile = new FileOutputStream(file);
DataOutputStream outStream = new DataOutputStream(outFile);
// Write various data types to the output stream
outStream.writeBoolean(true);
outStream.writeInt(123456);
outStream.writeChar(`j');
outStream.writeDouble(1234.56);
System.out.println(outStream.size()+" bytes were written");
outStream.close();
outFile.close();
FileInputStream inFile = new FileInputStream(file);
DataInputStream inStream = new DataInputStream(inFile);
System.out.println(inStream.readBoolean());
System.out.println(inStream.readInt());
System.out.println(inStream.readChar());
System.out.println(inStream.readDouble());
inStream.close();
inFile.close();
file.delete();
}
}
The program creates an object of class File that is used to access the test.txt file. This object is used to
create an instance of class FileOutputStream that is assigned to the outFile variable. An object of
class DataOutputStream is then constructed as a filter for the FileOutputStream object.
The writeBoolean(), writeChar(), writeInt(), and writeDouble() methods of DataOutputStream are
used to write examples of primitive data types to the filtered output stream. The number of bytes
written to the output stream is determined by the size() method and displayed to the console window.
The output streams are then closed.
The File object, created at the beginning of the program, is then used to create an object of class
FileInputStream. The output stream is then filtered by creating an object of DataInputStream.
The primitive data types that were written to the output file in the beginning of the program are now
read from the filtered input stream and displayed to the console window.
The program's output shows that the data values were successfully written and read using the data I/O
filters:
15 bytes were written
true
123456
j
1234.56
The PrintStream Class
The PrintStream class should be no stranger to you. The System.out object that you have been using
for most of the sample programs is an instance of the PrintStream class. It is used to write output to
the Java console window.
PrintStream's power lies in the fact that it provides two methods, print() and println(), that are
overloaded to print any primitive data type or object. Objects are printed by first converting them to
strings using their toString() method, inherited from the Object class. To provide custom printing for
any class, all you have to do is override the toString() method for that class.
PrintStream provides the capability to automatically flush all output bytes in the stream when a new
line character is written to the stream. This feature can be enabled or disabled when the stream is
created.
Because PrintStream is a filter, it takes an instance of OutputStream as an argument to its constructor.
A second constructor adds the capability to use the autoflushing feature.
PrintStream introduces only one new method besides the extensively overloaded print() and println()
methods. The checkError() method is used to flush stream output and determine whether an error
occurred on the output stream. This capability is useful for printing output to devices, such as
printers, where error status is needed to notify the user of any changes to the device state.
Piped I/O
Piped I/O provides the capability for threads to communicate via streams. A thread sends data to
another thread by creating an object of PipedOutputStream that it connects to an object of
PipedInputStream. The output data written by one thread is read by another thread using the
PipedInputStream object.
The process of connecting piped input and output threads is symmetric. An object of class
PipedInputThread can also be connected to an existing object of class PipedOutputThread.
Java automatically performs synchronization with respect to piped input and output streams. The
thread that reads from an input pipe does not have to worry about any conflicts with tasks that are
being written to the corresponding output stream thread.
Both PipedInputStream and PipedOutputStream override the standard I/O methods of InputStream
and OutputStream. The only new method provided by these classes is the connect() method. Both
classes provide the capability to connect a piped stream when it is constructed by passing the
argument of the piped stream to which it is to be connected as an argument to the constructor.
The PipedIOApp Program
The PipedIOApp program creates two threads of execution, named Producer and Consumer, that
communicate using connected objects of classes PipedOutputStream and PipedInputStream. Producer
sends the message "This is a test." to Consumer one character at a time, and Consumer reads the
message in the same manner. Producer displays its name and any characters that it writes to the
console window. Consumer reads the message and displays its name and the characters it reads to the
console window. The source code for the PipedIOApp program is shown in Listing 17.7.
LISTING 17.7. THE SOURCE CODE OF THE PipedIOApp PROGRAM.
import java.lang.Thread;
import java.lang.System;
import java.lang.InterruptedException;
import java.lang.Runnable;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.IOException;
class PipedIOApp {
public static void main(String args[]) {
Thread thread1 = new Thread(new PipeOutput("Producer"));
Thread thread2 = new Thread(new PipeInput("Consumer"));
thread1.start();
thread2.start();
boolean thread1IsAlive = true;
boolean thread2IsAlive = true;
do {
if(thread1IsAlive && !thread1.isAlive()){
thread1IsAlive = false;
System.out.println("Thread 1 is dead.");
}
if(thread2IsAlive && !thread2.isAlive()){
thread2IsAlive = false;
System.out.println("Thread 2 is dead.");
}
}while(thread1IsAlive || thread2IsAlive);
}
}
class PipeIO {
static PipedOutputStream outputPipe = new PipedOutputStream();
static PipedInputStream inputPipe = new PipedInputStream();
static {
try {
// Connect input and output pipes
outputPipe.connect(inputPipe);
}catch (IOException ex) {
System.out.println("IOException in static initializer");
}
}
String name;
public PipeIO(String id) {
name = id;
}
}
class PipeOutput extends PipeIO implements Runnable {
public PipeOutput(String id) {
super(id);
}
public void run() {
String s = "This is a test.";
try {
for(int i=0;i<s.length();++i){
outputPipe.write(s.charAt(i));
System.out.println(name+" wrote "+s.charAt(i));
}
outputPipe.write(`!');
} catch(IOException ex) {
System.out.println("IOException in PipeOutput");
}
}
}
class PipeInput extends PipeIO implements Runnable {
public PipeInput(String id) {
super(id);
}
public void run() {
boolean eof = false;
try {
while (!eof) {
int inChar = inputPipe.read();
if(inChar != -1) {
char ch = (char) inChar;
if(ch=='!'){
eof=true;
break;
}else System.out.println(name+" read "+ch);
}
}
} catch(IOException ex) {
System.out.println("IOException in PipeOutput");
}
}
}
This program is somewhat longer than the other examples in this chapter due to the overhead needed
to set up the threading. The main() method creates the two Producer and Consumer threads as objects
of classes PipeOutput and PipeInput. These classes are subclasses of PipeIO that implement the
Runnable interface. The main() method starts both threads and then loops, checking for their death.
The PipeIO class is the superclass of the PipeOutput and PipeInput classes. It contains the static
variables, outputPipe and inputPipe, that are used for interthread communication. These variables are
assigned objects of classes PipedOutputStream and PipeInputStream. The static initializer is used to
connect outputPipe with inputPipe using the connect() method. The PipeIO constructor provides the
capability to maintain the name of its instances. This is used by the PipeInput and PipeOutput classes
to store thread names.
The PipeOutput class extends PipeIO and implements the Runnable interface, making it eligible to be
executed as a separate thread. The required run() method performs all thread processing. It loops to
write the test message one character at a time to the outputPipe. It also displays its name and the
characters that it writes to the console window. The ! character is used to signal the end of the
message transmission. Notice that IOException is handled within the thread rather than being
identified in the throws clause of the run() method. In order for run() to properly implement the
Runnable interface, it cannot throw any exceptions.
The PipeInput class also extends PipeIO and implements the Runnable interface. It simply loops and
reads a character at a time from inputPipe, displaying its name and the characters that it reads to the
console window. It also handles IOException in order to avoid having to identify the exception in its
throws clause.
The output of PipeIOApp shows the time sequencing of the thread input and output taking place
using the connected pipe I/O streams. The output generated by running the program on your
computer will probably differ because of differences in your computer's execution speed and I/O
performance. The output generated when I ran the program is as follows:
Producer
Producer
Producer
Producer
Producer
Consumer
Consumer
Consumer
Producer
Producer
Producer
Consumer
Consumer
Producer
Producer
Producer
Consumer
Consumer
Consumer
Producer
Producer
Consumer
Consumer
Consumer
Producer
Producer
Thread 1
Consumer
Consumer
Consumer
Consumer
Thread 2
wrote T
wrote h
wrote i
wrote s
wrote
read T
read h
read i
wrote i
wrote s
wrote
read s
read
wrote a
wrote
wrote t
read i
read s
read
wrote e
wrote s
read a
read
read t
wrote t
wrote .
is dead.
read e
read s
read t
read .
is dead.
Object I/O
The ObjectOutputStream and ObjectInputStream classes allow objects and values of primitive types
to be written to and read from streams. These classes implement the ObjectOutput and ObjectInput
interfaces. Of the methods specified by ObjectOutput, the writeObject() method is the most
interesting; it writes objects that implement the Serializable interface to a stream. The ObjectInput
interface provides the readObject() method to read the objects written to a stream by the writeObject
() method.
The Serializable interfaces are used to identify objects that can be written to a stream. It does not
define any constants or methods, but it does place some constraints on which classes are serializable.
Chapter 40, "Using Object Serialization and JavaSpaces," covers the Serializable interface and object
I/O in detail.
The ObjectIOApp Program
The ObjectIOApp program, shown in Listing 17.8, shows how the ObjectOutputStream and
ObjectInputStream classes can be used to write and read objects from streams.
LISTING 17.8. THE SOURCE CODE OF THE ObjectIOApp PROGRAM.
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.File;
import java.io.IOException;
import java.util.Date;
public class ObjectIOApp {
public static void main(String args[]) throws IOException,
ClassNotFoundException {
File file = new File("test.txt");
FileOutputStream outFile = new FileOutputStream(file);
ObjectOutputStream outStream = new ObjectOutputStream(outFile);
TestClass1 t1 = new TestClass1(true,9,'A',0.0001,"java");
TestClass2 t2 = new TestClass2();
String t3 = "This is a test.";
Date t4 = new Date();
// Write objects to stream
outStream.writeObject(t1);
outStream.writeObject(t2);
outStream.writeObject(t3);
outStream.writeObject(t4);
outStream.close();
outFile.close();
FileInputStream inFile = new FileInputStream(file);
ObjectInputStream inStream = new ObjectInputStream(inFile);
// Read objects from stream and display them
System.out.println(inStream.readObject());
System.out.println(inStream.readObject());
System.out.println(inStream.readObject());
System.out.println(inStream.readObject());
inStream.close();
inFile.close();
file.delete();
}
}
class TestClass1 implements Serializable {
boolean b;
int i;
char c;
double d;
String s;
TestClass1(boolean b,int i,char c,double d,String s){
this.b = b;
this.i = i;
this.c = c;
this.d = d;
this.s = s;
}
public String toString(){
String r = String.valueOf(b)+" ";
r += String.valueOf(i)+" ";
r += String.valueOf(c)+" ";
r += String.valueOf(d)+" ";
r += String.valueOf(s);
return r;
}
}
class TestClass2 implements Serializable {
int i;
TestClass1 tc1;
TestClass1 tc2;
TestClass2(){
i=0;
tc1 = new TestClass1(true,2,'j',1.234,"Java");
tc2 = new TestClass1(false,7,'J',2.468,"JAVA");
}
public String toString(){
String r = String.valueOf(i)+" ";
r += tc1.toString()+" ";
r += tc2.toString();
return r;
}
}
ObjectIOApp is similar in design to the DataIOApp program in Listing 17.6. It creates a File object to
support I/O to the test.txt file. The File object is used to create an object of class FileOutputStream.
This object is then used to create an object of class ObjectOutputStream, which is assigned to the
outStream variable.
Four objects are created and assigned to the t1 through t4 variables. An object of class TestClass1 is
assigned to the t1 variable, and an object of class TestClass2 is assigned to the t2 variable. The
TestClass1 and TestClass2 classes are declared at the end of Listing 17.8. A String object is assigned
to t3, and a Date object is assigned to t4.
The objects referenced by the t1 through t4 variables are written to outStream using the writeObject()
method. The stream and file are then closed. The test.txt file is reopened as a FileInputStream object,
which is then converted to an ObjectInputStream object and assigned to the inStream variable. Four
objects are read from inStream, using the readObject() method, and then written to standard output.
The program's output is as follows:
true 9 A 1.0E-4 java
0 true 2 j 1.234 Java false 7 J 2.468 JAVA
This is a test.
Thu Jan 15 17:43:16 PST 1998
Note that you'll receive a different date value from this one. TestClass1 and TestClass2 are dummy
test classes that are used to make the example work. Their toString() methods are automatically
invoked by the println() method to convert objects to string values for printing.
The Reader and Writer Classes
The Reader and Writer classes are abstract classes at the top of a class hierarchy that support the
reading and writing of Unicode character streams. These classes were introduced with Java 1.1.
The Reader Class
The Reader class supports the standard read(), reset(), skip(), mark(), markSupported(), and close()
methods. In addition to these, the ready() method returns a boolean value that indicates whether the
next read operation will succeed without blocking.
The direct subclasses of the Reader class are BufferedReader, CharArrayReader, FilterReader,
InputStreamReader, PipedReader, and StringReader.
The Writer Class
The Writer class is the output complement to the Reader class. It declares the write(), flush(), and
close() methods. Its direct subclasses are BufferedWriter, CharArrayWriter, FilterWriter,
OutputStreamWriter, PipedWriter, StringWriter, and PrintWriter. Each of these subclasses, except
PrintWriter, is an output complement to a Reader subclass.
Character Array and String I/O
The CharArrayReader and CharArrayWriter classes are similar to the ByteArrayInputStream and
ByteArrayOutputStream classes in that they support I/O from memory buffers. The difference
between these classes is that CharArrayReader and CharArrayWriter support 16-bit character I/O,
and ByteArrayInputStream and ByteArrayOutputStream support 8-bit byte array I/O.
The CharArrayReader class does not add any new methods to those provided by Reader. The
CharArrayWriter class adds the following methods to those provided by Writer:
●
reset()--Resets the buffer so that it can be read.
●
size()--Returns the current size of the buffer.
●
toCharArray()--Returns a character array copy of the output buffer.
●
toString()--Copies and converts the output buffer to a String object.
●
writeTo()--Writes the buffer to another output stream (Writer object).
These methods are similar to those provided by the ByteArrayOutputStream class.
The StringReader class provides the capability to read character input from a string. Like
CharArrayReader, it does not add any additional methods to those provided by Reader. The
StringWriter class is used to write character output to a StringBuffer object. It adds the getBuffer()
and toString() methods. The getBuffer() method returns the StringBuffer object corresponding to the
output buffer. The toString() method returns a String copy of the output buffer.
The CharArrayIOApp and StringIOApp Programs
The CharArrayIOApp program (see Listing 17.9) is based on the ByteArrayIOApp program (see
Listing 17.1) introduced at the beginning of this chapter. It writes the string "This is a test." one
character at a time to a CharArrayWriter object. It then converts the output buffer to a
CharArrayReader object. Each character of the input buffer is read and appended to a StringBuffer
object. The StringBuffer object is then converted to a String object. The number of characters read
and the String object are then displayed. The program output follows:
outstream: This is a test.
size: 15
15 characters were read
They are: This is a test.
The StringIOApp program (see Listing 17.10) is similar to CharArrayIOApp. It writes output to a
StringBuffer instead of a character array. It produces the same output as CharArrayIOApp.
LISTING 17.9. THE SOURCE CODE OF THE CharArrayIOApp PROGRAM.
import java.lang.System;
import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.IOException;
public class CharArrayIOApp {
public static void main(String args[]) throws IOException {
CharArrayWriter outStream = new CharArrayWriter();
String s = "This is a test.";
for(int i=0;i<s.length();++i)
outStream.write(s.charAt(i));
System.out.println("outstream: "+outStream);
System.out.println("size: "+outStream.size());
CharArrayReader inStream;
inStream = new CharArrayReader(outStream.toCharArray());
int ch=0;
StringBuffer sb = new StringBuffer("");
while((ch = inStream.read()) != -1)
sb.append((char) ch);
s = sb.toString();
System.out.println(s.length()+" characters were read");
System.out.println("They are: "+s);
}
}
LISTING 17.10. THE SOURCE CODE OF THE StringIOApp PROGRAM.
import java.lang.System;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.IOException;
public class StringIOApp {
public static void main(String args[]) throws IOException {
StringWriter outStream = new StringWriter();
String s = "This is a test.";
for(int i=0;i<s.length();++i)
outStream.write(s.charAt(i));
System.out.println("outstream: "+outStream);
System.out.println("size: "+outStream.toString().length());
StringReader inStream;
inStream = new StringReader(outStream.toString());
int ch=0;
StringBuffer sb = new StringBuffer("");
while((ch = inStream.read()) != -1)
sb.append((char) ch);
s = sb.toString();
System.out.println(s.length()+" characters were read");
System.out.println("They are: "+s);
}
}
The InputStreamReader and OutputStreamWriter Classes
The InputStreamReader and OutputStreamWriter classes are used to convert between byte streams
and character streams. The InputStreamReader class converts an object of an InputStream subclass
into a character-oriented stream. The OutputStreamWriter class converts a character output stream to
a byte output stream.
The InputStreamReader Class
The InputStreamReader() constructor takes an InputStream object as a parameter and creates an
InputStreamReader object. This provides a bridge between byte-oriented input streams and characteroriented input streams. A second InputStreamReader constructor also takes a String parameter that
identifies the character encoding to be used in byte-to-character conversion. The getEncoding()
method may be used to retrieve the encoding that is in effect. The ready() method is used to
determine whether a character can be read without blocking.
The InputConversionApp Program
The InputConversionApp program, shown in Listing 17.11, converts the standard input stream
(System.in) from a byte stream to a character stream. The input characters are echoed to standard
output. It also prints out the encoding that is in effect on your system. The following is an example of
the output generated when the program is run on my computer:
Encoding: 8859_1
>This is a test.
This is a test.
>
The 8859_1 encoding is the International Standard Organization (ISO) Latin-1 character encoding.
Chapter 19, "Internationalization," identifies other encodings.
LISTING 17.11. THE SOURCE CODE OF THE InputConversionApp PROGRAM.
import java.lang.System;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.IOException;
public class InputConversionApp {
public static void main(String args[]) throws IOException {
InputStreamReader in = new InputStreamReader(System.in);
BufferedReader inStream = new BufferedReader(in);
// Get the encoding that is in use
System.out.println("Encoding: "+in.getEncoding());
String inputLine;
do {
System.out.print(">");
System.out.flush();
inputLine=inStream.readLine();
System.out.println(inputLine);
} while (inputLine.length() != 0);
}
}
The OutputStreamWriter Class
The OutputStreamWriter class allows a character stream to be converted to a byte stream. Its
constructor takes the name of an object of an OutputStream subclass as a parameter. The characters
written to an OutputStreamWriter object are translated and written to the OutputStream object
specified in the OutputStreamWriter object's constructor. The translation is performed according to
the encoding specified in the System property file.encoding. A different encoding scheme may be
specified by supplying the name of the encoding scheme in the OutputStreamWriter constructor. The
getEncoding() method may be used to retrieve the current character encoding that is in effect.
The FileReader and FileWriter Classes
The FileReader and FileWriter classes are subclasses of InputStreamReader and OutputStreamWriter
that are used to perform character-based file I/O. These classes do not provide any additional access
methods. However, their constructors provide the capability to create input and output character
streams using String objects that represent filenames, File objects, and FileDescriptor objects.
The CharFileIOApp Program
Listing 17.12 demonstrates the use of the FileReader and FileWriter classes. It converts the
FileIOApp program that was introduced earlier in the chapter (see Listing 17.2) to character-oriented
I/O and produces the following output:
15 characters were read
They are: This is a test.
The main difference between CharFileIOApp and FileIOApp is that FileReader and FileWriter
classes are used instead of the FileInputStream and FileOutputStream classes. The other difference is
the use of a StringBuffer object (instead of a byte array) to capture the characters read from the input
file stream.
LISTING 17.12. THE SOURCE CODE OF THE CharFileIOApp PROGRAM.
import java.lang.System;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.File;
import java.io.IOException;
public class CharFileIOApp {
public static void main(String args[]) throws IOException {
FileWriter outStream = new FileWriter("test.txt");
String s = "This is a test.";
for(int i=0;i<s.length();++i)
outStream.write(s.charAt(i));
outStream.close();
FileReader inStream = new FileReader("test.txt");
StringBuffer sb = new StringBuffer("");
int ch=0;
while((ch = inStream.read()) != -1)
sb.append((char) ch);
s = sb.toString();
System.out.println(s.length()+" characters were read");
System.out.println("They are: "+s);
inStream.close();
File f = new File("test.txt");
f.delete();
}
}
Buffered Character I/O
Buffered character I/O is supported by the BufferedReader and BufferedWriter classes. These classes
are character-based analogs to the BufferedInputStream and BufferedOutputStream classes. In Java
1.1, the readLine() method of the BuffereddReader class replaced the readLine() method of the
DataInputStream class for reading lines of text from the console, a file, or other character-oriented
input streams.
The BufferedWriter class provides the capability to write buffered data to character-based output
streams. It adds the newLine() method to the methods that it inherits (and overrides) from the Writer
class. The newLine() method allows new line characters to be written in a system-independent
manner. It is preferable to simply writing an \n character to the output stream. The line.separator
system property defines the system- specific new line character.
The LineNumberReader Class
The LineNumberReader class is a subclass of the BufferedReader class that is used to associate line
numbers with each line of text that is read from a stream. Lines are terminated by a new line
character (\n), a carriage return (\r), or a carriage return-new line combination (\r\n).
In addition to the methods that it inherits from BufferedReader, the LineNumberReader class declares
the getLineNumber() and setLineNumber() methods. The getLineNumber() method returns the
current line number. The setLineNumber() method sets the current line number to an integer value.
The LineNumberIOApp Program
The LineNumberIOApp program (see Listing 17.13) illustrates the use of the LineNumberReader
class. It creates a FileReader on the LineNumberIOApp.java source file and then uses the FileReader
object to create a LineNumberReader object. The character file is read, one line at a time, and its
contents are displayed using line numbers obtained via the getLineNumber() method. The output of
this program follows:
1. import java.lang.System;
2. import java.io.LineNumberReader;
3. import java.io.FileReader;
4. import java.io.BufferedWriter;
5. import java.io.IOException;
6.
7. public class LineNumberIOApp {
8. public static void main(String args[]) throws IOException {
9.
FileReader inFile = new FileReader("LineNumberIOApp.java");
10.
LineNumberReader inLines = new LineNumberReader(inFile);
11.
String inputLine;
12.
while ((inputLine=inLines.readLine()) != null) {
13.
System.out.println(inLines.getLineNumber()+". "+inputLine);
14.
}
15. }
16. }
LISTING 17.13. THE SOURCE CODE OF THE LineNumberIOApp PROGRAM.
import java.lang.System;
import java.io.LineNumberReader;
import java.io.FileReader;
import java.io.BufferedWriter;
import java.io.IOException;
public class LineNumberIOApp {
public static void main(String args[]) throws IOException {
FileReader inFile = new FileReader("LineNumberIOApp.java");
LineNumberReader inLines = new LineNumberReader(inFile);
String inputLine;
while ((inputLine=inLines.readLine()) != null) {
// Get and print the line number
System.out.println(inLines.getLineNumber()+". "+inputLine);
}
}
}
Filtered Character I/O
The FilterReader and FilterWriter classes are character-oriented analogs of the FilterInputStream and
FilterOutputStream classes. The FilterReader class uses the in variable for input filtering and
FilterWriter class uses the out variable for output filtering. Consult the section "Filtered I/O" earlier
in this chapter for a description of I/O filtering.
The PushbackReader Class
The PushbackReader class is a subclass of FilterReader that provides the capability to push a
character that was previously read back onto the input stream so that it can be read again. It is the
character-oriented analog of the PushbackInputStream class that you studied earlier in the chapter.
The PipedReader and PipedWriter Classes
The PipedReader and PipedWriter classes support character-oriented piped I/O in the same way that
PipedInputStream and PipedOutputStream support byte-oriented piped I/O. Consult the section
"Piped I/O" earlier in this chapter for a description of piped input and output.
The PrintWriter Class
The PrintWriter class is the character-oriented replacement for the PrintStream class. The PrintWriter
class improves PrintStream by using a platform-dependent line separator to print lines instead of the
new line (\n) character. The System line.separator property identifies the system unique line
separator. PrintWriter also provides better support for Unicode characters than PrintStream. The
checkError() method is used to flush printed output and test for an error condition. The setError()
method is used to set an error condition. PrintWriter provides support for printing primitive data
types, character arrays, strings, and general objects. Objects are converted to a string (via the
inherited or overridden toString() method) before being printed.
The RandomAccessFile Class
The RandomAccessFile class provides the capability to perform I/O directly to specific locations
within a file. The name random access comes from the fact that data can be read from or written to
random locations within a file rather than as a continuous stream of information. Random access is
supported through the seek() method, which allows the pointer corresponding to the current file
position to be set to arbitrary locations within the file.
RandomAccessFile implements both the DataInput and DataOuput interfaces. This provides the
capability to perform I/O using primitive data types.
RandomAccessFile also supports basic file read/write permissions, allowing files to be accessed in
read-only or read-write modes. A mode stream argument is passed to the RandomAccessFile
constructor as r or rw, indicating read-only and read-write file access. The read-only access attribute
may be used to prevent a file from being inadvertently modified.
RandomAccessFile introduces several new methods besides those inherited from Object and
implemented from DataInput and DataOutput. These methods include seek(), getFilePointer(), and
length(). The seek() method sets the file pointer to a particular location within the file. The
getFilePointer() method returns the current location of the file pointer. The length()method returns
the length of the file in bytes.
The RandomIOApp Program
The RandomIOApp program provides a simple demonstration of the capabilities of random-access I/
O. It writes a boolean, int, char, and double value to a file and then uses the seek() method to seek to
offset location 1 within the file. This is the position after the first byte in the file. It then reads the int,
char, and double values from the file and displays them to the console window. Next, it moves the
file pointer to the beginning of the file and reads the boolean value that was first written to the file.
This value is also written to the console window. The source code of the RandomIOApp program is
shown in Listing 17.14.
LISTING 17.14. THE SOURCE CODE OF THE RandomIOApp PROGRAM.
import java.lang.System;
import java.io.RandomAccessFile;
import java.io.IOException;
public class RandomIOApp {
public static void main(String args[]) throws IOException {
RandomAccessFile file = new RandomAccessFile("test.txt","rw");
file.writeBoolean(true);
file.writeInt(123456);
file.writeChar(`j');
file.writeDouble(1234.56);
// Use seek() to move to a specific file location
file.seek(1);
System.out.println(file.readInt());
System.out.println(file.readChar());
System.out.println(file.readDouble());
file.seek(0);
System.out.println(file.readBoolean());
file.close();
}
}
Although the processing performed by RandomIOApp is quite simple, it illustrates how random I/O
allows you to move the file pointer to various locations within a file to directly access values and
objects contained within the file.
The program's output is as follows:
123456
j
1234.56
true
The StreamTokenizer Class
The StreamTokenizer class is used by parsers to convert an input character stream into a stream of
lexical tokens. It uses special methods to identify parser parameters, such as ordinary, whitespace,
quote, and comment characters. These methods also enable and disable number and end-of-line
parsing.
Seven variables are defined for the StreamTokenizer class, four of which are constant class variables.
The TT_EOF, TT_EOL, TT_NUMBER, and TT_WORD constants are used to identify the type of
input token encountered when parsing the input stream. The ttype variable is set either to one of these
constants or to a single character based on the kind of token that is read from the input stream. The
TT_ constants are used to indicate a number, word, end of line, or end of file. When a word token is
read, the actual word is stored in the sval variable and ttype is set to TT_WORD. When a number
token is read, its value is stored in the nval variable and ttype is set to TT_NUMBER. When other
special characters, such as @ or *, are read from the input stream, they are assigned directly to the
ttype variable.
The StreamTokenizer constructor takes a Reader object as an argument and generates a
StreamTokenizer object. The StreamTokenizer access methods can be divided into two groups: parser
parameter-definition methods and stream-processing methods.
The parser parameter-definition methods are used to control the operation of the parser. The
commentChar(), slashSlashComments(), and slashStarComments() methods are used to define
comments. Comments are ignored by the parser. The whitespaceChars(), wordChars(), quoteChar(),
ordinaryChar(), and ordinaryChars() methods are used to set the parser's token-generation parameters.
The parseNumbers() and eolIsSignificant() methods toggle number and end-of-line parsing. The
lowerCaseMode() method controls whether input words are converted to lowercase, and the
resetSyntax() method is used to reset the syntax table, causing all characters to be treated as special
characters.
The stream-processing methods are used to read tokens from the input stream, push tokens back out
onto the input stream, and return the current line number associated with the input stream. The
nextToken() method is used to get the next token from the input stream. The pushBack() method
pushes the current token back out onto the input stream. The lineno() method returns the current line
number associated with the input stream.
The toString() method of class Object is overwritten to allow printing of the current token.
The StreamTokenApp Program
The StreamTokenApp program demonstrates the ease with which StreamTokenizer can be used to
create a parser. This program reads input from the standard input stream, parses input tokens, and
displays the token type and value to the console window (see Listing 17.15).
LISTING 17.15. THE SOURCE CODE OF THE StreamTokenApp PROGRAM.
import java.lang.System;
import java.io.StreamTokenizer;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.IOException;
public class StreamTokenApp {
public static void main(String args[]) throws IOException {
BufferedReader inData =
new BufferedReader(new InputStreamReader(System.in));
StreamTokenizer inStream = new StreamTokenizer(inData);
inStream.commentChar(`#');
boolean eof = false;
do {
int token=inStream.nextToken();
// Parse according to input token
switch(token){
case inStream.TT_EOF:
System.out.println("EOF encountered.");
eof = true;
break;
case inStream.TT_EOL:
System.out.println("EOL encountered.");
break;
case inStream.TT_WORD:
System.out.println("Word: "+inStream.sval);
break;
case inStream.TT_NUMBER:
System.out.println("Number: "+inStream.nval);
break;
default:
System.out.println((char) token+" encountered.");
if(token=='!') eof=true;
}
} while(!eof);
}
}
The program creates a new object of class BufferedReader using System.in as an argument. It then
converts the BufferedReader object into a StreamTokenizer object and assigns it to the inStream
variable. It then sets the comment-line character to #.
Having set up the parser, StreamTokenApp reads tokens from inStream until the end of file is
encountered. It uses a switch statement to identify the type and value of each token read.
The following is an example of the output produced by StreamTokenizer. Try running it with
different input lines. An exclamation point (!) is used to terminate the program's execution:
This is a test.
Word: This
Word: is
Word: a
Word: test.
123 456
Number: 123.0
Number: 456.0
12.34 56.78
Number: 12.34
Number: 56.78
@ $ % ^
@ encountered.
$ encountered.
% encountered.
^ encountered.
#This is a comment
This is #a comment
Word: This
Word: is
!
© Copyright, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
- 18 Printing
●
●
●
JDK 1.1 Printing Classes and Methods
❍ Working with Print Jobs
❍ output+="\nPage dimension (in pixels):";
❍ Page Layout Controls
❍ void printDimensions(Graphics g,Dimension size){
❍ Printing Text and Graphics
❍ setMenuBar(menuBar);
The java.awt.print Package
❍ The PrintBookApp Program
Summary
One of the most useful capabilities that can be added to a Java program is printing information that is
created with the program. Printing support was added in version 1.1 of the JDK but was both
primitive and inconsistent. JDK 1.2 adds new printing support that corrects the deficiencies of JDK
1.1.
This chapter shows you how to print from your window programs. It identifies the AWT classes and
methods used for printing, covers several programming examples that explain how to print text and
graphics, and shows how to work with print jobs. When you finish this chapter, you'll be able to
include printing capabilities in your applications and applets.
JDK 1.1 Printing Classes and Methods
The printing support provided with JDK 1.1 uses the PrintJob class of java.awt. This is an abstract
class used to encapsulate print requests. An object of the PrintJob class is returned by the getPrintJob
() method of the Toolkit class. This method initiates a platform-dependent print request using
platform-specific dialog boxes. It has three parameters: a Frame object that identifies the application
window from which the print request is generated, a String object that provides a title for the print
job, and a Properties object that allows job-specific print properties to be specified and retrieved.
NOTE: In the Java vernacular, you draw on a Graphics object to display information
to the screen or printer.
The PrintJob class provides the following six methods:
●
●
●
●
getGraphics()--Returns a Graphics object that is drawn on to accomplish the printing. The
Graphics object is sent to the printer when its disposed() method is invoked.
getPageDimension()--Returns a Dimension object that identifies the width and height in pixels
of the page to be printed.
getPageResolution()--Identifies the page resolution in pixels per inch.
lastPageFirst()--Returns a boolean value indicating whether the pages of a print job are printed
in reverse order.
●
end()--Completes the print job.
●
finalize()--Invoked by the garbage collector when the PrintJob is no longer in use.
The getGraphics() method is key to printing--it provides a Graphics object that is used for drawing
text and graphics. This Graphics object implements the PrintGraphics interface, which can be used to
distinguish between a Graphics object that is used for printing and one that is used for screen display.
The PrintGraphics interface consists of a single method, getPrintJob(), which returns the PrintJob
associated with the Graphics object.
After drawing has been completed for a Graphics object, the object's dispose() method is invoked,
which causes it to be printed. The end() method is invoked to end a print job.
The getPageResolution()and getPageDimension()methods are used to determine how a page is to be
laid out. The getPageResolution() method returns the number of pixels per inch supported by a
printer. The page dimensions returned by getPageDimension() are not the actual pixel dimensions of
the page to be printed. Rather, the dimensions are a mapping (often unsuccessful) of screen
coordinates to the graphics context used for printing. Because the dimensions returned by this method
are inaccurate (as you'll see in the next section), it should not be used for page layout.
Working with Print Jobs
The PrintJob class is easy to use. To create a PrintJob object, invoke the getPrintJob() method of the
Toolkit class. You can then invoke the methods of the PrintJob class to retrieve printer information,
obtain a PrintGraphics object, or complete a print job. The PrintTestApp program, shown in Listing
18.1, shows how to work with PrintJob objects to obtain printer-related information. When you run
this program, the opening window, shown in Figure 18.1, is displayed. Select Print from the File
menu and a Print dialog box, similar to the one shown in Figure 18.2, is displayed. Click the OK
button and the Print dialog box closes. The program window is updated to display the following
information, as shown in Figure 18.3:
●
The name of the print job
●
Any Properties object returned by the getPrintJob() request
●
The dimensions of the page in pixels
●
The printer's resolution in pixels per inch
●
Whether the printer prints the last page first
Depending on your printer and printer driver, the program may cause a blank page to be ejected.
LISTING 18.1. THE SOURCE CODE OF THE PrintTestApp PROGRAM.
import java.awt.*;
import java.awt.event.*;
import java.util.Properties;
import ju.ch09.*;
public class PrintTestApp extends Frame {
Object menuItems[][] = {{"File","Print","-","Exit"}};
MenuItemHandler mih = new MenuItemHandler();
MyMenuBar menuBar = new MyMenuBar(menuItems,mih,mih);
TextArea textArea = new TextArea();
Toolkit toolkit;
int screenWidth = 300;
int screenHeight = 300;
public static void main(String args[]){
PrintTestApp app = new PrintTestApp();
}
public PrintTestApp() {
super("PrintTestApp");
setup();
setSize(screenWidth,screenHeight);
addWindowListener(new WindowEventHandler());
show();
}
void setup() {
setMenuBar(menuBar);
toolkit=getToolkit();
add("Center",textArea);
}
class MenuItemHandler implements ActionListener, ItemListener {
public void actionPerformed(ActionEvent ev){
String s=ev.getActionCommand();
String name="Test print job";
Properties properties=new Properties();
if(s=="Exit"){
System.exit(0);
}else if(s=="Print"){
PrintJob pj=toolkit.getPrintJob(PrintTestApp.this,
name,properties);
if(pj==null) textArea.setText("A null PrintJob was returned.");
else{
String output="Name: "+name+"\nProperties: "+properties.
toString();
Dimension pageDim=pj.getPageDimension();
int resolution=pj.getPageResolution();
boolean lastPageFirst=pj.lastPageFirst();
output+="\nPage dimension (in pixels):";
output+="\n height: "+String.valueOf(pageDim.height);
output+="\n width: "+String.valueOf(pageDim.width);
output+="\nResolution (pixels/inch): "+String.valueOf
(resolution);
output+="\nLast Page First: "+String.valueOf(lastPageFirst);
textArea.setText(output);
Graphics g = pj.getGraphics();
g.dispose();
pj.end();
}
}
}
public void itemStateChanged(ItemEvent e){
}
}
class WindowEventHandler extends WindowAdapter {
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
FIGURE 18.1. The opening window of the PrintTestApp program.
FIGURE 18.2. A Windows 95 Print dialog box.
Figure 18.3 shows the parameters that are displayed for my Canon BJC-70 printer.
FIGURE 18.3. The printer information for a Canon BJC-70 printer.
The setup() method of the PrintTestApp class creates a Toolkit object and assigns it to the toolkit
variable. It also creates a TextArea object to display results to the user. The MenuItemHandler class
handles the selection of the Print menu item by invoking the Toolkit class's getPrintJob() method to
return a PrintJob object for printing. This object is assigned to the pj variable. The pj variable is
checked to make sure that the print job is not null. In this case, the getPageDimension(),
getPageResolution(), and lastPageFirst() methods are invoked to retrieve information about the
printer. This information is displayed to the screen, along with the Properties object returned by the
getPrintJob() method. The getGraphics() method of the PrintJob class is invoked to retrieve a
Graphics object for printing. This object is immediately disposed by invoking its dispose() method.
The end() method of the PrintJob class is then invoked to complete the processing of the print job.
The values of the page dimensions reported for the Canon BJC-70 printer were 792 pixels by 612
pixels. The values returned for other printers will differ. These dimensions are not the physical
dimensions of a printed page, as you'll see in the next section. The printer resolutions in pixels per
inch returned by getPageResolution() is 72. My printer is configured for 360 pixels per inch.
However, 792 by 612 at 72 pixels per inch represents an 11 by 8.5 inch page.
Page Layout Controls
Java programs are required to perform their own page layout and pagination. The getPageDimension
() and getPageResolution() methods provide the mechanism to do this. Unfortunately, these methods
do not always return correct results. The methods return logical page dimensions that are used to
provide compatibility with the screen display.
The PrintDimApp program, shown in Listing 18.2, illustrates the use of the getPageDimension()
method in laying out pages for printing. The PrintDimApp opening screen is shown in Figure 18.4.
When you select Print from the File menu, it prints a rectangle around the border of a page. On my
Canon BJC-70 printer, it prints the rectangle with 10 percent margins around the page. You can use
this program to determine how well the page dimensions returned by getPageDimension() work with
your printer.
FIGURE 18.4. The opening window of the PrintDimApp program.
LISTING 18.2. THE SOURCE CODE OF THE PrintDimApp PROGRAM.
import java.awt.*;
import java.awt.event.*;
import java.util.Properties;
import ju.ch09.*;
public class PrintDimApp extends Frame {
Object menuItems[][] = {{"File","Print","-","Exit"}};
MenuItemHandler mih = new MenuItemHandler();
MyMenuBar menuBar = new MyMenuBar(menuItems,mih,mih);
Toolkit toolkit;
int screenWidth = 200;
int screenHeight = 200;
public static void main(String args[]){
PrintDimApp app = new PrintDimApp();
}
public PrintDimApp() {
super("PrintDimApp");
setup();
setSize(screenWidth,screenHeight);
addWindowListener(new WindowEventHandler());
show();
}
void setup() {
setMenuBar(menuBar);
toolkit=getToolkit();
}
void printDimensions(Graphics g,Dimension size){
int width=size.width;
int height=size.height;
int x1=(int) (width*0.1);
int x2=(int) (width*0.9);
int y1=(int) (height*0.1);
int y2=(int) (height*0.9);
g.drawRect(x1,y1,x2-x1,y2-y1);
g.dispose();
}
class MenuItemHandler implements ActionListener, ItemListener {
public void actionPerformed(ActionEvent ev){
String s=ev.getActionCommand();
String name="Test print job";
Properties properties=new Properties();
if(s=="Exit"){
System.exit(0);
}else if(s=="Print"){
PrintJob pj=toolkit.getPrintJob(PrintDimApp.this,
name,properties);
if(pj!=null){
printDimensions(pj.getGraphics(),pj.getPageDimension());
pj.end();
}
}
}
public void itemStateChanged(ItemEvent e){
}
}
class WindowEventHandler extends WindowAdapter {
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
The overall structure of PrintDimApp is similar to PrintTestApp. The major difference between the
two programs is the way that the Print menu item is handled.
The PrintDimApp program creates a PrintJob object using the getPrintJob() method of the Toolkit
class. It invokes the printDimensions() method, passing it a Graphics object and Dimension object
retrieved via the getGraphics() and getPageDimension() methods of PrintJob.
The printDimensions() method uses the Dimension object to draw a rectangle on the Graphics object.
This rectangle is drawn with margins that are 10% of the page width and page height. The dispose()
method is invoked to initiate printing of the Graphics object.
Printing Text and Graphics
The PrintJob class provides an easy-to-use interface for printing. Text and graphics are drawn to the
printer in the same way they are drawn to the screen--you just display them to a different Graphics
object. In fact, you can copy everything that is displayed to the screen to the printer by using a
common drawing method for both. The PrintSampleApp program, shown in Listing 18.3,
demonstrates how this can be accomplished.
When you run PrintSampleApp, it displays the opening window, shown in Figure 18.5. If you select
Print from the File menu, the contents of the window can be sent to your printer. The
PrintSampleApp program shows how graphics (rectangles, circles, and lines) and text are printed.
FIGURE 18.5. The opening window of the PrintSampleApp program.
LISTING 18.3. THE SOURCE CODE FOR THE PrintSampleApp PROGRAM.
import java.awt.*;
import java.awt.event.*;
import java.util.Properties;
import ju.ch09.*;
public class PrintSampleApp extends Frame {
Object menuItems[][] = {{"File","Print","-","Exit"}};
MenuItemHandler mih = new MenuItemHandler();
MyMenuBar menuBar = new MyMenuBar(menuItems,mih,mih);
MyCanvas canvas = new MyCanvas();
Toolkit toolkit;
int screenWidth = 500;
int screenHeight = 500;
public static void main(String args[]){
PrintSampleApp app = new PrintSampleApp();
}
public PrintSampleApp() {
super("PrintSampleApp");
setup();
setSize(screenWidth,screenHeight);
addWindowListener(new WindowEventHandler());
show();
}
void setup() {
setMenuBar(menuBar);
toolkit=getToolkit();
add("Center",canvas);
}
class MenuItemHandler implements ActionListener, ItemListener {
public void actionPerformed(ActionEvent ev){
String s=ev.getActionCommand();
String name="Test print job";
Properties properties=new Properties();
if(s=="Exit"){
System.exit(0);
}else if(s=="Print"){
PrintJob pj=toolkit.getPrintJob(PrintSampleApp.this,
name,properties);
if(pj!=null){
canvas.printAll(pj.getGraphics());
pj.end();
}
}
}
public void itemStateChanged(ItemEvent e){
}
}
class WindowEventHandler extends WindowAdapter {
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
class MyCanvas extends Canvas {
public void paint(Graphics g){
Dimension size=getSize();
int width=size.width;
int height=size.height;
int x1=(int) (width*0.1);
int x2=(int) (width*0.9);
int y1=(int) (height*0.1);
int y2=(int) (height*0.9);
g.drawRect(x1,y1,x2-x1,y2-y1);
g.drawOval(x1,y1,x2-x1,y2-y1);
g.drawLine(x1,y1,x2,y2);
g.drawLine(x2,y1,x1,y2);
String text = "Print Me! ";
text+=text;
text+=text;
g.drawString(text,x1,(int)((y1+y2)/2));
g.dispose();
}
}
The PrintSampleApp program creates an object of the MyCanvas class and adds it to the center of the
application window. The paint() method of the MyCanvas class draws a rectangle, oval, two lines,
and the text Print Me! Print Me! Print Me! on a graphics object. When the screen is initially painted
and then repainted, the Graphics object is displayed to the application window. When the Print menu
item is selected from the File menu, the printAll() method of the Component class is invoked for the
MyCanvas object displayed in the application window. The printAll() method is passed the Graphics
object of a PrintJob as an argument. The printAll() method prints a Component object (and all
subcomponents) to a Graphics object. This causes the contents of the screen to be copied to the
printer.
The java.awt.print Package
The java.awt.print package is a new AWT package that was added with JDK 1.2, replacing the print
capabilities of JDK 1.1. The package consists of the following three interfaces and four classes:
●
●
●
●
●
●
●
Paper--Specifies the physical characteristics of the paper used for printing. Provides methods
for getting and setting the paper size and the drawing area.
PageFormat--Specifies the size and orientation of a page to be printed. Provides methods for
setting the Paper object to be used and the page orientation. Also provides methods for
switching the drawing space between portrait and landscape mode and for retrieving the
characteristics of the drawing area.
Pageable--An interface specifying methods used for objects that represent a set of pages to be
printed. These methods retrieve the number of pages to be printed and a specific page from
within the page list.
PrinterJob--Initiates, manages, and controls a printing request. Provides methods for printing
Pageable objects and specifying print properties.
Book--Maintains a list of pages to be printed. Provides methods for adding and managing
pages. This class implements the Pageable interface.
Printable--An interface that defines the print() method for printing a page on a Graphics
object.
PrinterGraphics--An interface that privides access to PrinterJob objects that are currently
printing.
These classes provide the capability to create and process multiple page printouts using the current
system printer. The GraphicsEnvironment class of java.awt provides the getPrinterJob() method,
which can be used to create a PrinterJob object. The getLocalGraphicsEnvironment() method is used
to produce an instance of the GraphicsEnvironment class.
Once you create a PrinterJob object, you invoke its print() method, passing it an object that
implements the Pageable interface. The Book class implements this interface and is the type of object
that you will most likely be printing.
Objects of the Book class are created using the Book() constructor and pages are added to the book
via the append() method. This method takes an argument of the PageFormat class and an argument
that implements the Printable interface. The PageFormat argument merely specifies the page format
(letter, landscape, and so on). In most cases, you will be using a default page format. The object that
implements the Printable interface is the heart of the printing application. You must create objects of
a class that implements Printable to determine how text and graphics are drawn to each page.
The Printable interface specifies one method--the print() method. This method is invoked with an
object of the Graphics class. You implement this method by drawing to the Graphics object. The
PrintBookApp program, described in the next section, shows how this is accomplished.
The PrintBookApp Program
The PrintBookApp program, shown in Listing 18.4, shows how to use the classes and interfaces of
the java.awt.print package. When you run the program, it displays the opening window, shown in
Figure 18.6. Select Print from the file menu and the program prints three pages on your printer. The
first page displays the text The JDK 1.2 Printing API really works! in the center of the page and a
horizontal line at the bottom of the page. The second page displays an oval that is surrounded by a
rectangle. The third page displays the text Last Page! in landscape mode. These three pages illustrate
the printing versatility provided by the java.awt.print package.
FIGURE 18.6. The opening window of the PrintBookApp program.
The actionPerformed() method of the MenuItemHandler class handles the selection of the Print menu
item. It creates a PrinterJob object and assigns it to the pj variable. This variable is then passed to the
createBook() method, which returns the Book object to be printed. The setPageable() method of the
PrinterJob class is used to set the Book object to be printed. The Book object is printed using the print
() method.
The createBook() method creates the three-page book that is printed. This method begins by creating
a new Book object, followed by PageFormat objects representing the default page format (letter) and
the landscape page format. A PagePrinter (described below) array is created to specify the Printable
object for each page of the book.
The size of the printable area of each page is calculated in points. (A point is 1/72 of an inch.) The
getImageableWidth() and getImageableHeight methods return the page's dimensions. These
dimensions are assigned to pageWidth and pageHeight. The default font is then set to 18-point bold
Helvetica.
The first page of the book is created as a PagePrinter object. The addPrintElement() method is used to
specify what is to be printed to the page. The argument to addPrintElement() is an object of the
PrintElement class (described later). The first print element consists of the text The JDK 1.2 Printing
API really works!, which is printed using the value of font at x-position 100 (picas) and y-position
pageHeight/2 picas. The second print element consists of a line that is drawn from (0,pageHeight) to
(pageWidth,pageHeight).
The second page draws a rectangle from (100,100) to (pageWidth-100,pageHeight-100) and an oval
from (120,120) to (pageWidth-120,pageHeight-120).
The third page draws the text Last Page! at (pageHeight/2,pageWidth/2). However, these coordinates
are switched when the page is printed in landscape mode.
The three pages are appended to the book, with the first two pages using the default format and the
last page using a landscape format.
The PagePrinter class implements the Printable interface and supports the printing of each page of the
book. It manages a Vector of PrintElement elements. This Vector is assigned to the pageContents
variable. The print() method prints a page's contents to a Graphics object. This method is invoked by
the underlying printing system, and the Graphics object is mapped to the printable portion of a page.
The print() method creates an Enumeration of the keys of the pageContents vector. It then loops
through these keys, extracts each key's value, and invokes the print() method of PrintElement object.
The PrintElement class encapsulates the objects that are printed to a page. It supports text, lines,
rectangles, and ovals. The type variable is set to text or graphics. The text variable is set to any text
that is to be printed. The font variable specifies the text's font. The shape variable is used to identify
the type of geometric shape to be displayed. The x, y, width, and height variables are used to specify
the position and size of an object that is printed.
Two constructors are provided--one for creating text elements and the other for creating graphics
elements. The print() method uses methods of the Graphics class to print text, lines, rectangles, and
ovals.
LISTING 18.4. THE PrintBookApp PROGRAM.
import java.awt.*;
import java.awt.event.*;
import java.awt.print.*;
import java.awt.geom.*;
import java.utll.*;
import ju.cho9.*;
public class PrintBookApp extends Frame {
Object menuItems [] [] = {{"File","Print","-","Exit"}};
MenuItemHandler mih = new MenuItemHandler ();
MyMenuBar menuBar = new MyMenuBar (menuItems,mih,mih);
int screenWidth = 400;
int screenHeight = 400;
public static void main(String args [] ) {
PrintBookApp app = new PrintBookApp ();
}
public PrintBookApp() {
super("PrintBookApp")'
setMenuBar(menuBar)'
setSize(screenWidth,screenHeight);
addWindowListener (new WindowEventHandler());
show();
}
Book createBook(PrinterJob pj) {
Book book = neew Book();
//Default page format
PageFormat defaultFormat = new PageFormat ()'
defaultFormat = pj.defaultPage (defaultFormat);
//Landscape page format
PageFormat landscapeFormat = new PageFormat ();
landscapeFormat.setOrientation(PageFormat.LANDSCAPE);
//Contents of each page
PagePrinter [] page = new PagePrinter [3];
//Determine page size in points (1/72 of an inch)
int pageWidth = (int) defaultFormat.getImageableWidth ();
int pageHeight = (int) defaultFormat.getImageableHeight ();
Font font = new Font ("Helvetica", Font.BOLD,18);
//Page 0
page [0] = new PagePrinter();
page[0].addPrintElement(
new PrintElement("The JDK 1.2 Printing API really works!",font,
100,pageHeight/2));
page[0].addPrintElement (new PrintElement("line",
0,pageHeight,pageWidth,pageHeight));
//Page 1
page[1] = new PagePrinter();
page[1].addPrintElement (new
PrintElement("rectangle",100,100,pageWidth-200,pageHeight-200));
page[1].addPrintElement(new
PrintElement("oval",120,120,pageWidth-240,pageHeight-240));
//Page 2
page[2] = new PagePrinter();
page[2].addPrintElement (new
PrintElement("Last Page!",font,pageheight/2,pageWidth/2));
//Add pages to book
book.append(page[0],defaultFormat);
book append(page[1],defaultFormat);
book append(page[2],landscapeFormat);
return book;
}
class MenuItemHandler implements ActionListener, ItemListener {
public void actionPerformed(ActionEvent ev) {
String s=ev.getActionCommand();
if(s=="Exit"){
System.exit(0);
}else if(s=="Print"{
PrinterJob pj=PrinterJob.getPrinterJob();
Book book = createBook(pj);
try{
pj.setPageable(book);
pj.print();
}catch (Exception ex) {
System.out.println(ex.toString());
}
}
}
public void itemStateChanged(ItemEvent e){
}
}
class WindowEventHandler extends WindowAdapter {
public voidd windowClosing(WindowEvent e){
System.exit(0);
}
}
}
class PagePrinter implements Printable {
Vector pageContents;
public PagePrinter() {
pageContents = new Vector();
}
public int print(Graphics g,PageFormat pageFormat, int pageIndex) {
Enumeration printElements = pageContents.elements();
while(printElements.hasMoreElements()) {
PrintElement pe = (PrintElement) printElements.nextElement();
pe.print(g);
}
return Printable.PAGE_EXISTS;
}
public void addPrintElement(PrintElement pe) {
pageContents.addElement(pe);
}
}
class PrntElement {
static final int TEXT = 1;
static final int GRAPHICS = 2;
int type;
String text;
Font font;
String shape;
int x,y,width,height;
public PrintElement(String text,Font font,int x, int y) {
type = TEXT;
this.text = text;
this.font = font;
this.x =x;
this.y = y;
}
public PrintElement(String shape,int x,int y,int width,int height)
{
type = GRAPHICS;
this.shape = shape.toUpperCase();
this.x = x;
this.y = y;
this.width = width;
this height = height;
}
public void print(Graphics g) {
Font oldFont = g.getFont();
if(type == TEXT) {
g.setFont(font);
g.drawString(text,x,y);
}else if(type == GRAPHICS) {
if(shape.equals("LINE")) {
g.drawLine(x,y,width,height);
}else if(shape.equals("OVAL")) {
g.drawOval(x,y,width,height)'
}else if(shape.equals(RECTANGLE")) {
g.drawRect(x,y,width,height);
}
}
g.setFont(oldFont);
}
}
NOTE: The classes of the Java 2D API are covered in Chapter 20, "Working with 2D
and 3D Graphics."
Summary
This chapter showed you how to include printing capabilities in your window programs, and covered
the classes and methods used to support printing. You created examples that showed you how to print
text and graphics and work with print jobs. Chapter 19, "Internationalization," shows how to develop
Java programs that provide multilanguage capabilities.
© Copyright 1998, Macmillan Publishing. All rights reserved.
Java 1.2 Unleashed
- 19 Internationalization
●
●
●
●
●
●
●
●
What Is Internationalization?
Using Unicode
Managing Locales and Resources
The ResourceBundle Classes
Performing Locale-Specific Format Conversions
❍ The DateFormat Class
❍ The NumberFormat Class
❍ The MessageFormat Class
❍ The FieldPosition and ParsePosition Classes
Collation
❍ }catch(Exception ex){
❍ }
The Iterator Classes and Interfaces of java.text
Summary
Being the de facto programming language of the Web, Java is an international programming
language. It is being used in every country connected to the Web, and it is increasingly being called
upon to develop applications and applets for use in the native languages of these countries.
Fortunately, the developers of Java anticipated its international appeal and designed it accordingly.
The decision to provide comprehensive support of the Unicode character set was a major step toward
Java's internationalization. (Unicode is covered in the section "Using Unicode" later in this chapter.)
In addition to Unicode support, the JDK provides classes and interfaces that simplify the process of
incorporating locale-specific resources (such as text strings, dates, and currencies) within Java
programs. These classes and interfaces allow locale-specific resources to be separately maintained
and easily converted.
This chapter covers Java's internationalization support. You'll be introduced to the Unicode character
set, and you'll learn how to use the Locale and ResourceBundle classes to maintain locale-specific
information. You'll also learn how the java.text package facilitates conversion of numbers, dates, and
other units. When you finish this chapter, you'll be able to develop Java programs that adjust their
output to the language and customs of the locale in which they execute.
What Is Internationalization?
In an age when individuals around the world are globally connected via the Internet, programs are
often required to be tailorable to the language and customs of the locales in which they execute.
Programs that provide these capabilities are referred to as global programs.
Global programs can be difficult to develop, but they don't have to be. If you write a program that
mixes language-dependent text strings throughout its code and displays all its output using the
customs of a single country, you will have a terrible time converting it to the language and customs of
another locale. If and when you do complete the conversion, you will have to maintain multiple
versions of the same program--one for each locale. When you take this kind of approach, developing
global programs is complex, difficult, and time-consuming.
On the other hand, if you carefully isolate locale-specific resources, such as text strings, currencies,
and dates, and maintain these resources separately from locale-independent code, global programs
can be developed with a minimum of additional effort. Tailoring of such programs for use in specific
locales can often be reduced to providing foreign-language equivalents of native-language text strings
and specifying the use of alternative format sets.
Internationalization is the process of designing and developing global programs in such a way that
locale-specific information is separately and efficiently maintained. Internationalization allows global
programs to be more easily localized.
The JDK supports internationalization by using a multilanguage character set (Unicode 2.0), the
Locale, ResourceBundle and other classes of java.util, the format conversion classes of java.text, and
the Unicode character-stream support of java.io. This chapter focuses on java.text but also discusses
how the internationalization-related classes and interfaces of other packages are used to develop
global Java applications and applets.
Using Unicode
Unlike most other programming languages, Java provides comprehensive support for the Unicode 2.0
character set. Unicode is a 16-bit character set, meaning that it is capable of representing 65,536
characters. This is a large character set and can be used to represent the characters used by many of
the world's popular languages. The 128 characters of the popular ASCII character set are the first 128
characters of Unicode.
NOTE: ASCII stands for American Standard Code for Information Interchange.
NOTE: More information about the Unicode character set can be found at http://www.
unicode.org.
Unicode characters are written in Java using Unicode escape character sequences. These sequences
are of the form \uxxxx, where the four x's are replaced with hexadecimal digits. Each of the four
hexadecimal digits represents four bits of a 16-bit Unicode character.
To display Unicode characters other than ASCII, you need a Unicode font. In the absence of such a
font, Java displays Unicode characters using the \uxxxx notation. The Bitstream Cyberbit font is an
example of a font that supports Unicode. It can be downloaded from the Bitstream Web site at http://
www.bitstream.com/cyberbit/ ftpcyber.htm.
Managing Locales and Resources
The Locale class is defined in the java.util packages. This class provides internationalization support
by describing geographic, political, or cultural regions. Locale objects are created by supplying the
language and country arguments to the Locale() constructor or by using any of the predefined Locale
constants. The access methods of Locale support the setting and retrieving of language, country, and
variant-related values. The LocaleApp program, shown in Listing 19.1, illustrates the use of the
Locale class in describing a locale in terms of a country and a language. Its output is as follows:
java LocaleApp
CURRENT LOCALE:
Country: United States
Language: English
OTHER LOCALES:
Country: ROC
Language: Chinese
Country: Korea
Language: Korean
Country: Italy
Language: Italian
Country: Canada
Language: English
Country: Canada
Language: French
LISTING 19.1. THE LocaleApp PROGRAM.
import java.util.*;
class LocaleApp {
public static void main(String args[]) {
Locale currentLocale = Locale.getDefault();
Locale locales[]={Locale.TAIWAN,Locale.KOREA,
Locale.ITALY,Locale.CANADA,Locale.CANADA_FRENCH};
System.out.println("CURRENT LOCALE:");
describeLocale(currentLocale);
System.out.println("OTHER LOCALES:");
for(int i=0;i<locales.length;++i)
describeLocale(locales[i]);
}
static void describeLocale(Locale l){
System.out.println("Country: "+l.getDisplayCountry());
System.out.println("Language: "+l.getDisplayLanguage());
System.out.println();
}
}
The LocaleApp program invokes the getDefault() method of the Locale class to retrieve the current
locale that is in effect. It then creates an array of sample Locale objects using the Locale constants to
Taiwan, Korea, Italy, Canada, and French Canada. The describeLocale() method is then used to
display the country and language associated with each Locale object.
NOTE: If you run the LocaleApp program with a default Locale other than the United
States, the results will vary slightly.
The ResourceBundle Classes
The ResourceBundle class of java.util also supports internationalization. It is used to store localespecific resources and tailor a program's appearance to the particular locale in which it is being run.
The ResourceBundle class is extended by the ListResourceBundle and PropertyResourceBundle
classes. The ListResourceBundle class organizes resources in terms of an array of object pairs, where
the first object is a String key and the second object is the key's value. The PropertyResourceBundle
class organizes locale-specific resources using a property file.
The ResourceBundleApp program in Listing 19.2 shows how resource bundles can be used to tailor a
program's output. It is invoked with a two-character ISO-3166 country code and displays the names
of five animals in English or Spanish, depending on the country code that was used.
NOTE: Lists of ISO-3166 country codes and ISO-639 language codes can be found at
http://www.ics.uci.edu/pub/ietf/http/related/.
The following examples of program output show how the program tailors the information it displays
using the methods of the Locale, ResourceBundle, and ListResourceBundle classes:
java ResourceBundleApp
cow
horse
cat
elephant
dog
java ResourceBundleApp
cow
horse
cat
elephant
dog
java ResourceBundleApp
cow
horse
cat
elephant
dog
java ResourceBundleApp
vaca
caballo
gato
elefante
perro
java ResourceBundleApp
vaca
caballo
gato
elefante
CA
US
GB
ES
MX
perro
NOTE: The TextBundle and TextBundle_es classes, introduced later in this section,
must be compiled before you run ResourceBundleApp.
LISTING 19.2. THE ResourceBundleApp PROGRAM.
import java.util.*;
class ResourceBundleApp {
public static void main(String args[]) {
if(args.length!=1){
System.out.println("Usage: java ResourceBundleApp country_code");
System.exit(0);
}
Locale mexico = new Locale("es","MX");
Locale spain = new Locale("es","ES");
Locale locales[] = {mexico,spain,Locale.US,Locale.CANADA,Locale.
UK};
Locale newLocale=null;
for(int i=0;i<locales.length;++i){
if(args[0].equals(locales[i].getCountry())){
newLocale=locales[i];
break;
}
}
if(newLocale==null){
System.out.println("Country not found.");
System.exit(0);
}
ResourceBundle resources=ResourceBundle.getBundle("TextBundle",
newLocale);
Enumeration enum=resources.getKeys();
while(enum.hasMoreElements()){
String key=(String) enum.nextElement();
System.out.println(resources.getString(key));
}
}
}
The ResourceBundleApp program creates Locale objects for Mexico and Spain and creates a list of
supported locales, including Mexico, Spain, the United States, Canada, and Great Britain. It checks
the two-character country code that is passed to the program as a command-line argument with the
list of supported locales. The newLocale variable is assigned the Locale object whose country code
matches the one passed via the command line. The getCountry() method of the Locale class returns
the two-character country code of a Locale object.
The getBundle()method of the ResourceBundle class is invoked to retrieve the ResourceBundle
object associated with the Locale object stored in newLocale. Two resource bundle classes are
available: the default (English) resource bundle, shown in Listing 19.3, and the Spanish language
resource bundle, shown in Listing 19.4. The getBundle() method looks for classes of the following
form until it finds one that matches: ll is the two-character (lowercase) language code of the locale,
and CC is the two-character (uppercase) country code of the locale. The following are examples of
these file name formats:
●
TextBundle_ll_CC
●
TextBundle_ll
●
TextBundle
For example, if you pass the GB country code (Great Britain) to ResourceBundleApp, getBundle()
will look for resource bundle classes TextBundle_en_GB and TextBundle_en before settling on
TextBundle.
NOTE: The language code for English is en. The language code for Spanish is es. The
country codes for Mexico, Spain, United States, Canada, and United Kingdom are MX,
ES, US, CA, and GB.
The getKeys() method of the ResourceBundle class returns an enumeration of the keys used to access
locale-specific resources. The getString() method of ResourceBundle returns a String representation
of the resource object associated with the key.
LISTING 19.3. THE TextBundle CLASS.
import java.util.*;
public class TextBundle extends ListResourceBundle {
public Object[][] getContents() {
return contents;
}
static final Object[][] contents = {
{"dog","dog"},
{"cat","cat"},
{"horse","horse"},
{"cow","cow"},
{"elephant","elephant"}
};
}
The TextBundle class is a subclass of ListResourceBundle, which is a subclass of ResourceBundle.
The getContents() method of ListResourceBundle is overridden to return an array of keys and their
associated language-specific resources. The getContents() method is used to generate the information
returned by the getKeys() and getString() methods used in ResourceBundleApp.
The contents array is an array of two-element arrays: the first element is the key, and the second
element is its value.
The TextBundle_es class is a Spanish language version of the TextBundle class. It provides a Spanish
translation of the words "dog," "cat," "horse," "cow," and "elephant."
LISTING 19.4. THE TextBundle_es CLASS.
import java.util.*;
public class TextBundle_es extends ListResourceBundle {
public Object[][] getContents() {
return contents;
}
static final Object[][] contents = {
{"dog","perro"},
{"cat","gato"},
{"horse","caballo"},
{"cow","vaca"},
{"elephant","elefante"}
};
}
Performing Locale-Specific Format Conversions
The classes of java.text are used to provide locale-specific format conversions for use with numbers,
dates, and other objects. Format is an abstract class that is extended by other classes to support
parsing and format conversion. It declares the format() method to convert objects to strings and the
parseObject() method to convert strings to objects. These methods are overridden by its subclasses.
The DateFormat Class
DateFormat is an abstract class used to format and parse date and time values using locale-specific
customs. It supports four formatting styles defined by the FULL, LONG, MEDIUM, and SHORT
constants. These styles determine the length of the formatted output. DateFormat defines other
constants for identifying specific date and time fields. The getInstance(), getDateInstance(),
getTimeInstance(), and getDateTimeInstance() methods return instances of DateFormat that are
specific to a locale. Other methods are provided for working with objects of the Calendar, TimeZone,
and other date-related classes covered in Chapter 11, "Using the Utility and Math Packages."
The SimpleDateFormat Class
The SimpleDateFormat class extends the DateFormat class to provide a default implementation of
date formatting and parsing capabilities. It allows date and time formatting patterns to be used to
customize formatting and parsing. The SimpleDateFormat class makes use of special date and time
pattern symbols that are discussed in the class's API description.
The DateFormatApp program, shown in Listing 19.5, illustrates the use of the date- formatting
capabilities of the SimpleDateFormat class. When you run the program, it produces the following
type-formatted output. The date and time displayed are the current date and time of the locale in
which the program is run:
java DateFormatApp
The year is 1998 AD.
The month is July.
It is 09 o'clock PM, Pacific Standard Time.
NOTE: If DateFormatApp displays an incorrect time zone value, check your user.
timezone system property to make sure that it is set correctly.
Although the output may not be that impressive, the formatting capabilities provided by
SimpleDateFormat are efficient and easy to use. The pattern string places single quotes around text
that is not a date/time formatting pattern. The formatting patterns used in the pattern string are as
follows:
●
yyyy--Year
●
GG--Era
●
MMMMMMMMM--Month
●
hh--Hour
●
a--AM/PM designator
●
zzzz--Time zone
The pattern is supplied as an argument to the SimpleDateFormat constructor to create a format
pattern-specific object. The current date is passed to the format() method of this object to create a
String object that is formatted using the current date and the format pattern.
LISTING 19.5. THE DateFormatApp PROGRAM.
import java.text.*;
import java.util.*;
class DateFormatApp {
public static void main(String args[]) {
String pattern="'The year is `";
pattern +="yyyy GG";
pattern +="'.\nThe month is `";
pattern+="MMMMMMMMM";
pattern+="'.\nIt is `";
pattern+="hh";
pattern+="' o''clock `";
pattern+="a, zzzz";
pattern+="'.'";
SimpleDateFormat format = new SimpleDateFormat(pattern);
String formattedDate = format.format(new Date());
System.out.println(formattedDate);
}
}
The DateFormatSymbols Class
The DateFormatSymbols class is used to provide access to locale-specific date symbols, such as the
names of days, months, and other date and time units. DateFormatSymbols objects are created using
the getDateFormatSymbols method of the SimpleDateFormat class or via the DateFormatSymbols()
constructor. Several get methods allow locale-specific formatting strings to be retrieved.
The NumberFormat Class
The NumberFormat class is an abstract class that supports the locale-specific formatting and parsing
of numbers. The INTEGER_FIELD and FRACTION_FIELD constants are used to identify fields
within decimal numbers. The format() and parse() methods support number formatting and parsing.
Other methods are provided to access the number of digits to the left and right of the decimal point,
to work with locales, and to access other number-formatting attributes.
The NumberFormatApp program, shown in Listing 19.6, illustrates the use of the NumberFormat
class in supporting locale-specific currency formatting. It prints out a value of 1,000,000 currency
units using the locale-specific currency value, as shown in the following:
java NumberFormatApp
$1,000,000.00
LISTING 19.6. THE NumberFormatApP PROGRAM.
import java.text.*;
import java.util.*;
class NumberFormatApp {
public static void main(String args[]) {
NumberFormat format = NumberFormat.getCurrencyInstance(
Locale.getDefault());
String formattedCurrency = format.format(1000000);
System.out.println(formattedCurrency);
}
}
The DecimalFormat Class
The DecimalFormat class extends the NumberFormat class to support the formatting of decimal
numbers using locale-specific customs. The class supports the specification and use of custom
formatting patterns. The format() and parse() methods are used to perform formatting and parsing. A
number of get and set methods are provided to access specific formatting parameters. The
DecimalFormat class makes use of special number formatting pattern symbols that are discussed in
the class's API description.
The DecimalFormatSymbols Class
The DecimalFormatSymbols class provides access to the locale-specific symbols used in formatting
numbers. These symbols include decimal separators, grouping separators, and others used by objects
of the DecimalFormat class. Instances of DecimalFormatSymbols are created using the
getDecimalFormatSymbols() method of the DecimalFormat class and the DecimalFormatSymbols()
constructors. Several methods are provided to set and retrieve formatting information, such as the
decimal separator character, grouping separators, the minus sign, the infinity symbol, the not-anumber symbol, and the percentage sign.
The ChoiceFormat Class
The ChoiceFormat class extends the NumberFormat class to identify strings that serve as labels for
numbers within specific intervals. The ChoiceFormat constructor takes an array of double values
used to specify numeric intervals and an array of String objects that identify the labels associated
with those intervals. The double values are referred to as limits. The methods of the ChoiceFormat
class support the formatting and parsing of strings based on the limits and their labels.
The ChoiceFormatApp program in Listing 19.7 illustrates the use of the ChoiceFormat class. It uses a
random number generator to predict the likelihood of rain. Its output varies every time you run it.
Sample output follows:
java ChoiceFormatApp
The likelihood of rain today is very low (0.05002163005399529).
java ChoiceFormatApp
The likelihood of rain today is high (0.954441890602895).
java ChoiceFormatApp
The likelihood of rain today is moderate (0.3000466839384621).
The ChoiceFormatApp program defines four limits: 0.0, 0.1, 0.3, and 0.7. It defines four labels that
correspond to intervals defined by these limits:
●
very low--From 0.0 up to, but not including, 0.1.
●
low--From 0.1 up to, but not including, 0.3.
●
moderate--From 0.3 up to, but not including, 0.7.
●
high--From 0.7, on up.
An object of the ChoiceFormat class is created using the limits and labels arrays. A random number
between 0 and 1 is fed into the format() method of the ChoiceFormat object to select the label
associated with the interval in which the random number generator falls.
LISTING 19.7. THE ChoiceFormatApp PROGRAM.
import java.text.*;
import java.util.*;
class ChoiceFormatApp {
public static void main(String args[]) {
double limits[] = {0.0,0.1,0.3,0.7};
String labels[] = {"very low","low","moderate","high"};
ChoiceFormat format = new ChoiceFormat(limits,labels);
String prediction = "The likelihood of rain today is ";
double r = Math.random();
prediction += format.format(r)+" ("+r+").";
System.out.println(prediction);
}
}
The MessageFormat Class
The MessageFormat class extends the Format class to format objects as messages that are inserted
into a String object. The MessageFormat constructor takes a String argument that specifies a messageformatting pattern. This pattern contains formatting elements where time, date, number, and choice
objects may be inserted. Consult the API documentation of the MessageFormat class for a description
of the syntax used to create formatting patterns. The format() method is used to insert objects into a
message formatting pattern. The parse() method is used to parse the objects contained in a string
according to a message-formatting pattern.
The MessageFormatApp program, shown in Listing 19.8, provides a simple introduction to the use of
the MessageFormat class. It generates output in the following form:
java MessageFormatApp
The time is 4:16:05 PM and your lucky number is 620.
MessageFormatApp creates a format pattern with time and number fields and uses this pattern to
construct a MessageFormat object. It creates an array of two objects: the current time (as a Date
object) and a random Integer object. It then invokes the format() method of the MessageFormat
object to produce the formatted output that is displayed to the console window.
LISTING 19.8. THE MessageFormatApp CLASS.
import java.text.*;
import java.util.*;
class MessageFormatApp {
public static void main(String args[]) {
String pattern = "The time is {0,time} and ";
pattern += "your lucky number is {1,number}.";
MessageFormat format = new MessageFormat(pattern);
Object objects[] = {new Date(),
new Integer((int)(Math.random()*1000))};
String formattedOutput=format.format(objects);
System.out.println(formattedOutput);
}
}
The FieldPosition and ParsePosition Classes
The FieldPosition class is used to identify fields in formatted output. It keeps track of the field's
position within the formatted output. The FieldPosition() constructor takes an integer value that is
used to identify the field. Its methods are used to retrieve the indices of the beginning and end of the
field and the field's identifier.
The ParsePosition class is similar to the FieldPosition class. While FieldPosition is used for
formatting, ParsePosition is used for parsing. Its constructor takes an integer that identifies its index
within the string being parsed. The getIndex() and setIndex() methods are used to change this index.
Collation
Different languages have different alphabets and unique ways of sorting text strings written in those
languages. Collation, as it applies to java.text, is the process of sorting or arranging text strings
according to locale-specific customs. The java.text package supports collation through the Collator,
RuleBasedCollator, CollationKey, and CollationElementIterator classes.
The Collator class is an abstract class that is used to compare String objects using locale-specific
customs. It is subclassed to provide implement-specific collation algorithms. The getInstance()
method is used to retrieve a locale-specific Collation instance. Some languages recognize different
strengths in determining whether letters are identical or different; this is common to languages that
support accented characters. The setStrength() of Collator may be used to set different collation
strength levels. The compare() method compares two strings and returns an int value indicating the
results of the comparison. The other methods of Collator support the decomposition of composite
characters (for example, accented characters) and the creation of CollationKey objects.
The CollationKey class provides a compact representation of a String object according to the
collation rules of a Collator object. CollationKey objects are optimized to support fast String
comparisons and are preferred over the compare() method of the Collator class for extensive
comparisons, such as those found in sorting algorithms. CollationKey objects are generated using the
getCollationKey() method of the Collator class. The compareTo() and equals() methods of
CollationKey are used to perform comparisons. The toByteArray() method can be used to convert a
CollationKey object to a byte array. The getSourceString() method returns the String object from
which a CollationKey object was generated.
The RuleBasedCollator class extends Collator to provide a concrete collator implementation. It
allows you to define your own collation rules. However, in most cases, you'll want to use the
predefined rules that are specific to your locale. The getRules() method may be used to retrieve the
collation rules that are in effect for a RuleBasedCollator object. The getCollationKey() method
overrides that of the Collator class. The getCollationElementIterator() method returns a
CollationElementIterator object for the collator. Iterator classes are covered in the next section.
The CollateApp program, shown in Listing 19.9, shows how the RulesBasedCollator and
CollationKey classes can be used to sort a file. The CollateApp program takes a filename as a
command-line argument and produces a sorted version of the file's contents as its output. The
following output shows how the file CollateApp.java is sorted. Note how the default collation rules
treat blanks that appear at the beginning of a string:
java CollateApp CollateApp.java
}
}
}
}
}
}
}
}
}catch(Exception ex){
boolean changes=true;
BufferedReader in = new BufferedReader(new FileReader(args[0]));
changes=false;
changes=true;
class CollateApp {
CollationKey keys[]=new CollationKey[keyVector.size()];
CollationKey temp=keys[i];
Collator.getInstance(defaultLocale);
for(int i=0;i<keys.length;++i)
for(int i=0;i<keys.length;++i)
for(int i=0;i<keys.length-1;++i){
if(args.length!=1){
if(compare>0){
import java.io.*;
import java.text.*;
import java.util.*;
in.close();
int compare=keys[i].compareTo(keys[i+1]);
keys[i]=(CollationKey) keyVector.elementAt(i);
keys[i]=keys[i+1];
keys[i+1]=temp;
keys=sort(keys);
keyVector.addElement(collator.getCollationKey(line));
Locale defaultLocale = Locale.getDefault();
public static void main(String args[]) {
return keys;
RuleBasedCollator collator = (RuleBasedCollator)
static CollationKey[] sort(CollationKey keys[]){
String line;
System.exit(0);
System.exit(0);
System.out.println("Usage: java CollateApp file");
System.out.println(ex);
System.out.println(keys[i].getSourceString());
try {
Vector keyVector = new Vector();
while((line=in.readLine())!=null)
while(changes){
LISTING 19.9. THE CollateApp PROGRAM.
import java.text.*;
import java.util.*;
import java.io.*;
class CollateApp {
public static void main(String args[]) {
if(args.length!=1){
System.out.println("Usage: java CollateApp file");
System.exit(0);
}
Locale defaultLocale = Locale.getDefault();
RuleBasedCollator collator = (RuleBasedCollator)
Collator.getInstance(defaultLocale);
Vector keyVector = new Vector();
try {
BufferedReader in = new BufferedReader(new FileReader(args[0]));
String line;
while((line=in.readLine())!=null)
keyVector.addElement(collator.getCollationKey(line));
in.close();
}catch(Exception ex){
System.out.println(ex);
System.exit(0);
}
CollationKey keys[]=new CollationKey[keyVector.size()];
for(int i=0;i<keys.length;++i)
keys[i]=(CollationKey) keyVector.elementAt(i);
keys=sort(keys);
for(int i=0;i<keys.length;++i)
System.out.println(keys[i].getSourceString());
}
static CollationKey[] sort(CollationKey keys[]){
boolean changes=true;
while(changes){
changes=false;
for(int i=0;i<keys.length-1;++i){
int compare=keys[i].compareTo(keys[i+1]);
if(compare>0){
changes=true;
CollationKey temp=keys[i];
keys[i]=keys[i+1];
keys[i+1]=temp;
}
}
}
return keys;
}
}
The CollateApp program creates a RulesBasedCollator object using the getInstance() method of the
Collator class. It selects the collator corresponding to the default locale. It reads in each line of the
file, creates a CollationKey object corresponding to the input line, and stores the line in a Vector
object. It then converts the vector to an array to simplify the sorting process. The sort() method is
invoked to sort the CollationKey array. The String objects corresponding to the sorted CollationKey
objects are retrieved via the getSourceString() method. These String objects are then printed.
The sort() method sorts the CollationKey array using the CollationKey compareTo() method. This
method returns a positive integer if the CollationKey object being compared is greater than the one it
is being compared to. It returns 0 if they are equal and a negative integer if the CollationKey object
being compared is less than the one it is being compared to.
The Iterator Classes and Interfaces of java.text
The CharacterIterator interface defines methods that are implemented by classes that provide the
capability to step through (iterate) a sequence of characters. These methods allow you to set your
position within the text, move to other positions, and return the character at a specific position. The
StringCharacterIterator class implements CharacterIterator to support string iteration and parsing.
The BreakIterator class is used to find text boundaries. It provides useful static methods for localespecific parsing of character sequences by word, line, or sentence.
The CollationElementIterator class supports string iteration and returns information used to collate
strings using locale-specific customs.
Summary
In this chapter you were introduced to Java's internationalization support. You learned about the
Unicode character set and learned how to use the Locale and ResourceBundle classes to maintain
locale-specific information. You also learned how the classes of the java.text package facilitate the
conversion of numbers, dates, and other units. In the next chapter you'll be introduced to the new
multimedia capabilities provided by JDK 1.2.
© Copyright 1998, Macmillan Publishing. All rights reserved.
Java 1.2 Unleashed
- 20 Working with 2D and 3D Graphics
●
●
●
●
The Java 2D API
Moving from Graphics to Graphics2D
❍ Drawing Graphics
❍ Using Text and Fonts
❍ Using Transforms
The Java 3D API
❍ The javax.media.j3d Package
❍ The javax.vecmath Package
❍ Using 3D Graphics in Your Programs
Summary
Slick graphics can change an average program into an outstanding one. That's because most of us are
visually oriented. We prefer pictures over text descriptions, maps over directions, and colorful graphs
over equations. We also prefer programs that use graphics to simplify the information they present. In
Chapter 7, "Working with the Canvas," you learned how to use the basic graphics capabilities of the
AWT, which were present in JDK 1.1. JDK 1.2 extends the JDK 1.1 graphics capabilities with the
Java 2D API, which provides comprehensive support for drawing, image processing, and text
rendering. Concurrent with JDK 1.2, but separate from it, JavaSoft also released the Java 3D API.
This API provides support for three-dimensional graphics used in advanced modeling and virtual
reality applications.
In this chapter, you'll explore the Java 2D and Java 3D APIs. You'll learn how the Java 2D API can
be used to enhance line drawing, painting, and text rendering operations. You'll then use the Java 3D
API to display and manipulate three-dimensional objects. When you finish this chapter, you'll be able
to use these advanced graphics capabilities in your programs.
The Java 2D API
The Java 2D API is a very large part of the JDK 1.2 AWT. It consists of the following six packages,
plus numerous classes and interfaces from the java.awt package:
●
java.awt.color
●
java.awt.font
●
java.awt.geom
●
java.awt.image
●
com.sun.java.image.codec.jpeg
●
java.awt.image.renderable
Because the 2D API is so large, it is impractical to learn this API by going directly to its classes and
interfaces. Instead, it is easier first to learn the capabilities that it provides, and then which classes
and interfaces are important in providing these capabilities.
The 2D API provides the following general capabilities:
●
●
●
●
●
●
Graphics drawing--Complete line drawing support, including the capability to draw general
2D objects using a variety of line and fill patterns. General graphics transformations (such as
rotation, scaling, and translation) are supported.
Image processing and display--Advanced image creation, filtering, compositing, and display.
Advanced text rendering and font support--Font faces are composed of glyphs that are
displayed using normal drawing methods. Text can be filled, rotated, scaled, and so on.
System-independent fonts can be developed.
Device-independent graphics--Graphics operations take place in a device- independent user
space. User space is then mapped to device-dependent coordinate systems and capabilities.
Device-dependent graphics translation and display--Uniform rendering automatically performs
the necessary conversions between user space and the device space of the target device.
Advanced color definition--Support for a variety of color models and conversion between
models.
By learning to use these capabilities, you can greatly improve the quality of the graphics in your
applets and applications.
Moving from Graphics to Graphics2D
In Chapter 7, you learned how to draw line art and display text and images using the Graphics class.
The Java 2D API extends the Graphics class with the Graphics2D class, which is the heart of the 2D
API. It lets you do everything that you could with the AWT 1.1 Graphics class, plus a whole lot more.
You obtain a reference to a Graphics2D object in the same manner as a Graphics object. In most
cases, you'll simply cast a Graphics object to a Graphics2D object. The following code shows how
this is accomplished using the paint() method of the Component class:
public void paint(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
/* Now I can use the methods of Graphics and Graphics2D
with g2d. */
}
The Graphics2D class uses two coordinate spaces for drawing graphics, text, and images. The user
coordinate space is a device-independent logical coordinate space. The origin (0,0) is in the upperleft corner. Horizontal (x) coordinates increase toward the right of the drawing area, and vertical (y)
coordinates increase toward the bottom of the drawing area.
Each target rendering device (such as a monitor screen or a printer) has its own separate device space.
The dimensions, orientation, and display capabilities of the display space vary with each device. The
Java 2D rendering system automatically and transparently converts between user space and device
space.
The available display devices are described by the GraphicsEnvironment class. The static
getLocalGraphicsEnvironment() method returns a GraphicsEnvironment object for the local system.
The getAllFonts() method returns a list of all available Font objects. The getScreenDevices() and
getPrinterJob() methods provide access to screen and printer devices.
The GraphicsDevice class is used to describe graphics devices, such as screens or printers. Each of
these devices may have one or more configurations. For example, a screen may be capable of both
640¥480 and 800¥600 resolution. The GraphicsConfiguration class is used to describe the
configuration of a GraphicsDevice object. The getConfigurations() method of the GraphicsDevice
class is used to obtain access to these configurations.
Drawing Graphics
The Shape interface defines the methods supported by all geometrical shapes. This interface is
implemented by the following classes of the java.awt.geom and java.awt packages:
●
●
●
●
●
●
●
●
GeneralPath--Defines a general geometric shape.
Line2D--Defines a line that can be drawn using the 2D API. It is extended by Line2D.Float
and Line2D.Double.
Rectangle--A java.awt class that defines a rectangle.
RectangularShape--Defines a shape that can be enclosed in a rectangle. It is extended by
Arc2D, Ellipse2D, Rectangle2D, and RoundRectangle2D.
Polygon--A java.awt class that defines a general polygon.
CubicCurve2D--Defines a segment of a cubic parametric curve. It is extended by
CubicCurve2D.Float and CubicCurve2D.Double.
QuadCurve2D--Defines a segment of a quadratic curve. It is extended by QuadCurve2D.Float
and QuadCurve2D.Double.
Area--Used to specify an arbitrarily shaped area consisting of other shape objects.
These classes are extended by other, more specific shape classes in the java.awt.geom and java.awt
packages. Subclasses with the .Float and .Double extensions are used to specify shapes using floatingpoint coordinates.
The Java 2D API also implements fonts in terms of the Shape interface. Individual characters or
character combinations (ligatures) are represented as a combination of glyphs. Glyphs represent
individual shapes that are used to display text using a particular font face. The GlyphSet,
GlyphMetrics, and GlyphJustificationInfo classes are used to work with glyphs. However, in most
cases you won't use these classes. Instead, you'll simply draw text on the screen using a particular
font. The important point to remember is that your text is actually drawn as a set of shapes. This
means that you can change the pen and fill style used to draw your text. (Refer to "Pen and Fill
Styles" later in this chapter.) You can also rotate, translate, and manipulate text using the same
methods that you use for other geometrical objects.
THE BASIC DRAWING METHOD OF THE GRAPHICS2D CLASS IS DRAW(). YOU CAN USE
IT TO DRAW ANY OBJECT THAT IMPLEMENTS THE SHAPE INTERFACE. GRAPHICS2D
ALSO SUPPORTS DRAWIMAGE() AND DRAWSTRING() METHODS THAT ARE TAILORED
TO IMAGE AND TEXT DRAWING. FINALLY, BECAUSE GRAPHICS2D IS A SUBCLASS OF
GRAPHICS, IT SUPPORTS ALL OF THE STANDARD GRAPHICS DRAWING METHODS.
Listing 20.1 illustrates the basics of line and text drawing using Java 2D. When you run this program,
it displays the five geometric objects shown in Figure 20.1. These objects are a diagonal line, a
rectangle, a circle, a tetragon, and a rounded rectangle.
FIGURE 20.1. The Draw2D program displays a variety of geometric figures.
The shapes array contains the five objects shown in Figure 20.1. The elements of this array are
created by the createShapes() method. These shapes consist of the following objects from the java.
awt.geom package:
●
●
●
●
●
A Line2D.Double object from (0,0) to (100,100).
A Rectangle2D.Double object with the upper-left corner at (100,100) and a width and height
of 200.
An Ellipse2D.Double object with a bounding box beginning at (200,200) and width and height
of 100.
A GeneralPath object composed of four line segments.
A RoundRectangle2D.Double object with the upper-left corner at (350,250), a width of 200,
and a height of 100.
The paint() method of the MyCanvas class displays the five objects. It casts its Graphics parameter to
a Graphics2D object and then invokes the draw() method of Graphics2D for each of the objects in the
shapes array.
LISTING 20.1. THE Draw2D PROGRAM.
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import ju.ch09.MyMenu;
import ju.ch09.MyMenuBar;
public class Draw2D extends Frame {
static final int numShapes = 5;
Shape shapes[] = new Shape[numShapes];
static final int width = 600;
static final int height = 400;
MyMenuBar menuBar;
EventHandler eh = new EventHandler();
public static void main(String args[]){
Draw2D app = new Draw2D();
}
public Draw2D() {
super("Draw2D");
setupMenuBar();
add("Center",new MyCanvas());
createShapes();
setSize(width,height);
addWindowListener(eh);
show();
}
void createShapes() {
for(int i=0;i<shapes.length;++i) shapes[i] = null;
shapes[0] = new Line2D.Double(0.0,0.0,100.0,100.0);
shapes[1] = new Rectangle2D.Double(100.0,100.0,200.0,200.0);
shapes[2] = new Ellipse2D.Double(200.0,200.0,100.0,100.0);
GeneralPath path =
new GeneralPath(new Line2D.Double(300.0,100.0,400.0,150.0));
path.append(new Line2D.Double(400.0,150.0,350.0,200.0),true);
path.append(new Line2D.Double(350.0,200.0,325.0,175.0),true);
path.append(new Line2D.Double(325.0,175.0,300.0,100.0),true);
shapes[3] = path;
shapes[4] = new RoundRectangle2D.Double
(350.0,250,200.0,100.0,50.0,25.0);
}
void setupMenuBar(){
Object menuItems[][] = {{"File","Exit"}};
menuBar = new MyMenuBar(menuItems,eh,eh);
setMenuBar(menuBar);
}
class MyCanvas extends Canvas {
public void paint(Graphics graphics) {
Graphics2D g = (Graphics2D) graphics;
for(int i=0;i<shapes.length;++i) {
if(shapes[i]!=null) g.draw(shapes[i]);
}
}
}
class EventHandler extends WindowAdapter implements ActionListener,
ItemListener {
public void actionPerformed(ActionEvent e){
String selection=e.getActionCommand();
if("Exit".equals(selection)){
System.exit(0);
}
}
public void itemStateChanged(ItemEvent e){
}
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
Antialiasing
When graphics and text are drawn to a particular device, they may appear to be somewhat jagged,
depending on the device resolution. This effect, known as aliasing, occurs because the position of the
pixels used to render the drawing differs from their ideal mathematical location. The jagged effect of
aliasing can be reduced using a technique known as antialiasing, which sets the values of
surrounding pixels to smooth out jagged contours. Antialiasing requires a fair amount of
computational power and may slow down performance. To use antialiasing, use the
setRenderingHints() method of Graphics2D to set the ANTIALIASING hint to ANTIALIAS_ON.
You can also set the RENDERING hint to RENDER_QUALITY to improve the overall quality in
which graphics and text are rendered. For example, the following code sets both the
ANTIALIASING and RENDERING hints:
Graphics2D g = (Graphics2D) getGraphics();
g.setRenderingHints(Graphics2D.ANTIALIASING,Graphics2D.
ANTIALIAS_ON);
g.setRenderingHints(Graphics2D.RENDERING,Graphics2D.
RENDER_QUALITY);
You can check the state of ANTIALIASING and RENDERING using the getRenderingHints()
method of Graphics2D.
Pen and Fill Styles
One of the advantages of the Java 2D API is its support for pen and fill styles. Pen styles can be used
to change the type of line used to draw a Shape object. For example, you can change the thickness
and pattern of a line so that it is displayed as a thin dotted line. The pen style of an object is specified
by an object of a class that implements the Stroke interface. The BasicStroke class provides an
implementation of this interface. It allows strokes to be defined based on the following:
●
Stroke width
●
End and join styles
●
Dash pattern and phase
Fill patterns are defined by objects that implement the Paint interface. Three types of fill patterns are
defined:
●
Solid color fill
●
Gradient fill
●
Pattern fill
The Color class provides a default implementation of Paint for providing a solid color fill pattern.
The GradientPaint class defines a fill pattern as a gradient between two colors. The TexturePaint
class implements Paint to define a fill pattern, using a simple image fragment that is repeated
uniformly throughout the interior of the object being filled.
Listing 20.2 illustrates the basics of pen and fill styles. Figure 20.2 shows the output generated by this
program. Note that it draws the same objects as the Draw2D program in Listing 20.1. It just uses
different pen and fill styles.
The PenFill program is essentially the same as Draw2D. The only notable differences are in the paint
() method of MyCanvas. The dashPattern array is used to create a dash pattern consisting of a ten-unit
dash, followed by a ten-unit space, five-unit dash, and five-unit space. The setStroke() method of
Graphics2D is used to define the overall pen style. The CAP_ROUND and JOIN_MITER constants
are used to specify the ends and joins of line segments.
The setPaint() method is used to set the background color of the rectangle to blue. The fill() method is
used to perform the actual filling of the rectangle.
FIGURE 20.2. The PenFill program adds pen and fill styles to Draw2D.
The setPaint() method is also used to set the fill color of the circle to a color gradient between red and
green. The color gradient is specified as an object of the GradientPaint class.
The texture variable is assigned a new object of the TexturePaint class. The arguments to the
TexturePaint constructor consist of a BufferedImage object containing the fill pattern, a Rectangle2D.
Double object identifying the fill area, and the type of interpolation algorithm to be used in filling
objects within the area.
The createBufferedImage() method returns a BufferedImage object containing the fill pattern. This
fill pattern consists of a 20¥20 image that uses a red-blue-green (RGB) color model. The pattern
consists of two perpendicular diagonal lines that form an "X" pattern.
LISTING 20.2. THE PenFill PROGRAM.
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.awt.image.*;
import ju.ch09.MyMenu;
import ju.ch09.MyMenuBar;
public class PenFill extends Frame {
static final int numShapes = 5;
Shape shapes[] = new Shape[numShapes];
static final int width = 600;
static final int height = 400;
MyMenuBar menuBar;
EventHandler eh = new EventHandler();
public static void main(String args[]){
PenFill app = new PenFill();
}
public PenFill() {
super("PenFill");
setupMenuBar();
add("Center",new MyCanvas());
createShapes();
setSize(width,height);
addWindowListener(eh);
show();
}
void createShapes() {
for(int i=0;i<shapes.length;++i) shapes[i] = null;
shapes[0] = new Line2D.Double(0.0,0.0,100.0,100.0);
shapes[1] = new Rectangle2D.Double(100.0,100.0,200.0,200.0);
shapes[2] = new Ellipse2D.Double(200.0,200.0,100.0,100.0);
GeneralPath path =
new GeneralPath(new Line2D.Double(300.0,100.0,400.0,150.0));
path.append(new Line2D.Double(400.0,150.0,350.0,200.0),true);
path.append(new Line2D.Double(350.0,200.0,325.0,175.0),true);
path.append(new Line2D.Double(325.0,175.0,300.0,100.0),true);
shapes[3] = path;
shapes[4] = new RoundRectangle2D.Double
(350.0,250,200.0,100.0,50.0,25.0);
}
void setupMenuBar(){
Object menuItems[][] = {{"File","Exit"}};
menuBar = new MyMenuBar(menuItems,eh,eh);
setMenuBar(menuBar);
}
class MyCanvas extends Canvas {
public void paint(Graphics graphics) {
Graphics2D g = (Graphics2D) graphics;
float[] dashPattern = {10.0f,10.0f,5.0f,5.0f};
g.setStroke(new BasicStroke(5,
BasicStroke.CAP_ROUND,
BasicStroke.JOIN_MITER,
10.0f,
dashPattern,
0.0f));
g.draw(shapes[0]);
g.setPaint(Color.blue);
g.draw(shapes[1]);
g.fill(shapes[1]);
g.setPaint(new GradientPaint(350.0f,200.0f,Color.red,
325.0f,175.0f,Color.green));
g.draw(shapes[2]);
g.fill(shapes[2]);
g.setColor(Color.black);
g.draw(shapes[3]);
TexturePaint texture = new TexturePaint(
createBufferedImage(),
new Rectangle2D.Double(350.0,250,200.0,100.0);
g.setPaint(texture);
g.draw(shapes[4]);
g.fill(shapes[4]);
}
BufferedImage createBufferedImage() {
BufferedImage image =
new BufferedImage(20,20,BufferedImage.TYPE_INT_RGB);
Graphics2D g = image.createGraphics();
g.draw(new Line2D.Double(0.0,0.0,10.0,10.0));
g.draw(new Line2D.Double(0.0,10.0,10.0,0.0));
return image;
}
}
class EventHandler extends WindowAdapter implements ActionListener,
ItemListener {
public void actionPerformed(ActionEvent e){
String selection=e.getActionCommand();
if("Exit".equals(selection)){
System.exit(0);
}
}
public void itemStateChanged(ItemEvent e){
}
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
Clipping
In some cases, you may not want to display an entire Shape or Image object. The 2D API allows you
to define a clipping path, which is a subset of the graphic or image to be displayed. Only the portions
of a Shape or Image object that lies within the clipping path are displayed.
The setClip() method of the Graphics class (inherited by Graphics2D) is used to set the current
clipping path. The setClip() method takes a Shape object as an argument, and any shape may be used
for clipping.
Listing 20.3 illustrates how clipping is implemented. Figure 20.3 shows the output generated by this
program. Note that it draws the same objects as the PenFill program in Listing 20.2. It just clips the
objects to a 300¥250 rectangle. The only significant difference between Clipper and PenFill is the
inclusion of the following statement in the paint() method of MyCanvas:
g.setClip(new Rectangle2D.Double(75.0,75.0,300.0,250.0));
This statement invokes the setClip() method of Graphics to set the clipping area to a Rectangle2D.
Double object, consisting of a 300¥250 rectangle located at (75,75). All objects subsequently drawn
to the Graphics2D object are clipped if they extend beyond this rectangle.
FIGURE 20.3. The Clipper program adds clipping to PenFill.
Listing 20.3. The Clipper program.
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.awt.image.*;
import ju.ch09.MyMenu;
import ju.ch09.MyMenuBar;
public class Clipper extends Frame {
static final int numShapes = 5;
Shape shapes[] = new Shape[numShapes];
static final int width = 600;
static final int height = 400;
MyMenuBar menuBar;
EventHandler eh = new EventHandler();
public static void main(String args[]){
Clipper app = new Clipper();
}
public Clipper() {
super("Clipper");
setupMenuBar();
add("Center",new MyCanvas());
createShapes();
setSize(width,height);
addWindowListener(eh);
show();
}
void createShapes() {
for(int i=0;i<shapes.length;++i) shapes[i] = null;
shapes[0] = new Line2D.Double(0.0,0.0,100.0,100.0);
shapes[1] = new Rectangle2D.Double(100.0,100.0,200.0,200.0);
shapes[2] = new Ellipse2D.Double(200.0,200.0,100.0,100.0);
GeneralPath path =
new GeneralPath(new Line2D.Double(300.0,100.0,400.0,150.0));
path.append(new Line2D.Double(400.0,150.0,350.0,200.0),true);
path.append(new Line2D.Double(350.0,200.0,325.0,175.0),true);
path.append(new Line2D.Double(325.0,175.0,300.0,100.0),true);
shapes[3] = path;
shapes[4] = new RoundRectangle2D.Double
(350.0,250,200.0,100.0,50.0,25.0);
}
void setupMenuBar(){
Object menuItems[][] = {{"File","Exit"}};
menuBar = new MyMenuBar(menuItems,eh,eh);
setMenuBar(menuBar);
}
class MyCanvas extends Canvas {
public void paint(Graphics graphics) {
Graphics2D g = (Graphics2D) graphics;
g.setClip(new Rectangle2D.Double(75.0,75.0,300.0,250.0));
float[] dashPattern = {10.0f,10.0f,5.0f,5.0f};
g.setStroke(new BasicStroke(5,
BasicStroke.CAP_ROUND,
BasicStroke.JOIN_MITER,
10.0f,
dashPattern,
0.0f));
g.draw(shapes[0]);
g.setPaint(Color.blue);
g.draw(shapes[1]);
g.fill(shapes[1]);
g.setPaint(new GradientPaint(350.0f,200.0f,Color.red,
325.0f,175.0f,Color.green));
g.draw(shapes[2]);
g.fill(shapes[2]);
g.setColor(Color.black);
g.draw(shapes[3]);
TexturePaint texture = new TexturePaint(
createBufferedImage(),
new Rectangle2D.Double(350.0,250,200.0,100.0);
g.setPaint(texture);
g.draw(shapes[4]);
g.fill(shapes[4]);
}
BufferedImage createBufferedImage() {
BufferedImage image =
new BufferedImage(20,20,BufferedImage.TYPE_INT_RGB);
Graphics2D g = image.createGraphics();
g.draw(new Line2D.Double(0.0,0.0,10.0,10.0));
g.draw(new Line2D.Double(0.0,10.0,10.0,0.0));
return image;
}
}
class EventHandler extends WindowAdapter implements ActionListener,
ItemListener {
public void actionPerformed(ActionEvent e){
String selection=e.getActionCommand();
if("Exit".equals(selection)){
System.exit(0);
}
}
public void itemStateChanged(ItemEvent e){
}
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
Using Text and Fonts
As mentioned earlier in this chapter in the "Drawing Graphics" section, Java font faces are comprised
of glyphs, which are drawn in the same manner as other Shape objects. This means that text can be
drawn using different pen and fill styles, and it can also be clipped and rotated. You'll learn how to
rotate graphics and text in the "Using Transforms" section later in this chapter.
The Font class provides several methods for accessing information about how glyphs are drawn. The
getGlyphOutline() method returns a Shape object that describes a glyph code. The getGlyphSet()
returns a GlyphSet object that describes a text string. The GlyphSet object provides access to the
glyph codes (int values) that define individual glyphs. The getGlyphMetrics() and
getGlyphJustificationInfo() methods return metric and justification information about a glyph code.
The Java 2D API also provides extensive support for text formatting and layout. The TextAttribute
class is used to specify the style attributes of text.
The TextLayout class is used to format and layout stylized text. The TextLayout class takes care of
nearly all of your text processing needs and provides the following capabilities:
●
Breaking, wrapping, and rendering text
Support of bidirectional text (required to display text in some foreign languages)
●
Working with multiple baselines
●
Access to text metrics (ascent, descent, and so on)
●
Font substitution
●
Justification support
●
Caret and cursor positioning and movement
●
Highlighting
●
Hit testing (Determining a text offset from the caret position)
TextLayout objects are constructed using String objects and displayed using the draw() method.
TextLayout also provides numerous methods for obtaining information about the text that it processes.
Listing 20.4 shows how the TextLayout class is used to create text using multiple fonts. The
StyledText program displays three lines of text, as shown in Figure 20.4.
The paint() method of MyCanvas invokes the createStyledStrings() method to create an array of
TextLayout objects. The yOffset variable specifies the vertical position where the next string should
be displayed. A for statement iterates through the TextLayout array and draws each string at a
horizontal position of 100 and a vertical position of 100 plus the value of yOffset. The getAscent(),
getDescent(), and getLeading() methods of TextLayout are used to calculate the new value of yOffset.
FIGURE 20.4. The StyledText program uses the TextLayout class to create and display text using
multiple fonts.
The createStyledStrings() method creates a three-element array of TextLayout, which it uses as a
return value. Three fonts are used to provide variety to the text contained in these three strings.
LISTING 20.4. THE StyledText PROGRAM.
import
import
import
import
import
public
java.awt.*;
java.awt.event.*;
java.awt.font.*;
ju.ch09.MyMenu;
ju.ch09.MyMenuBar;
class StyledText extends Frame {
static final int width = 600;
static final int height = 400;
MyMenuBar menuBar;
FontRenderContext frc;EventHandler eh = new EventHandler();
public static void main(String args[]){
StyledText app = new StyledText();
}
public StyledText() {
super("StyledText");
setupMenuBar();
add("Center",new MyCanvas());
setSize(width,height);
addWindowListener(eh);
show();
}
void setupMenuBar(){
Object menuItems[][] = {{"File","Exit"}};
menuBar = new MyMenuBar(menuItems,eh,eh);
setMenuBar(menuBar);
}
class MyCanvas extends Canvas {
public void paint(Graphics graphics) {
Graphics2D g = (Graphics2D) graphics;frc=g.getFontRenderContext
();
TextLayout[] s = createStyledStrings();
int yOffset = 0;
for(int i=0;i<s.length;++i) {
s[i].draw(g,100,100+yOffset);
yOffset += s[i].getAscent()+s[i].getDescent()+s[i].getLeading();
}
}
}
TextLayout[] createStyledStrings() {
TextLayout[] s = new TextLayout[3];
Font f1 = new Font("Helvetica",Font.BOLD,24);
Font f2 = new Font("TimesRoman",Font.ITALIC,14);
Font f3 = new Font("Helvetica",Font.PLAIN,12);
s[0] = new TextLayout("This is the first sentence.",f1,frc);
s[1] = new TextLayout("This is the second sentence.",f2,frc);
s[2] = new TextLayout("This is the third sentence.",f3.frc);
return s;
}
class EventHandler extends WindowAdapter implements ActionListener,
ItemListener {
public void actionPerformed(ActionEvent e){
String selection=e.getActionCommand();
if("Exit".equals(selection)){
System.exit(0);
}
}
public void itemStateChanged(ItemEvent e){
}
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
Displaying Images
In addition to its extensive support for drawing graphics and text, the Java 2D API provides
additional capabilities for image processing. Images are two-dimensional arrays of pixels. These
arrays are often referred to as raster images or rasters. The color of each pixel is specified by a value
that is either a color value or an index to a table of color values. In the first case, the image is said to
use a direct color model. In the second case, the image uses an indexed color model. The Java 2D
API supports both types of color models via the DirectColorModel and IndexedColorModel classes,
which contain several subclasses that provide support for a variety of specific color models.
The Java 2D API also provides support for image compositing. Compositing is the process of
rendering an image, graphic, or text based on the colors of objects that have already been rendered.
For example, consider displaying a yellow sun on a blue sky. The yellow image can simply replace
the pixels of the blue image, or it can blend in with the blue image. Compositing defines this blending
process. The Composite interface defines methods that are implemented by classes that support
compositing. Composite objects are used by Graphics2D objects when they draw graphics or text, or
display images.
The AlphaComposite class provides a default implementation of the Composite interface.
AlphaComposite supports the blending of new pixel data with existing pixel data using alpha color
values in the new and existing pixel data. The alpha color values identify the transparency of a color
using a scale of 0.0 to 1.0. If a value of 1.0 is used, the new pixel data completely replaces existing
pixel data. If a value of 0.0 is used, any existing pixel data is used instead of new pixel data. If a
number between 0.0 and 1.0 is used, the new and existing pixel data are used in proportion to this
value. For example, a value of 0.6 causes the color of the new pixel data to contribute 60% of the
value of the composite color and the existing pixel data to contribute 40% of the value. In addition to
the alpha values of the new and existing pixel data, a separate alpha scale factor may also be
specified. This scale factor ranges from 0.0 to 1.0 and is multiplied by the alpha values of the new
and existing colors. In addition to this scale factor, the AlphaComposite class provides additional
compositing rules. These rules are implemented as class constants and may be used to specify a
particular compositing approach.
Listing 20.5 illustrates how the AlphaComposite class is used to implement compositing. The output
of the Composite program is shown in Figure 20.5. It consists of a purple rectangle and a red
rectangle. The red rectangle is displayed over the purple rectangle. Compositing is used to blend the
colors of the two images together at their point of intersection. The Composite program uses a
transparency value of 0.5 by default. You can change this value by supplying a new transparency
value between 0.0 and 1.0 as a command-line argument.
The Composite program uses the alpha field variable to store the transparency value that is used to
composite the two images. This value is modified if a command-line argument is supplied.
The paint() method of the MyCanvas class creates an AlphaComposite object using the static
getInstance() method of the AlphaComposite class. This object uses a source-over-compositing
approach and the alpha value specified by the alpha field variable. The setComposite() method of
Graphics2D is used to specify the use of the AlphaComposite object.
FIGURE 20.5. The Composite program shows how images can be blended together using the
AlphaComposite class.
Having set up compositing, the images contained in the image0.gif and image1.gif files are displayed
using the drawImage() method of the Graphics class. The first image is the purple rectangle, and the
second image is the red rectangle.
LISTING 20.5. THE Composite PROGRAM.
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import ju.ch09.MyMenu;
import ju.ch09.MyMenuBar;
public class Composite extends Frame {
static float alpha = 0.5f;
static final int width = 600;
static final int height = 400;
MyMenuBar menuBar;
EventHandler eh = new EventHandler();
public static void main(String args[]){
if(args.length>0) alpha = (new Float(args[0])).floatValue();
Composite app = new Composite();
}
public Composite() {
super("Composite");
setupMenuBar();
add("Center",new MyCanvas());
setSize(width,height);
addWindowListener(eh);
show();
}
void setupMenuBar(){
Object menuItems[][] = {{"File","Exit"}};
menuBar = new MyMenuBar(menuItems,eh,eh);
setMenuBar(menuBar);
}
class MyCanvas extends Canvas {
public void paint(Graphics graphics) {
Graphics2D g = (Graphics2D) graphics;
AlphaComposite composite =
AlphaComposite.getInstance(AlphaComposite.SRC_OVER,alpha);
g.setComposite(composite);
Toolkit toolkit = Toolkit.getDefaultToolkit();
Image image0 = toolkit.getImage("image0.gif");
Image image1 = toolkit.getImage("image1.gif");
g.drawImage(image0,200,100,this);
g.drawImage(image1,100,150,this);
}
}
class EventHandler extends WindowAdapter implements ActionListener,
ItemListener {
public void actionPerformed(ActionEvent e){
String selection=e.getActionCommand();
if("Exit".equals(selection)){
System.exit(0);
}
}
public void itemStateChanged(ItemEvent e){
}
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
Using Transforms
One of the unique features of the Java 2D API is that it provides a uniform coordinate transformation
model. This model includes the AffineTransformation class, which supports linear transformations
between sets of 2D coordinates. A linear transformation calculates new coordinates by multiplying
existing coordinates by a scaling factor and then adding an offset value. The AffineTransform class
can be used to translate (move), scale, rotate, flip, and shear graphics, text, and images.
AffineTransformation objects are created by specifying a transformation matrix as an argument to the
AffineTransformation() constructor. This matrix is defined as follows:
m00 m01 m02
m10 m11 m12
0
0
1
THE MATRIX IS USED TO TRANSFORM A POINT (X,Y) TO A NEW POINT (X',Y') BY FIRST
EXTENDING (X,Y) TO (X,Y,1) AND THEN MULTIPLYING THE MATRIX BY THIS POINT:
m00 m01 m02 x = m00*x + m01*y + m02
m10 m11 m12 y = m10*x + m11*y + m12
0
0
1
1=1
(x',y') is then set to (m00*x + m01*y + m02,m10*x + m11*y + m12).
The AffineTransformation class provides a set of static convenience methods that can be used instead
of specifying a transformation matrix. These methods are as follows:
●
●
●
●
getTranslateInstance()--Creates an AffineTransformation object that is an (x,y) translation.
getRotateInstance()--Creates an AffineTransformation object that is a rotation about a point
using a specified angle.
getScaleInstance()--Creates an AffineTransformation object that is an xy-scaling.
getShearInstance()--Creates an AffineTransformation object that represents a shearing.
Shearing is a transformation that scales coordinates of one axis (x or y) using coordinates of
the other axis.
An AffineTransformation object is used by invoking the transform() method of the Graphics2D class.
Multiple transforms can be used by repeatedly invoking transform(). The last transformation
specified is the first transformation that is used. Once a transformation has been specified, it is used
with all graphics, text, and images that are drawn to the Graphics2D object.
Listing 20.6 shows how the AffineTransformation class is used to transform graphics, text, and
images. Figure 20.6 shows the output of the Transform program. It rotates the display of a line, a red
rectangular image, and text by p/16 radians.
FIGURE 20.6. The Transform program shows how graphics, images, and text can be rotated using
the AffineTransforma- tion class.
The paint() method of MyCanvas creates an AffineTransform object using the static getRotateInstance
() method of the AffineTransform class. The rotation is specified as p/16 radians, which is about 11
degrees. The setTransform() method of Graphics2D is used to put the transform into effect. The
following objects are then drawn to the Graphics2D object:
●
A line from (0,0) to (300,300)
●
The text "Java 2D API"
●
The red rectangular image contained in image1.gif
These objects are rotated by p/16 radians when they are rendered.
LISTING 20.6. THE Transform PROGRAM.
import java.awt.*;
import java.awt.event.*;
import java.awt.font.*;
import java.awt.geom.*;
import java.awt.image.*;
import ju.ch09.MyMenu;
import ju.ch09.MyMenuBar;
public class Transform extends Frame {
static final int width = 600;
static final int height = 400;
MyMenuBar menuBar;
EventHandler eh = new EventHandler();
public static void main(String args[]){
Transform app = new Transform();
}
public Transform() {
super("Transform");
setupMenuBar();
add("Center",new MyCanvas());
setSize(width,height);
addWindowListener(eh);
show();
}
void setupMenuBar(){
Object menuItems[][] = {{"File","Exit"}};
menuBar = new MyMenuBar(menuItems,eh,eh);
setMenuBar(menuBar);
}
class MyCanvas extends Canvas {
public void paint(Graphics graphics) {
Graphics2D g = (Graphics2D) graphics;
AffineTransform transform =
AffineTransform.getRotateInstance(Math.PI/16.0d);
g.setTransform(transform);
Line2D.Double shape =
new Line2D.Double(0.0,0.0,300.0,300.0);
g.draw(shape);
g.getFont(new Font("Helvetica",Font.BOLD,24));
String text = ("Java 2D API");
g.drawString(text,300,50);
Toolkit toolkit = Toolkit.getDefaultToolkit();
Image image = toolkit.getImage("image1.gif");
g.drawImage(image,100,150,this);
}
}
class EventHandler extends WindowAdapter implements ActionListener,
ItemListener {
public void actionPerformed(ActionEvent e){
String selection=e.getActionCommand();
if("Exit".equals(selection)){
System.exit(0);
}
}
public void itemStateChanged(ItemEvent e){
}
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
NOTE: The rotate(), scale(), shear(), and translate() methods of the Graphics2D class
can be used in lieu of working with AffineTransformation objects.
NOTE: An affine transformation always translates straight lines into straight lines and
parallel lines into parallel lines.
The Java 3D API
The Java 3D API is a separate standard extension API that is used to create three- dimensional
graphics, applets, and applications. It can be downloaded from JavaSoft's Web site at http://java.sun.
com:80/products/java-media/3D/index.html. It consists of a self-installing executable file. After
installing this file, follow the directions in the Readme.txt file for setting up your CLASSPATH. The
Java 3D API is supported on Windows, UNIX, Macintosh, and JavaOS platforms. It uses the graphics
APIs provided by these operating systems, such as OpenGL, Direct3D, and QuickDraw3D.
The 3D API consists of the two packages, javax.media.j3d and javax.vecmath, and supporting classes
and interfaces from the com.sun.j3d.utils package. The javax.media.j3d package provides the basic
classes and interfaces that implement the Java 3D API. The javax.vecmath class provides support for
vector-based mathematics. The com.sun.j3d.utils package is not documented as part of the Java 3D
API, but it contains classes and interfaces that simplify the building of 3D applications and applets.
The javax.media.j3d Package
The javax.media.j3d package consists of three interfaces and over 100 classes that support basic 3D
operations. The features provided by these classes and interfaces include the following:
●
●
●
●
●
●
●
●
●
A scene-graph-based programming model--Java 3D applications are compatible with popular
approaches to modeling 3D worlds.
3D object representation--3D points, rectangles, triangles, text, and other objects are
supported.
3D transformations--A number of 3D geometric transforms are provided.
Multiple view support--3D worlds can be viewed from a variety of perspectives. These
perspectives can be dynamically changed.
Dynamic behavior and timing--Java 3D worlds support moving worlds, sophisticated event
models, and dynamic sensor objects.
Lighting--Comprehensive lighting support, including fog, is provided.
High-performance 3D rendering--The rendering implementation supports many advanced
features and may use native 3D rendering support.
Compatibility support--Java 3D provides hooks for supporting current 3D file formats,
including Virtual Reality Markup Language (VRML) 1.0 and VRML 2.0.
Sound support--Indigenous support for 3D spatial sound is provided.
The classes and interfaces that support these operations were designed using the best features of the
OpenGL, QuickDraw3D, Direct3D, and XGL graphics libraries.
The javax.vecmath Package
The javax.vecmath package consists of a number of classes that implement 3D objects.
The Tuple3b class represents a point in 3 space. It is extended by Color3b, which implements a 3byte vector that is used for colors. The Tuple3f and Tuple3d classes provide floating-point and
double-precision 3-space points. The Tuple4b class represents a point in 4 space. The Tuple4f and
Tuple4d classes provide floating-point and double-precision representations. The Color3f, Color4b,
and Color4f classes are used to represent three- and four-dimensional color values.
The Point2f, Point3f, Point3d, Point4f, and Point4d classes represent points in 2, 3, and 4 space.
The Vector2f, Vector3f, Vector4f, Vector3d, and Vector4d classes provide floating-point and doubleprecision vectors in 2, 3, and 4 space. The GVector class provides a general vector implementation.
The Matrix3f, Matrix3d, Matrix4f, and Matrix4d classes represent three- and four-dimensional
matrices. The GMatrix class provides a general matrix implementation.
The TexCoord2f and TexCoord3f classes represent coordinates in 2 and 3 space.
The Quat4f and Quat4d classes represent four-dimensional quaternion values.
The AxisAngle4d and AxisAngle4f classes represent an angle about a vector. AxisAngle4d uses
double values, and AxisAngle4f uses floating-point values.
Using 3D Graphics in Your Programs
A complete treatment of 3D programming with the Java 3D API could fill an entire book by itself.
Rather than wading through all the classes of the Java 3D API, I'll shown you a simple 3D application
and describe the classes and interfaces that make it work. You can then use this program as a basis
for developing your own Java 3D applications and applets.
Listing 20.7 contains the source code of the Draw3D program. This program draws a 3D colored
cube in the center of the application window and rotates the cube about the y-axis, as shown in Figure
20.7. In Java 3D, the default coordinate system is a right-handed system, with +y being up, +x
horizontal to the right, and +z being outward toward the viewer.
FIGURE 20.7. The Draw3D program displays a moving 3D cube.
The Draw3D program defines a Canvas3D object and assigns it to the canvas3D field variable. The
Draw3D() constructor adds the Canvas3D object to the center of the application window. The
Canvas3D class provides a canvas for 3D rendering. It is analogous to the Canvas class of java.awt.
The setup3DGraphics() method is invoked by the Draw3D constructor to set up the 3D scene to be
rendered. This method creates a SimpleUniverse object. The SimpleUniverse class (from the com.sun.
j3d.utils.universe package) simplifies the creation of a virtual 3D world. The getViewingPlatform()
method is invoked to retrieve a ViewPlatform object for the universe. The
setNominalViewingTransform() method sets up a simple default view of the universe. The Java 3D
API provides the capability to view a 3D world from a variety of perspectives. The addBranchGraph
() method adds a BranchGraph object to the universe. A BranchGraph is used to define a 3D scene.
The createSceneGraph() method creates the BranchGraph object that specifies the 3D scene to be
displayed. It creates a BranchGraph object to be used as a return value and adds a TransformGroup
object to it. The TransformGroup is used to define a 3D transformation on objects in the scene. In this
case, it is used to rotate a colored cube. The setCapability() method is used to allow the
TransformGroup object to be updated during program execution.
The ColorCube class of the com.sun.j3d.utils.geometry package provides a quick and easy way to
create a colored 3D cube. This is an undocumented part of the Java 3D API. Without this class, we
would have to construct and color our own 3D object. The relative size of the ColorCube object is set
to 0.25, and the object is added to the TransformGroup.
A RotationInterpolator object is created to rotate the cube. It is constructed using a default Alpha
object and the TransformGroup object. The Alpha object defines a default timing to be used in the
rotation. A BoundingSphere object is constructed to define the bounds of the rotation. This object is
centered at the origin and has a radius of 100. The setSchedulingBounds() method is used to associate
the BoundingSphere object with the RotationInterpolator object. The RotationInterpolator object is
then added to the TransformGroup object.
Note that no paint() method is needed to render the 3D scene. The Java 3D rendering engine
automatically paints the Canvas3D object.
LISTING 20.7. THE Draw3D PROGRAM.
import
import
import
import
import
import
import
import
java.awt.*;
java.awt.event.*;
javax.media.j3d.*;
javax.vecmath.*;
com.sun.j3d.utils.geometry.ColorCube;
com.sun.j3d.utils.universe.*;
ju.ch09.MyMenu;
ju.ch09.MyMenuBar;
public class Draw3D extends Frame {
Canvas3D canvas3D = new Canvas3D(null);
static final int width = 600;
static final int height = 400;
MyMenuBar menuBar;
EventHandler eh = new EventHandler();
public static void main(String args[]){
Draw3D app = new Draw3D();
}
public Draw3D() {
super("Draw3D");
setupMenuBar();
add("Center",canvas3D);
setSize(width,height);
setup3DGraphics();
addWindowListener(eh);
show();
}
void setup3DGraphics() {
// Create a simple universe that is used for the 3D world.
SimpleUniverse universe = new SimpleUniverse(canvas3D);
// Get the ViewPlatform for this universe and set its view.
universe.getViewingPlatform().setNominalViewingTransform();
// Create a scene and add it to the universe.
universe.addBranchGraph(createSceneGraph());
}
BranchGroup createSceneGraph() {
// Create the return object
BranchGroup branchGroup = new BranchGroup();
// Create a transform group for creating a 3D transformation.
TransformGroup transGroup = new TransformGroup();
// Allow the transform group to be updated during execution.
transGroup.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
// Add the transform group to the branch group
branchGroup.addChild(transGroup);
// Add a color cube to the transform group
transGroup.addChild(new ColorCube(0.25));
// Create a 3D transformation object.
RotationInterpolator ri = new RotationInterpolator(
new Alpha(), transGroup);
BoundingSphere bounds =
new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0);
ri.setSchedulingBounds(bounds);
transGroup.addChild(ri);
return branchGroup;
}
void setupMenuBar(){
Object menuItems[][] = {{"File","Exit"}};
menuBar = new MyMenuBar(menuItems,eh,eh);
setMenuBar(menuBar);
}
class EventHandler extends WindowAdapter implements ActionListener,
ItemListener {
public void actionPerformed(ActionEvent e){
String selection=e.getActionCommand();
if("Exit".equals(selection)){
System.exit(0);
}
}
public void itemStateChanged(ItemEvent e){
}
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
Summary
In this chapter, you explored the Java 2D and Java 3D APIs. You learned how the Java 2D API can
be used to enhance line drawing, painting, and text rendering, and you created applications that
demonstrated these capabilities. You also learned about the Java 3D API and used it to display and
manipulate three-dimensional objects. In the next chapter, you'll learn how to add multimedia
capabilities to your applets and applications.
© Copyright, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
- 21 Using Audio and Video
●
●
●
●
●
Audio and Video Basics
The Java Media Framework
❍ The JMF Player
❍ The JMF API
❍ The javax.media.protocol Package
Adding Audio and Video Clips to Your Programs
❍ The MediaApplication Program
❍ The MediaApplet Applet
The Real-Time Transport Protocol (RTP) Session Manager API
Summary
One of the most interesting features that you can add to an applet or application is the capability to
play multimedia files, such as audio or video. Recognizing the need for a multimedia API, JavaSoft
developed the Java Media Framework (JMF), which consists of an API for playing and receiving
multimedia files in a variety of audio and video formats. The JMF includes API packages, media
stream/file players, codecs, and the Java Sound Engine.
In this chapter, you'll learn how to use the capabilities provided by the JMF to incorporate audio and
video support into your applications and applets. You'll learn the basics of audio and video file
formats, learn how to use the JMF player, and investigate the JMF API. You'll also learn about JMF's
support for the Real-Time Transport Protocol (RTP). When you finish this chapter, you'll be able to
add multimedia features to your applications and applets.
Audio and Video Basics
There are a number audio and video file formats that are used to store sounds and moving images.
Each of these formats represents a compromise between fidelity, range, file size, and performance.
For example, there is a limited range of frequencies that can be detected by the human ear. Within
this range, the fidelity of an audio file is determined by the rate at which the sound is sampled
(samples/second), the amount of information per sample (8, 16, or 32 bits), and the number of sound
channels (mono or stereo). The greater the sample rate and sample size, the greater the file size. File
size can be offset by the use of compression, but at higher compression rates there may be detectable
impacts on system performance. Specialized codecs (compressors/decompressors) may be used to
improve performance.
Video format tradeoffs are similar to audio tradeoffs. However, the size of most video files dwarfs
that of audio files. Video fidelity is a function of the size of a video frame (in pixels), the number of
colors per pixel, and the number of frames per second. Compression is extremely important in video
because video files are so large. Specialized codecs are required for use in nearly all video formats.
Examples of common audio formats are as follows:
●
●
●
●
●
WAVE--The Microsoft Windows audio file format.
AIFF--The Audio Interchange File Format, typically used with Macintosh and Silicon
Graphics computers.
AU--The Sun audio file format.
RMF--The Rich Music Format, an audio file format created by Headspace, Inc. for online
playback through the Beatnik Plug-in.
MIDI (type 1 and type 2)--The Musical Instrument Digital Interface, a digital format for
musical instruments.
The use of these audio formats is organized along political lines. The most common audio format
used with Microsoft Windows-based systems is Microsoft's Wave format (.WAV). The most
common format used with Solaris is the Sun Audio Format (.AU). Historically, new audio file
formats were introduced for use with different computer hardware and software platforms. The RMF
format is intended to be a platform- independent format. The MIDI format is not based on sound
sampling but is a digital format for identifying the instruments, rhythms, and notes used in a musical
composition. In this respect, it is more like digital sheet music or an audio animation.
Examples of common video formats are as follows:
●
MPEG--A sequence of video formats developed by the Moving Picture Experts Group.
●
MOV--The Apple QuickTime video format.
●
VIV--A streaming video format developed by Vivo Software, Inc.
●
AVI--The Microsoft Video for Windows file format.
●
ActiveMovie--Microsoft's streaming video format.
Of these video formats, MPEG produces the highest-quality video using the smallest file size. This is
a result of the superior compression techniques it uses. The QuickTime and AVI formats were
developed for use with the Macintosh and PC. The QuickTime format is more popular, and
QuickTime players are available for a number of operating system platforms. The Vivo and
ActiveMovie formats support streaming video, or video that is downloaded a little at a time from an
Internet stream instead of as an entire file. The Vivo format is an excellent format for use with Web
applications. ActiveMovie is Microsoft's venture into this area.
NOTE: Apple Computer provides an implementation of QuickTime that is
independent of the JMF. It is referred to as QuickTime for Java and is available from
Apple's Web site at http://www.apple.com/quicktime/.
The Java Media Framework
The Java Media Framework is an API for using audio and video within Java applications and applets.
This API supports the playing of a wide variety of media types. It also provides examples of mediaplaying applications and applets. The JMF is available from JavaSoft's Web site at http://www.
javasoft.com/products/java-media/ jmf/index.html. It is packaged as a self-extracting, self-installing
file. To install the JMF on Windows 95, 98, or NT, your system should include the following:
●
ActiveMovie
●
Direct X 2.0 (or greater)
Both ActiveMovie and Direct X 2.0 are available from Microsoft at http://www.microsoft.com/
directx/resources/devdl.htm.
The media types supported by JMF 1.0 include the following:
●
QuickTime (.mov)
●
Video for Windows (.avi)
●
Vivo (.viv)
●
Sun Audio (.au)
●
Audio Interchange File Format (.aiff)
●
Wave (.wav)
●
Musical Instrument Digital Interface (.midi)
●
Rich Music Format (.rmf)
●
Groupe Speciale Mobile (.gsm)
●
MPEG-1 (.mpg)
●
MPEG Audio (.mp2)
●
Real-Time Transport Protocol (.rtp)
The JMF Player
The best way to get a feel for the capabilities provided by JMF is to use the JMF Player. If you
installed the JMF under Windows, a JMF program group should have been created for you. Doubleclick the JMF Player icon to launch the JMF Player. Figure 21.1 shows its initial display.
FIGURE 21.1.The JMF Player.
Select Open File from the File menu to launch an Open file dialog box. Navigate to the samples
\media subdirectory of the directory in which you installed the JMF. You should find some example
media files in this directory. Open Sample1.mov to play a QuickTime movie. Figure 21.2 shows a
snapshot of the movie that is displayed.
FIGURE 21.2. Playing a QuickTime movie with the JMF Player.
When you are finished playing the movie, click the pause icon in the lower-left corner of the
application window. Then open the Sample2.mpg movie from the same directory. Figure 21.3
provides a snapshot of how this movie is displayed.
Figure 21.3. Playing an MPEG movie with the JMF Player.
You can also try some of the audio samples that are included with the JMF. I was impressed by the
clarity of the sound that was played on my notebook computer.
The JMF API
Having had a taste of the capabilities provided by JMF, I'll bet you can't wait to start using it in your
applets and applications. We'll cover the JMF API first and then illustrate the use of this API with an
application and an applet.
The JMF API consists of the javax.media and the javax.media.protocol packages. These packages are
standard extension APIs. The javax.media package is fairly large, consisting of 13 interfaces and 27
classes. Twenty-six of these classes and interfaces define events and event listeners. Event handling
is a big part of media playing. However, we'll cover the other classes and interfaces before we
introduce the JMF events and event handlers.
The Player interface is the most important element of the javax.media package. Classes that
implement this interface are used to play actual multimedia objects. The Player interface extends the
MediaHandler, Controller, and Duration interfaces. The realize() method (inherited from Controller)
is used to construct the media-specific portions of a Player object. The start() method signals that the
media should be played as soon as possible. Other methods are provided for accessing the visual
component and controllers associated with the Player object.
The Controller interface extends the Clock interface to manage the state of a media object. Classes
that implement this interface manage the following media states:
●
Unrealized--The initial state of a Controller.
●
Realizing--The Controller gathers all resources required to operate.
●
Realized--The Controller has completed its realization.
●
Prefetching--The Controller is filling its buffers with media content.
●
Prefetched--The prefetch has been completed.
●
Started--The Controller is rendering the prefetched media.
A Controller defines methods and generates events that support the management of these states. The
Player interface is a subinterface of Controller that supports the playing of media.
The Control interface defines methods for exerting control over a media object. The
getControlComponent() method returns a GUI component used to control a media object. The
CachingControl interface extends the Control interface to define methods used to control the loading
of media files/data. The GainControl interface defines methods for getting and setting audio signal
gain.
The MediaHandler interface is implemented by classes that manage media that is retrieved from a
DataSource object (defined in javax.media.protocol). This interface is extended by the Player and
MediaProxy interfaces. The MediaProxy interface is implemented by classes that transform data from
one DataSource object to another DataSource object.
The Manager class provides access to system-dependent media resources via static methods. The
createPlayer() method is used to create a Player object that is capable of playing a media object
referenced by a MediaLocator, URL, or DataSource object. Other methods allow DataSource and
TimeBase objects to be created.
The MediaLocator class describes the location of media to be played. MediaLocator objects are
constructed by passing a URL object, or a string that represents a URL, to the MediaLocator
constructor. The MediaLocator class provides methods for accessing the media's location. The
PackageManager class maintains a store of package prefix names used to locate protocol-handling
and other media-related classes.
The Time class encapsulates time as used by media players. It provides time constants and methods
for accessing time down to the nanosecond level. The TimeBase interface defines methods for a
constant, uninterruptable source of time. The Clock interface defines methods for managing time with
respect to the playing of media. The Duration interface defines the getDuration() method for
obtaining information about the duration of a media object.
The javax.media Event Hierarchy
As previously mentioned, event handling is a big part of media playing. The javax.media package
defines a variety of events to provide feedback to media handling software. The MediaEvent interface
is implemented by all JMF events. These event handling classes form the class hierarchy.
ControllerEvent--Base interface for all Controller events.
TransitionEvent--Generated when a Controller changes to a new state.
StartEvent--Generated when a Controller enters the Start state.
RealizeCompleteEvent--Generated when a Controller changes from the Realizing to the Realized
state.
PrefetchCompleteEvent--Generated when a Controller moves from the Prefetching to the Prefetched
state.
StopEvent--Generated when a Controller enters the Stop state.
DataStarvedEvent--Generated when a Controller has lost data or stopped receiving data.
DeallocateEvent--Generated when the resources of a Controller have been deallocated and need to be
reallocated to continue media operations.
EndOfMediaEvent--Generated when a Controller has reached the end of its media and is stopping.
RestartingEvent--Generated when a Controller changes from the Started state to the Prefetching state.
StopByRequestEvent--Generated when a Controller is stopped as a result of its stop() method being
invoked.
StopAtTimeEvent--Generated when a Controller reaches its stop time.
StopTimeChangeEvent--Generated by a Controller when its stop time is updated.
ControllerClosedEvent--Generated when a Controller is no longer operational.
ControllerErrorEvent --Generated when an error occurs that causes a Controller to stop functioning.
ConnectionErrorEvent--Generated when an error occurs within a DataSource object.
ResourceUnavailableEvent--Generated when a Controller is unable to access a required resource.
InternalErrorEvent--Generated as the result of an internal error in a Controller.
CachingControlEvent--Generated by a CachingControl object when the caching state changes.
MediaTimeSetEvent--Generated when the media of a Controller has had its time updated.
RateChangeEvent--Generated when the rate of a Controller changes.
DurationUpdateEvent--Generated when the duration of a Controller changes.
GainChangeEvent--Generated by a GainControl object when its state changes.
The ControllerListener interface is used to handle events generated by Controller objects. These
events consist of ControllerEvent and all of its subclasses. The GainChangeListener interface is used
to handle the GainChangeEvent, which is generated by GainControl objects.
The javax.media.protocol Package
The javax.media.protocol package has nine interfaces and six classes that are used to transfer data
from its source to a media player. These classes and interfaces are as follows:
●
DataSource--An abstract class that encapsulates a media protocol handler. It implements the
Controls and Duration interfaces, and provides methods for connecting to a media object and
controlling the transfer of data from the object.
●
PullDataSource--A subclass of DataSource whose data is "pulled" by a media player.
●
URLDataSource--A subclass of PullDataSource whose data is retrieved from a URL.
●
PushDataSource--A subclass of DataSource whose data is "pushed" to a media player.
●
●
●
●
●
●
●
●
●
●
●
Positionable--An interface that is implemented by a DataSource that allows the media position
within a stream to be changed.
PullSourceStream--An interface that defines a stream that reads data from a DataSource.
PushSourceStream--An interface that defines a stream used by a DataSource to push data to a
media player.
Seekable--An interface that is implemented by SourceStream objects that support
repositioning within the stream.
SourceStream--Defines methods that are implemented by a media data stream.
SourceTransferHandler--Interface implemented to support handling of PushSourceStream
objects.
RateConfiguration--An interface for accessing streams that operate at a specific rate.
RateConfigureable--An interface that is implemented by a DataSource that supports multiple
rate configurations.
RateRange--A class that maintains information about the range of rates at which data can be
transferred from a DataSource.
ContentDescriptor--A class that is used to describe the type of content contained in a
DataSource.
Controls--An interface that defines methods for obtaining objects that control other objects.
In many cases, you won't have to effect the actual transfer of data from a source to a Player. As you'll
see in the MediaApplication application in Listing 21.1, Player implementations transfer data as part
of their prefetch processing.
NOTE: Future versions of JMF will support media capture and media conferencing.
Adding Audio and Video Clips to Your Programs
Now that you've been introduced to the classes and interfaces of the JMF API, we'll put together an
example of an application and applet that uses these classes and interfaces to play audio and video
media. The MediaApplication program in the following section presents a simplified version of the
JMF Player. This application can play all of the media that the JMF Player can play, but its GUI
features have been minimized so that the application source code can fit in and be described within a
single chapter. After presenting the MediaApplication program, the next section shows how to
include media playing capabilities in an applet.
The MediaApplication Program
The MediaApplication program in Listing 21.1 covers all of the basics of media playing using the
JMF. Make sure that you have the JMF installed before running the program. Its initial display is
shown in Figure 21.4. The program isn't as pretty as the JMF Player, but at 20% of its size, it is much
easier to understand. The MediaApplication program is capable of playing all of the media types that
the JMF Player plays.
Select Open from the File menu and open the Sample1.mov file that is contained in the samples
\media subdirectory of the JMF directory. Note that the program informs you that it is loading the
media player and the media (see Figure 21.5).
When the appropriate media player and the selected media have been loaded, the program plays the
media in the center of the application window. Note that a media control slider is displayed at the
bottom of the application window, as shown in Figure 21.6.
Select Open from the File menu to play other media files, such as the MPEG movie or audio files that
are provided with the JMF. Note that the old GUI components are removed and new ones are added
when switching between media files.
FIGURE 21.4. The MediaApplication opening display.
FIGURE 21.5. The user is notified that the media is loading.
FIGURE 21.6. The MediaApplication displays a QuickTime movie.
LISTING 21.1. THE MediaApplication SOURCE CODE.
import
import
import
import
java.awt.*;
java.awt.event.*;
ju.ch09.*;
javax.media.*;
public class MediaApplication extends Frame
implements ControllerListener {
// Declare media-related variables
Player player = null;
Player newPlayer = null;
Component visualComponent = null;
Component controllerComponent = null;
// Other variables
Object menuItems[][] = {{"File","Open","-","Exit"}};
MenuItemHandler mih = new MenuItemHandler();
MyMenuBar menuBar = new MyMenuBar(menuItems,mih,mih);
int screenWidth = 400;
int screenHeight = 400;
TextField text = new TextField();
String directory = ".";
public static void main(String args[]){
MediaApplication app = new MediaApplication();
}
public MediaApplication() {
super("MediaApplication");
setMenuBar(menuBar);
add("North",text);
setSize(screenWidth,screenHeight);
addWindowListener(new WindowEventHandler());
show();
}
String getFileName() {
// Display file dialog
FileDialog dialog = new FileDialog(MediaApplication.this,
"Open Media File", FileDialog.LOAD);
dialog.setDirectory(directory);
dialog.show();
if(dialog.getFile()==null) return null;
directory = dialog.getDirectory();
String file = directory + dialog.getFile();
return file;
}
Player createPlayer(String fileName) {
Player newPlayer;
try {
MediaLocator locator = new MediaLocator("file:"+fileName);
if(locator == null) return null;
newPlayer = Manager.createPlayer(locator);
}catch(Exception ex) {
text.setText(ex.toString());
return null;
}
return newPlayer;
}
void realizeComplete() {
visualComponent = player.getVisualComponent();
controllerComponent = player.getControlPanelComponent();
if(visualComponent != null)
add("Center",visualComponent);
if(controllerComponent != null)
add("South",controllerComponent);
validate();
player.prefetch();
}
void prefetchComplete() {
text.setText("");
if(player.getTargetState() != Controller.Started)
player.start();
}
void controllerError() {
player.close();
if(visualComponent != null) remove(visualComponent);
if(controllerComponent != null) remove(controllerComponent);
validate();
visualComponent = null;
controllerComponent = null;
player.removeControllerListener(this);
player = null;
}
void controllerClosed() {
if(visualComponent != null) remove(visualComponent);
if(controllerComponent != null) remove(controllerComponent);
player = null;
System.gc();
System.runFinalization();
if(newPlayer!=null) {
player = newPlayer;
newPlayer = null;
player.addControllerListener(this);
text.setText("Loading ...");
player.realize();
}
validate();
}
public synchronized void controllerUpdate(ControllerEvent e) {
// Determine event type
if(e instanceof RealizeCompleteEvent) realizeComplete();
else if(e instanceof PrefetchCompleteEvent) prefetchComplete();
LISTING 21.1. CONTINUED
else if(e instanceof ControllerErrorEvent) controllerError();
else if(e instanceof ControllerClosedEvent) controllerClosed();
}
class MenuItemHandler implements ActionListener, ItemListener {
public void actionPerformed(ActionEvent ev){
String s=ev.getActionCommand();
if(s.equals("Exit")){
System.exit(0);
}else if(s=="Open"){
// Get the name of the media file
String fileName = getFileName();
if(fileName == null) return;
// Create player for file
newPlayer = createPlayer(fileName);
// Stop old player
boolean closingPlayer = false;
if(player!=null){
closingPlayer = true;
player.close();
}
if(newPlayer == null) return;
if(!closingPlayer) {
player = newPlayer;
player.addControllerListener(MediaApplication.this);
text.setText("Loading ...");
player.realize();
}
}
}
public void itemStateChanged(ItemEvent e){
}
}
class WindowEventHandler extends WindowAdapter {
public void windowClosing(WindowEvent e){
// Stop the player
if(player!=null) {
player.close();
while(player!=null) {
// wait a half second
try{
Thread.currentThread().sleep(500);
}catch(Exception ex) {
}
}
}
System.exit(0);
}
}
}
How the MediaApplication Works
The MediaApplication class implements the ControllerListener interface so that it can handle
Controller-related events involved in the loading and playing of media. The player and newPlayer
variables are used to manage the current Player object and any new Player object that is created. The
visualComponent and controllerComponent variables reference the visual component displayed by a
Player object and the component that is used to control the Player.
The user plays a new media file by opening it using the Open menu item in the File menu. To
understand how this works, we'll start with the actionPerformed() method of the MenuItemHandler
class and trace the thread of execution.
When the Open menu item is selected, the actionPerformed() method invokes the getFileName()
method to retrieve the name of the file to be opened. The getFileName() method displays a File Open
dialog box to the user. If the user selects a file, actionPerformed() passes the file name to the
createPlayer() method. The createPlayer() method creates a Player object by first creating a
MediaLocator object that identifies the selected media file's location, and then invoking the
createPlayer() method of the Manager class to create a Player object that is suitable for the media.
The new Player object is then returned to actionPerformed().
The actionPerformed() method checks to see if there is currently a media file being played. If so, it
invokes the close() method of the current Player object. The starting of the new player is then put off
until the current player generates the ControllerClosedEvent.
If there is no current player, actionPerformed() adds the MediaApplication instance as a listener for
Controller-related events and then invokes the realize() method of the new Player object. The
TextField is also updated with a loading message.
At this point, a new media file has been opened. If there was no previous file being played, the new
Player is in the Realizing state. Otherwise, the old Player is about to be changed into the Stop state.
The rest of the media playing involves handling of ControllerEvent events.
The controllerUpdate() method implements the ControllerListener interface and provides a central
point for handling all Controller-related events. Remember that all Player objects are also Controller
objects. The controllerUpdate() method checks the event to see which subclass of ControllerEvent it
is an instance of. It then invokes one of the following four methods, depending on the type of event:
●
●
●
●
realizeComplete()--This method handles the RealizeCompleteEvent, which is the first event
generated by a new player after its realize() method has been invoked. The realizeComplete()
method gets the media's visual component (for video files) and adds it to the center of the
application window. It also gets the media's controller component (the slider) and adds that to
the bottom of the application window. The validate() method of the Container class is invoked
so that the application's frame is laid out with the new components. The prefetch() method of
the Player class is invoked to begin prefetching media data into available buffers.
prefetchComplete()--This method handles the PrefetchCompleteEvent, which occurs after
media data has been prefetched into the Player object's buffers. The prefetchComplete()
method removes the loading message in the TextField and invokes the Player object's start()
method to start playing the media file.
controllerError()--This method handles the ControllerErrorEvent, which is generated as the
result of any errors encountered by the Player. It closes the Player and removes its visual and
controller components. It then removes the MediaAppplication instance as an event listener
for the Player.
controllerClosed()--This method handles the ControllerClosedEvent, which occurs after the
current Player object has been closed. The controllerClosed() method removes the Player's
visual and controller components, sets the Player to null, and then garbage-collects the
resources associated with the Player. If a new player has been selected, it sets up the Player's
ControllerListener and invokes the Player's realize() method. The TextField is updated with
the loading message.
As you can see from the MediaApplication's description, very little code is required to set up a
Player. Once a Player has been set up, the bulk of the processing involves handling the events that
occur as the Player moves from state to state.
The MediaApplet Applet
The MediaApplet, shown in Listing 21.2, shows how media playing capabilities can be incorporated
into an applet. The MediaApplet is a simplification of MediaApplication that plays a single
QuickTime file. The HTML file shown in Listing 21.3 is used to run MediaApplet. Before running
the applet, copy the Sample1.mov file from the samples\media directory of JMF to your ju\ch21
directory. When you open media.htm with appletviewer, it displays the applet shown in Figure 21.7.
MediaApplet can be easily tailored to play other media files.
FIGURE 21.7. The MediaApplet displays a QuickTime movie.
Having covered MediaApplication, the source code of MediaApplet will be easy to understand. The
MediaApplet class implements the ControllerListener interface and declares the player,
visualComponent, and controllerComponent variables in the same manner as MediaApplication.
The init() method lays out the applet and creates the Player object. It creates a URL object for the
Sample1.mov file and then passes this URL to the createPlayer() method of the Manager class. It then
adds the MediaApplet instance as an event handler for ControllerEvent events and invokes the
Player's realize() method.
The stop() method responds to the stopping of the applet by closing the current Player and waiting
until it has been completely closed. It does this to keep the media from being played in the absence of
a visible applet.
The realizeComplete(), prefetchComplete(), controllerError(), controllerClosed(), and
controllerUpdate() methods handle Controller-related events in the same manner as
MediaApplication.
LISTING 21.2. THE MediaApplet SOURCE CODE.
import
import
import
import
import
import
public
java.applet.*;
java.awt.*;
java.awt.event.*;
ju.ch09.*;
javax.media.*;
java.net.*;
class MediaApplet extends Applet
implements ControllerListener {
// Declare media-related variables
Player player = null;
Component visualComponent = null;
Component controllerComponent = null;
// Other variables
TextField text = new TextField();
public void init() {
setLayout(new BorderLayout());
add("North",text);
// Create player
try {
URL url = new URL(getDocumentBase(),"Sample1.mov");
player = Manager.createPlayer(url);
} catch(Exception ex) {
text.setText(ex.toString());
}
if(player != null) {
player.addControllerListener(this);
text.setText("Loading ...");
player.realize();
}else text.setText("Unable to play media.");
}
public void stop() {
if(player!=null) player.close();
while(player!=null) {
// wait a half second
try{
Thread.currentThread().sleep(500);
}catch(Exception ex) {
}
}
}
void realizeComplete() {
visualComponent = player.getVisualComponent();
controllerComponent = player.getControlPanelComponent();
if(visualComponent != null)
add("Center",visualComponent);
if(controllerComponent != null)
add("South",controllerComponent);
validate();
player.prefetch();
}
void prefetchComplete() {
text.setText("");
if(player.getTargetState() != Controller.Started)
player.start();
}
void controllerError() {
player.close();
if(visualComponent != null) remove(visualComponent);
if(controllerComponent != null) remove(controllerComponent);
validate();
visualComponent = null;
controllerComponent = null;
player.removeControllerListener(this);
player = null;
}
void controllerClosed() {
if(visualComponent != null) remove(visualComponent);
if(controllerComponent != null) remove(controllerComponent);
player = null;
validate();
}
public synchronized void controllerUpdate(ControllerEvent e) {
// Determine event type
if(e instanceof RealizeCompleteEvent) realizeComplete();
else if(e instanceof PrefetchCompleteEvent) prefetchComplete();
else if(e instanceof ControllerErrorEvent) controllerError();
else if(e instanceof ControllerClosedEvent) controllerClosed();
}
}
LISTING 21.3. THE media.htm FILE.
<HTML>
<HEAD>
<TITLE>A Media-Playing Applet</TITLE>
</HEAD>
<BODY>
<APPLET CODE="MediaApplet.class" HEIGHT=400 WIDTH=400>
</APPLET>
</BODY>
</HTML>
The Real-Time Transport Protocol (RTP) Session Manager API
The JMF also provides support for the Real-Time Transport Protocol (RTP). RTP is a protocol for
transferring audio and video data in real-time from a media server to media players. It is a streaming
protocol and does not guarantee error-free delivery of data. Typical media players drop late or error
packets in order to keep up with new packets that are being received. RTP is designed to use the UDP
transport protocol. It is supported by both Microsoft and Netscape and promises to be a popular
protocol for streaming audio and video over the Internet. RTP is described in RFC 1889, which is
available at http://www.cis.ohio-state.edu/rfc/rfc1889.
JMF supports RTP playback (client-side RTP) through the RTP Session Manager API. This API is
contained in the javax.medi.rtp package. The RTP Session Manager API was not fully implemented
at the time of this writing.
Summary
In this chapter, you learned how to use the capabilities provided by the JMF to incorporate audio and
video support into your applications and applets. You covered the basics of audio and video file
formats, learned how to use the JMF player, and investigated the JMF API. You also learned about
JMF's support for RTP. In the next chapter, you'll learn how to create Java-based animations for use
in applets and applications.
© Copyright 1998, Macmillan Publishing. All rights reserved.
Java 1.2 Unleashed
- 22 Creating Animations
●
●
●
●
●
●
●
Animation Basics
A Simple Animation
A Graphics Animation
Improving Animation Display Qualities
An Updated Graphics Animation
The Animation API
Summary
This chapter shows you how to include animation sequences in your window programs. It identifies
the basic elements of implementing an animation and then describes approaches to improving the
quality of an animation's display by selectively repainting parts of a window and using the
MediaTracker class to support the loading of the images used in an animation. When you finish this
chapter, you'll be able to include animation in your window programs.
Animation Basics
While including animation sequences in your Java programs may at first appear to be complicated, it
is, in fact, rather easy once you learn the basics. Animations are nothing more than the rapid display
of still images such that the pattern of image display causes the appearance of movement for the
objects contained in the image. To create an animation, you need to produce the sequence of objects
that are to be displayed and then write a Java program that will display that sequence at a particular
display rate.
For many, the hardest part of developing an animation is producing the images that are to be
displayed. This part requires drawing skills and is completely separate from Java programming. Don't
fret if you are unable to easily draw these animation sequences. Chances are that you're better at it
than most. The important point of this chapter is to learn how to display, in the form of an animation,
the sequences that you do come up with.
Many animations display their image sequences in a looping fashion. A looping animation gives the
appearance that it is much longer than it actually is and it can run indefinitely. Looping animations
also require fewer image frames. If your animation displays 10 to 20 image frames per second and
you want it to run for a minute, you will need 600 to 1,200 images. That's a lot of work for a oneminute animation. It is much easier to develop a small but varied looping animation and have it loop
several times during the course of a minute.
The major parameter of an animation, besides the type and quality of the images it displays, is the
number of image frames it displays per-second. This is typically a fixed number between 5 and 25.
The more frames per-second that are displayed, the smoother the animation appears to be. For
example, television is 30 frames per-second. The frames-per-second parameter translates into a frame
delay parameter that is used to determine how long a program should wait before it displays the next
image frame. This is typically measured in milliseconds. For example, frames-per-second rates of 5,
10, and 20 translate into frame delays of 200, 100, and 50 milliseconds.
A common approach to implementing an animation is to create a program thread that runs in an
infinite loop and displays the frames of the animation sequence one-at-a-time, waiting frame-delay
milliseconds between each frame's display.
A Simple Animation
In order to get a better understanding of the basics of the animation process, you can develop a
simple, character-based animation. The source code of the SimpleAnimationApp program is shown
in Listing 22.1.
LISTING 22.1. THE SOURCE CODE OF THE SimpleAnimationApp PROGRAM.
import java.awt.*;
import java.awt.event.*;
public class SimpleAnimationApp extends Frame implements Runnable {
Thread animation;
// Set the frame delay
int frameDelay = 100;
// The objects to be displayed
String frames[] =
{"*","**","***","****","*****","****","***","**","*"};
int numFrames = frames.length;
int currentFrame = 0;
long lastDisplay = 0;
int screenWidth = 200;
int screenHeight = 200;
public static void main(String args[]) {
SimpleAnimationApp app = new SimpleAnimationApp();
}
public SimpleAnimationApp() {
super("Simple Animation");
setup();
setSize(screenWidth,screenHeight);
addWindowListener(new WindowEventHandler());
show();
animation = new Thread(this);
animation.start();
}
void setup() {
setupMenuBar();
setFont(new Font("default",Font.BOLD,18));
}
void setupMenuBar() {
MenuBar menuBar = new MenuBar();
Menu fileMenu = new Menu("File");
MenuItem fileExit = new MenuItem("Exit");
fileExit.addActionListener(new MenuItemHandler());
fileMenu.add(fileExit);
menuBar.add(fileMenu);
setMenuBar(menuBar);
}
public void paint(Graphics g) {
g.drawString(frames[currentFrame],60,60);
}
public void run() {
// The animation loop
do {
long time = System.currentTimeMillis();
if(time - lastDisplay > frameDelay) {
repaint();
try {
Thread.sleep(frameDelay);
}catch(InterruptedException ex){
}
++currentFrame;
currentFrame %= numFrames;
lastDisplay = time;
}
} while (true);
}
class MenuItemHandler implements ActionListener, ItemListener {
public void actionPerformed(ActionEvent ev){
String s=ev.getActionCommand();
if(s=="Exit"){
System.exit(0);
}
}
public void itemStateChanged(ItemEvent e){
}
}
class WindowEventHandler extends WindowAdapter {
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
Compile and run SimpleAnimationApp. Your program's display should look like the one shown in
Figure 22.1.
FIGURE 22.1. A simple animation.
A string of asterisks is modulated to give the appearance of movement.
While this short animation is by no means in line for any awards, it does illustrate all the basic
elements of more complex and entertaining animations.
The SimpleAnimationApp class declares the animation Thread, the frameDelay variable, the array of
frames[] used to implement the animation's display, the numFrames variable, the currentFrame
variable, the time of the lastDisplay of a frame, and the standard menu bar and window size variables.
The setup of the SimpleAnimationApp program is fairly standard, with the exception of the creation
of the animation thread at the end of the class constructor and the invocation of the animation thread's
start() method.
The paint() method contains a single statement that is used to display a string of asterisks on the
console window.
The run()method implements the animation loop. It checks the current system time and the time of
the last image display to see if it is time to display a new frame. It uses the currentTimeMillis()
method of the System class to read the current time in milli- seconds. If it is time to display another
frame, the run() method invokes the repaint() method to display the current frame and then tries to
sleep for frameDelay milliseconds. It updates the currentFrame using modular arithmetic and changes
the time of lastDisplay.
A Graphics Animation
Because the SimpleAnimationApp program provides all the basic elements required of an animation,
we can easily modify the animation to support graphics. Figures 22.2 through 22.5 provide four stick
figures I drew using the Windows Paint program. These crude figures can be used to create an
animation of a stick figure that attempts to fly or exercise.
FIGURE 22.2. stickman1.gif.
FIGURE 22.3. stickman2.gif.
FIGURE 22.4. stickman3.gif.
FIGURE 22.5. stickman4.gif.
You may easily substitute your own figures for the ones used in this example.
The source code of the GraphicAnimationApp program is shown in Listing 22.2.
LISTING 22.2. THE SOURCE CODE OF THE GraphicAnimationApp PROGRAM.
import java.awt.*;
import java.awt.event.*;
public class GraphicAnimationApp extends Frame implements Runnable {
Thread animation;
int frameDelay = 100;
Image frames[];
int numFrames;
int currentFrame = 0;
long lastDisplay = 0;
int screenWidth = 400;
int screenHeight = 400;
public static void main(String args[]) {
GraphicAnimationApp app = new GraphicAnimationApp();
}
public GraphicAnimationApp() {
super("Graphic Animation");
setup();
setSize(screenWidth,screenHeight);
addWindowListener(new WindowEventHandler());
show();
animation = new Thread(this);
animation.start();
}
void setup() {
setupMenuBar();
setFont(new Font("default",Font.BOLD,18));
Toolkit toolkit = getToolkit();
frames = new Image[4];
// Load the animation frames
frames[0] = toolkit.getImage("stickman1.gif");
frames[1] = toolkit.getImage("stickman2.gif");
frames[2] = toolkit.getImage("stickman3.gif");
frames[3] = toolkit.getImage("stickman4.gif");
numFrames = frames.length;
}
void setupMenuBar() {
MenuBar menuBar = new MenuBar();
Menu fileMenu = new Menu("File");
MenuItem fileExit = new MenuItem("Exit");
fileExit.addActionListener(new MenuItemHandler());
fileMenu.add(fileExit);
menuBar.add(fileMenu);
setMenuBar(menuBar);
}
public void paint(Graphics g) {
g.drawImage(frames[currentFrame],125,80,this);
}
public void run() {
// The animation loop
do {
long time = System.currentTimeMillis();
if(time - lastDisplay > frameDelay) {
repaint();
try {
Thread.sleep(frameDelay);
}catch(InterruptedException ex){
}
++currentFrame;
currentFrame %= numFrames;
lastDisplay = time;
}
} while (true);
}
class MenuItemHandler implements ActionListener, ItemListener {
public void actionPerformed(ActionEvent ev){
String s=ev.getActionCommand();
if(s=="Exit"){
System.exit(0);
}
}
public void itemStateChanged(ItemEvent e){
}
}
class WindowEventHandler extends WindowAdapter {
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
When you run GraphicAnimationApp, your display should look like the one shown in Figure 22.6.
FIGURE 22.6. The Graphic- AnimationApp program display.
Unless you have a really fast computer and video card, your program display probably has some very
noticeable flickering. Don't worry about that problem now. You'll learn about ways to improve the
quality of an animation's display in the following section. For now, just focus on how you modified
the SimpleAnimationApp program to support graphic-based animation.
The GraphicAnimationApp program is similar to the SimpleAnimationApp program. These are the
differences between the two programs.
●
●
In GraphicAnimationApp, the frames[] array was changed from an array of String objects to
an array of Image objects.
In GraphicAnimationApp, the setup() method was updated to create a Toolkit object and use it
to load the stickman images.
These simple changes were all that was needed to convert the program from a simple text-based
animation to a graphics-based animation.
Improving Animation Display Qualities
The GraphicAnimationApp program has some serious deficiencies in the way that it displays
animation images. The first and probably the most noticeable problem is that it tries to start
displaying the images before they are completely loaded. This is an easy problem to solve using the
MediaTracker class.
The MediaTracker class provides the capability to manage the loading of image files. You use the
addImage()method to add an image to the list of images being tracked. After adding an image to a
MediaTracker object, you can check on the image or all images managed by the MediaTracker object
using the access methods provided by the MediaTracker class.
The other major problem with the animation's display is that the entire screen is repainted with each
new frame, which causes a significant amount of flickering. This image flickering can be mitigated
by limiting the area of the window that is updated with each new image. The repaint() and update()
methods of the component class provide this capability.
You are already familiar with limited screen repainting from using the repaint() method in Chapter 7,
"Working with the Canvas." The update() method provides the capability to update a Graphics object
without first clearing the current image. This allows successive images to be displayed as marginal
increments to the currently displayed image.
Another option to improving an animation's display quality is to change the frame delay. By
decreasing the number of frames-per-second being displayed, you are able to lower the rate at which
flickering occurs. However, you do this at the expense of the overall quality of your animation,
because higher frame display rates tend to smooth out any gaps between successive images.
An Updated Graphics Animation
The GraphicUpdateApp program shows how to use the MediaTracker class, together with limited
repainting and frame-delay adjustments, to improve the quality of the GraphicAnimationApp
program. Its source code is shown in Listing 22.3.
LISTING 22.3. THE SOURCE CODE OF THE GraphicUpdateApp PROGRAM.
import java.awt.*;
import java.awt.event.*;
public class GraphicUpdateApp extends Frame implements Runnable {
Thread animation;
int frameDelay = 200;
Image frames[];
int numFrames;
int currentFrame = 0;
long lastDisplay = 0;
boolean fullDisplay = false;
MediaTracker tracker;
int screenWidth = 400;
int screenHeight = 400;
public static void main(String args[]) {
GraphicUpdateApp app = new GraphicUpdateApp();
}
public GraphicUpdateApp() {
super("Updated Graphic Animation");
setup();
pack();
setSize(screenWidth,screenHeight);
addWindowListener(new WindowEventHandler());
show();
animation = new Thread(this);
animation.start();
}
void setup() {
setupMenuBar();
setFont(new Font("default",Font.BOLD,18));
Toolkit toolkit = getToolkit();
frames = new Image[4];
// Load animation frames
frames[0] = toolkit.getImage("stickman1.gif");
frames[1] = toolkit.getImage("stickman2.gif");
frames[2] = toolkit.getImage("stickman3.gif");
frames[3] = toolkit.getImage("stickman4.gif");
numFrames = frames.length;
tracker = new MediaTracker(this);
// Use the MediaTracker object to manage the frames
for(int i=0;i<numFrames;++i) tracker.addImage(frames[i],i);
}
void setupMenuBar() {
MenuBar menuBar = new MenuBar();
Menu fileMenu = new Menu("File");
MenuItem fileExit = new MenuItem("Exit");
fileExit.addActionListener(new MenuItemHandler());
fileMenu.add(fileExit);
menuBar.add(fileMenu);
setMenuBar(menuBar);
}
public void paint(Graphics g) {
if(allLoaded())
g.drawImage(frames[currentFrame],125,80,this);
else{
String stars = "*";
for(int i=0;i<currentFrame;++i) stars += "*";
g.drawString(stars,60,60);
}
}
boolean allLoaded() {
for(int i=0;i<numFrames;++i) {
if(tracker.statusID(i,true) != MediaTracker.COMPLETE) return
false;
}
return true;
}
public void run() {
// The animation loop
do {
long time = System.currentTimeMillis();
if(time - lastDisplay > frameDelay) {
if(allLoaded()) {
if(fullDisplay) repaint (115,160,160,90);
else{
fullDisplay = true;
repaint();
}
}else repaint();
try {
Thread.sleep(frameDelay);
}catch(InterruptedException ex){
}
++currentFrame;
currentFrame %= numFrames;
lastDisplay = time;
}
} while (true);
}
class MenuItemHandler implements ActionListener, ItemListener {
public void actionPerformed(ActionEvent ev){
String s=ev.getActionCommand();
if(s=="Exit"){
System.exit(0);
}
}
public void itemStateChanged(ItemEvent e){
}
}
class WindowEventHandler extends WindowAdapter {
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
}
When you run GraphicUpdateApp, it will display an animated string of asterisks while the image
files are being loaded. After that, it will immediately display the image animation. This reduces the
unsightly flickering caused when an image is displayed while it is being loaded.
Notice how GraphicUpdateApp implements the limited area repainting. You can run your mouse
over the image display to determine the boundaries of the repaint area.
You should also notice that GraphicUpdateApp displays images at a slower rate. The frame-delay
rate was increased from 100 microseconds to 200 microseconds, decreasing the frame display rate by
a factor of 2.
The changes made to GraphicAnimationApp by GraphicUpdateApp consist of the declaration of the
fullDisplay and tracker variables and modifications to the setup(), paint(), and run() methods. In
addition, the allLoaded() method was created. The following summarizes the changes that were made.
●
●
●
●
●
The fullDisplay variable is used to ensure that a full display of the stickman was accomplished
before attempting a limited display using the repaint() method. The tracker variable is used to
refer to a MediaTracker object.
The setup() method is updated to create the MediaTracker object and to add the images being
loaded with this object.
The paint() method was updated to draw the images after they've been loaded and to draw
asterisk strings before the images are loaded.
The allLoaded() method uses the statusID() method of the MediaTracker class to determine
whether all images have been completely loaded.
The run() method has been modified to use the allLoaded() method and the fullDisplay
variable to determine whether it should repaint the entire screen or only a limited portion of it.
The Animation API
Although it wasn't included in the JMF version 1.0, Sun intends to incorporate an Animation API in
future versions of the JMF. The Animation API will provide a standard set of animation capabilities
and will consist of two packages, referred to as Sprite and Scripting. The Sprite package will provide
classes and methods for working with 2D images. The Scripting package will allow animations to be
defined as scripted images. A scripting engine and animation player will be provided. The player will
be capable of synchronizing animation effects with other JMF players. When it becomes available,
the Animation API will provide a platform-independent solution for high-end business presentations,
computer-aided training, games, and entertainment software.
Summary
This chapter showed how to include animation sequences in your window programs. It identified the
basic elements of implementing an animation and described approaches to improving the quality of
an animation's display. It showed you how to selectively repaint parts of a window and how to use the
MediaTracker class to support the loading of the images used in an animation. Chapter 23,
"Integrating Speech and Telephony Capabilities," completes Part VI, "Multimedia Programming," by
discussing the Speech and Telephony APIs.
© Copyright, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
- 23 Integrating Speech and Telephony Capabilities
●
●
●
The Java Speech API
❍ Speech Recognition
❍ Speech Synthesis
The Java Telephony API
Summary
In the previous chapters of Part 6, you learned a variety of approaches to making user interfaces more
lively and attractive by incorporating multimedia features. Some of the most interesting new
technologies in user interface design allow users and computers to talk to each other. Speech
recognition enables users to translate speech into commands, data, and text, and simplifies the
interface between the user and the computer. Speech synthesis enables the computer to provide
output to the user via the spoken word. Although these technologies have been available for a few
years, they haven't yet been integrated into mainstream software applications. The Java Speech API,
which is being developed by Sun and several other companies, will bridge this gap and make speech
capabilities standard features in Java applications.
One of the most common devices that we use to speak and listen is the telephone. Mobile devices,
such as the Nokia 9000i, are being developed that integrate computer and telephone capabilities. The
Java Telephony API is designed to incorporate telephony features into Java applications. This API
will let you place and answer calls from within a Java application, provide touch-tone navigation, and
manage multiple telephone connections. A number of advanced telephony capabilities are also being
planned.
In this chapter, you'll preview the Speech and Telephony APIs and learn about the capabilities they
will provide. You'll learn how Java Speech will be used to add speech recognition and synthesis to
your programs, and how Java Telephony will be used to develop sophisticated telephony
applications. When you finish this chapter, you'll understand what these two important APIs can
bring to your Java programs.
The Java Speech API
The Java Speech API provides the capability to incorporate speech technology (both input and
output) into Java applets and applications. When it becomes available, it will support speech-based
program navigation, speech-to-text translation, and speech synthesis. The Java Speech API is being
developed by Sun in collaboration with IBM, AT&T, Texas Instruments, Phillips, Apple, and other
companies. At the time of this writing, the following specifications had been developed:
●
●
●
●
Java Speech API Specification--Defines the packages used to implement basic Java Speech
capabilities, speech recognition, and speech synthesis.
Java Speech Programmer's Guide--Describes how to use the Java Speech API to develop
speech-enabled applications.
Java Speech Grammar Format (JSGF) Specification--Describes the JSGF and explains how it
is used to create platform-independent speech recognition grammars. These grammars identify
the words that a user speaks and their meaning in particular program contexts.
Java Speech Markup Language (JSML) Specification--Describes the role of JSML and shows
how it's used to mark up text documents for use with speech synthesizers.
These products are available at the Java Speech Web site, located at http://java.sun.com:80/products/
java-media/speech/index.html.
The Speech API consists of the following three packages:
●
javax.speech--Provides classes and interfaces that support audio connectivity and manage the
use of speech processing engines.
●
javax.speech.recognition--Provides classes and interfaces that support speech recognition.
●
javax.speech.synthesis--Provides classes and interfaces that support speech synthesis.
The javax.speech package consists of the following classes and interfaces:
●
●
Central--Class that provides central access (via static methods) to all capabilities of the Speech
API.
Engine--Interface that is implemented by speech recognition and synthesis engines.
●
●
EngineAttributes--Defines the attributes that are supported by an Engine object.
EngineCentral--Provides the operating modes of a speech Engine in terms of
EngineModeDesc objects.
●
EngineModeDesc--Defines an Engine operating mode.
●
EngineList--A collection of EngineModeDesc objects.
●
●
AudioManager--Interface that defines methods for controlling audio input and output and
managing audio events.
VocabManager--Interface that defines methods for managing words that are used by a speech
engine.
●
Word--Encapsulates speakable words.
●
SpeechEvent--The superclass of all speech events.
●
AudioEvent--Subclass of SpeechEvent that is generated by speech Engine objects based on
audio input and output processing.
●
AudioListener--Defines methods for handling AudioEvent objects.
●
AudioAdapter--Implementation of the AudioListener interface.
●
EngineEvent--Reports changes in speech Engine status.
●
EngineListener--Defines methods for handling EngineEvent objects.
●
EngineAdapter--Implementation of the EngineListener interface.
The following sections cover the javax.speech.recognition and javax.speech.synthesis packages.
Speech Recognition
Speech recognition allows computers to listen to a user's speech and determine what the user has said.
It can range from simple, discrete command recognition to continuous speech translation. Although
speech recognition has made much progress over the last few years, most recognition systems still
make frequent errors. These errors can be reduced by using better microphones, reducing background
noise, and constraining the speech recognition task. Speech recognition constraints are implemented
in terms of grammars that limit the variety in user input. The JSGF provides the capability to specify
rule grammars, which are used for speech recognition systems that are command- and control-
oriented. These systems only recognize speech as it pertains to program operation and do not support
general dictation capabilities.
Even with the constraints posed by grammars, errors still occur and must be corrected. Almost all
applications that employ speech recognition must provide error-correction facilities.
Speech recognition is supported by the javax.speech.recognition package, which consists of 15
interfaces and 19 classes. These classes and interfaces make up four major groups: Recognizer,
Grammar, Rule, and Result.
The Recognizer interface extends the Engine interface to provide access to a speech recognition
engine. RecognizerAttributes and RecognizerModeDesc are used to access the attributes and
operational modes of the Recognizer. Recognizer objects generate RecognizerEvent objects as they
change state during speech processing. The RecognizerInterface defines methods for handling these
events. The RecognizerAdapter class provides a default implementation of this interface. The
AudioLevelEvent is generated as a result of a change in the audio level of a Recognizer. The
RecognizerAudioListener interface defines methods for handling this event, and the
RecognizerAudioAdapter class provides a default interface implementation.
The Grammar interface provides methods for handling the grammars used by a Recognizer. It is
extended by RuleGrammar and DictationGrammar, which support rule grammars and dictation
grammars. The GrammarSyntaxDetail class is used to identify errors in a grammar. The
GrammarEvent class is used to signify the generation of Result object that matches a Grammar. The
GrammarListener interface defines methods for handling this event, and the GrammarAdapter class
provides a default implementation of this interface.
The Rule class encapsulates rules that are used with a RuleGrammar. It is extended by
RuleAlternatives, RuleCount, RuleName, RuleParse, RuleSequence, RuleTag, and RuleToken, which
specify different aspects of grammar rules.
The Result interface provides access to the recognition results generated by a Recognizer. The
FinalResult interface is used for results that have been finalized (accepted or rejected). It is extended
by FinalRuleResult and FinalDictationResult to provide additional information for RuleGrammar and
DictationGrammar objects. The ResultToken interface provides access to a single word of a Result.
The ResultEvent class is used to signal the status of results that are generated by a Recognizer. It is
handled via the ResultListener interface and the default ResultAdapter class. The
GrammarResultAdapter class is used to handle both ResultEvent and GrammarEvent objects.
The SpeakerManager interface is used to manage speaker profiles for a Recognizer.
Speech Synthesis
Speech synthesis is the opposite of speech recognition. It allows computers to generate spoken output
to users. It can take the form of bulk text-to-speech translation, or of intricate speech-based responses
that are integrated into an application's interface.
Speech synthesis systems must satisfy the two main requirements of understandability and
naturalness. Understandability is improved by providing adequate pronunciation information to
speech generators. This eliminates "guesses" on the part of the speech synthesizer. JSML is used to
provide pronunciation information, as required. Naturalness is improved by using a non-mechanical
voice and managing emphasis, intonation, phrasing, and pausing. JSML also provides markup
capabilities that control these speech attributes.
When you're synthesizing speech, it is often desirable to select attributes of the voice that is
generated. For example, you might want to choose between male and female voices or old and young
voices. The Speech API provides control over these features. In addition, text that is to be synthesized
can be marked up with event markers that cause events to be generated as they are processed. Event
handlers can be designed to manipulate graphical interface components in synchronization with
speech synthesis. For example, you can design a speaker's face that changes facial expressions as it
"talks."
The flexibility of the synthesis component of the Speech API is provided by JSML. JSML, like
HTML, is an SGML-based markup language. JSML allows text to be marked up using the following
synthesis-related information:
●
Paragraph and sentence boundaries
●
Pronunciation of words and other text elements
●
Pauses
●
Emphasis
●
Pitch
●
Speaking rate
●
Loudness
These capabilities may not have your computer reading poetry, but they will allow you to greatly
enhance any speech that it generates. Listing 23.1 provides an example of a JSML file.
Listing 23.1. An example JSML file.
<?XML version="1.0" encoding="UCS-2"?>
<JSML>
<PARA><SENT>This is the <EMP>first</EMP> sentence of
the first paragraph.</SENT> <SENT>This is the second
sentence.</SENT><BREAK SIZE = "large"/><SENT>This is the
<EMP>last</EMP> sentence of this paragraph.</SENT></PARA>
<PARA><PROS RATE="+10%" VOL=".9"><SENT>This is the second
paragraph.</SENT></PARA>
</JSML>
The first line identifies the file as being XML version 1.0. The <JSML> and </JSML> tags surround
the JSML markup. Within these tags are two paragraphs marked by the <PARA> and </PARA> tags.
The first paragraph consists of three sentences marked by <SENT> and </SENT>. The second
paragraph has a single sentence.
The word first is surrounded by <EMP> and </EMP>. This signifies that the word "first" should be
emphasized. The <BREAK SIZE="large"/> tag specifies that a long pause should occur between the
second and third sentences.
In the second paragraph, the <PROS RATE="+10%" VOL=".9"> tag is an example of a prosody tag.
Prosody tags control the timing, intonation, and phrasing of speech. The RATE attribute specifies that
the speech rate should be increased by 10%. The VOL attribute specifies that the volume of speech
should be set at 90% of its maximum.
The example JSML file illustrates the use of JSML tags. However, the markup language is much
richer than indicated by the example. For more information on JSML, download the JSML
specification from the Java Speech Web site.
JSML is a subset of the eXtensible Markup Language (XML), which is a subset of the Standard
Generalized Markup Language (SGML). JSML looks like HTML with different tags. (HTML is also
a subset of SGML.) Figure 23.1 shows the relationship between JSML, XML, HTML, and SGML.
FIGURE 23.1. The relationship between JSML and other markup languages.
The Java Speech API supports speech generation via the javax.speech.synthesis package. This
package provides the following five interfaces and six classes:
●
Synthesizer--Extends Engine to implement a synthesizer engine.
●
SynthesizerAttributes--Provides access to the control attributes of a Synthesizer.
●
SynthesizerModeDesc--Used to specify an operational mode for a Synthesizer.
●
SynthesizerEvent--Event generated by a Synthesizer as it changes state.
●
SynthesizerListener--Defines methods for handling SynthesizerEvent objects.
●
SynthesizerAdapter--An implementation of the SynthesizerListener interface.
●
●
Speakable--An interface for providing JSML text to a Synthesizer.
SpeakableEvent--Event generated by a Speakable object that identifies the state of JSML
processing.
●
SpeakableListener--Defines methods for handling SpeakableEvent objects.
●
SpeakableAdapter--An implementation of the SpeakableListener interface.
●
Voice--Allows the age and gender of a voice to be specified.
To use the synthesizer package, invoke the createSynthesizer() method of the Central class to create a
Synthesizer object. Pass an argument of the SynthesizerModeDesc class to createSynthesizer() to
specify the Synthesizer mode. Invoke the allocate() method of the Synthesizer (inherited from
Engine) to start up the Synthesizer's engine. After that, use the speak() and speakPlainText() methods
to put text in the Synthesizer's input queue.
The Java Telephony API
The Java Telephony API (JTAPI) is a set of APIs that provide telephony capabilities for Java
applications. It supports basic telephony capabilities, such as call placement and call answering, and
advanced capabilities, such as call centers and media streams. JTAPI provides both direct control
over telephony resources and indirect access through networked resources. This means that you can
create server applications that provide telephony resources over a network, and client applications
that use these resources.
The JTAPI consists of the following 18 packages:
●
javax.telephony--Provides the core classes and interfaces used by all telephony applications.
●
javax.telephony.capabilities--Provides support for basic call and connection capabilities.
●
javax.telephony.events--Defines the basic events used in all telephony applications.
●
javax.telephony.callcenter--Provides support for developing call center applications.
●
●
●
javax.telephony.callcenter.capabilities--Provides capabilities such as routing and automated
call distribution used in call center applications.
javax.telephony.callcenter.events--Defines the events used in call center applications.
javax.telephony.callcontrol--Provides call control features, such as call hold, call transferring,
and conferencing.
●
●
●
●
javax.telephony.callcontrol.capabilities--Extends the interfaces of the basic javax.telephony.
capabilities package to support call control applications.
javax.telephony.callcontrol.events--Defines the events used in call control applications.
javax.telephony.media--Supports media streams (touch tone and non-touch tone) used in
telephony media-exchange applications.
javax.telephony.media.capabilities--Defines the MediaTerminalConnectionCapabilities
interface, which supports media streaming applications.
●
javax.telephony.media.events--Defines the events used with media streams.
●
javax.telephony.phone--Provides control over the physical features of telephone equipment.
●
●
●
●
●
javax.telephony.phone.capabilities--Provides interfaces for controlling equipment
components.
javax.telephony.phone.events--Defines the events used with the javax.telephone.phone
package.
javax.telephony.privatedata--Provides classes for accessing telephone hardware switches.
javax.telephony.privatedata.capabilities--Provides an interface that is used to access the
capabilities provided by javax.telephony.privatedata.
javax.telephony.privatedata.events--Defines the events used with the javax.telephone.
privatedata package.
Although the number of packages provided with JTAPI may seem ominous, basic telephony
applications are constructed using a few common elements of the javax.telephony package. The
Terminal interface is used to provide access to a physical hardware device at the endpoint of a
telephone connection. For example, telephone sets are accessed as Terminal objects. The
TerminalConnection interface provides physical access to a telephone connection, while the
Connection interface models a logical connection between a Call object and an Address object. An
instance of the Call interface represents an actual telephone call. The Address interface is used with a
telephone number, or in Internet telephony applications, an IP address combined with other endpoint
information. The Provider interface is used to access a telephony/service provider software element.
The JTAPI home page, located at http://java.sun.com/products/jtapi/index.html, provides information
about the current status of the JTAPI project.
Summary
In this chapter, you were introduced to the Speech and Telephony APIs and learned about their
planned capabilities. You learned how Java Speech will be used to add speech recognition and
synthesis to Java programs and how Java Telephony will be used to develop sophisticated telephony
applications. This was the last chapter of Part VI. In Part VII, you'll learn how to develop componentbased Java software using JavaBeans.
© Copyright 1998, Macmillan Publishing. All rights reserved.
Java 1.2 Unleashed
- 24 The Software Component Assembly Model
●
●
●
●
●
●
●
Components and Containers
Introspection and Discovery
Interface Methods and Properties
Persistence
Events
Visual Design
Summary
In this book you develop almost all of your applications and applets from scratch because you're
trying to learn Java. Once you become comfortable in Java programming and go out to develop realworld Java applications and applets, you won't be so eager to start from scratch. You'll want to use
available off-the-shelf Java components whenever possible.
Java components are available in a number of forms. For example, you can go down to your local
software superstore and purchase a set of Java API packages. You can then use these new APIs to
create objects that are instances of the classes and interfaces of the new APIs. You're familiar with
this process because you've been learning to do this with the API of JDK 1.2.
If you purchase a visual Java development tool, such as Symantec's Visual Café for Java, you'll be
able to drag and drop GUI components onto the interface design of your applications and applets.
Some of these GUI components may be new components that are not included with the JDK 1.2.
Many of these components are made available as Java beans.
You don't need to purchase a visual design tool to get access to Java beans. Many beans are available
for download via the Web. You can use these beans with freely available visual design tools, such as
the JavaBeans Development Kit (BDK) from JavaSoft.
In this chapter, you'll be introduced to the JavaBeans software component model. You'll learn how
the software component model works and how software components are used to simplify the
development of complex software. You'll study the features of component-based software
development and learn how JavaBeans supports these features. When you finish this chapter, you'll
understand how JavaBeans are used in component-based software development.
NOTE: This chapter introduces the concepts of the software component model and
summarizes how JavaBeans supports these concepts. Chapter 26, "Developing Beans,"
takes a detailed look at the JavaBeans API and shows how to develop simple beans.
Components and Containers
JavaBeans are Java software components that are designed for maximum reuse. They are often
visible GUI components, but can also be invisible algorithmic components. They support the
software component model pioneered by Microsoft's Visual Basic and Borland's Delphi. This model
focuses on the use of components and containers.
Components are specialized, self-contained software entities that can be replicated, customized, and
inserted into applications and applets. Containers are simply components that contain other
components. A container is used as a framework for visually organizing components. Visual
development tools allow components to be dragged and dropped into a container, resized, and
positioned.
You are familiar with the concept of components and containers from your study of the AWT. The
components and containers of the JavaBeans component model are similar in many ways to the
Component and Container classes of the AWT.
●
Components come in a variety of different implementations and support a wide range of
functions.
●
Numerous individual components can be created and tailored for different applications.
●
Components are contained within containers.
●
Components can also be containers and contain other components.
●
Interaction with components occurs through event handling and method invocation.
In other ways, the components and containers of JavaBeans extend beyond the Component and
Container classes of the AWT.
●
●
●
JavaBeans components and containers are not restricted to the AWT. Almost any kind of Java
object can be implemented as a JavaBean.
Components written in other programming languages can be reused in Java software
development via special Java interface code. You'll learn how to use non-Java components,
such as Component Object Model (COM) objects in Chapter 54, "Dirty Java."
Components written in Java can be used in other component implementations, such as
ActiveX, via special interfaces referred to as bridges. You'll also study bridges in Chapter 54,
"Dirty Java."
The important point to remember about JavaBeans components and containers is that they support a
hierarchical software development approach where simple components can be assembled within
containers to produce more complex components. This capability allows software developers to make
maximum reuse of existing software components when creating new software or improving existing
software. Figure 24.1 summarizes the use of components and containers.
FIGURE 24.1. Using components and containers.
Introspection and Discovery
Component interfaces are well-defined and may be discovered during a component's execution. This
feature, referred to as introspection, allows visual programming tools to drag and drop a component
onto an application or applet design and dynamically determine what component interface methods
and properties are available. Interface methods are public methods of a bean that are available for use
by other components. Properties are attributes of a bean that are implemented by the bean class's field
variables and accessed via accessor methods.
JavaBeans support introspection at multiple levels. At a low level, introspection can be accomplished
using the reflection capabilities of the java.lang.reflect package. These capabilities allow Java objects
to discover information about the public methods, fields, and constructors of loaded classes during
program execution. Reflection allows introspection to be accomplished for all beans. All you have to
do is declare a method or variable as public and it can be discovered using reflection.
An intermediate level introspection capability provided by JavaBeans utilizes design patterns. Design
patterns are method naming conventions that are used by the introspection classes of java.beans to
infer information about reflected methods based on their names. For example, design patterns can be
used by visual design tools to identify a bean's event generation and processing capabilities by
looking for methods that follow the naming conventions for event generation and event listening.
Design tools can use design patterns to obtain a great deal of information about a bean in the absence
of explicitly provided information.
Design patterns are a low overhead approach to supporting introspection in component development.
All you have to do is adhere to the naming convention of design patterns and visual design tools will
be able to make helpful inferences about how your components are used.
At the highest level, JavaBeans supports introspection through the use of classes and interfaces that
provide explicit information about a bean's methods, properties, and events. By explicitly providing
this information to visual design tools, you can add help information and extra levels of design
documentation that will be automatically recognized and presented in the visual design environment.
Figure 24.2 illustrates the introspection and discovery capabilities of JavaBeans. These capabilities
are important in that they allow software components to be developed in such a way that information
about the components can be obtained automatically by visual design tools.
FIGURE 24.2. Introspection and visual design.
Interface Methods and Properties
Properties determine the appearance or behavior of a component. A component's properties can be
modified during the visual design of an application. Most visual design tools provide property sheets
to facilitate the setting of a component's properties. Property sheets identify all of the properties of a
component and often provide help information related to specific properties. The properties and help
information are discovered by visual design tools using introspection. Figure 24.3 provides an
example of a property sheet.
In JavaBeans, all properties are accessed through special interface methods, referred to as accessor
methods. There are two types of accessor methods: getter methods and setter methods. Getter
methods retrieve the values of properties, and setter methods set property values.
FIGURE 24.3. Using property sheets to customize component properties.
Interface methods are methods that are used to modify the behavior or state of a component or to
retrieve information about the state of a component. These methods are often used to support event
handling. Most visual design tools provide the capability to connect events generated in one
component with the interface methods of other components. For example, suppose a container
contains two button components, labeled Start and Stop, and a ticker tape component, as shown in
Figure 24.4. Also suppose that the buttons generate the button-clicked event when they are clicked
and the ticker tape component provides the startTape() and stopTape() interface methods. Most visual
design tools let you graphically connect the button-clicked events of the Start and Stop buttons with
the startTape() and stopTape() methods. This allows you to implement your interface without having
to write the code to connect your interface components.
FIGURE 24.4. Interfaces methods can be connected to events.
Persistence
The property sheets of visual design tools are used to tailor the properties of components for specific
applications. The modified properties are stored in such a manner that they remain with the
component from design to execution. The capability to store changes to a component's properties is
known as persistence. Persistence allows components to be customized for later use. For example,
during design, you can create two button beans--one with a blue background color and a yellow
foreground color and another with a red background color and a white foreground color. The color
modifications are stored along with instances of each bean object. When the beans are displayed
during a program's execution, they are displayed using the modified colors.
JavaBeans supports persistence through object serialization. Object serialization is the capability to
write a Java object to a stream in such a way that the definition and current state of the object are
preserved. When a serialized object is read from a stream, the object is initialized and in exactly the
same state it was in when it was written to the stream. Figure 24.5 summarizes how object
serialization supports persistence. Chapter 40, "Using Object Serialization and JavaSpaces," covers
object serialization.
FIGURE 24.5. Persistence is implemented through object serialization.
Events
Visual development tools allow components to be dragged and dropped into a container, resized, and
positioned. The visual nature of these tools greatly simplifies the development of user interfaces.
However, component-based visual development tools go beyond simple screen layout. They also
allow component event handling to be described in a visual manner.
You should be familiar with events, having worked with event handling code in most of the examples
in this book. In general, events are generated in response to certain actions, such as the user clicking
or moving the mouse or pressing a keyboard key. The event is handled by an event handler. Beans
can handle events that occur local to them. For example, a button-based bean is required to handle the
clicking of a button. Beans can also call upon other beans to complete the handling of an event. For
example, a button bean can handle the button-clicked event by causing a text string to be displayed in
a status-display bean. Visual development tools support the connection of event sources (for example,
the button bean) with event listeners (for example, the status-display bean) using graphical design
tools. In many cases, event handling can be performed without having to write event-handling code.
You'll see a concrete example of this when you use the BDK in the next chapter. This code is
automatically generated by the visual design tools. Figure 24.6 graphically depicts the relationship
between event sources and event listeners.
FIGURE 24.6. Event sources fire events that are handled by event listeners.
Visual Design
One of the ultimate benefits of using a component-based approach to software development is that
you can use visual design tools to support your software development efforts. These tools greatly
simplify the process of complex software development. They also allow you to develop higherquality software, more quickly, and at a lower cost. Some of the features typically found in
component-based visual design tools are as follows:
●
●
Components and containers can be dragged onto a visual design worksheet.
Components can be dragged into containers and assembled into more complex, higher-level
components.
●
Visual layout tools can be used to organize components within containers.
●
Property sheets can be used to tailor component properties for different applications.
●
●
●
Component interaction editors can be used to connect the events generated by one component
with the interface methods of other components.
Code can be automatically generated to implement visual interface designs.
Traditional software development tools, such as source code editors, compilers, debuggers,
and version control managers can be integrated within the visual design environment.
Figure 24.7 summarizes the various ways in which visual design tools simplify the process of
component-based software development. If you've never used a visual design tool, you're in for a big
surprise. Even the freely available BeanBox of the JavaBeans development kit provides a number of
useful tools for facilitating the development of component-based software.
FIGURE 24.7. Visual design tools greatly simplify the process of component-based software
development.
Summary
In this chapter you were introduced to component-based software development. You learned how the
software component model works and how software components are used to simplify the
development of complex software. You studied the features of component-based software
development and learned how JavaBeans supports these features. In the next chapter you'll download,
install, and familiarize yourself with the JavaBeans development kit (BDK) provided by JavaSoft.
© Copyright, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
- 25 The JavaBeans Development Kit
●
●
●
●
●
●
Downloading and Installing the BDK
Inside the BDK
Using the BeanBox
Understanding the Example Beans
Other Bean Development Tools
Summary
In the previous chapter you covered the basics of component-based software development. This
background information will help you understand how the tools of the JavaBeans Development Kit
(BDK) work. However, there is no substitute for hands-on experience. In this chapter you'll download
and install the BDK and take a tour of what it has to offer. You'll learn how to use the BeanBox to
develop and test your beans and investigate some of the example beans included with the BDK.
When you finish this chapter, you'll know how to use the BDK to begin your own beans development.
Downloading and Installing the BDK
The BDK is freely available from the JavaBeans home page, which is located at http://java.sun.com/
beans/index.html. This Web page also contains links to JavaBeans technical specifications and
information on future plans for JavaBeans. Follow the links to the BDK 1.0 download page and
download the version that is appropriate for your operating system. The rest of this section assumes
that you are using Windows 95 or NT.
The Windows version of the BDK is available as a self-installing executable file. Just double-click
the file's icon to start the installation program. Follow the installation instructions and install it in the
default directory (c:\bdk).
Inside the BDK
The BDK provides several examples of JavaBeans, a tutorial, and supporting documentation. But
most important, it provides a tool, referred to as the BeanBox, that can be used to display, customize,
and test the beans that you'll develop. The BeanBox also serves as a primitive visual development
tool. You'll use the BeanBox to see the important aspects of visual component-based software
development as it applies to JavaBeans. Download and install the BDK before continuing on to the
next section. Once you've installed the BDK, restart your system to make sure that all installation
changes take effect.
NOTE: Through the rest of the chapter, it will be assumed that you've installed the
BDK in its default location, the c:\bdk directory. If you install the BDK in a different
directory, you'll have to map between c:\bdk and your installation directory.
Using the BeanBox
The BeanBox of the BDK is an example of a simple visual development tool for JavaBeans. It is
located in the c:\bdk\beanbox directory. Change to this directory and start the BeanBox as follows:
c:\bdk\beanbox>run
The BeanBox application loads and displays three windows labeled ToolBox, BeanBox, and
PropertySheet, as shown in Figures 25.1, 25.2, and 25.3.
The ToolBox window contains a list of available Java beans. These beans are components that can be
used to build more complex beans, Java applications, or applets.
FIGURE 25.1. The ToolBox window.
FIGURE 25.2. The BeanBox window.
FIGURE 25.3. The PropertySheet window.
Visual software development tools, such as the BeanBox, allow beans to be visually organized by
placing them at the location where you want them to be displayed. Click the Juggler bean in the
ToolBox window and then click in the BeanBox; the Juggler bean is placed in the BeanBox, as
shown in Figure 25.4. The Juggler bean juggles when it is placed in the BeanBox.
FIGURE 25.4. Adding a bean to the BeanBox.
Note that the PropertySheet is updated to display the properties of the Juggler bean (see Figure 25.5).
You can customize the Juggler bean by changing its properties. Change the animationRate property
to 500, as shown in Figure 25.6. Note how the Juggler slows the rate at which it juggles the beans.
FIGURE 25.5. The Juggler's PropertySheet.
FIGURE 25.6. Changing the Juggler's animationRate property.
Now add a couple of buttons to the BeanBox. Select an OurButton bean in the ToolBox and then
place it in the BeanBox, as shown in Figure 25.7. A button labeled Press is displayed. Use the
button's property sheet to change its label to Start, as shown in Figure 25.8. Now create a second
button labeled Stop, as shown in Figure 25.9.
FIGURE 25.7. Adding a button to the BeanBox.
FIGURE 25.8. Editing the button's label.
FIGURE 25.9. Adding a second button to the BeanBox.
By now you can see where this application is going. You're going to use the Start and Stop buttons to
control the animation. To do this, you'll connect the Start button's actionPerformed() event handler to
the startJuggling() method of the Juggler bean and the Stop button's actionPerformed() event handler
to the stopJuggling() method of the Juggler bean.
Click the Start button and then select Edit | Events | Action | ActionPerformed from the BeanBox
menu bar, as shown in Figure 25.10. A red line is now shown emanating from the Start button. This
line represents a logical connection from the Start button's actionPerformed() event handler. Click the
Juggler bean to close the connection. When you do, the EventTargetDialog box, shown in Figure
25.11, is displayed. This dialog box lists the interface methods of the Juggler bean. Select
startJuggling. By doing so, you connect the clicking of the Start button to the startJuggling() method
via the actionPerformed() event handler of the Start button bean. The EventTargetDialog box notifies
you that it is compiling an adapter class. The BeanBox creates a special class, referred to as an
adapter class, to connect the clicking of the button with the startJuggling() method of the Juggler. It
must compile this class and add it to the running BeanBox to support this connection.
FIGURE 25.10. Selecting the actionPerformed() event handler.
FIGURE 25.11. Connecting to the startJuggling() method.
Now that you know how to associate events with interface methods, connect the Stop button to the
stopJuggling() method of the Juggler bean. Click the Stop button and select Edit | Events | action |
actionPerformed from the BeanBox menu bar. Connect the red connector to the Juggler bean and
select the stopJuggling method.
Now you can have some fun with the Juggler. Click the Stop button to stop the juggling and click the
Start button to get it going again.
Understanding the Example Beans
You should be impressed by how easy it was to develop an interesting (or at least entertaining)
application using the BeanBox and JavaBeans. In fact, you didn't have to write a single line of code
to create the application. That's the power of component-based software development. Given a good
stock of beans, you can quickly and easily assemble a large variety of useful applications.
In the example of the previous section, you learned how to use the OurButton and Juggler beans. The
ToolBox that comes with the BeanBox lists 16 beans. I recommend that you play around with these
beans to familiarize yourself with how they work. You studied the theory behind component-based
software in the previous chapter. Now is the time to get some practical experience to back up your
theoretical understanding. Try to see how the BeanBox and the example beans support the
component-based model described in Chapter 24.
Just to whet your appetite, what follows is a short description of the beans that are in the ToolBox.
●
●
BlueButton--A simple blue button with background, foreground, label, and font properties
OrangeButton--A simple orange button with background, foreground, label, and font
properties
●
OurButton--A gray button with additional font properties
●
ExplicitButton--A simple gray button with background, foreground, label, and font properties
●
EventMonitor--A text area that is used to view events as they happen
●
JellyBean--A jelly bean that is associated with a cost
●
Juggler--A juggler animation
●
TickTock--An interval timer
●
Voter--A component that maintains a yes or no state
●
ChangeReporter--A text field
●
Molecule--A graphical field for displaying 3D pictures of molecules
●
QuoteMonitor--A component that displays stock quotes received from a quote server
●
JDBC SELECT--An SQL interface to a database
●
SorterBean--An animation of a bubble sort
●
BridgeTester--A bean used to test bean bridges (refer to Chapter 28, "Using Bridges")
●
TransitionalBean--A button that changes colors
Now fire up the BeanBox and try out some of these beans. You'll learn how the java.beans packages
support the implementation of the capabilities that you observe with the BeanBox.
Other Bean Development Tools
The BeanBox is a fairly basic visual design tool, yet it provides the important features of visual
component-based software development. There are a number of very good visual design tools that
support Java software development. If you're serious about developing your own beans, or using
them to create applets or applications, it's recommended that you obtain one of these high-end tools.
They'll save you plenty of time and effort in the long run. A list of available tools is available from
JavaWorld at http://www.javaworld.com/javaworld/tools/jw-tools-index.html. Chapter 56, "Java
Development Tools," describes the best of these tools. Table 25.1 provides a summary of popular
tools that support bean development.
TABLE 25.1. BEAN DEVELOPMENT TOOLS.
Tool
Vendor
Retail
Price
Description
Java Workshop 2.0
Sun Microsystems,
Inc.
$110
Complete IDE that supports applet,
application, and bean development
Java Studio
Sun Microsystems,
Inc.
$69
Bean-oriented visual development tool
JavaPlan
Sun Microsystems,
Inc.
$3,995/seat Enterprise-wide Java development tool;
supports bean development
Visual Café for Java 2.5 Symanted, Inc.
$99.95 to
$499.95
Family of highly-rated visual
development tools oriented around
beans
Visual Age for Java
IBM
Free to
$99.95
Bean-oriented visual development
toolset
Visual J++
Microsoft, Inc.
$99.95
Microsoft's answer to Java software
development
Jbuilder
Borland, Inc.
Super Mojo
Penumbra Software, $39.95
Inc.
Popular Java visual design tool.
JDesignerPro
BulletProof
Corporation
$695
Application development environment
and middleware
SuperCede Java Edition SuperCede, Inc.
$29.95
A cost-effective Java visual design
toolset
Jamba
$149
Visual authoring environ- ment aimed
at minimiz- ing the need for coding
Interleaf, Inc.
$99.95 to
$2,495
Suit of bean-oriented Java development
tools.
Summary
In this chapter you downloaded and installed the BDK and took a tour of its contents. You learned
how to use the BeanBox to develop and test beans and looked at some of the example beans included
with the BDK. You also learned about some of the other bean development tools. In the next chapter
you'll study the classes of the java.beans packages and learn how to use them to develop your own
beans.
© Copyright, Macmillan Computer Publishing. All rights reserved.
Java 1.2 Unleashed
- 26 Developing Beans
●
●
●
●
How Do Beans Work?
❍ Graphic Representation and Visual Layout
❍ Customizable and Persistent Properties
❍ Introspection
❍ Connecting Events to Interface Methods
Inside java.beans
❍ Design Support
❍ Introspection Support
❍ Change Event-Handling Support
❍ Aggregation
❍ The java.beans.beancontext Package
Developing Beans
❍ A Gauge Bean
❍ A Text Canvas Bean
❍ A Quiz Applet
❍ Using Serialization
Summary
Now that you are familiar with the software component assembly model and the JavaBeans
development kit, it's time to learn how to develop your own beans. In this chapter, you'll learn how
beans work and take a tour of the java.beans packages. You'll also learn how to write bean code in
Java. When you finish this chapter, you'll be able to create a few beans of your own.
How Do Beans Work?
Chapter 24, "The Software Component Assembly Model," presented the underlying concepts related
to component-based software development. Chapter 25, "The JavaBeans Development Kit," showed
how these concepts were embodied in an actual visual development tool. The point of the BeanBox
tutorial in Chapter 25 was to give you some hands-on experience of how beans are used in software
development. This section covers some of the underlying mechanisms that enable beans to be used in
this manner. You may want to have your BeanBox up and running when you read through this
section so that you can see how these mechanisms are implemented by it.
Graphic Representation and Visual Layout
One of the first things that you probably noticed when you started up the BeanBox was the ToolBox
full of JavaBeans. Several of these beans had icons. JavaBeans have the capability to support a
variety of icons for display by visual development tools.
Beans themselves can also be graphically displayed by visual development tools. When you placed
the Juggler and OurButton beans in the BeanBox, they were displayed exactly how they appear in a
final application. You can move them to their intended position and resize them to the desired
dimensions.
Some beans are invisible in the sense that they do not have a graphical display. An example of an
invisible bean could be a specialized algorithm, such as an image filter. Visual development tools
usually create special graphical objects that allow the invisible beans to be manipulated in the same
manner as visible beans during software development. Of course, the special graphical objects of the
invisible beans are not displayed by the final application or applet.
Customizable and Persistent Properties
Properties are attributes of a bean that can be modified to change the appearance or behavior of a
bean. They are accessed through special methods, referred to as accessor methods. Visual
development tools allow properties to be changed through the use of property sheets, lists of
properties that can be specified for a bean. Visual building tools, like the BeanBox, display a property
sheet in response to a bean's selection. You used property sheets to change the animationRate
property of the Juggler bean and the label property of the OurButton bean.
In addition to the simple property editing capabilities exhibited by the BeanBox example, individual
beans can define custom property editors that allow properties to be edited using specialized dialog
boxes. These custom property editors are implemented as special classes that are associated with the
bean's class. The custom property editors are available to visual development tools, but because they
are not part of the bean's class, they do not need to be compiled into applications or applets. This lets
you provide extra design capabilities for a bean without having to develop bloated applications.
Suppose that you are using a bean that provides extensive customization support. You change the
bean's background color to red and its foreground color to white, change a label associated with the
bean, and alter a few other properties. You may wonder what happens to the property changes. How
are the changes packaged along with the bean's class?
Beans store any property changes so that new property values come into effect and are displayed
when the modified bean is used in an application. The capability to permanently store property
changes is known as persistence. JavaBeans implement persistence by serializing bean objects that
are instances of a bean class. Serialization is the process of writing the current state of an object to a
stream. Because beans are serialized, they must implement the java.io.Serializable or java.io.
Externalizable interfaces. Beans that implement java.io.Serializable are automatically saved. Beans
that implement java.io.Externalizable are responsible for saving themselves.
NOTE: Chapter 40, "Using Object Serialization and JavaSpaces," covers object
serialization in more detail.
When a bean object is saved through serialization, all of the values of the variables of the object are
saved. In this way, any property changes are carried along with the object. The only exceptions to this
are variables that are identified as transient. The values of transient variables are not serialized.
Bean Properties
Beans support a few different types of properties. In the BeanBox tutorial, you saw examples of
simple properties. The animationRate property of the Juggler bean used a simple numeric value, and
the label property of the OurButton bean used a text value.
An indexed property is a property that can take on an array of values. Indexed properties are used to
keep track of a group of related values of the same type. For example, an indexed property could be
used to maintain the values of a scrollable list.
A bound property is a property that alerts other objects when its value changes. For example, you
could use a bound property to implement a temperature control dial. Whenever the user changes the
control, notification of the change is propagated to objects that regulate temperature.
A constrained property differs from a bound property in that it notifies other objects of an impending
change. Constrained properties give the notified objects the power to veto a property change. You
could use a constrained property to implement a bean that fires a missile under two-person control.
When one person initiates a missile launch, a notification is sent to a second user, who could either
confirm or deny the launch.
Accessor Methods
All properties are accessed through accessor methods. There are two types of accessor methods:
getter methods and setter methods. Getter methods retrieve the values of properties, and setter
methods set property values. The names of getter methods begin with get and are followed by the
name of the property to which they apply. The names of setter methods begin with set and are
followed by the property name.
Methods Used with Simple Properties
If a bean has a property named fooz of type foozType that can be read and written, it should have the
following accessor methods:
public foozType getFooz()
public void setFooz(foozType foozValue)
A property is read-only or write-only if one of the preceding accessor methods are missing.
NOTE: If a property is boolean, getter methods are written using is instead of get. For
example, isFooz() would be used instead of getFooz() if fooz is a boolean property.
Methods Used with Indexed Properties
A bean that has an indexed property will have methods that support the reading and writing of
individual array elements as well as the entire array. For example, if a bean has an indexed widget
property in which each element of the array is of type widgetType, it will have the following accessor
methods:
public
public
public
public
widgetType getWidget(int index)
widgetType[] getWidget()
void setWidget(int index, widgetType widgetValue)
void setWidget(widgetType[] widgetValues)
Methods Used with Bound Properties
Beans with bound properties have getter and setter methods, as previously identified, depending upon
whether the property values are simple or indexed. Bound properties require certain objects to be
notified when they change. The change notification is accomplished through the generation of a
PropertyChangeEvent. Objects that want to be notified of a property change to a bound property must
register as listeners. Accordingly, the bean that's implementing the bound property supplies methods
of the form:
public void addPropertyChangeListener(PropertyChangeListener l)
public void removePropertyChangeListener(PropertyChangeListener l)
NOTE: The PropertyChangeEvent class and PropertyChangeListener interface are
defined in java.beans.
The preceding listener registration methods do not identify specific bound properties. To register
listeners for the PropertyChangeEvent of a specific property, the following methods must be provided:
public void addPropertyNameListener(PropertyChangeListener l)
public void removePropertyNameListener(PropertyChangeListener l)
In the preceding methods, PropertyName is replaced by the name of the bound property.
Objects that implement the PropertyChangeListener interface must implement the propertyChange()
method. This method is invoked by the bean for all of its registered listeners to inform them of a
property change.
Methods Used with Constrained Properties
The previously discussed methods used with simple and indexed properties also apply to constrained
properties. In addition, the following event registration methods are provided:
public
public
public
public
void
void
void
void
addVetoableChangeListener(VetoableChangeListener l)
removeVetoableChangeListener(VetoableChangeListener l)
addPropertyNameListener(VetoableChangeListener l)
removePropertyNameListener(VetoableChangeListener l)
Objects that implement the VetoableChangeListener interface must implement the vetoableChange()
method. This method is invoked by the bean for all of its registered listeners to inform them of a
property change. Any object that does not approve of a property change can throw a
PropertyVetoException within its vetoableChange() method to inform the bean whose constrained
property was changed that the change was not approved.
Introspection
In order for beans to be used by visual development tools, the beans must be able to dynamically
inform the tools of their interface methods and properties and also what kind of events they may
generate or respond to. This capability is referred to as introspection. The Introspector class of java.
beans provides a set of static methods for tools to obtain information about the properties, methods,
and events of a bean.
The Introspector supports introspection in the following ways:
●
Reflection and design patterns--The java.lang.reflect package provides the capability to
identify the fields and methods of a class. The Introspector uses this capability to review the
names of the methods of a bean's class. It identifies a bean's properties by looking at the
method names for the getter and setter naming patterns, identified in previous sections of this
chapter. It identifies a bean's event generation and processing capabilities by looking for
methods that follow the naming conventions for event generation and event listening. The
Introspector automatically applies reflection and design (naming) patterns to a bean class to
obtain information for design tools in the absence of explicitly provided information.
●
Explicit specification--Information about a bean may be optionally provided by a special bean
information class that implements the BeanInfo interface. The BeanInfo interface provides
methods for explicitly conveying information about a bean's methods, properties, and events.
The Introspector recognizes BeanInfo classes by their name. The name of a BeanInfo class is
the name of the bean class followed by BeanInfo. For example, if a bean was implemented via
the MyGizmo class, the related BeanInfo class would be named MyGizmoBeanInfo.
Connecting Events to Interface Methods
Beans, being primarily GUI components, generate and respond to events. Visual development tools
provide the capability to link events generated by one bean with event- handling methods
implemented by other beans. For example, a button component may generate an event as the result of
the user clicking on that button. A visual development tool would enable you to connect the handling
of this event to the interface methods of other beans. The bean generating the event is referred to as
the event source. The bean listening for (and handling) the event is referred to as the event listener.
Inside java.beans
Now that you have a feel for what beans are, how they are used, and some of the mechanisms they
employ, let's take a look at the classes and interfaces of the java.beans packages. These classes and
interfaces are organized into the categories of design support, introspection support, and change
event-handling support.
Design Support
The classes in this category help visual development tools to use beans in a design environment.
The Beans class provides seven static methods that are used by application builders:
●
instantiate()--Creates an instance of a bean from a serialized object.
●
isInstanceOf()--Determines if a bean is of a specified class or interface.
●
getInstanceof()--Returns an object that represents a particular view of a bean.
●
isDesignTime()--Determines whether beans are running in an application builder environment.
●
setDesignTime()--Identifies the fact that beans are running in an application builder
environment.
●
isGuiAvailable()--Determines whether a GUI is available for beans.
●
setGuiAvailable()--Identifies the fact that a GUI is available for beans.
The Visibility interface is implemented by classes that support the capability to answer questions
about the availability of a GUI for a bean. It provides the avoidingGui(), dontUseGui(), needsGui(),
and okToUseGui() methods. The VisibilityState interface provides the isOkToUseGui()method.
The methods of the PropertyEditor interface are implemented by classes that support custom property
editing. These methods support a range of property editors, from simple to complex. The setValue()
method is used to identify the object that is to be edited. The getValue() method returns the edited
value. The isPaintable() and paintValue() methods support the painting of property values on a
Graphics object. The getJavaInitializationString() method returns a string of Java code that is used to
initialize a property value. The setAsText() and getAsText() methods are used to set and retrieve a
property value as a String object. The getTags() method returns an array of String objects that are
acceptable values for a property. The supportsCustomEditor() method returns a boolean value
indicating whether a custom editor is provided by a PropertyEditor. The getCustomEditor() method
returns an object that is of a subclass of Component and is used as a custom editor for a bean's
property. The addPropertyChangeListener() and removePropertyChangeListener() methods are used
to register event handlers for the PropertyChangeEvent associated with a property.
The PropertyEditorManager class provides static methods that help application builders find property
editors for specific properties. The registerEditor() method is used to register an editor class for a
particular property class. The getEditorSearchPath() and setEditorSearchPath() methods support
package name lists for finding property editors. The findEditor() method finds a property editor for a
specified class. Unregistered property editors are identified by the name of the property followed by
Editor.
The PropertyEditorSupport class is a utility class that implements the PropertyEditor interface. It is
subclassed to simplify the development of property editors.
The methods of the Customizer interface are implemented by classes that provide a graphical
interface for customizing a bean. These classes are required to be subclasses of java.awt.Component
so that they can be displayed in a panel. The addPropertyChangeListener() method is used to enable
an object that implements the PropertyChangeListener interface as an event handler for the
PropertyChangeEvent of the object being customized. The removePropertyChangeListener() method
is used to remove a PropertyChangeListener. The setObject() method is used to identify the object
that is to be customized.
Introspection Support
The classes and interfaces in this category provide information to application builders about the
interface methods, properties, and events of a bean.
The Introspector Class
The Introspector class provides static methods that are used by application builders to obtain
information about a bean's class. The Introspector gathers this information using information
explicitly provided by the bean designer whenever possible and uses reflection and design patterns
when explicit information is not available. The getBeanInfo() method returns information about a
class as a BeanInfo object. The getBeanInfoSearchPath() method returns a String array to be used as
a search path for finding BeanInfo classes. The setBeanInfoSearchPath() method updates the list of
package names used to find BeanInfo classes. The decapitalize() method is used to convert a String
object to a standard variable name in terms of capitalization.
The BeanInfo Interface
The methods of the BeanInfo interface are implemented by classes that want to provide additional
information about a bean. The getBeanDescriptor() method returns a BeanDescriptor object that
provides information about a bean. The getIcon() method returns an Image object that is used as an
icon to represent a bean. It uses the icon constants defined in BeanInfo to determine which type of
icon should be returned. The getEventSetDescriptors() method returns an array of EventSetDescriptor
objects that describe the events generated (fired) by a bean. The getDefaultEventIndex() method
returns the index of the most commonly used event of a bean. The getPropertyDescriptors() method
returns an array of PropertyDescriptor objects that support the editing of a bean's properties. The
getDefaultPropertyIndex() method returns the most commonly updated property of a bean. The
getMethodDescriptors() method returns an array of MethodDescriptor objects that describe a bean's
externally accessible methods. The getAdditionalBeanInfo() method returns an array of objects that
implement the BeanInfo interface.
The SimpleBeanInfo Class
The SimpleBeanInfo class provides a default implementation of the BeanInfo interface. It is
subclassed to implement BeanInfo classes.
The FeatureDescriptor Class and Its Subclasses
The FeatureDescriptor class is the top-level class of a class hierarchy that is used by BeanInfo objects
to report information to application builders. It provides methods that are used by its subclasses for
information gathering and reporting.
The BeanDescriptor class provides global information about a bean, such as the bean's class and its
Customizer class, if any. The EventSetDescriptor class provides information on the events generated
by a bean. The PropertyDescriptor class provides information on a property's accessor methods and
property editor. It is extended by the IndexedPropertyDescriptor class, which provides access to the
type of the array implemented as an indexed property and information about the property's accessor
methods.
The MethodDescriptor and ParameterDescriptor classes provide information about a bean's methods
and parameters.
Change Event-Handling Support
The PropertyChangeEvent is generated by beans that implement bound and constrained properties as
the result of a change in the values of these properties. The PropertyChangeListener interface is
implemented by those classes that listen for the PropertyChangeEvent. It consists of a single method,
propertyChange(), that is used to handle the event.
The VetoableChangeListener interface is implemented by classes that handle the
PropertyChangeEvent and throw a VetoableChangeEvent in response to certain property changes.
The vetoableChange() method is used to handle the PropertyChangeEvent.
The PropertyChangeSupport class is a utility class that can be subclassed by beans that implement
bound properties. It provides a default implementation of the addPropertyChangeListener(),
removePropertyChangeListener(), and firePropertyChange() methods.
The VetoableChangeSupport class, like the PropertyChangeSupport class, is a utility class that can be
subclassed by beans that implement constrained properties. It provides a default implementation of
the addVetoableChangeListener(), removeVetoableChangeListener(), and fireVetoableChange()
methods.
Aggregation
The Aggregate interface has been added in JDK 1.2 as a means of aggregating several objects into a
single bean. It is extended by the Delegate interface, which provides methods for accessing
Aggregate objects. The AggregateObject class is an abstract class that implements the Delegate
interface and provides a foundation for creating other aggregate classes. Note that aggregation has
nothing to do with inheritance. It is just a way of combining multiple objects into a single bean.
The java.beans.beancontext Package
JDK 1.2 introduces the java.beans.beancontext package, which provides classes and interfaces for
enabling beans to access their execution environment, referred to as their bean context. The
BeanContextChild interface provides methods for getting and setting this context and for managing
context-related event listeners. BeanContextChild is extended by the BeanContext interface, which
provides methods by which beans can access resources and services that are available within their
context. Objects that implement BeanContext function as containers for other beans. The
BeanContextMemberShipListener interface provides an event listener interface for events that occur
as the result of changes to the beans that are members of a bean context. The DesignMode interface
of java.beans provides the capability for a BeanContext object to determine whether it is being
executed in a design or execution mode.
In addition to the interfaces described in the previous paragraph, the java.beans.beancontext package
provides the following six classes:
●
●
●
●
●
●
BeanContextEvent--Events of this class are fired when the state of a bean context changes.
BeanContextMembershipEvent--Extends BeanContextEvent to support changes in the
membership of a bean context.
BeanContextAddedEvent--Events of this class are fired when a bean is added to a bean
context. This class extends BeanContextMembershipEvent.
BeanContextRemovedEvent--Events of this class are fired when a bean is removed from a
bean context. This class extends BeanContextMembershipEvent.
BeanContextSupport--Provides an implementation of the BeanContext interface.
BeanContextSupport.BCSChildInfo--Used to maintain information on the beans that are
contained within a bean context.
The easiest way to implement a bean context is to extend the BeanContextSupport class.
BeanContextSupport provides numerous methods for managing beans that are contained within a
particular context.
Developing Beans
In this section, you'll learn how to create your own beans and use them in an applet. First, you'll
create a simple gauge that can be used as a widget for applets and applications. Next, you'll create a
bean that can be used to display text without the use of a TextArea or TextField object. After that,
you'll learn how to use these beans in an applet that displays multiple-choice quiz questions.
A Gauge Bean
When you studied all of the classes and interfaces of java.beans in previous sections, you might have
been left with the impression that beans are complicated and hard to develop. In fact, the opposite is
true. You can easily convert existing classes to beans with minimal programming overhead.
Listing 26.1 contains the code for a bean that displays a simple gauge. The gauge is displayed as a
3D-style box that is filled somewhere between its minimum and maximum values. The color of the
gauge's border and its fill color are both configurable. So are its dimensions and horizontal/vertical
orientation.
LISTING 26.1. THE Gauge.java BEAN.
import java.io.Serializable;
import java.beans.*;
import java.awt.*;
import java.awt.event.*;
public class Gauge extends Canvas implements Serializable {
// Set constants and default values
public static final int HORIZONTAL = 1;
public static final int VERTICAL = 2;
public static final int WIDTH = 100;
public static final int HEIGHT = 20;
public int orientation = HORIZONTAL;
public int width = WIDTH;
public int height = HEIGHT;
public double minValue = 0.0;
public double maxValue = 1.0;
public double currentValue = 0.0;
public Color gaugeColor = Color.lightGray;
public Color valueColor = Color.blue;
public Gauge() {
super();
}
public Dimension getPreferredSize() {
return new Dimension(width,height);
}
// Draw bean
public synchronized void paint(Graphics g) {
g.setColor(gaugeColor);
g.fill3DRect(0,0,width-1,height-1,false);
int border=3;
int innerHeight=height-2*border;
int innerWidth=width-2*border;
double scale=(double)(currentValue-minValue)/
(double)(maxValue-minValue);
int gaugeValue;
g.setColor(valueColor);
if(orientation==HORIZONTAL){
gaugeValue=(int)((double)innerWidth*scale);
g.fillRect(border,border,gaugeValue,innerHeight);
}else{
gaugeValue=(int)((double)innerHeight*scale);
g.fillRect(border,border+(innerHeight-ÂgaugeValue),innerWidth,
gaugeValue);
}
}
// Methods for accessing bean properties
public double getCurrentValue(){
return currentValue;
}
public void setCurrentValue(double newCurrentValue){
if(newCurrentValue>=minValue && newCurrentValue<=maxValue)
currentValue=newCurrentValue;
}
public double getMinValue(){
return minValue;
}
public void setMinValue(double newMinValue){
if(newMinValue<=currentValue)
minValue=newMinValue;
}
public double getMaxValue(){
return maxValue;
}
public void setMaxValue(double newMaxValue){
if(newMaxValue >= currentValue)
maxValue=newMaxValue;
}
public int getWidth(){
return width;
}
public void setWidth(int newWidth){
if(newWidth > 0){
width=newWidth;
updateSize();
}
}
public int getHeight(){
return height;
}
public void setHeight(int newHeight){
if(newHeight > 0){
height=newHeight;
updateSize();
}
}
public Color getGaugeColor(){
return gaugeColor;
}
public void setGaugeColor(Color newGaugeColor){
gaugeColor=newGaugeColor;
}
public Color getValueColor(){
return valueColor;
}
public void setValueColor(Color newValueColor){
valueColor=newValueColor;
}
public boolean isHorizontal(){
if(orientation==HORIZONTAL) return true;
else return false;
}
public void setHorizontal(boolean newOrientation){
if(newOrientation){
if(orientation==VERTICAL) switchDimensions();
}else{
if(orientation==HORIZONTAL) switchDimensions();
orientation=VERTICAL;
}
updateSize();
}
void switchDimensions(){
int temp=width;
width=height;
height=temp;
}
void updateSize(){
setSize(width,height);
Container container=getParent();
if(container!=null){
container.invalidate();
container.doLayout();
}
}
}
To see how the bean works, copy the Gauge.jar file from your ch26 directory to the \bdk\jars
directory and then start up the BeanBox using the following commands:
copy Gauge.jar \bdk\jars
cd \bdk\beanbox
run
The BeanBox opens and displays the ToolBox, BeanBox, and PropertySheet windows. You will
notice a new bean at the bottom of the ToolBox. This is the Gauge bean from Listing 26.1. Note that
it comes with its own icon, as shown in Figure 26.1.
FIGURE 26.1. The Gauge bean now has an icon in the ToolBox.
Click the Gauge bean's ToolBox icon and then click in the BeanBox. The bean is displayed as a
horizontal 3D box, as shown in Figure 26.2.
FIGURE 26.2. Adding the Gauge bean to the BeanBox.
The bean's property sheet displays a number of properties that may be changed to alter the bean's
appearance, as shown in Figure 26.3. The foreground, background, and font properties are the default
properties of visible beans. These properties reflect the getForeground(), setForeground(),
getBackground(), setBackground(), getFont(), and setFont() methods of the Component class.
The rest of the properties shown in the style sheet were defined in Listing 26.1. The minValue and
maxValue properties identify the minimum and maximum values associated with the gauge. The
currentValue property identifies the current value of the gauge.
Figure 26.3. The Gauge bean's PropertySheet.
The width and height properties control the gauge's dimensions. The horizontal property takes on
boolean values. When set to True, the gauge is displayed horizontally. When set to False, the gauge is
displayed vertically. When the orientation of a gauge is switched, so are its width and height.
The gaugeColor and valueColor properties identify the color of the gauge's border and the color to be
displayed to identify the gauge's current value.
To see how the gauge's properties work, make the following changes:
●
Change the currentValue property to .7.
●
Change the horizontal property to False.
●
Change the height property to 200.
●
Change the gaugeColor property to green.
●
Change the valueColor property to orange.
Figure 26.4 shows the results of these changes on the bean's display.
FIGURE 26.4. Changing the Gauge bean's properties.
How the Gauge Bean Works
The first thing that you'll notice about the Gauge bean's source code is that it imports java.io.
Serializable. All bean classes implement Serializable or Externalizable. These interfaces support bean
persistence, allowing beans to be read from and written to permanent storage (for example, hard
disk). When a bean implements Serializable, serialization of the bean's data is performed
automatically by Java, meaning you don't have to figure out how to write objects to streams or read
them back in. When a bean implements Externalizable, the bean is responsible for performing all the
serialization overhead. Serializable is obviously the easiest to implement of the two interfaces. All
you have to do is add Serializable to your class's implements clause and poof!--serialization is
automatically supported. Chapter 40, "Using Object Serialization and JavaSpaces," covers object
serialization.
Besides serialization, you won't notice anything bean-specific about the rest of the Gauge class. In
fact, it looks just like any other custom AWT class. Gauge extends Canvas so that it can draw to a
Graphics object. It defines a few constants for use in initializing its field variables. You should note
that these field variables correspond to the Gauge bean's properties.
The getPreferredSize() method is an important method for visible beans to implement. It tells
application builder tools how much room is needed to display a bean. All of your visible beans
should implement getPreferredSize().
The paint() method draws the bean on a Graphics object. Visible beans need to implement paint() in
order to display themselves. The paint() method of Gauge works by drawing a 3D rectangle using the
gaugeColor and then drawing an inner rectangle using the valueColor. The dimensions of the inner
rectangle are calculated based on the value of currentValue and the orientation variables.
Gauge provides getter and setter methods for each of its properties. These methods adhere to the
naming conventions used for bean properties. The Introspector class of java.beans automatically
reports the properties corresponding to these methods to application builder tools, such as the
BeanBox.
The switchDimensions() method is used to switch the values of width and height when the bean's
orientation is switched.
The updateSize() method is invoked when the bean changes its size. It invokes setSize() to inform a
layout manager of its new size. It invokes the invalidate() method of its container to invalidate the
container's layout and doLayout() to cause the component to be redisplayed.
The GaugeBeanInfo Class
You may be wondering, "What about all of those other classes and interfaces of java.beans?" For
simple beans, you don't really need them. However, we created a GaugeBeanInfo class so that the
bean's icon can be displayed. The GaugeBeanInfo class is shown in Listing 26.2.
LISTING 26.2. THE GaugeBeanInfo CLASS.
import java.beans.*;
import java.awt.*;
public class GaugeBeanInfo extends SimpleBeanInfo {
// Return icon to be used with bean
public Image getIcon(int size) {
switch(size){
case ICON_COLOR_16x16:
return loadImage("gauge16c.gif");
case ICON_COLOR_32x32:
return loadImage("gauge32c.gif");
case ICON_MONO_16x16:
return loadImage("gauge16m.gif");
case ICON_MONO_32x32:
return loadImage("gauge32c.gif");
}
return null;
}
}
The GaugeBeanInfo class extends the SimpleBeanInfo class and implements one method--getIcon().
The getIcon() method is invoked by application builders to obtain an icon for a bean. It uses the
constants defined in the BeanInfo interface to select a color or monochrome icon of size 16¥16 or 32
¥32 bits.
The Gauge.mf Manifest File
The Gauge.mf manifest file is used to build the Gauge.jar file. It identifies the Gauge.class file as a
bean. To create the Gauge.jar file, use the following command:
jar cfm Gauge.jar Gauge.mf Gauge*.class gauge*.gif
All the files that you need for this example are installed in your ch26 directory. Remember to copy
your beans' .jar files from the ch26 directory to the \bdk\jars directory to have them loaded by the
BeanBox. The contents of the Gauge.mf file are as follows:
Manifest-Version: 1.0
Name: Gauge.class
Java-Bean: True
A Text Canvas Bean
Did you ever wish that you could draw text on a canvas without having to fiddle around with fonts
and font metrics? The bean that you'll develop next will make your wish come true. You can use it in
place of the TextArea and TextField classes to display text in applets and window applications.
The name of this bean is TCanv, which is short for Text Canvas. The source code for the TCanv bean
is shown in Listing 26.3. Let's start by learning how TCanv works. Copy the TCanv.jar file from the
ch26 directory to the \bdk\jars directory using the following command:
copy TCanv.jar \bdk\jars
When you open up your BeanBox, you will notice the TCanv bean at the bottom of your ToolBox, as
shown in Figure 26.5.
Click on the TCanv icon and then in the BeanBox. The TCanv bean is displayed, as shown in Figure
26.6. Its property sheet is shown in Figure 26.7. The background, foreground, and font properties are
the default properties of visible beans. The leftMargin and topMargin properties are used to insert
space between the edges of the bean and the text it displays. The border property is used to display a
border around the perimeter of the bean. The width and height properties control the bean's
dimensions.
FIGURE 26.5. The TCanv bean is now in the ToolBox.
Figure 26.6. The TCanv bean is in the BeanBox.
FIGURE 26.7. The TCanv bean's PropertySheet.
The text property identifies the actual text that is displayed by the bean. Because some application
builders, such as the BeanBox, do not let you enter a new line character in a text property, the vertical
bar character (|) is used to indicate a new line. At least one character should be contained on a line for
the line to be displayed.
To distinguish it from the rest of the BeanBox and to show how its properties work, make the
following changes:
●
Change the text property to This|is|a|test!.
●
Change the leftMargin and topMargin properties to 20.
●
●
Change the font property to a 14-point font. (Click on the font property to open the FontEditor
dialog box.)
Change the background property to yellow.
Figure 26.8 shows the effect of these changes on the bean.
FIGURE 26.8. The result of changing the TCanv bean's properties.
LISTING 26.3. THE TCanv BEAN.
import java.io.*;
import java.util.*;
import java.beans.*;
import java.awt.*;
import java.awt.event.*;
public class TCanv extends Canvas implements Serializable {
// Set constants and default values
public static final int WIDTH = 200;
public static final int HEIGHT = 200;
public int width = WIDTH;
public int height = HEIGHT;
public int leftMargin = 5;
public int topMargin = 5;
public String text = "";
public boolean border = true;
public TCanv() {
super();
}
public Dimension getPreferredSize() {
return new Dimension(width,height);
}
// Draw bean
public synchronized void paint(Graphics g) {
if(border) g.drawRect(0,0,width-1,height-1);
Font font = g.getFont();
FontMetrics fm = g.getFontMetrics(font);
int lineHeight = fm.getHeight();
int y=fm.getLeading()+fm.getAscent();
StringTokenizer tokenizer = new StringTokenizer(text,"|");
String line;
while(tokenizer.hasMoreTokens()){
line=tokenizer.nextToken();
if(border) g.drawString(line,leftMargin+1,topMargin+y+1);
else g.drawString(line,leftMargin,topMargin+y);
y+=lineHeight;
}
}
// Methods for accessing bean properties
public String getText(){
return text;
}
public void setText(String newTextValue){
text=newTextValue;
}
public int getWidth(){
return width;
}
public void setWidth(int newWidth){
if(newWidth > 0){
width=newWidth;
updateSize();
}
}
public int getHeight(){
return height;
}
public void setHeight(int newHeight){
if(newHeight > 0){
height=newHeight;
updateSize();
}
}
public int getLeftMargin(){
return leftMargin;
}
public void setLeftMargin(int newLeftMargin){
if(newLeftMargin >= 0) leftMargin=newLeftMargin;
}
public int getTopMargin(){
return topMargin;
}
public void setTopMargin(int newTopMargin){
if(newTopMargin >= 0) topMargin=newTopMargin;
}
public boolean isBorder(){
return border;
}
public void setBorder(boolean newBorder){
border = newBorder;
}
void updateSize(){
setSize(width,height);
Container container=getParent();
if(container!=null){
container.invalidate();
container.doLayout();
}
}
}
Inside TCanv
The TCanv class, like the Gauge class, extends Canvas and implements Serializable. It defines the
field variables corresponding to its properties and implements getPreferredSize() and paint(). It also
implements a few getter and setter methods. Starting to recognize a pattern?
The paint() method checks the border variable and draws a border around the bean, as required. It
then gets the value of the current font and the font's FontMetrics object. It invokes the getHeight()
method of the FontMetrics class to get the line height of the current font in pixels. It then uses a
StringTokenizer object to parse the String object of the text variable based on the | delimiter. Finally,
the text is displayed one line at a time. The hasMoreTokens() and nextToken() methods of
StringTokenizer are used to step through the parsed text string and to display them on the Graphics
object of the bean's canvas.
Listing 26.4 shows the code for the TCanvBeanInfo. This class is similar to GaugeBeanInfo and is
used to provide icons to application builders.
LISTING 26.4. THE TCanvBeanInfo CLASS.
import java.beans.*;
import java.awt.*;
public class TCanvBeanInfo extends SimpleBeanInfo {
// Return TCanv icon
public Image getIcon(int size) {
switch(size){
case ICON_COLOR_16x16:
return loadImage("tcanv16c.gif");
case ICON_COLOR_32x32:
return loadImage("tcanv32c.gif");
case ICON_MONO_16x16:
return loadImage("tcanv16m.gif");
case ICON_MONO_32x32:
return loadImage("tcanv32c.gif");
}
return null;
}
}
The manifest file used to create TCanv.jar is as follows:
Manifest-Version: 1.0
Name: TCanv.class
Java-Bean: True
This file is used to identify the TCanv class as a bean. The following command is used to create the
TCanv.jar file:
jar cvfm TCanv.jar TCanv.mf TCanv*.class tcanv*.gif
A Quiz Applet
Now that you have a couple of beans under your belt, let's use them in an applet. The Quiz applet,
shown in Listing 26.5, uses both beans. It displays arithmetic multiple-choice quiz questions to the
user. These questions are displayed in a TCanv bean. A second TCanv bean displays status
information. A Gauge bean displays the user's quiz score in graphical form.
FIGURE 26.9. The Quiz applet as displayed by appletviewer.
Figure 26.10. Keeping track of the score using the Gauge bean.
Figure 26.9 shows how the applet is initially displayed by appletviewer. The applet is displayed by
opening the quiz.htm file contained in your ch26 directory. The questions are randomized to reduce
the likelihood of a question being asked twice. When you click on an answer, the TCanv beans are
updated with new questions and status information. The Gauge bean updates the user's quiz score, as
shown in Figure 26.10.
LISTING 26.5. THE Quiz APPLET.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class Quiz extends Applet {
// Declare bean objects
TCanv question = new TCanv();
Gauge gauge = new Gauge();
String labels[]={"
A
","
B
","
C
","
Button button[] = new Button[labels.length];
TCanv status=new TCanv();
int questions = 0;
int correctAnswers = 0;
int currentAnswer;
public void init() {
Panel mainPanel = new Panel();
Panel gaugePanel = new Panel();
Panel bottomPanel = new Panel();
Panel buttons = new Panel();
D
"};
// Set bean properties
question.setLeftMargin(20);
question.setTopMargin(20);
gauge.setHorizontal(false);
gauge.setMaxValue(100.0);
gauge.setCurrentValue(100.0);
gauge.setHeight(200);
gauge.setWidth(20);
status.setHeight(20);
status.setWidth(200);
status.setTopMargin(0);
status.setBorder(false);
mainPanel.setLayout(new BorderLayout());
mainPanel.add("Center",question);
gaugePanel.add(new Label("Score: (0-100%)"));
gaugePanel.add(gauge);
mainPanel.add("East",gaugePanel);
bottomPanel.setLayout(new BorderLayout());
for(int i=0;i<labels.length;++i){
button[i] = new Button(labels[i]);
button[i].addActionListener(new ButtonHandler());
buttons.add(button[i]);
}
buttons.add(status);
bottomPanel.add("Center",buttons);
mainPanel.add("South",bottomPanel);
add(mainPanel);
}
public void start(){
displayQuestion();
}
void displayQuestion() {
question.setText(nextQuestion());
if(questions==0) status.setText("Click the correct answer.");
else{
String s="Questions: "+String.valueOf(questions);
s+=" Correct: "+String.valueOf(correctAnswers);
status.setText(s);
}
}
String nextQuestion() {
String q = "What is ";
String operand[] = {"+","-","*"};
int op1 = randomInt(100);
int op2 = randomInt(100);
int op = randomInt(3);
String operator = operand[op];
int ans=0;
switch(op){
case 0:
ans=op1+op2;
break;
case 1:
ans=op1-op2;
break;
case 2:
ans=op1*op2;
break;
}
currentAnswer=randomInt(labels.length);
q+=String.valueOf(op1)+operator+String.valueOf(op2)+"?| ";
for(int i=0;i<labels.length;++i){
q+="|"+labels[i];
if(i==currentAnswer) q+=String.valueOf(ans);
else{
int delta = randomInt(10);
if(delta==0) delta=1;
int add = randomInt(2);
if(add==1) q+=String.valueOf(ans+delta);
else q+=String.valueOf(ans-delta);
}
}
return q;
}
int randomInt(int max){
int r = (int) (max*Math.random());
r %= max;
return r;
}
void answer(int i){
++questions;
if(i==currentAnswer){
++correctAnswers;
displayQuestion();
}else{
status.setText("Try again!");
}
// Update bean properties
double score = (double) correctAnswers/(double) questions;
gauge.setCurrentValue(score*100.0);
gauge.repaint();
question.repaint();
status.repaint();
}
class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent e){
String s = e.getActionCommand();
for(int i=0;i<labels.length;++i){
if(labels[i].equals(s)){
answer(i);
break;
}
}
}
}
}
Inside the Quiz Applet
The Quiz applet provides a very crude example of using beans in an applet. Normally, if you were
using beans, you would slap together an applet using a visual programming tool. In this case, you
could avoid having to do most of the applet programming.
The Quiz applet is valuable in that it shows you how beans can be used in the same manner as other
GUI components. A second purpose of the applet is to make you appreciate the use of serialization.
You'll learn about beans, serialization, and applets later in this chapter when you study a serialized
clone of Quiz, named Quiz2.
The Quiz applet creates two TCanv beans and assigns them to the question and status variables. A
Gauge bean is created and assigned to the gauge variable. The bean assigned to the question variable
displays the text of a question. The bean assigned to the status variable displays the status information
to the right of the answer buttons.
The applet's init()method lays out the applet and sets the properties of the beans. The left and top
margins of the question bean are set to 20. The Gauge bean is changed to vertical and its maximum
value is set to 100. Its current value is also set to 100, giving the user a vote of confidence. The
gauge's width and height dimensions are also modified. The dimensions of the status bean are
adjusted. Its top margin is set to 0 and its border is turned off.
The applet's start() method simply invokes the displayQuestion() method to display a quiz question to
the user. The displayQuestion() method invokes the question bean's setText() method to display the
text of the question. The setText() method of the status bean is invoked to display status information
to the user.
Questions are created by the nextQuestion() method. This method generates an arithmetic question
based on the addition, subtraction, and multiplication of integers between 0 and 100. It displays the
answer along with three other incorrect answers. These answers are displayed in random order.
The randomInt() method generates a random integer from zero to one less than a specified maximum.
The answer() method supports the handling of the answer buttons by checking if the user answered
correctly and then updating and displaying the score accordingly. The repaint() methods of the beans
are invoked to cause the beans to update their respective displays.
The ButtonHandler class supports the handling of the events associated with clicking the answer
buttons.
The quiz.htm file, shown in Listing 26.6, is used to display the Quiz applet.
LISTING 26.6. THE quiz.htm FILE.
<HTML>
<HEAD>
<TITLE>Quiz</TITLE>
</HEAD>
<BODY>
<APPLET CODE="Quiz.class" WIDTH=400 HEIGHT=300>
[Quiz applet]
</APPLET>
</BODY>
</HTML>
Using Serialization
While reading through the source code of the Quiz applet, you probably were wondering what
benefit, if any, was derived from using beans. That's a legitimate concern. The answer is that in the
absence of an application builder tool, beans are just a little easier to work with than other classes.
The one feature of beans that is apparent, whether you are using them as part of an application builder
or by hand, is their support for persistence.
The Quiz applet did not make use of persistence. Instead of customizing beans using the BeanBox,
the Quiz applet included special code in the init() method to accomplish bean editing and
customization. The Quiz2 applet, shown in Listing 26.7, which is a takeoff on the Quiz applet, does
show how persistence is used. Listing 26.8 shows the quiz2.htm file used to display the applet. Go
ahead and display quiz2.htm using the appletviewer. You should notice that the Quiz2 applet behaves
in the same way as Quiz.
LISTING 26.7. THE Quiz2 APPLET.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.beans.*;
public class Quiz2 extends Applet {
// Declare beans
TCanv question, status;
Gauge gauge;
String labels[]={"
A
","
B
","
C
","
D
Button button[] = new Button[labels.length];
int questions = 0;
int correctAnswers = 0;
int currentAnswer;
public void init() {
Panel mainPanel = new Panel();
Panel gaugePanel = new Panel();
Panel bottomPanel = new Panel();
Panel buttons = new Panel();
try{
// Load serialized beans
question = (TCanv) Beans.instantiate(null,"qcanv");
gauge = (Gauge) Beans.instantiate(null,"vgauge");
status = (TCanv) Beans.instantiate(null,"scanv");
"};
}catch(Exception ex){
}
mainPanel.setLayout(new BorderLayout());
mainPanel.add("Center",question);
gaugePanel.add(new Label("Score: (0-100%)"));
gaugePanel.add(gauge);
mainPanel.add("East",gaugePanel);
bottomPanel.setLayout(new BorderLayout