Rating: 
Summary: absolutely the best general "advanced" java book
Review: Certainly the best java book I have read recently. It should be required reading for anyone with 3+ months of java experience. The next best book in this class is _Essential Java Style_ by Jeff Langr. Another, although somewhat dated, is _Java Design_ by Peter Coad.It is my hope that all java coders read this book and take the tips to heart. Stamp out annoying code!
Rating:
Summary: Effective Java Tutorial
Review: You have to love a book that over and over again points out really obvious things that you never really thought of before; those are the tips that are instantly memorable, and some of them are real head-whackers. Then there's all those other tips, some of them based in the various (good and bad) design decisions made in the core Java libs over the years, some of them based on esoteric pattern theory, some of them just downright clever, but there's not one of them I'd question. If you want to improve your java coding in a single weekend, or even improve your object oriented coding in any language, this book is money well spent.
Rating:
Summary: Read this now
Review: If you are a beginner leave it alone. If you have been in Java for more than six months read this book NOW! before you develop the bad habits that reading this book can educate you to avoid. I wish this book had been around five years ago when I started programming in Java but it was not. It has taken me all that time to acquire the knowledge contained in this book and a hell of a lot of hard work reading and coding. Now there really is no excuse for sloppy Java programming !
Rating:
Summary: Outstanding
Review: Excellent coverage, exploring nooks and crannies (important ones) of topics I thought familiar. Superb exploration of O-O topics and how they apply to Java. You definitely want Java programming experience before reading this book, however.
Rating:
Summary: True to Its Name
Review: This book is intended to follow in the footsteps of Scott Meyers' "Effective C++" books, and does a great job of it! The 57 (instead of Meyers' 50) topics are very well chosen, and the level of detail is excellent. Code examples, showing both the correct way and the wrong way to do things, are just the right length - complete enough to make their point, yet still nice and short. The items on equals(), clone(), and the typesafe enum pattern are worth the price of the book themselves. BTW, avoid the vastly inferior "Practical Java" - it's more of an introduction to Java, with much less detail, and many tips which will seem trivial to an experienced Java programmer.
Rating: 
Summary: Good book...
Review: Too bad Peter Haggar already wrote the same exact thing a year-and-a-half ago. See: Practical Java, Peter Haggar, Addison-Wesley, 1999, ISBN 0201616467
Rating:
Summary: An absolute must!
Review: Not for the absolute beginner, but anyone who cares about writing good java code really needs to read this book. A java programmer who doesn't read this book at least once a year should lose his qualifications ;-).
Rating:
Summary: Superb for non-novices
Review: This is not a book for novices, but for the experienced Java programmer who wants to become even better. It assumes a thorough knowledge of Java syntax and a fair amount of knowledge of the basic packages, such as java.util. There is a time and a place for "good enough" programming, and a time and a place for "doing it right." Bloch has been deeply involved in creating the official Java libraries, and is heavily biased toward doing it right. Fortunately, this is a bias he freely admits. Much of the emphasis is on making programs really flexible, really useful, and bulletproof. The book is organized as a series of 57 recommendations, but that doesn't tell the whole story. Bloch doesn't just recommend, but in most cases conclusively demonstrates just how essential it is to follow the recommendation. Moreover, many of the recommendations are richly detailed; for example, item 13, "Favor immutability," goes into considerable detail about just how naive attempts to make an object immutable can be circumvented, and how to really ensure immutability. Some of the recommendations, though important, are relatively commonplace; but there are others that I have seen nowhere else. The recommendations cover the gamut from general programming advice to highly Java-specific advice. Bloch's writing style is (mostly) excellent, and I found the book difficult to put down (and on my very short list of books to read a second time!). I highly recommend this book to anyone who has pretty much mastered the basics of Java programming.
Rating:
Summary: Hits the mark
Review: This is modeled on Scott Meyers' "Effective C++." There are fifty-seven items toward improving Java programs and their design. These are roughly grouped under nine chapter headings. Some of the items are covered elsewhere, but they do bear repeating. On the whole, this hits the mark. After the introduction, the next three chapters are "Creating and Destroying Objects," "Methods Common to All Objects," and "Classes and Interfaces." An example is item 8 in the chapter on methods common to all objects -- always override hashCode if you override equals. Otherwise, you're likely to violate the contract for Object.hashCode, specifically, the requirement that equal objects have the same hashCode. The next three chapters are "Substitutes for C Constructs," "Methods," and "General Programming." Item 21 in the chapter on substitutes for C constructs is the typesafe enum pattern, a generalization of the Singleton pattern to n-tuples. The author says, "Unfortunately, it is not yet widely known." It is #74 in "The Elements of Java Style" by Vermeulen et al., another book that should be on every Java programmer's shelf. The explanation here is more detailed and makes clearer the point of this pattern. The next three chapters are "Exceptions," "Threads," and "Serialization." Item 43 in the chapter on exceptions is to throw exceptions appropriate to the level of abstraction. You can always subclass Exception and include a link to the lower-level exception. As I said, this hits the mark. I recommend buying it and keeping it close at hand.
Rating:
Summary: too expensive
Review: When James Gosling himself reviews this book as a must have, what java programmer would not buy it? My only complaint is, that it is too expensive. You get less than 300 pages for this price. Why? I am still considering whether to buy or not. But as you have to rate to comment, I stick to James Gosling and the other reviewers and give it 5 star.
| 
