|
Your search returned 1 matching documents
Effective Java:Programming Language Guide
by
Joshua Bloch,
Joshua Bloch
|
Prentice Hall PTR
second edition
May 2008
384 pages
|
Reviewed by Campbell Ritchie, June 2008
          (10 of 10)
I had been waiting for this 2nd edition for ages, and I have not been disappointed by it.
Everything is there:
* Why you don't concatenate Strings repeatedly
* Confusion between "L" and "l" and "1"
* How to get floating-point arithmetic wrong
* Why you avoid returning null
* Why you always use library classes.
These few previous points ought to be taught to even the rawest beginner, but the remainder of the book is only suitable for the more experienced programmer. Bloch takes a tour de force through all the features of the language. Some chapters are about general programming, including the methods inherited from java.lang.Object, others about specific features like concurrency.
he book is completely up to date for Java 6. It is clear and easy to read, although dense with information, so one cannot skim through it. Bloch pulls no punches. He tells us the features he likes and which he doesn't. He warns against using finalize() and clone() and calls classes like StringTokenizer, and the older concurrency mechanisms obsolete.
Anybody who wants to understand the workings of the language, to get up to speed and write code which really works: you're not borrowing my copy. Buy your own and you will be really pleased with it.
Discuss book in the Saloon —
More info at Amazon.com
|
Prentice Hall PTR
second edition
May 2008
384 pages
|
Reviewed by Michael Ernest, May 2008
(10 of 10)
This updated edition has plenty to recommend it. The chapter "Substitutes for C Constructs" is replaced by two new ones, "Generics" and "Enums and Annotations." Some existing items are amended to reflect these constructs. Some new ones promote the use of concurrency over traditional Java threads.
All in all, the second edition boasts 78 items compared to the first edition's 57 items. As before, the justifications driving each item are lucid and compelling, and much, much more valuable in my mind when used to assert confidence in a proven technique. I understand some people come to Effective Java as a primer. I can see how it woud be useful as such, but the arguments laid out seem to me more valuable once you've fumbled a bit on your own.
One item ("For instance control, prefer enum types to readResolve") amounts to a retraction; I consider it a sign of strength, that the book has so little to apologize for.
Sometimes you want answers on best practice from the best authority you can find. If you have a better source than Google's Chief Java Architect, share! I remain impressed by and indebted to Bloch for his simple, elegant style. I've been waiting for a long time to read his take on these new topics. Thank you Josh!
Discuss book in the Saloon —
More info at Amazon.com
|
Prentice Hall PTR
second edition
May 2008
384 pages
|
Reviewed by Jeanne Boyarsky, July 2008
(10 of 10)
The second edition of "Effective Java" is almost like a completely different book from the first. There were new chapters addressing Java 5 topics such as generics, enums and autoboxing. Existing patterns were rewritten for Java 5/6 - both conceptually and for the code examples. For example, overloading now address varargs. The number of items grew from 57 to 78 as well and the author removed the old ones that are obsolete.
As a reference, chapter one provided a table to quickly find items on Java 5. The appendix provided a cross mapping to find items from the first edition in this copy.
For those new to "Effective Java", it is meant for intermediate to advanced Java developers. It provides best practices, recipes and idioms for working with Java. The author is good about listing both advantages and disadvantages to choose when to apply a tip.
When thinking about my favorite chapter, I have trouble picking just one. I'm torn between the concurrency and enum chapters. The book goes beyond the common "use enums over constants" and goes into things like EnumBitSets.
I learned a lot reading the first edition of this book and learned just as much reading the second. If you have the first edition, but this one anyway. And if you haven't read the first edition, get your hands on the latest copy!
Discuss book in the Saloon —
More info at Amazon.com
|
Prentice Hall PTR
1 edition
June 2001
272 pages
|
Reviewed by Peter Tran, August 2001
(10 of 10)
Have you ever overridden the equals() method, but not have it work correctly? Do you miss some of the C constructs and wonder how you can do the same thing in JAVA? Have you ever wished you could come up with better design for your classes?
Then this book is for you. First, this is definitely not a book for beginners. I'm not saying you have to be a guru to appreciate the material presented. I made a lot of the same mistakes Joshua pointed out in his book early in my JAVA career. For example, the check list for Item 7: Obeying the general contract when overriding equals, will more than pay for the book when you don't have to spend several hours trying to figure out why your equals() implementation isn't working. (If my manager is reading this review, let it be known that this book wasn't available a year ago, and implementing equals() correctly isn't trivial!) The book is littered with examples of actual design patterns used in the JDK library, and the material is very up-to-date with references to the JDK 1.4.
Anyone aspiring to write good JAVA code that others will appreciate reading and maintaining should be required to own a copy of this book. This is one of those rare books where the information won't become obsolete with subsequent release of the JDK library. A definite must-have for any JAVA developer/programmer.
Discuss book in the Saloon —
More info at Amazon.com
|
|
