Rating: 
Summary: Mediocre Book
Review: The author neither explain the patterns particularly well, nor does he offer examples to which most developers can relate. Examples and explanations of where specific patterns would be useful is not covered well for all patterns. An explanation of the advantages and disadvantages of using specific patterns is not covered.In addition, the book is riddled with so many typos that it becomes a chore just to figure out what the author was saying, not to mention what he meant. In many of his examples, the author shows off his lack of detailed understanding of how Java works. For instance, on page 40 he tries to show an example of an exception which must be caught, but he subclasses RuntimeException instead of Exception. Even with all this, the book does seem to offer a moderate level of understanding of patterns as they relate to Java. This book could have been a LOT better, but it also could have been worse.
Rating: 
Summary: Just enough practical code that you need
Review: I've been trying to learn design patterns more than two years.
In the beginning, I read (TRY to read) GOF's book, but I had no idea how to apply it in my code. Then I learn a few tricks only AFTER I create & compile the code snipets presented in the book.
That was a big learning curve since GOF doesn't come with pre-compiled code, and to me, you can only learn it by running it and see how it happens. I copied & pasted all of maze quesions into my project & and ran (what a pain!!).
The accompanying CD for this book is worth 4 1/2 stars (with some better examples it would've been 5 stars). I would rate the book itself probabaly 3 1/2 stars. Too many typos and lack of clean-cut explanation.
HAVING SAID THAT, is there any better book(& sample code) out there in the market that's better? NOT that I know of.
Don't get disappointed that the lanauage used is Java. I don't really like Java. If you're a hard core C++ programmer, you can EASILY convert the sample programs in C++. More code but it can be done (since Java already incorporates some of design pattern's idea into the language).
The most important thing that you need to do in learning design pattern is LEARNING IT BY DOING IT (not just reading it).
Follow each example very closely and memorize the usage. If the example is outrageous (like swimming/seeding one), just skip it.
When someone talks about a particular pattern, just recollect what you learn in the sample code.
I believe this is by far the best way to learn design patterns.
THEN you can read more about the topic in GOF.
Rating: 
Summary: Zero stars really
Review: The author should not even be trying to write about Java, let alone about applying patterns using Java. Abysmal book - I read it in the local library and thought, wow a Java patterns bookk based on Gof. More like Goof. Stay away, stay far far away.
Rating:
Summary: no more insights
Review: The book does not provide any more insights than GoF's book. It is ok to see a different implementation (java version) of the patterns in the GoF's book, and how a few patterns were applied in JFC design, if that is all you want. Be prepared to have a hard time reading if you are NOT familiar with the patterns in GoF's book (!So you have to read GoF book anyways!). I just browsed the free on-line version in case I miss out something, and it seems that I don't have to worry about it since the author just followed the exactly the steps of GoF. BTW, you defintely do not need this book as a companion book for GoF's book if you know both C++ and java. And for those who are crying out to get the java design patterns, my guess is they do not know C++(and SmallTalk) so that they could not get much out of the examples in GoF's book.
Rating:
Summary: read Design Patterns Explained instead
Review: This book misses the point of patterns. It explains patterns as if they are solutions to recurring problems. Gee, I thought that's what they are? Well, they are - to some extent. They are more about a way to think. The problem with patterns as design solutions is that they don't help you until it is too late. Design Patterns Explained talks about why patterns are good solutions. You can then use this information on any project.
Rating:
Summary: Regurgitation of the GoF
Review: I don't think this book is any clearer than the GoF. I feel that the material presented in this book is pretty much the same as that of the GoF. Instead I would recommend: "Design Patterns Explained, by Alan Shalloway".
Rating:
Summary: Supplementary for GoF book for Java Developer
Review: It serves as a good supplementary to the GoF Pattern book for Java developer. The sample in the GoF is C++ and some examples may not be familiar to Java developer (e.g. compiler example in the Visitor pattern). For Java developer, I suggest to read the GoF pattern book to get the concept of each pattern and come back to see the java example here.
Rating: 
Summary: Quite disappointing
Review: I was excited to find a design pattern book for Java programmers. Examples are in Java and Mr Cooper uses UML to draw diagrams of the patterns. However, later I found out that examples are too simple and there are some annoying mistakes that now make me question Mr Cooper's expertise in Java and design patterns. I am referring to the Memento pattern on page 201, as I have read carefully the pattern in both this book and Gamma, et al, book, "Design Patterns, Elements of Reusable Object-Oriented Software". In Gamma's book, the Memento object is inside the Originator and there are two methods, CreateMemento and SetMemento, in the Originator. The resulting Memento object will be often smaller than the originator because Memento object often stores part of the state in the originator. However, in Cooper's example for this pattern, the Originator object is inside the Memento, therefore, the Memento object will be larger than the originator. I am not saying this won't work. However, since Cooper's book is an interpretation of Gamma's book, Mr COoper should try to interpret all patterns correctly. In the same chapter, on page 202, Cooper says: "... another class in the same package can access protected or private-protected variables..." Anyone with good understanding of Java knows that private variables are only accessible from inside the same class.
Rating:
Summary: DO NOT PURCHASE THIS BOOK! You will regret it.
Review: I was very disappointed in this book and wish I had done even a small amount of research prior to purchasing it. As others have noted, the examples are difficult to follow. The editing is non-existent; the reader has to spend way to much time deciphering the examples to make them useful. Code snippets are internally inconsistent (at least with regards to code style), code snippets are duplicated across pages, references are made to objects that you haven't been introduced to. At this point, I'm nearly halfway through this book after repeated attempts to read it through (its not very long -- 300+ pages) and cannot say my grasp of Design Patterns, as applied to Java, is much better than when I started. Go online and follow tutorials. You'll find better information. The fact that this book retails for [$$$] should be at least a misdemeanor.
Rating:
Summary: Tell us facts
Review: The author's opinions seemed to taint the ideas in this book. He's obviously a very strong proponent of good object-oriented design, but with almost thoughtless blind faith.
| 
