Like any human language, Java
provides a way to express concepts. If successful, this medium of expression
will be significantly easier and more flexible than the alternatives as problems
grow larger and more complex.
You can’t look at Java as just a
collection of features—some of the features make no sense in isolation.
You can use the sum of the parts only if you are thinking about design,
not simply coding. And to understand Java in this way, you must understand the
problems with it and with programming in general. This book discusses
programming problems, why they are problems, and the approach Java has taken to
solve them. Thus, the set of features I explain in each chapter are based on the
way I see a particular type of problem being solved with the language. In this
way I hope to move you, a little at a time, to the point where the Java mindset
becomes your native tongue.
Throughout, I’ll be taking the
attitude that you want to build a model in your head that allows you to develop
a deep understanding of the language; if you encounter a puzzle you’ll be
able to feed it to your model and deduce the
answer.
This book assumes that you have some
programming familiarity: you understand that a program is a collection of
statements, the idea of a subroutine/function/macro, control statements such as
“if” and looping constructs such as “while,” etc.
However, you might have learned this in many places, such as programming with a
macro language or working with a tool like Perl. As long as you’ve
programmed to the point where you feel comfortable with the basic ideas of
programming, you’ll be able to work through this book. Of course, the book
will be easier for the C programmers and more so for the C++ programmers,
but don’t count yourself out if you’re not experienced with those
languages (but come willing to work hard; also, the multimedia CD that
accompanies this book will bring you up to speed on the basic C syntax necessary
to learn Java). I’ll be introducing the concepts of object-oriented
programming (OOP) and Java’s basic control mechanisms, so you’ll be
exposed to those, and the first exercises will involve the basic control-flow
statements.
Although references will often be made to
C and C++ language features, these are not intended to be insider comments, but
instead to help all programmers put Java in perspective with those languages,
from which, after all, Java is descended. I will attempt to make these
references simple and to explain anything that I think a non- C/C++ programmer
would not be familiar
with.
At about the same time that my first book
Using C++ (Osborne/McGraw-Hill, 1989) came out, I began teaching that
language. Teaching programming languages has become my profession; I’ve
seen nodding heads, blank faces, and puzzled expressions in audiences all over
the world since 1989. As I began giving in-house training with smaller groups of
people, I discovered something during the exercises. Even those people who were
smiling and nodding were confused about many issues. I found out, by chairing
the C++ track at the Software
Development Conference for a number of years (and later the Java track), that I
and other speakers tended to give the typical audience too many topics too fast.
So eventually, through both variety in the audience level and the way that I
presented the material, I would end up losing some portion of the audience.
Maybe it’s asking too much, but because I am one of those people resistant
to traditional lecturing (and for most people, I believe, such resistance
results from boredom), I wanted to try to keep everyone up to
speed.
For a time, I was creating a number of
different presentations in fairly short order. Thus, I ended up learning by
experiment and iteration (a technique that also works well in Java program
design). Eventually I developed a course using everything I had learned from my
teaching experience—one that I would be happy giving for a long time. It
tackles the learning problem in discrete, easy-to-digest steps, and in a
hands-on seminar (the ideal learning situation) there are exercises following
each of the short lessons. I now give this course in
public Java seminars, which you can
find out about at www.BruceEckel.com. (The introductory seminar is also
available as a CD ROM. Information is available at the same Web
site.)
The feedback that I get from each seminar
helps me change and refocus the material until I think it works well as a
teaching medium. But this book isn’t just seminar notes—I tried to
pack as much information as I could within these pages, and structured it to
draw you through onto the next subject. More than anything, the book is designed
to serve the solitary reader who is struggling with a new programming
language.
Like my previous book Thinking in
C++, this book has come to be structured around the process of teaching the
language. In particular, my motivation is to create something that provides me
with a way to teach the language in my own seminars. When I think of a chapter
in the book, I think in terms of what makes a good lesson during a seminar. My
goal is to get bite-sized pieces that can be taught in a reasonable amount of
time, followed by exercises that are feasible to accomplish in a classroom
situation.
My goals in this book are
to:
The Java language and libraries from Sun
Microsystems (a free download) come with documentation in electronic form,
readable using a Web browser, and virtually every third party implementation of
Java has this or an equivalent documentation system. Almost all the books
published on Java have duplicated this documentation. So you either already have
it or you can download it, and unless necessary, this book will not repeat that
documentation because it’s usually much faster if you find the class
descriptions with your Web browser than if you look them up in a book. (Plus it
will be up-to-date.) This book will provide extra descriptions of the classes
only when it’s necessary to supplement the documentation so you can
understand a particular example.
This book was designed with one thing in
mind: the way people learn the Java language. Seminar audience feedback helped
me understand the difficult parts that needed illumination. In the areas where I
got ambitious and included too many features all at once, I came to
know—through the process of presenting the material—that if you
include a lot of new features, you need to explain them all, and this easily
compounds the student’s confusion. As a result, I’ve taken a great
deal of trouble to introduce the features as few at a time as
possible.
The goal, then, is for each chapter to
teach a single feature, or a small group of associated features, in such a way
that no additional features are relied upon. That way you can digest each piece
in the context of your current knowledge before moving on.
Here is a brief description of the
chapters contained in the book, which correspond to lectures and exercise
periods in my hands-on seminars.
Chapter 1: Introduction to
Objects
This chapter is an overview of what
object-oriented programming is all about, including the answer to the basic
question “What’s an object?”, interface vs. implementation,
abstraction and encapsulation, messages and functions, inheritance and
composition, and the all-important polymorphism. You’ll also get an
overview of issues of object creation such as constructors, where the objects
live, where to put them once they’re created, and the magical garbage
collector that cleans up the objects that are no longer needed. Other issues
will be introduced, including error handling with exceptions, multithreading for
responsive user interfaces, and networking and the Internet. You’ll learn
what makes Java special, why it’s been so successful, and about
object-oriented analysis and design.
Chapter 2: Everything is an
Object
This chapter moves you to the point where
you can write your first Java program, so it must give an overview of the
essentials, including the concept of a reference to an object; how to
create an object; an introduction to primitive types and arrays; scoping and the
way objects are destroyed by the garbage collector; how everything in Java is a
new data type (class) and how to create your own classes; functions, arguments,
and return values; name visibility and using components from other libraries;
the static keyword; and comments and embedded
documentation.
Chapter 3: Controlling Program
Flow
This chapter begins with all of the
operators that come to Java from C and C++. In addition, you’ll discover
common operator pitfalls, casting, promotion, and precedence. This is followed
by the basic control-flow and selection operations that you get with virtually
any programming language: choice with if-else; looping with for and while;
quitting a loop with break and continue as well as Java’s labeled break
and labeled continue (which account for the “missing goto” in Java);
and selection using switch. Although much of this material has common threads
with C and C++ code, there are some differences. In addition, all the examples
will be full Java examples so you’ll get more comfortable with what Java
looks like.
Chapter 4: Initialization &
Cleanup
This chapter begins by introducing the
constructor, which guarantees proper initialization. The definition of the
constructor leads into the concept of function overloading (since you might want
several constructors). This is followed by a discussion of the process of
cleanup, which is not always as simple as it seems. Normally, you just drop an
object when you’re done with it and the garbage collector eventually comes
along and releases the memory. This portion explores the garbage collector and
some of its idiosyncrasies. The chapter concludes with a closer look at how
things are initialized: automatic member initialization, specifying member
initialization, the order of initialization, static initialization and
array initialization.
Chapter 5: Hiding the
Implementation
This chapter covers the way that code is
packaged together, and why some parts of a library are exposed while other parts
are hidden. It begins by looking at the package and import
keywords, which perform file-level packaging and allow you to build libraries of
classes. The subject of directory paths and file names is also examined. The
remainder of the chapter looks at the public, private, and
protected keywords, the concept of “friendly” access, and
what the different levels of access control mean when used in various contexts.
Chapter 6: Reusing Classes
The concept of inheritance is standard in
virtually all OOP languages. It’s a way to take an existing class and add
to its functionality (as well as change it, the subject of Chapter 7).
Inheritance is often a way to reuse code by leaving the “base class”
the same, and just patching things here and there to produce what you want.
However, inheritance isn’t the only way to make new classes from existing
ones. You can also embed an object inside your new class with
composition. In this chapter you’ll learn about these two ways to
reuse code in Java, and how to apply them.
Chapter
7: Polymorphism
On your own, you might take nine months
to discover and understand polymorphism, a cornerstone of OOP. Through small,
simple examples you’ll see how to create a family of types with
inheritance and manipulate objects in that family through their common base
class. Java’s polymorphism allows you to treat all objects in this family
generically, which means the bulk of your code doesn’t rely on specific
type information. This makes your programs extensible, so building programs and
code maintenance is easier and cheaper.
Chapter 8: Interfaces & Inner
Classes
Java provides a third way to set up a
reuse relationship, through the interface, which is a pure abstraction of
the interface of an object. The interface is more than just an abstract
class taken to the extreme, since it allows you to perform a variation on
C++’s “multiple inheritance,” by creating a class that can be
upcast to more than one base type.
At first, inner classes look like a
simple code hiding mechanism: you place classes inside other classes.
You’ll learn, however, that the inner class does more than that—it
knows about and can communicate with the surrounding class—and that the
kind of code you can write with inner classes is more elegant and clear,
although it is a new concept to most and takes some time to become comfortable
with design using inner classes.
Chapter 9: Holding your Objects
It’s a fairly simple program that
has only a fixed quantity of objects with known lifetimes. In general, your
programs will always be creating new objects at a variety of times that will be
known only while the program is running. In addition, you won’t know until
run-time the quantity or even the exact type of the objects you need. To solve
the general programming problem, you need to create any number of objects,
anytime, anywhere. This chapter explores in depth the container library that
Java 2 supplies to hold objects while you’re working with them: the simple
arrays and more sophisticated containers (data structures) such as ArrayList
and HashMap.
Chapter 10: Error Handling with
Exceptions
The basic philosophy of Java is that
badly-formed code will not be run. As much as possible, the compiler catches
problems, but sometimes the problems—either programmer error or a natural
error condition that occurs as part of the normal execution of the
program—can be detected and dealt with only at run-time. Java has
exception handling to deal with any problems that arise while the program
is running. This chapter examines how the keywords try, catch,
throw, throws, and finally work in Java; when you should
throw exceptions and what to do when you catch them. In addition, you’ll
see Java’s standard exceptions, how to create your own, what happens with
exceptions in constructors, and how exception handlers are located.
Chapter 11: The Java IO System
Theoretically, you can divide any program
into three parts: input, process, and output. This implies that IO
(input/output) is an important part of the equation. In this chapter
you’ll learn about the different classes that Java provides for reading
and writing files, blocks of memory, and the console. The distinction between
“old” IO and “new” Java IO will be shown. In addition,
this section examines the process of taking an object, “streaming”
it (so that it can be placed on disk or sent across a network) and
reconstructing it, which is handled for you with Java’s object
serialization. Also, Java’s compression libraries, which are used in
the Java ARchive file format (JAR), are
examined.
Chapter 12: Run-Time Type
Identification
Java run-time type identification (RTTI)
lets you find the exact type of an object when you have a reference to only the
base type. Normally, you’ll want to intentionally ignore the exact type of
an object and let Java’s dynamic binding mechanism (polymorphism)
implement the correct behavior for that type. But occasionally it is very
helpful to know the exact type of an object for which you have only a base
reference. Often this information allows you to perform a special-case operation
more efficiently. This chapter explains what RTTI is for, how to use it and how
to get rid of it when it doesn’t belong there. In addition, the Java
reflection mechanism is introduced.
Chapter 13: Creating Windows and
Applets
Java comes with the “Swing”
GUI library, which is a set of classes that handle windowing in a portable
fashion. These windowed programs can either be applets or stand-alone
applications. This chapter is an introduction to Swing and the creation of World
Wide Web applets. The important “Java Beans” technology is
introduced. This is fundamental for the creation of Rapid-Application
Development (RAD) program-building tools.
Chapter 14: Multiple Threads
Java provides a built-in facility to
support multiple concurrent subtasks, called threads, running within a
single program. (Unless you have multiple processors on your machine, this is
only the appearance of multiple subtasks.) Although these can be used
anywhere, threads are most apparent when trying to create a responsive user
interface so, for example, a user isn’t prevented from pressing a button
or entering data while some processing is going on. This chapter looks at the
syntax and semantics of multithreading in Java.
Chapter 15: Distributed Computing
All the Java features and libraries seem
to really come together when you start writing programs to work across networks.
This chapter explores communication across networks and the Internet, and the
classes that Java provides to make this easier. It introduces the very important
concepts of Servlets and JSPs (for server-side programming),
along with Java DataBase Connectivity (JDBC), and Remote Method
Invocation (RMI). Finally, there’s an introduction to the new
technologies of JINI, JavaSpaces, and Enterprise JavaBeans
(EJBs).
Appendix A: Passing & Returning
Objects
Since the only way you talk to objects in
Java is through references, the concepts of passing an object into a function
and returning an object from a function have some interesting consequences. This
appendix explains what you need to know to manage objects when you’re
moving in and out of functions, and also shows the String class, which
uses a different approach to the problem.
Appendix B: The Java Native
Interface (JNI)
A totally portable Java program has
serious drawbacks: speed and the inability to access platform-specific services.
When you know the platform that you’re running on, it’s possible to
dramatically speed up certain operations by making them native methods,
which are functions that are written in another programming language (currently,
only C/C++ is supported). This appendix gives you enough of an introduction to
this feature that you should be able to create simple examples that interface
with non-Java code.
Appendix C: Java Programming
Guidelines
This appendix contains suggestions to
help guide you while performing low-level program design and writing
code.
Appendix D: Recommended
Reading
I’ve discovered that simple
exercises are exceptionally useful to complete a student’s understanding
during a seminar, so you’ll find a set at the end of each
chapter.
Most exercises are designed to be easy
enough that they can be finished in a reasonable amount of time in a classroom
situation while the instructor observes, making sure that all the students are
absorbing the material. Some exercises are more advanced to prevent boredom for
experienced students. The majority are designed to be solved in a short time and
test and polish your knowledge. Some are more challenging, but none present
major challenges. (Presumably, you’ll find those on your own—or more
likely they’ll find
you).
There are two multimedia CDs associated
with this book. The first is bound into the book itself: Thinking in C,
described at the end of the preface, which prepares you for the book by bringing
you up to speed on the necessary C syntax you need to be able to understand
Java.
A second
Multimedia CD ROM is available,
which is based on the contents of the book. This CD ROM is a separate product
and contains the entire contents of the week-long “Hands-On
Java” training seminar. This is more than 15 hours of lectures that I have
recorded, synchronized with hundreds of slides of information. Because the
seminar is based on this book, it is an ideal accompaniment.
The CD ROM contains all the lectures
(with the important exception of personalized attention!) from the five-day
full-immersion training seminars. We believe that it sets a new standard for
quality.
The Hands-On Java CD ROM is available
only by ordering directly from the Web site
www.BruceEckel.com.
All the source code for this book is
available as copyrighted freeware, distributed as a single package, by visiting
the Web site www.BruceEckel.com. To make sure that you get the most
current version, this is the official site for distribution of the code and the
electronic version of the book. You can find mirrored versions of the electronic
book and the code on other sites (some of these sites are found at
www.BruceEckel.com), but you should check the official site to ensure
that the mirrored version is actually the most recent edition. You may
distribute the code in classroom and other educational
situations.
The primary goal of the copyright is to
ensure that the source of the code is properly cited, and to prevent you from
republishing the code in print media without permission. (As long as the source
is cited, using examples from the book in most media is generally not a
problem.)
//:! :CopyRight.txt Copyright ©2000 Bruce Eckel Source code file from the 2nd edition of the book "Thinking in Java." All rights reserved EXCEPT as allowed by the following statements: You can freely use this file for your own work (personal or commercial), including modifications and distribution in executable form only. Permission is granted to use this file in classroom situations, including its use in presentation materials, as long as the book "Thinking in Java" is cited as the source. Except in classroom situations, you cannot copy and distribute this code; instead, the sole distribution point is http://www.BruceEckel.com (and official mirror sites) where it is freely available. You cannot remove this copyright and notice. You cannot distribute modified versions of the source code in this package. You cannot use this file in printed media without the express permission of the author. Bruce Eckel makes no representation about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty of any kind, including any implied warranty of merchantability, fitness for a particular purpose or non-infringement. The entire risk as to the quality and performance of the software is with you. Bruce Eckel and the publisher shall not be liable for any damages suffered by you or any third party as a result of using or distributing software. In no event will Bruce Eckel or the publisher be liable for any lost revenue, profit, or data, or for direct, indirect, special, consequential, incidental, or punitive damages, however caused and regardless of the theory of liability, arising out of the use of or inability to use software, even if Bruce Eckel and the publisher have been advised of the possibility of such damages. Should the software prove defective, you assume the cost of all necessary servicing, repair, or correction. If you think you've found an error, please submit the correction using the form you will find at www.BruceEckel.com. (Please use the same form for non-code errors found in the book.) ///:~
You may use the code in your projects and
in the classroom (including your presentation materials) as long as the
copyright notice that appears in each source file is
retained.
In the text of this book, identifiers
(function, variable, and class names) will be set in bold. Most keywords
will also be set in bold, except for those keywords that are used so much that
the bolding can become tedious, such as “class.”
I use a particular coding style for the
examples in this book. This style follows the style that Sun itself uses in
virtually all of the code you will find at its site (see
http://java.sun.com/docs/codeconv/index.html), and seems to be supported
by most Java development environments. If you’ve read my other works,
you’ll also notice that Sun’s coding style coincides with
mine—this pleases me, although I had nothing to do with it. The subject of
formatting style is good for hours of hot debate, so I’ll just say
I’m not trying to dictate correct style via my examples; I have my own
motivation for using the style that I do. Because Java is a free-form
programming language, you can continue to use whatever style you’re
comfortable with.
The programs in this book are files that
are included by the word processor in the text, directly from compiled files.
Thus, the code files printed in the book should all work without compiler
errors. The errors that should cause compile-time error messages are
commented out with the comment //! so they can be easily discovered and
tested using automatic means. Errors discovered and reported to the author will
appear first in the distributed source code and later in
updates of the book (which will also
appear on the Web site
www.BruceEckel.com).
I generally rely on the Sun
implementation of Java as a reference when determining whether behavior is
correct.
Over time, Sun has released three major
versions of Java: 1.0, 1.1 and 2 (which is called version 2 even though the
releases of the JDK from Sun continue to use the numbering scheme of 1.2, 1.3,
1.4, etc.). Version 2 seems to finally bring Java into the prime time, in
particular where user interface tools are concerned. This book focuses on and is
tested with Java 2, although I do sometimes make concessions to earlier features
of Java 2 so that the code will compile under Linux (via the Linux JDK that was
available at this writing).
If you need to learn about earlier
releases of the language that are not covered in this edition, the first edition
of the book is freely downloadable at www.BruceEckel.com and is also
contained on the CD that is bound in with this book.
One thing you’ll notice is that,
when I do need to mention earlier versions of the language, I don’t use
the sub-revision numbers. In this book I will refer to
Java 1.0, Java 1.1, and Java 2
only, to guard against typographical errors produced by
further sub-revisioning of these
products.
My company provides five-day, hands-on,
public and in-house
training
seminars based on the material in this book. Selected material from each chapter
represents a lesson, which is followed by a monitored exercise period so each
student receives personal attention. The audio lectures and slides for the
introductory seminar are also captured on CD ROM to provide at least some of the
experience of the seminar without the travel and expense. For more information,
go to www.BruceEckel.com.
My company also provides consulting,
mentoring and walkthrough services to help guide your project through its
development cycle—especially your company’s first Java project.
No matter how many tricks a writer uses
to detect errors, some always creep in and these often leap off the page for a
fresh reader.
There is an error submission form linked
from the beginning of each chapter in the HTML version of this book (and on the
CD ROM bound into the back of this book, and downloadable from
www.BruceEckel.com) and also on the Web site itself, on the page for this
book. If you discover anything you believe to be an error, please use
this form to submit the error along with your suggested correction. If
necessary, include the original source file and note any suggested
modifications. Your help is
appreciated.
The cover of Thinking in Java is
inspired by the American Arts & Crafts Movement, which began near the turn
of the century and reached its zenith between 1900 and 1920. It began in England
as a reaction to both the machine production of the Industrial Revolution and
the highly ornamental style of the Victorian era. Arts & Crafts emphasized
spare design, the forms of nature as seen in the art nouveau movement,
hand-crafting, and the importance of the individual craftsperson, and yet it did
not eschew the use of modern tools. There are many echoes with the situation we
have today: the turn of the century, the evolution from the raw beginnings of
the computer revolution to something more refined and meaningful to individual
persons, and the emphasis on software craftsmanship rather than just
manufacturing code.
I see Java in this same way: as an
attempt to elevate the programmer away from an operating-system mechanic and
toward being a “software craftsman.”
Both the author and the book/cover
designer (who have been friends since childhood) find inspiration in this
movement, and both own furniture, lamps, and other pieces that are either
original or inspired by this period.
The other theme in this cover suggests a
collection box that a naturalist might use to display the insect specimens that
he or she has preserved. These insects are objects, which are placed within the
box objects. The box objects are themselves placed within the “cover
object,” which illustrates the fundamental concept of aggregation in
object-oriented programming. Of course, a programmer cannot help but make the
association with “bugs,” and here the bugs have been captured and
presumably killed in a specimen jar, and finally confined within a small display
box, as if to imply Java’s ability to find, display, and subdue bugs
(which is truly one of its most powerful
attributes).
Thanks to the Doyle Street Cohousing
Community for putting up with me for the two years that it took me to write the
first edition of this book (and for putting up with me at all). Thanks very much
to Kevin and Sonda Donovan for subletting their great place in gorgeous Crested
Butte, Colorado for the summer while I worked on the book. Also thanks to the
friendly residents of Crested Butte and the Rocky Mountain Biological Laboratory
who made me feel so welcome.
Thanks to Claudette Moore at Moore
Literary Agency for her tremendous patience and perseverance in getting me
exactly what I wanted.
My first two books were published with
Jeff Pepper as editor at Osborne/McGraw-Hill. Jeff appeared at the right place
and the right time at Prentice-Hall and has cleared the path and made all the
right things happen to make this the most pleasant publishing experience
I’ve ever had. Thanks, Jeff—it means a lot to me.
I’m especially indebted to Gen
Kiyooka and his company Digigami, who graciously provided my Web server for the
first several years of my presence on the Web. This was an invaluable learning
aid.
Thanks to Cay Horstmann (co-author of
Core Java, Prentice Hall, 2000), D’Arcy Smith (Symantec),
and Paul Tyma (co-author of Java Primer Plus, The Waite Group, 1996), for
helping me clarify concepts in the language.
Thanks to people who have spoken in my
Java track at the Software Development Conference, and students in my seminars,
who ask the questions I need to hear in order to make the material more
clear.
Special thanks to Larry and Tina
O’Brien, who helped turn my seminar into the original Hands-On Java
CD ROM. (You can find out more at
www.BruceEckel.com.)
Lots of people sent in corrections and I
am indebted to them all, but particular thanks go to (for the first edition):
Kevin Raulerson (found tons of great bugs), Bob Resendes (simply incredible),
John Pinto, Joe Dante, Joe Sharp (all three were fabulous), David Combs (many
grammar and clarification corrections), Dr. Robert Stephenson, Franklin Chen,
Zev Griner, David Karr, Leander A. Stroschein, Steve Clark, Charles A. Lee,
Austin Maher, Dennis P. Roth, Roque Oliveira, Douglas Dunn, Dejan Ristic, Neil
Galarneau, David B. Malkovsky, Steve Wilkinson, and a host of others.
Prof. Ir. Marc Meurrens put in a great
deal of effort to publicize and make the electronic version of the first edition
of the book available in Europe.
There have been a spate of smart
technical people in my life who have become friends and have also been both
influential and unusual in that they do yoga and practice other forms of
spiritual enhancement, which I find quite inspirational and instructional. They
are Kraig Brockschmidt, Gen Kiyooka, and Andrea Provaglio, (who helps in the
understanding of Java and programming in general in Italy, and now in the United
States as an associate of the MindView team).
It’s not that much of a surprise to
me that understanding Delphi helped me understand Java, since there are many
concepts and language design decisions in common. My Delphi friends provided
assistance by helping me gain insight into that marvelous programming
environment. They are Marco Cantu (another Italian—perhaps being steeped
in Latin gives one aptitude for programming languages?), Neil Rubenking (who
used to do the yoga/vegetarian/Zen thing until he discovered computers), and of
course Zack Urlocker, a long-time pal whom I’ve traveled the world
with.
My friend Richard Hale Shaw’s
insights and support have been very helpful (and Kim’s, too). Richard and
I spent many months giving seminars together and trying to work out the perfect
learning experience for the attendees. Thanks also to KoAnn Vikoren, Eric
Faurot, Marco Pardi, and the rest of the cast and crew at MFI. Thanks especially
to Tara Arrowood, who re-inspired me about the possibilities of
conferences.
The book design, cover design, and cover
photo were created by my friend Daniel Will-Harris, noted author and designer
(www.Will-Harris.com), who used to play with rub-on letters in junior
high school while he awaited the invention of computers and desktop publishing,
and complained of me mumbling over my algebra problems. However, I produced the
camera-ready pages myself, so the typesetting errors are mine.
Microsoft® Word 97 for Windows was used to write the book and to
create camera-ready pages. The body typeface is Georgia and the headlines
are in Verdana. The cover typeface is ITC Rennie
Mackintosh.
Thanks to the vendors who created the
compilers: Borland, the Blackdown group (for Linux), and of course,
Sun.
A special thanks to all my teachers and
all my students (who are my teachers as well). The most fun writing teacher was
Gabrielle Rico (author of Writing the Natural Way, Putnam, 1983).
I’ll always treasure the terrific week at Esalen.
The supporting cast of friends includes,
but is not limited to: Andrew Binstock, Steve Sinofsky, JD Hildebrandt, Tom
Keffer, Brian McElhinney, Brinkley Barr, Bill Gates at Midnight Engineering
Magazine, Larry Constantine and Lucy Lockwood, Greg Perry, Dan Putterman,
Christi Westphal, Gene Wang, Dave Mayer, David Intersimone, Andrea Rosenfield,
Claire Sawyers, more Italians (Laura Fallai, Corrado, Ilsa, and Cristina
Giustozzi), Chris and Laura Strand, the Almquists, Brad Jerbic, Marilyn
Cvitanic, the Mabrys, the Haflingers, the Pollocks, Peter Vinci, the Robbins
Families, the Moelter Families (and the McMillans), Michael Wilk, Dave Stoner,
Laurie Adams, the Cranstons, Larry Fogg, Mike and Karen Sequeira, Gary
Entsminger and Allison Brody, Kevin Donovan and Sonda Eastlack, Chester and
Shannon Andersen, Joe Lordi, Dave and Brenda Bartlett, David Lee, the
Rentschlers, the Sudeks, Dick, Patty, and Lee Eckel, Lynn and Todd, and their
families. And of course, Mom and
Dad.
Thanks to those who helped me rewrite the
examples to use the Swing library: Jon Shvarts, Thomas Kirsch, Rahim Adatia,
Rajesh Jain, Ravi Manthena, Banu Rajamani, Jens Brandt, Nitin Shivaram, and
everyone who expressed support. This really helped me jump-start the
project.