Effective Java (TM) Programming Language Guide Paperback – 5 Jun 2001
Customers who viewed this item also viewed
Customers who bought this item also bought
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Would you like to tell us about a lower price?
If you are a seller for this product, would you like to suggest updates through seller support?
You may think you're a hot Java programmer, but you aren't perfect--yet. Josh Bloch is one of the Java core architects and in Effective Java Programming Language Guide provides a Java master class.
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
Effective Java Programming Language Guide distills the hard-won wisdom of today's best Java programmers into 50 techniques for designing and constructing more robust, high-performance software. Josh Bloch, one of Sun's most widely respected Java developers, focuses on the practical problems virtually every Java developer encounters, offering specific solutions and top-notch code examples. Josh Bloch identifies 50 practices that lead directly to better code -- including better alternatives for common practices that have proven undesirable in real-world development. The techniques are specific, thoroughly explained, and supported by top-notch code examples. Among the highlights: why developers should avoid finalizers; when to use delegation instead of inheritance; and how to make the most of Java's powerful typesafe enum pattern. Nearly all 50 practices relate to the "core" of the Java platform -- the language itself -- making the book relevant to every Java developer.See all Product description
There was a problem filtering reviews right now. Please try again later.
As someone who has been coding in Java from 1999, I felt my understanding of the basics were fairly good. OO techniques such as inheritance, method overloading, object creation et al were fairly bread and butter for me. Reading this book has shown me numerous ways to increase the standard of my code and also given me good reasons to code the way I should.
Many developers are aware of the fact that they should override hashCode() if they are overriding equals(), but how many could tell you why. This book does and there are many further examples like this, each one designed to highlight scenarios that can raise common (and often subtle) errors which can be easily dealt with.
This book can almost be seen as a book of design patterns but rather than covering patterns to solve various problems (such as: front controller, composite and decorator) these patterns cover writing reliable, stable, efficient and bug free code rather than hacking something together than works.
Essential for anybody wishing to improve their code.
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.
I would say that this book finds its best audience in the experienced developer/architect who does not have a specific Java expertise but is very comfortable with some other programming language. However, everyone can benefit from in-depth explanations of often misunderstood subtleties like the "equals()", "hashCode()", "clone()" or "compareTo()" contracts. Or serialization: are you sure you master it?
You don't need a profound Java working experience to immediately grasp some concepts; I found that this guide was an excellent companion in my learning of Java, you can start reading it from day 0, and you will get back to it every time you want to know more about a new concept.
The best praise I can say about "Effective Java" is that in my opinion only a handful of experts in the whole Java community could rightfully say "This book shall not teach me no thing", and then I would like to work with these people.
I was absolutely amazed how much stuff I had never even thought about before in Java... from extending objects that override equals (ouch! how broken is that?) to creating properly Serializable objects. And did you ever hear of 'volatile' before? You might want to go and check all your threaded code after reading this!
Josh Bloch is the guru when it comes to publicly usable APIs and it really shows in his hints, which sometimes means you can take his advise with a pinch of salt if you aren't writing public APIs. This book will make you look back and shudder at your existing code... he even points out many pieces in the Java standard library that make him cringe!