This book encourages the reader to not only learn Java, but to
approach software development problems from the point of view of a
language that, from its inception, incorporated object orientation
(OO), concurrency, garbage collection, and portability as its most
important characteristics.

The book is composed of 16 chapters, which cover almost all aspects of
Java programming, starting from the language’s foundations, and
progressing toward more advanced themes. The author includes practical
examples, based on the Java 2 specification and JDK 1.4, and proposes
exercises at the end of each chapter. The book is not recommended as a
basic programming book; the concepts presented presuppose that the
reader has experience with programming languages.

The included CDROM, “Foundations for Java,” contains HTML
versions of the two first editions of the book, and some topics not 
included in the 3rd. No sources for the examples are included on the 
CD, but these can be accessed on the author’s Web site.

Chapters 1 and 2 present an overview of the topics presented later on
in the book. This introduction to object-oriented programming (OOP)
takes as its premise the idea that “all is an object.” This
principle must be assimilated by the reader before moving deeper into
Java.

In chapter 3, the author provides a complete overview of Java syntax,
and its basic control structures. Chapter 4 presents themes related to
OOP, beginning with object initialization and destruction. This is the
first difference noted when comparing Java with other programming
languages: garbage collection is viewed as a main characteristic of
the language.

Chapters 5, 6, and 7 present classic OOP concepts from the point of
view of Java, namely hiding information, reusing classes, and
polymophism. (Don’t confuse this book with others of the type
“Learning OOP with...”: OO is inherent to Java). The book
presents these chapters in a practical way, so the reader is
encouraged to interact with the examples and exercises. Eckel covers
the topics in a clear manner, in particular when talking about
polymorphism, despite the fact that this topic is complicated to
understand.

The level of abstraction in the text increases in chapter 8, as the
text begins to address advanced design topics. The concepts of
“interface” and “inner classes,” which are some of the
most relevant things in Java relating to other programming languages
like C and C++, are presented. Developers who are very familiar
with the use of abstract methods and callbacks may find these 
high-level concepts interesting.

The remaining chapters develop themes that programmers must pay
attention to when developing more robust systems. In chapter 9, error
handling by controlling exceptions is presented. The examples in this
chapter are well formulated, and teach readers how to lead with different
kinds of exceptions. Useful recommendations are made at the end of the
chapter; readers will benefit from considering these during their
development stage.

After a brief presentation of Java resources for RTTI in chapter 10,
chapter 11 addresses containers. Readers who are familiar with other
libraries, like the C++ Standard Template Library (STL), will find it
easy to follow this chapter: the examples are sufficient, and the text
includes a complete overview of Java container families, including
Arrays, Collections, Lists, Maps, Stacks, and Bitsets.

Java input/output (I/O) systems, and resources for concurrent
programming, are addressed extensively in chapters 12 and 13. Both
topics are foundations of the Java language. The author’s
discussion will prove useful to programmers who are seeking to better
exploit these resources. The explanation of I/O system includes topics
about object serialization and data compression. The chapter about
concurrency is particularly good; issues about threads, critical
sections, and shared resources are explained with clarity. The concept
of deadlocks is excellently illustrated using the classical “dining
philosophers” problem.

The creation of graphical user interfaces (GUIs) with Java 2 Swing is
addressed in chapter 14, as is the concept of an application framework
for constructing applets. The text provides a complete overview of
Swing components, from simple buttons to clipboards. Questions about
concurrency are addressed, and a comparison to Java Beans is made.

The last part (chapters 15 and 16) covers techniques for finding and
solving problems during the design and development phases with Java. A
review of the resources that Java includes, for unit testing, design
by contracts, logging, debugging, profiling, versions control, and
project management, is presented. These chapters also include useful
guidelines to follow when using Java professionally.

This book is definitely a good tool for discovering Java’s OO
world, and will be a complete resource for technical information for
those who seek to develop advanced applications with Java.