Any book that has endured through eight editions must have more than longevity in its favor. In the case of this work, it has completeness of treatment, attentiveness to the needs of the reader, a well-paced exposition of topics, a conversational style, and a presentation that uses graphics and text to complement each other. These characteristics combine to form a book that could serve as a textbook in a college-level course devoted to Java or to object-oriented programming, or as a guide to enable programmers familiar with C or C++ make the transition to Java. Those already familiar with Java will find it helpful in mastering the Java Platform, Standard Edition (Java SE) 6.
The authors demonstrate care in guiding the reader from the very first chapter, which succinctly introduces Java by discussing the Java White Paper, outlining a brief history of the language, and pointing out some common misconceptions about the language. The treatment of these matters is among the best available, and it provides a conceptual foundation for what follows.
The 13 chapters that follow blend conceptual care with operational care, and this is especially evident in the chapter on the Java programming environment. The authors guide the reader through the installation of the Java Development Kit (JDK), through compiling and running a program using the command line and then using an integrated development environment, and through a demonstration of applets. The graphically highlighted notes, a hallmark of the book as a whole, point out traps and pitfalls, and the entire chapter succeeds in easing a user through some of the most frustrating aspects of learning a new language in a new environment.
The chapter on the programming environment is followed by one on fundamental programming structures in Java. It covers a considerable number of topics, each of which is presented in the context of Java rather than in that of programming in general. The chapter covers ground quickly, and users, especially students, not familiar with such topics as data types and control flow will need to find amplification for these essential concepts.
The next three chapters, which cover objects and classes, inheritance, and inner and outer classes, form the conceptual and operational heart of the book, and they reveal that the major concern of the book is to explain and illustrate object-oriented programming. It achieves this goal with remarkable clarity and comprehensiveness. It blends theory with concrete examples, and it devotes considerable space to walking through programs to identify the thinking that drives them. Although some of the concepts will be slippery for novices and experienced procedural programmers alike, the authors’ careful explication of programs eases the way through a thicket of concepts and constructs such as inheritance, constructors and mutators, abstract classes, and interfaces.
Another tightly bound, three-chapter sequence addresses graphical programming, and it does so largely within Swing, a graphics interface library that is part of the standard library in Java SE. These chapters on graphics programming, event handling, and using interface components with Swing immerse the reader in such topics as event handling, creating frames, building menus, and layout management. As elsewhere in this text, the detailed, well-paced explanations of programs enable the reader to grasp numerous concepts fairly quickly.
The balance of the book covers deploying applications and applets, exceptions and debugging, generic programming, collections, and multithreading. The chapter on deploying applications provides a particularly striking example of how helpful tips on implementation details can be, in that the tips avoid frustrating problems such as having Swing components behave incorrectly because a class has not been extended. Attention to these details, though, does not obscure the motive for the chapter: to describe and to distinguish between applications and applets.
The chapter on error handling illustrates a concern that permeates the book. Although it does discuss errors, exception handling, and debugging, it emphasizes the difference between Java’s treatment of these issues and that of C and C++. The assumption is that readers are familiar with the concepts, but that these concepts need to be particularized with respect to Java.
Generic programming presents some difficulties that are not easily surmounted in an introductory book, but the authors manage to explain and illustrate generic programming in an exemplary manner. Nonetheless, it is nearly impossible not to be bogged down when discussing things such as reflection, wildcard types, and supertype bounds.
The book concludes with chapters on collections and multithreading. The authors discuss collections in terms of both theoretical issues in language design and in terms of such practical algorithms as binary search and sorting. The chapter on threads thoroughly covers the subject in a way that will benefit novices and seasoned programmers alike.
In sum, this volume covers a vast breadth of material with relative ease, and with a successful balance of thoroughness and clarity.
