A new edition of this title is available, ISBN-10: 0321356683 ISBN-13: 9780321356680
| |||||||||||||||
![]() Trade In this Item for up to Ģ1.72
Trade in Effective Java (Java Series) for an Amazon.co.uk gift card of up to Ģ1.72, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Special Offer until June 30, 2013: Receive an additional Ģ5 promotional Gift Card, when you trade-in at least Ģ10 worth of books. Learn more
|
|
There is a newer edition of this item:
|
A new edition of this title is available, ISBN-10: 0321356683 ISBN-13: 9780321356680
Product details
Would you like to update product info or give feedback on images?
|
Bloch provides 57 items (did he reject "varieties"?) grouped by subject. Each item highlights a "gotcha", expands on best practice or argues for deprecating a common practice. For example, among the gotchas, he points out problems with relying on finalisers, whose implementation varies from one JVM to another and may not run at all under some circumstances.
Best practice also gets a lot of airing. A neat example is not relying on Java's default object serialisation API, which--among other problems--can cause the object to break if you make any changes. This can result in a code maintenance nightmare. In the last category he discusses the string concatenation, "+". Using this can be a hundred times slower than appending to a StringBuffer. No problem for a one-off string but using it repeatedly can cripple performance.
Many of the items discussed are fairly trivial, such as returning zero rather than null for zero length arrays or avoiding the use of floats when you need precise answers--perhaps they were thrown in to make the magic "57"--but despite these Effective Java Programming Language Guide offers a fascinating insight into Java's architecture and solid, easily assimilated guidance on its effective usage.
Unlike most books for programmers, this is one you really will find difficult to put down. Every serious Java programmer should read it. --Steve Patient
The author is extremely knowledgeable and articulates his points in a clear, concise and logical presentation, which is a rare characteristic in today's overflowed and low-quality offer of "how-to-become-a-guru" manuals.
The Collections framework is clearly the author's backyard and you will learn about implementation details and rationales that you will not easily find anywhere else.
What I found most useful in the analysis of the various Java aspects was the author's perspective, which is based on the pros and cons of implementation choices, and strongly focused on API construction. Unless you work alone and deliver complete applications, you will define, design and implement an API sooner or later, maybe even without realizing it. With the help from this book you will most certainly design a robust, maintainable and useful API.
I also liked the practical approach that sometimes goes against OO principles: for example, just because Java embraced the OO philosophy does not mean that inheritance is the only way to go. Composition, static factories, singletons, immutable classes and some good old procedural programming are discussed in depth.
Another brilliant characteristic of this guide (and I would like to especially thank the author for this) is that although there are plenty of snippets to illustrate concepts, these are just skeletons, never longer than few lines and therefore they do not force you to waste your time and divert your attention from the core issue by analyzing pages over pages of code when maybe only one line could have served the purpose.
... Read more ›There are several sections covering different aspects of java programming. Bloch starts with an in depth look at some of the idiosyncrasies of the language that can lead to the creation of strange and nasty bugs. For example a surprising number of developers don’t realize that you have to override hashCode() when you override equals. Bloch goes into why. He also covers many design issues and good practices such as favouring static inner classes, favouring composition over inheritance and minimizing scope. In each case his analysis is succinct and thought provoking without ever becoming overly dense.
Finally, the book is organized in a very accessible manor. The contents refers to the 57 items that he highlights and the judicious use of bolding in the text is simple yet extremely effective at both highlighting the important points as well as making return visits for references accessible.
If there is one book all java programmers should have it is this one.