|Core Java for the Impatient, 3rd Ed|
Authors: Cay S. Horstmann
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 - something that really doesn't need worry the beginner.
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. 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 and it covers new features such as pattern matching instanceof/
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 penultimate 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 but the obsolete Nashorn engine covered in the previous edition is now ignored. The final chapter deals with modules and creating and using packages.
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 17 although the changes from the second edition are few.
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.
|Last Updated ( Tuesday, 28 March 2023 )|