Authors: Cay S. Horstmann
Publisher: Addison Wesley
Audience: Smart programmers wanting in-depth coverage
Reviewer: Mike James
The key to this book is the word "impatient" in the title. What does this mean exactly?
In this case it seems to mean "expert programmer but not necessarily in Java". This is not a book for the beginner. It might even not be a book for the advanced Java programmer. This is a book that simply tells many programmers far more than they want to know at a speed that may be far too fast.
On the other hand, if you really are smart and want to know a lot about Java this is a short sharp way to find out.
The first chapter starts out gently enough - "hello world", primitive types, variables and so on, but then it ramps up to Strings, flow of control, arrays, array list and using functions. In this one chapter you get what would be spread out over three or more chapters in a typical introduction to Java. The presentation is straightforward and direct, no spoon feeding, and there are lots of boxouts that speak about issues that if you were new to programming you would have little idea about.
Chapter 2 moves on to object oriented programming and again if you don't have any idea what objects are all about this will be too difficult. It introduces get/set methods, instance variables, static variables, this, the complexities of constructors and factory methods. To give you some idea how precise this all is the distinction between static nested and inner classes is described.
The next chapter is where you might start to get a little worried about the overall structure of the book. For some reason it deals with interfaces and lambda expression. The book does deal with Java 8 features as it goes along and not as if they had been tacked on to an earlier edition, but why deal with interfaces and lambda expressions in the same chapter? This is really two chapters stuck together. If you can ignore this, which is easy enough to do, then the description of both interfaces and lambda expressions is good.
Chapter 4 deals with inheritance and reflection and again it isn't clear why these two are jammed together. This is all fairly standards stuff - overriding, casts, abstract methods and so on. I was slightly amused to see the Object class being referred to as the Cosmic Superclass, but it makes the point. The topic of reflection is only discussed in the last part of the chapter and again why this wasn't split into two smaller chapters is a mystery.
Next we have exceptions, assertions and logging which are topics that do hang together for a coherent chapter but they probably could wait until later in the book because Chapter 6 on generic programming is the one that should follow inheritance and reflection. This is a good introduction to generics which explains why type erasure, the mechanism used to implement generics in Java results in so many restrictions on what you can do with them. Once you understand the mechanism it all becomes clear.
From Chapter 6 the book moves away from the Java language and into the classes that make up the library. Chapter 7 is on Collections, Chapter 8 covers Streams, Chapter 9 deals with I/O including regular expression and serialization, Chapter 10 is on concurrent programming, Chapter 11 is on Annotations, Chapter 12 is on the Date and Time API, and Chapter 13 is on internationalization. All these topics are described with a lot of attention to detail, but in many ways this is the least useful part of the book because using library classes is mostly straightforward - compared say to generics.
The book closes with a chapter on compiling and scripting and many will find this mostly irrelevant to their day-to-day use of Java. It covers the scripting API and using the Nashorn scripting engine for shell scripting.
While there are some minor issues with the organization, overall this is a good book. It is also really nice not to have to go over how things used to work before Java 8. As explained in the introduction, this is not a book for the beginner, but it is also not a book for someone who just wants to learnt he bare minimum and get on with writing programs. In this sense it isn't for the "impatient" but for the programmer wanting to understand in depth.
Highly recommended - but only if you can cope.