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). I’ll be introducing the
concepts of object-oriented programming 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 the past few years (and now also 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 http://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 a seminar handout – 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 which parts were difficult and 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 be introduced
to 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 also
learn about 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 “handle” 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; 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
and 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. In addition, 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. Once you’ve seen polymorphism,
the interface can be clearly understood. This chapter also introduces Java 1.1
inner classes.
Chapter 8: 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 tools that Java supplies
to hold objects while you’re working with them: the simple arrays and more
sophisticated collections (data structures) such as Vector and
Hashtable. Finally, the new and improved Java 1.2 collections library is
explored in depth.
Chapter 9: 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 10: The Java IO
system
Theoretically, you can divide any
program into three parts: input, process, and output. This implies that IO
(input/output) is a pretty 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 1.1 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 in Java version 1.1.
Also, Java 1.1’s compression libraries, which are used in the Java ARchive
file format (JAR), are examined.
Chapter 11: Run-time type
identification
Java run-time type identification
(RTTI) lets you find the exact type of an object when you have a handle 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
handle. 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 1.1
reflection feature is introduced.
Chapter 12: Passing and
returning objects
Since the only way you talk to
objects in Java is through “handles,” the concepts of passing an
object into a function and returning an object from a function have some
interesting consequences. This chapter 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.
Chapter 13: Creating windows
and applets
Java comes with the Abstract
Window Toolkit (AWT), which is a set of classes that handle windowing in
a portable fashion; these windowing programs can either be applets or
stand-alone applications. This chapter is an introduction to the AWT and the
creation of World Wide Web applets. We’ll also look at pros and cons of
the AWT and the GUI improvements introduced in Java 1.1. The important
“Java Beans” technology is introduced. This is fundamental for the
creation of Rapid-Application Development (RAD) program-building tools. Finally,
the new Java 1.2 “Swing” library is introduced – this provides
a dramatic improvement in UI components for Java.
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 powerful 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: Network
programming
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 the Internet, and the
classes that Java provides to make this easier. It also shows you how to create
a Java applet that talks to a common gateway interface (CGI) program,
shows you how to write CGI programs in C++ and covers Java 1.1’s Java
DataBase Connectivity (JDBC) and Remote Method Invocation
(RMI).
This chapter introduces the very
important and yet non-traditional “patterns” approach to program
design. An example of the design evolution process is studied, starting with an
initial solution and moving through the logic and process of evolving the
solution to more appropriate designs. You’ll see one way that a design can
materialize over time.
Chapter 17: Projects
This chapter includes a set of
projects that build on the material presented in this book, or otherwise
didn’t fit in earlier chapters. These projects are significantly more
complex than the examples in the rest of the book, and they often demonstrate
new techniques and uses of class libraries.
There are subjects that
didn’t seem to fit within the core of the book, and yet I find that I
discuss them during seminars. These are placed in the
appendices.
Appendix A: Using non-Java
code
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). There are other ways that Java supports non-Java code,
including CORBA. This appendix gives you enough of an introduction to these
features that you should be able to create simple examples that interface with
non-Java code.
Appendix B: Comparing
C++ and Java
If you’re a C++ programmer,
you already have the basic idea of object-oriented programming, and the syntax
of Java no doubt looks very familiar to you. This makes sense because Java was
derived from C++. However, there are a surprising number of differences between
C++ and Java. These differences are intended to be significant improvements, and
if you understand the differences you’ll see why Java is such a beneficial
programming language. This appendix takes you through the important features
that make Java distinct from C++.
Appendix C: Java programming
guidelines
This appendix contains suggestions
to help guide you while performing low-level program design and writing
code.
Appendix
D: Performance
This will allow you to find
bottlenecks and improve speed in your Java program.
Appendix E: A bit about
garbage collection
This appendix describes the
operation and approaches that are used to implement garbage
collection.
Appendix F: Recommended
reading
I’ve discovered that simple
exercises are exceptionally useful during a seminar to complete a
student’s understanding, 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).
To accompany this book a Multimedia
CD ROM is available separately, but this is not like the CDs that you’ll
usually find packaged with books. Those often only contain the source code for
the book. (The code for this book is freely downloadable from the Web site
www.BruceEckel.com.) 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 given by Bruce Eckel,
synchronized with 500 slides of information. The seminar is based on this book
so it is an ideal accompaniment.
The CD ROM contains two versions of
this book:
The CD ROM
contains over 600MB of content. We believe that it sets a new standard for
value.
The CD ROM contains everything in
the printable version of the book and everything (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.
All the source code for this book
is available as copyrighted freeware, distributed as a single package, by
visiting the Web site http://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 http://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 (c) Bruce Eckel, 1998 // Source code file from 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 email all // modified files with clearly commented changes to: // Bruce@EckelObjects.com. (Please use the same // address 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 seems to be supported by most Java
development environments. It was developed over a number of years, and was
inspired by Bjarne Stroustrup’s style in his
original The C++ Programming Language (Addison-Wesley, 1991;
2nd ed.). 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
http://www.BruceEckel.com).
Although I test the code in this
book with several different vendor implementations of Java, I generally rely on
the Sun implementation as a reference when determining whether behavior is
correct.
By the time you read this, Sun will
have released three major versions of Java: 1.0, 1.1 and 1.2 (Sun says it will
make a major release about every nine months!). Version 1.1 represents a
significant change to the language and should probably have been labeled 2.0.
(And if 1.1 is such a big change from 1.0, I shudder to think what will justify
the number 2.0.) However, it’s version 1.2 that seems to finally bring
Java into the prime time, in particular where user interface tools are
concerned.
This book covers versions 1.0, 1.1
and selected parts of 1.2, although in situations where a new approach is
clearly superior to the old, I definitely favor the new approach, often choosing
to teach the better approach and completely ignore the old approach. However,
there are some cases where it’s unavoidable to teach the old approach
before the new, in particular with the AWT, since not only is there a lot of old
Java 1.0 code out there, but some platforms still support only Java 1.0. I will
try to be scrupulous about pointing out which features belong to which
version.
One thing you’ll notice is
that I don’t use the sub-revision numbers. At this writing, the released
version of 1.0 from Sun was 1.02 and the released version of 1.1 was 1.1.5 (Java
1.2 was in beta). In this book I will refer to Java 1.0,
Java 1.1 and Java 1.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 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:
http://www.BruceEckel.com
or
email:
Bruce@EckelObjects.com
My company also provides consulting
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. If you discover anything you believe to be an error, please
send the original source file (which you can find at
http://www.BruceEckel.com) with a clearly commented error
(following the form shown on the Web page) and suggested correction via
electronic mail to Bruce@EckelObjects.com so that it might be fixed in
the electronic version on the Web site and in the next printing of the book.
When you submit a correction, please use the following format:
find: one-line string to search for comment: multi-line comment, best starting with "here's how I think it should read" ###
Where the ‘###’ is to
indicate the end of comment. This way, my correction tools can do a
“find” using the original text, and your suggested correction will
pop up in a window next to it.
Suggestions for additional
exercises or requests to cover specific topics in the next edition are welcome.
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 impending 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
towards 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, placed within
the box objects which 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).
First of all, thanks to the Doyle
Street Cohousing Community for putting up with me for the two years that it took
me to write 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. The World Gym in Emeryville and its enthusiastic
staff helped keep me sane during the final months of the book.
This is my first experience using
an agent, and I’m not looking back. 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 have graciously provided my Web
server, and to Scott Callaway who has maintained it. This has been an invaluable
aid while I was learning about the Web.
Thanks to Cay Horstmann (co-author
of Core Java, Prentice Hall 1997), 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 turned this book and my seminar into a teaching CD ROM. (You
can find out more at http://www.BruceEckel.com.)
Lots of people sent in corrections
and I am indebted to them all, but particular thanks go to: 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 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’re vegetarians, 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.
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 but 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, Deborah Sommers, Julie Shaw, Nicole Freeman, Cindy Blair, Barbara
Hanscome, Regina Ridley, Alex Dunne, and the rest of the cast and crew at
MFI.
The book design, cover design, and
cover photo were created by my friend Daniel Will-Harris, noted author and
designer (http://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 Bitstream Carmina
and the headlines are in Bitstream Calligraph 421
(www.bitstream.com). The symbols at the start of each chapter are
Leonardo Extras from P22 (http://www.p22.com). The cover typeface
is ITC Rennie Mackintosh.
Thanks to the vendors who supplied
me with compilers: Borland, Microsoft, Symantec, Sybase/Powersoft/Watcom, 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.