|
Effective Java Programming Language Guide (平装)
by Joshua Bloch
| Category:
Java language, Software development, IT, Technology |
| Market price: ¥ 508.00
MSL price:
¥ 468.00
[ Shop incentives ]
|
| Stock:
Pre-order item, lead time 3-7 weeks upon payment [ COD term does not apply to pre-order items ] |
MSL rating:
 Good for Gifts |
| MSL Pointer Review:
An essential reference on the nuances of Java, which you’ll consult from time to time. A must-own for Java developers. |
| If you want us to help you with the right titles you're looking for, or to make reading recommendations based on your needs, please contact our consultants. |
|
| |
AllReviews |
1 2   | Total 2 pages 12 items |
|
|
Charles Henry (MSL quote), USA
<2007-01-11 00:00>
For years it was said that the road to modern riches lay in a mastery of Java. This once inspired me to contact the Starbucks Corporation about acquiring a franchise with the remaining wisps in our trust fund (true story: an ill-starred thrice-great grandfather of mine set sail for Santiago in 1849, having misheard the talk about gold in San Francisco. This sort of thing runs in families). The chatter was of course about computers, not coffee, and years later I finally acted on this revised intelligence and sat down before my PC with this outstanding manual, determined to learn the new language of commerce. Bloch presents an admirably detailed and robustly structured survey of the elements of Java programming (named, I believe, for the Indonesian island upon which it was created). He takes the young cadet by the chin and methodically drills him through the paces. By lunchtime of the first day I felt like a union shop steward, having learned to "enforce noninstantiability with a private constructor" (chapter 2, page 12). By evening I was high-end a country club bouncer, having learned to "minimize the accessibility of classes and members" (Chapter 4, page 59). But by the time I got to the section on "returning zero-length arrays, not nulls" I was out of metaphors and completely over my head in this black new art. For weeks I felt inept and hopelessly outmoded, until one day I had the good fortune of hailing a taxicab whose driver was the author of one of this book's rivals. It was then that I realized that the bubble had truly burst, and that I hadn't missed out on anything after all. I tipped him handsomely. |
|
|
A German reader (MSL quote), Germany
<2007-01-11 00:00>
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. |
|
|
Goldin Evgeny (MSL quote), Israel
<2007-01-11 00:00>
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! |
|
|
Oyvind (MSL quote), USA
<2007-01-11 00:00>
I've read quite a few programming/development books in my time and a few of them have also been about Java. Most of these books have been good and worth the money, but once in a while I've come across a book that's been a real gem. This book is truly one of those gems, and has become one of the most priced possessions of my bookshelf.
If you ever though of yourself as a expert Java programmer, this book is still going to be a must. This book should be a part of any aspiring or accomplished Java programmer's personal library. It gave me quite a few surprises and presented an in-depth look into several topics I've never really touched on in detail before, nor ever seen a good explanation of in any other book.
Bloch goes into great detail with a logical and convincing style. His explanations are clear and surprisingly easy to understand. The layout of the book (structure and size) is also good, and it has a very good index of the contents. The book has the ability to keep you glued to your chair for a long time (it's actually very entertaining to read - imagine that?), and it will serve as a indispensable reference once you're done.
The book has 10 chapters with a total of 57 different parts (called items in the book). Some examples of these items are "Make defensive copies when needed", "Minimize the scope of local variables", "Favor immutability" and "Consider providing static factory methods instead of constructors". The items are organized in the following chapters: "Creating and destroying Objects", "Methods Common to All Objects", "Classes and Interfaces", "Substitutes for C Constructs", "Methods", "General Programming", "Exceptions", "Threads" and "Serialization".
Conclusion: If you are working on maintaining and/or developing your Java skills, this book is highly recommended! I give it an unconditional 5 STARS! |
|
|
Damon McCormick (MSL quote), USA
<2007-01-11 00:00>
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. |
|
|
Ian Davis (MSL quote), USA
<2007-01-11 00:00>
I read the reviews on this book, but I did not think that it would be as good as everyone says. I was wrong. I develop java applications commercially and I thought that I could read up a bit to make sure that I was still using good habits and making the best code. I could not believe the insight that the author has. The books does not just tell you what to do, it explains when some things should be used and when to choose another route. In many cases he gives many possible ways to solve a problem and gives the pros and cons of each. His writing style is fun to read (for someone who loves programming) and very professional. When reading you can feel his experience and authority on java along with his in depth knowledge of this internal JDK structure and paradigms. I will never sell this book, it is too valuable. Take his advice and save the world from the code you may have written without his guidance. |
|
|
An American reader, USA
<2007-01-11 00:00>
Ever since Scott Meyers wrote his seminal work Effective C++, the "effective" word has been frequently misused to produce mediocre work. But Joshua has produced a book equivalent in stature to Scott's, in the Java realm.
The pearls of implementation details and finer points of the language that could be learnt only from years of Java application and analyses, has been distilled into a comparatively small book.
The book has been divided into 10 chapters, for example "creating and Destroying Objects", "Classes and Interfaces" etc. If you are consum- mate Java developer you could dive into any section of your choice or even a specific chapter. The chapters though well connected, can still be read independently. If you are new to Java tread with care, time may be better spent reading an introductory Java book, which this isn't.
For example, this book consumes 8 pages to explain in detail, with examples, of all the vagaries of the "equals()" method. If you are programming in Java for a living, get this book now!
|
|
|
Amadan (MSL quote), USA
<2007-01-11 00:00>
Effective Java transformed my Java code. It made me a better programmer. If I were teaching a Java class, I would make this book a companion to the main text. I thought I knew Java pretty well and was following good basic practices, but almost every section in this book made me slap my forehead and run back to the code I was writing to refactor it. OKay, maybe you don't want to/can't go and refactor all your existing code, but you will definitely write your code differently after reading this book, unless you are one of those rare superstar programmers and Java gurus who has nothing more to learn.
This is the best Java book I have ever read. It is focused, concise, and relevant, and it does exactly one thing: teaches you how to write better Java code. It is not a tutorial on how to build Java applications or a guide to learning Java. You must already know Java to use this book. It's also not a reader on general programming; while it does emphasize good programming practices that you can and should use in any language, the 57 items in this book are specifically about Java and how to use the Java language most effectively.
The items range from very basic practices that anyone writing a single line of Java code should follow to some more advanced topics that not everyone will make use of immediately (notably the chapters on threads and serialization), but NOTHING here is fluff or esoteric. You should know this stuff. Learn it, live it, love it. Did I mention it should be required reading for any Java programmer? If I were hiring a Java programmer, having read this book would be a BIG plus for any candidate I was considering... I think this book is to Java what Code Complete is to general programming. Seriously.
The only slightly negative comment I have, not really a negative but just something to be aware of, is that this book (at least the latest version) only covers JDK 1.4, so some of the advice should be modified just a little for the latest release, 1.5. (Notably, the section on writing typesafe enum classes - the Enum class is now part of the Java language so you no longer need to "roll your own," but the tip still applies, as well as its suggestions on how to extend an enum class.) |
|
|
Leo Lim (MSL quote), USA
<2007-01-11 00:00>
If you have enough money to buy only one book in Java then this should be it! Bloch's masterpiece consists of 57 tips which specifically delve on using the Java API the way the desiners intended it to be. In case you're wondering, the author is a Senior Staff Engineer at Sun Microsystems and was the one who designed and implemented the Java Collections Framework and the java.math.package.
I have been programming in Java for 5 years already and still each tip teaches me something new (I was actually surprised when Bloch mentioned that the hashCode method has to be overriden if you were to override an Object's equals method).
However, you need to have programmed in Java for quite some time to appreciate this book as it will not teach you object oriented programming and the Java language constructs from scratch.
It's quite a shame that the details he expounds on this book are in the Java specifications but are merely glossed over by the anxious programmer searching for that elusive Java class method to meet some deadline. |
|
|
An American reader (MSL quote), USA
<2007-01-11 00:00>
This is a kind of book on Java that is long overdue! In C++ we already have been enjoying such great books as "Effective C++", "More Effective C++", "Exceptional C++", and "More Exceptional C++". This book provides similar guidelines for Java developers, and it definitely can compete with the mentioned volumes in its clarity and style.
The book covers generic programming, performance, and design techniques that every decent programmer should know and use when developing professional grade code. Although some of the covered issues are specific to the Java programming language, like eliminating obsolete object references and overriding toString(), most of the discussions apply to object-oriented programming in general, including programming in C++.
The reason for this is that Joshua Bloch pays a lot of attention to design patterns and programming style, and their influence on the software lifecycle. By clearly showing how many of the design and implementation decisions affect the clarity and aintainability of the code, it proves that almost any decision is a tradeoff of some sort. In other words, the author shows us how to use different language features judiciously to create optimal and robust implementations that will not likely to break in the future as the programs and the Java programming environment evolve. |
|
|
|
1 2 | Total 2 pages 12 items |
|
|
|
|
|
|
