Effective Java: Programming Language Guide (Java Series) (Paperback)

I've been working full-time in Java since 1995, prior to version 1.0. I've also written books and articles on Java and have been teaching Java at the University level as a sideline for four years. In that time I've accumulated a great deal of "expert" knowledge about the language, the JVM, and the APIs and developed opinions on the best approaches to use in Java. At this point, reading books such as this that contain a collection of tips and advice I am usually satisfied to gain one new piece of knowledge; I learned at least six new things from this book.

Of the 50+ books on Java I've read, this book contains by far the most comprehensive and useful collection of that hard-won knowledge of core Java. The bonus is the clear and concise manner in which it is presented.

Bloch is dead-on. There isn't a single factual error or piece of bad advice in the book. The most I came up with were a couple of omissions on some of the topics. However, omissions are inevitable given the technical depth of some of the topics Bloch covers, such as serialization, exceptions and threads.

I offer only two caveats about the book. The first is that the book is for advanced Java programmers. This is not to say that this information is not useful to every Java programmer, but you need to have a comprehensive knowledge of Java in order to appreciate many of the topics. This book does not provide comprehensive coverage, but rather fills in the detail and subtleties. I teach a Java IV class and recommend this to my students as additional reading after completing the class.

The other caveat is that this book is written from the perspective of writing public APIs. Bloch is the lead architect for the core JDK APIs where the classes and APIs have special security considerations. Several pieces of advice he gives apply absolutely to a public API where you want to defend the API from malicious code. However, if the code you are creating is intended for a less hostile and more trusting environment, fully following all of his advice will result in unnecessarily complex code. The one knock I give to the book is that Bloch does not delineate the circumstances that would dictate following his rather rigorous approach to bullet-proofing an API and can leave the reader with the mistaken perception that the advice applies equally to all categories of code.

Overall, this is absolutely a must-have book for the experienced Java programmer. Even if you are not yet an advanced Java programmer, buy this book and keep revisiting it as you advance until everything in the book makes sense to you.

The book contains 57 suggestions on what to do or not to do when writing Java code. Most are common sense, though not all -- the material on serialization was new to me, for example. But it's common sense that's developed over time, and much of it is not obvious until you have a lot of experience using the language. Even then, it's worth reading; I consider myself a fairly experienced Java programmer, and I'd say that a quarter of the book was new material for me. Even when I knew a technique he was recommending, it was really good to read the arguments Bloch made for doing something in a particular way. And I found that I agree with almost everything he wrote.

The book is very Java-specific. Some of the tips generalize to other, similar, object-oriented languages, or to systems with similar thread models, but, by and large, this is nitty gritty Java hacking. I like that: it allows Block to be concrete in what he says. And, unlike most of the stuff written by JavaSoft employees, this book does not try to pretend that Java is flawless, which is a refreshing perspective; see, for example, his discussion of the Cloneable interface.

What's best about the book is that it encodes a lot of the lore and feel of the language: how to use it in practice.

If you're working in Java, it belongs on your shelf next to the language specification, and those are the only two general books on the language you should need.

It's definitely not a beginners book, this is the book that core Java developers
should memorize by heart. This book is written by the Sun expert who both
design and develop Java run-time libraries (Collections, in particular, which is
one of the prettiest species in Java) and is definitely aware of their successes
and failures. Out of his experience Joshua brings hundreds of "how about this"
unexpectable situations - those I doubt you was ever thinking of before.

It contains 57 issues covering topics about:
- creating objects (how about static factories vs constructors ?)
- methods common to all objects (ever thought that overriding clone, equals, hashCode
and toString is easy ?),
- designing interfaces of your classes and interfaces (ever realized how immutability
is important ? ever wondered which one of the inner classes fits best ?)
- substitutes to C constructs (don't say there are no unions and enums in Java)
- general programming and methods (ever knew that overloading is dangerous in
it's nature and that ( 1.00 - ( 9 * 0.1 )) != 0.1 ?)
- exceptions (ever wondered how should you react to some particular failure -
terminate the JVM, throw the exception [which one ?], return null ?)
- threads (ever thought that double check locking is broken and that notify() is
more dangerous than notifyAll() anh what are 'alien' methods that cause deadlocks ?)
- serialization (making your object serializable should never be just declaring
it this way ! How about readResolve() and defensive readObject() ?)

Amazingly - this book contains tons of essential information but Joshua's
succinct style simple put it into 230 pages and 57 items. I don't think there's
any sentence or chapter you may ignore - every word author says worths remembering
very good and very carefully. I read it once but I'm definitely going to re-read
it once in a while.

If you need other proofs - just believe me that most of the Java articles on
JavaWorld and JDC reference this book in that or another way. If James Gosling is
saying "Some might think that I don't need any Java books, but I need this one",
doesn't it mean that you and me definitely need it too ?
I wish I could give it 6 starts, really.

Happy reading !