Customer Reviews

Effective Java: Programming Language Guide (Java Series)

5 star:		(111)
4 star:		(5)
3 star:		(3)
2 star:		(2)
1 star:		(0)

 

 

This book contains a generous cross-section of the knowledge that differentiates Java gurus from advanced Java programmers.

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.

I spend a lot of time thinking and talking about programming, languages, style, etc. This book is without question the best thing I've read about how to program in Java.

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.

IMHO, The Java Bible is out. It is that simple. I think this book deserves no
less popularity and respect than "Effective C++" which set the high standard
to the "Effective" series.

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 !

I like books that underpromise in their titles and overdeliver in their contents. This book has 57 items of programming advice that are not only well-chosen, but also reveal a clear, deep grasp of the language. Each one is justified with practical illustrations of what can happen if you only apply do-it-yourself intuition or, more likely, the most direct path to a solution.

Joshua Bloch is cited by several sources as a math prodigy and an accomplished researcher. None of that high-octane stuff affects this book. The prose style is simple and practical. The author never strains to detail a complex or abstract tangent. For example, his piece on random number generation (under Item 30, "Know and Use the Libraries"), raises a whole slew of "interesting" questions, but he stays on point (trust the library to do work you don't know needs doing). He avoids proving his assertions when a demonstration will suffice, so the book stays short and focussed.

Many of these points were review material for me, but I gained from Bloch's discussions nonetheless. As often as not, I preferred his reasoning over ones I have relied on; Bloch's just feels better rooted. And, in a world of high-stress schedules and moving-target projects, it's refreshing to hear someone with heavy concerns of his own preach the Good Word on better programming.

This book will strengthen your understanding of Java. It will confirm the things you've been doing right all along, and politely show you how you could do better. It might also give you a way to move people who wouldn't listen to broken-record you, but would listen to a smart stranger who says the same thing. ;)

So you've been a Java Developer since Day One. Or you've just decided to become one. Either way this book is a must read. Object Oriented programming takes a certain skill and understanding, and Josh Bloch's book addresses a number of Java programming idioms that most people don't pay enough attention to. I know I've certainly violated a number of the rules or suggestions made in this book.

The book is easy to read through, and can be used as a reference book as well as a learning guide. The top Java people around participated in its review, and if James Gosling stands up at a JavaOne keynote and recommends this book (which he did), that's enough to make me sit up and pay attention.

Get it. Read it. Use it. You won't regret it.

This book is the best resource I've encountered for someone who knows the Java language, but wants to master its use. I can virtually guarantee that the rules and techniques covered in "Effective Java" will form the new foundation on which you will build the rest of your best practices for writing excellent Java code.

Written by the Joshua Bloch, the acknowledged expert on the subject, it is as authoritative as they come and extremely well-written. After seven years as a senior developer architecting and implementing algorithms and class libraries in Java (and another 6 years using other languages before that), this book shocked me by summarizing much of what I knew about how to use the language effectively, while teaching me much that I did not know. It continues to top my recommended reading list for all new software developers at my company.

First, the disclaimer -- I know Josh, and to know him is to like him. I work at Sun, and used to call him from time to time for advice. Josh is the force behind the initial versions of the Java Collections API, a good example of how to design using interfaces.

I was really struck by this book when I read it -- it was exactly what I was looking for. Other books will teach you how to use Java; this one assumes you know that much and then teaches you how to use Java *well*. It's a bit like knowing how to draw cartoon-like figures and then learning to draw lifelike images. I also find his writing style very natural; believe it or not this was, for me, a page-turner.

The book is slightly dated since it does not reflect the many significant Tiger (5.0) features. In fact, I think Josh himself obsoleted some of his own advice by giving us a really good enum implementation. Still, most of the content is very relevant, and even the dated stuff is still important if for some reason you are stuck using 4.x. It also helps you understand why enums were done the way they were.

[...]

He hinted that he might make an updated version of the book; if so, I'm in for one -- this is *bar-none* my favorite Java book.

In fact, I should ask whether people have read "Effective Java" when conducting interviews, and then ask them to articulate some of what Josh said. Hmmm.

It has been an absolute pleasure to read this no-nonsense collection of observations and suggestions.

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.

This is the best software book I read, since Meilir Page-Jones landmark OO book. It is just an intellectual pleasure and delight to read. Even if you are not interested in Java itself, this book is well worth reading. I have to admit that I was annoyed at James Goslings praise in the book flap. After all he is the inventor of Java and a very smart guy indeed. But after reading this book, I do believe him that he truly needs this book.

This book is one of the handful of books about how TO USE JAVA. It is written in the tradition of Scott Meyers "Effective C++" and even surpasses this landmark book in quality. It has 57 items of interest organized in ten chapters. Each item can be read alone and the items can be read in any order. Still it is pure delight to read the book from cover to cover.

This book describes the consequences of the interplay of the basic Java concepts with nearly mathematical precision (no formulas). It helps you to write library quality code. It gives you a feeling, where you have to be careful... It increases the quality of your code and your joy of programming.

A very readable book that an aspiring developer should read after mastering the basics of Java. The contents is well-thought out, Java specific, and thus very good. No fluff here, and it does live up to the expectations set by C. Meyers! It won't turn you into a Java guru (for that, you need to know the core libraries very well - collections, networking, threads), but will move you in that direction quite a bit.
I loved the sections on Methods Common to All Objects (an equivalent of the 'canonical form ' in C++), immutable objects (author presents coherent reasoning behind them, it got me thinking and I saw the light!) exceptions (this is a very pedestrian topic, the advice is excellent and time-saving). Also, the typesafe enum pattern was very good.
The book is very well written and a real treat. Definitely buy it as your second or third book on Java :-)