Rating: 
Summary: The poor examples hamper my understanding
Review: I am not an expert on design patterns so I won't tell about the validity of the concepts written here. However, I am very upset that the author has chosen examples that are not familiar to the average programmer. I dont understand about five of the patterns discussed because of the examples. I have to do my own research to find out how a swimming competition works. Instead of making the readers quickly grasp the main idea of each pattern, the author may have probably applied his own interest on those "out of this world" examples.
Rating: 
Summary: Not bad but not THE Java design pattern book
Review: Any Java developer who has read "Design Patterns" by Gamma, et al, has probably tried to relate the patterns discussed to Java programs. This book provides a linkage between "Design Patterns" and Java. Each of the 23 patterns discussed in "Design Patterns" are covered in this book using an example of a Java Swing program. The book opens with a brief discussion of design patterns in general and a quick review of UML, which is used throughout the book. The book then has a chapter for each of the 23 patterns. The book then finishes with an overview of Swing and a case study demonstrating how design patterns might be used in an actual development project. Although the author says that this book is not meant to be a companion book to "Design Patterns," I found that is actually the best way to use this book. Reading the description of each pattern in "Design Patterns" followed by reading about the same pattern in this book helped me to understand each pattern in a deeper way than by reading either book by itself. This book is not, however, the Java version of "Design Patterns". Some of the examples seemed strained to make their point. Also, by limiting himself to Swing, the author missed the opportunity to discuss how to use patterns in server side Java development. In general, however, the book does a good job of explaining design patterns and how to use them.
Rating: 
Summary: Another hastily written poorly proofread book!
Review: I agree with most of the other reviewers. There is a crying need for a *good* book on design patterns using Java examples, but this is not that book! I have two main complaints with this book - typo errors and poor examples.For example, on page 54, in the explanation of the Builder pattern, it is stated "The simpler of the two builders is the list box builder." Then further down the page, the author contradicts himself by saying "The Check box builder is even simpler." On page 99, the paragraph reads, "The problem of replacing the Employee instance with the Boss instance means replacing a Vector element with a new one using the setElementAt method." This paragraph seems inappropriate since there is no setElementAt method in the code listing. What is he talking about? There are other typos too numerous to mention. Some of the examples are overly complex. For example in the Chain of Responsibility example, he uses a previously created adapter pattern which is unnecesary to understand the Chain of Responsibility pattern. I was using this book to make sure I had a good understanding of patterns as they are used in my Java Developer Certification project. I will need to consult other sources to confirm what I read in this book. One looses confidence in an author when there are so many errors. If you want to read this book for yourself, you can buy my copy of the book on e-bay. I'll be listing it soon.
Rating:
Summary: An Interesting Quick Read
Review: I should mention that I only scanned the book (I took about 4 hours to read 350 pages). I read the code, but did not try compiling it, nor did I work through the CD. I caught several obvious typos in the code. I thought the overall structure of the book was interesting, and I gained some knowledge about into the way that working programmers might implement design patterns. If you have a copy of the book laying around, it is worth taking a few hours for a quick read. I've noticed similar sentiments in the other reviews. The people who read the book quickly enjoyed it, the people who were looking for a more academic treatment of the subject did not. Of course, the (...) cover price is a bit pricy for a quick read. If you are looking for an easy to read book that will give you a feel for the way programmers use patterns...this book will suffice. I would not use it for a primary reference or for academic work. I do not think this book is worth the cover price...but if you see it on a bargain book rack, or in the library, I would read it.
Rating:
Summary: Good Intro
Review: I am an experienced Java developer who is trying to get up to speed on design patterns. I also wanted a book that would show how to implement a pattern using Java's unique language features/restrictions. This book did help me get up to speed on patterns. It was also nice not having to struggle with SmallTalk code and trying to convert these new concepts from SmallTalk to Java. Overall, I am glad that I invested the hours to study this book. My next step is to read the GoF and I feel I will get more out of that book now. Now for the "but". This book has many, many, many typos. I don't know or care who's fault is was to include the typos. It is the author and publishers job to ensure that a quality product is put out. Addison Wesley failed to properly proof-read and edit this book. This is a shame because Addison Wesley knows better. As to the complaints regarding the code not compiling, the source code snippets in the book do have typos. The source code on the CDROM did compile with no problems. So, make sure you have access to the CDROM source code when you are reading the book.
Rating:
Summary: Truly Awful
Review: This book is a complete waste of spacetime. The author clearly has no real comprehension of any of the patterns he purports to describe. His examples are bug-ridden, have hideous style, and often totally contradict the text. Simply comparing his class diagrams with those in the GoF book indicates that his code has almost no correlation with the actual patterns. Couple that with a frighful lack of basic Java knowledge and you have something that will only serve to damage young designers. As a concrete example: the Prototype pattern means, to Cooper, that your class has a clone method. That's it. And he can't even write *that* properly, and instead gives a thoroughly incorrect exposition of how Java cloning works. Stay far, far away. Please.
Rating:
Summary: It scares me that this book could be published
Review: The author is clearly trying to help beginners design better code, but I find it frightening that people are reading this book and putting his ideas into practice. James Cooper does not understand the essence of the patterns that he is trying to explain. He gets the patterns wrong from the start and then spends pages working his way out of the traps that he has set for himself. Please do not buy this book, unless you are looking for somehting to amaze your friends with. I seriously thought that this book was a hoax at first, and a pretty sick one at that.
Rating:
Summary: Singleton pattern is laughable
Review: After reading his Singleton pattern and implementation, I can't help but think that the author doesn't grasp the fundamentals of Java at all. Throwing a SingletonException from getInstance() when someone already has a reference to the singleton goes against the key advantage of the pattern. Another gem is the author's suggestion that there should be a central repository for singleton instances. Was this chapter even reviewed? I can only assume that the whole book is of this low quality so for your own sanity and the betterment of mankind do not buy this book.
Rating:
Summary: Avoid this book, it will only do you harm.
Review: I agree with many of the other reviews, that while there is a great need for a good book of this type, this is not it. You might as well read a book about design patterns in VB, it will probably do you less harm. Apart from the obvious typos and esoteric examples, this book falls way short of both understanding the issues, and communicating workable solutions to the reader. In some cases the author is not just advocating impractical solutions, he actually shows a fundamental lack of understanding of both the design patterns themselves and Object Orientation in general. I think that the biggest problem with the book is that unless the reader knows something about design patterns, and more specifically, implementing them in Java, then the examples provided will seem reasonable. Many of them are not. This I think explains why the book has a couple of good reviews, and an awful lot of bad ones. Take for instance the singleton, the simplest design pattern. The author’s implementations are far from the 'standard' or even common java implementations, and are not particularly practical. None of them are thread safe, in fact the author never even mentions thread safety, which is rather important if you want to ensure one instance in a multi-threaded language like Java. In addition the author also seems to have missed the OO boat completely, I am not sure how he came to the conclusion that a final class with static methods is the same as a single instance (remember that the singleton patterns intent is to “Ensure a class only has one instance, and provide a global point of access to it”)....or advocating implementations that create as many problems as the solve i.e. having to 'find' instances in large programs!!, or having to catch exceptions from constructors! In fact, as far as I can see none of his implementations fully satisfy the intent of the pattern as none of them fulfill the second part of the intent and provide a global point of access to the single instance. In addition a true singleton needs to be thread safe to completely fulfill the first part of the intent. I could go on and on… What scares me is that there are people with little experience or knowledge reading this book and taking it for gospel, and what is even more frightening is that I will at some point probably have to work with some of them, or maintain code that they have written.....
Rating:
Summary: Beware, the author does not understand the subject at all
Review: If you have not read this book yet, please save time and money by not reading it. It is a pity that Addison Wesley should have come out with the best OO book (the GoF book) and this one. I teach object orientation for a living and would strongly advise you against trying to learn patterns or OO from this book. The author does not understand the subject at all. The examples are very contrived; more importantly, they are needlessly complex and often miss the spirit of the pattern under discussion. There are numerous mistakes, and I am not talking about typos. In place after place the author mixes up classes and objects. To me it is very clear that this book (even the proposal) was not reviewed by competent people. Also, it is plain that the author just read the GoF book and without understanding it fully jumped in to try and fill the definite market need for a Java Patterns book. When publishers do this kind of thing I think it borders on the unethical. One trusts some publishers and relies on them for quality. I learnt my lesson so far as Addison Wesley goes.
| 
