|
|
Effective Java Programming Language Guide (Paperback)
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. |
Detail |
Author |
Description |
Excerpt |
Reviews |
|
|
|
Author: Joshua Bloch
Publisher: Addison-Wesley Professional
Pub. in: June, 2001
ISBN: 0201310058
Pages: 252
Measurements: 9.2 x 7.4 x 0.8 inches
Origin of product: USA
Order code: BA00539
Other information: 1st edition
|
|
Rate this product:
|
|
- MSL Picks -
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.
(From quoting Alberto Gemin, USA)
Target readers:
Java programmers, Computer Science majors, People interested in learning Java.
|
|
- Better with -
Better with
Head First Design Patterns (Head First) [ILLUSTRATED]
:
|
|
Customers who bought this product also bought:
 |
Head First Java, 2nd Edition [ILLUSTRATED] (Paperback)
by Kathy Sierra, Bert Bates
A wonderful job of explaining not only the how-to, but also the "why" of Java fundamentals, in very down-to-earth language. |
 |
Head First Design Patterns (Head First) [ILLUSTRATED] (Paperback)
by Elisabeth Freeman, Eric Freeman, Bert Bates, Kathy Sierra
Written in a typically Head First refreshing style, this is one of the easiest to read and absorb among the major reference sources for design patterns. |
 |
The Pragmatic Programmer: From Journeyman to Master (Paperback)
by Andrew Hunt, David Thomas
A classic reading on programming ranking with Code Complete and The Mythtical Man-Month. |
 |
Code Complete, Second Edition (Paperback)
by Steve McConnell
Focusing on actual code construction, but touching on every aspect of software engineering including psychology/behavior, this book is an essential reading for every and all developers. |
 |
Refactoring: Improving the Design of Existing Code (Hardcover)
by Martin Fowler, Kent Beck, John Brant, William Opdyke, Don Roberts
Full of code examples in Java, easy to read and right into target, this book is a masterly and comprehensive reference on refactoring. |
|
|
Joshua Bloch is a principal engineer at Google and a Jolt Award-winner. He was previously a distinguished engineer at Sun Microsystems and a senior systems designer at Transarc. Josh led the design and implementation of numerous Java platform features, including JDK 5.0 language enhancements and the award-winning Java Collections Framework. He holds a Ph.D. in computer science from Carnegie Mellon University.
|
|
From the Publisher:
That is, really understand it? Do you want to write code that is clear, correct, robust, and reusable? Look no further! The book you are holding will provide you with this and many other benefits you may not even know you were looking for. Become a more effective programmer.
Featuring fifty-seven valuable rules of thumb, Effective Java™ Programming Language Guide contains working solutions to the programming challenges most developers encounter every day. Offering comprehensive descriptions of techniques used by the experts who developed the Java platform, the book reveals what to do - and what not to do - in order to produce clear, robust, and efficient code.
Each rule appears in the form of a short, stand-alone essay offering insight, code examples, and "war stories" from this uniquely qualified author. The essays include specific advice and insights into the subtleties of the language and are illustrated with exceptional code examples. Throughout the book, common language idioms and design patterns are examined and insightful and enlightening tips and techniques are provided.
Coverage includes:
* Customary and effective language usage that is saturated with expert advice in a concise, readable, and easy-to-access format.
* Patterns, antipatterns, and idioms to help you get the most out of the Java platform.
* Commonly misunderstood subtleties of the language and its libraries: how to avoid the traps and pitfalls.
* Focus on the language and its most fundamental libraries: java.lang, java.util, and, to a lesser extent, java.io.
* Detailed coverage of serialization, including practical advice that is not available elsewhere.
Appealing to a broad spectrum of the programming community, Effective Java™ Programming Language Guide presents the most practical, authoritative guidelines available for writing efficient, well-designed programs for the Java platform.
|
In 1996 I pulled up stakes and headed west to work for JavaSoft, as it was then known, because it was clear that was where the action was. In the intervening five years I've served as Java Platform Libraries Architect. I've designed, implemented and maintained many of the libraries, and served as a consultant for many others. Presiding over these libraries as the Java platform matured was a once-in-a-lifetime opportunity. It is no exaggeration to say that I had the privilege to work with some of the great software engineers of our generation. In the process, I learned a lot about the Java programming language--what works, what doesn't, and how to use the language and its libraries to best effect.
This book is my attempt to share my experience with you, so that you can imitate my successes while avoiding my failures. I borrowed the format from Scott Meyers's Effective C++ Meyers98, which consists of fifty items, each conveying one specific rule for improving your programs and designs. I found the format to be singularly effective and I hope you do too.
In many cases, I took the liberty of illustrating the items with real-world examples from the Java platform libraries. When describing something that could have been done better, I tried to pick on code that I wrote myself, but occasionally I pick on something written by a colleague. I sincerely apologize if, despite my best efforts, I've offended anyone. Negative examples are cited not to cast blame but in the spirit of cooperation, so that all of us can benefit from the experience of those who've gone before.
While this book is not targeted solely at developers of reusable components, it is inevitably colored by my experience writing such components over the past two decades. I naturally think in terms of exported APIs (Application Programming Interfaces) and I encourage you to do likewise. Even if you aren't developing reusable components, thinking in these terms tends to improve the quality of the software you write. Furthermore, it's not uncommon to write a reusable component without knowing it: you write something useful, share it with your buddy across the hall, and before long you have half a dozen users. At this point, you no longer have the flexibility to change the API at will, and are thankful for all the effort that you put into designing the API when you first wrote the software.
My focus on API design may seem a bit unnatural to devotees of the new lightweight software development methodologies, such as Extreme Programming Explained Beck99. These methodologies emphasize writing the simplest program that could possibly work. If you're using one of these methodologies you'll find that a focus on API design serves you well in the refactoring process. The fundamental goals of refactoring are the improvement of system structure and the avoidance of code duplication. These goals are impossible to achieve in the absence of well-designed APIs for the components of the system.
No language is perfect, but some of them are excellent. I have found the Java programming language and its libraries to be immensely conducive to quality and productivity, and a joy to work with. I hope this book captures my enthusiasm and helps make your use of the language more effective and enjoyable.
Josh Bloch
Cupertino, California
|
|
| View all 12 comments |
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! |
View all 12 comments |
|
|
|
|
