My first impression of this book was irritation: the title implies a broad exposure to Android, but such exposure is in fact virtually absent from the index or the table of contents. The prefatory text pays lip service to the mobile platform, and the content ignores it almost completely. My initial antagonism was premature. Between the covers is a thoughtful introduction to the latest version of Java, and the book is well capable of standing on its own merits. (However, having such a reaction provokes a boo and a hiss for the marketing machinery that conceived of such a misleading title.)
The printed book is only some of the content that Friesen has prepared. He explains that the practical necessities of paperback printing have limited the printed work to ten chapters and an appendix; six more chapters will be available as portable document formats (PDFs) on his Web site.
The user level of this work is editorially described as for beginners. Yet the first code example, rather than the traditional “Hello World,” dumps the command-line arguments to standard output. This is representative of the tone of the book. It is for beginners only to the extent that it covers Java for coders who may not be familiar with this language. Even so, this is not an introduction to programming at large, incidentally using Java as a simple learning tool. Readers should be somewhat familiar with the theory, concepts, and practice of writing object-oriented code prior to approaching this book. Basically, it presents Java as a professional programming environment rather than as a learn-to-code language.
The introductory chapter, besides repeatedly supercharging “Hello World,” includes a glance at a couple of popular and free integrated development environments (IDEs) for Java. The second chapter covers Java fundamentals. The third chapter is an overview of object-oriented programming for Java. Chapters 4 and 5 delve, in some depth, into many not-so-fundamental features of Java (for example, inner classes, generics, and annotations). Chapters 6 through 10 investigate and explain several packages that make up part of the rich Java application programming interface (API), comprising the obligatory collection framework and fearlessly including topics such as reflection, references, and concurrency APIs. Missing (even from the list of PDFs) is any real information about Abstract Window Toolkit (AWT) and Swing.
The subject matter is presented in a clear style that is refreshingly concise and well organized. There are code snippets of adequate length and complexity to illustrate the use of possibly arcane APIs and bring their meaning and usage to bear for real applications. All treatment is current up to Java, Standard Edition (SE) 6, including the localization enhancements in that release. There are necessary notes of the small incompatibilities between what Android supports and what Java 6 would require. All of the example code is available for download from the publisher’s Web site (http://www.apress.com/9781430231561). Each chapter includes a set of exercises to assess one’s own progress; the appendix includes solutions to the exercises.
Overall, Friesen competently presents how to wield Java SE 6 in a professional setting in order to accomplish both common tasks and less simple ones (for instance, how to manage caches). The provided material appears to be enhanced by additional downloads that, if of the same quality as the book, are obligatory reading for developers who are new to Java. Covering Android is only a very minor goal of this work, contrary to what the title would imply. This may or may not be a drawback, depending on the reader’s ultimate goal.