Rating: 
Summary: Just what I needed
Review: If you are looking for concrete examples of how to use Design Patterns in Java, I recommend this book. The examples are clear and straight forward. I found the much praised Gang of Four book too abstract to learn from, and was glad to have these examples in Java. Get this book if you want to learn from simple examples.
Rating: 
Summary: Don't waste your money
Review: This is the worst book I have read on java design patterns. The writting, like the author's column on java-pro magazine and his book on java, is unclear, at times even somewhat goofey. Most examples are strange and irrelevant to IT professionals. Over all, it reads as if the author is talking to himself while sleep walking. Programs provided on the CD are also pieces of pointless show offs and overkills, This book is hastly put together. It is clearly not written for anyone who wants to learn the subject
Rating: 
Summary: Good idea, sloppy execution
Review: The idea is great - provide an explanation of design patterns using visual java components as examples. The author's explanations were usually clear. But there are so many typos that I quickly lost confidence in the code samples and the book itself. It also looks like the coverage Swing was an after-thought. The last few chapters are a superficial tutorial on Swing that provide very little insight into Swing or design patterns.Looks to me like the author did his job, but the publisher (editors, proofreaders, etc.) let him down.
Rating: 
Summary: Clear and concise with concrete examples
Review: First let's deal with the typos. There are many of them and some are serious. Looks like there was a rush to market here. Hopefully these will be corrected in the next printing. If it weren't for all the typos, I would have given this book 5 stars. Now to the book itself. I love the organization: all the GoF patterns, each with a clear and concise description. Plus each pattern is accompanied by at least one working example. Each example has a Swing interface so you can run and modify the code to get a better acquaintance with the pattern. Each example is accompanied by a UML diagram which shows how the objects in the pattern relate to each other. The UML diagrams do not show the Swing interface. This is good, it puts the focus on the pattern itself, not on the GUI wrapper. After reading this book, I feel that I have a very good basic understanding of the GoF patterns -- well worth the price of the book.
Rating:
Summary: Clear writing and provides good basic understanding of GOF
Review: Cooper is a very clear writer and provides down to earth explanations for each pattern as well as complete Java/Swing examples. I would compare Cooper's writing with Mark Watson for clarity, and have recommended this book to many programmers, especially those relatively new to object oriented concepts.
Rating: 
Summary: Quite Disappointing
Review: Just like another reader I found this book quite disapponing. While reading this book there was never a AHA| moment, that author has explained this concept well. My yardstick for measuring any Author's writing is Ivor Horton (writer of Java and C++ books). In case you still have access to Web Tutorials for this book, then that is good enough. Buying the book is not very good invetsment.
Rating:
Summary: Meets but does not exceed expectations
Review: I needed a book that could quickly get me through the concepts of the Gang of Four's Design Patterns book using Java and that's what I got. The book covers 23 patterns concisely and with practical examples illustrated in Java code and UML diagrams. The preface of the book states that it is not a companion to the Design Patterns text so I didn't expect elaborate explanations and extensive code examples, I didn't want them either. As "A Tutorial" the text quickly explains what Design Patterns are, introduces UML and gets on with teaching the patterns. Each pattern has at least one example with its Java code described. Some of the examples, like those involving swimmers, seemed a bit esoteric, but they all illustrated their patterns sufficiently. The text only shows the Java code that illustrates the design, other code required to run the example is thankfully hidden away on the CD-ROM. The best thing about this book and about design patterns in general is that it takes your OO understanding up another level. If you are familiar with the basic OO principles of inheritance, polymorphism, etc., then you know how to build objects to meet your needs. The design patterns illustrated here takes you to the next step to show you what you should build to solve particular problems. It doesn't do your thinking for you, you still have to implement your own solutions, but now you're not lost in the woods as at least you have a place to start. What would have been even nicer if the book hadn't been loaded with so may typos. Most of them are very minor, but their sheer abundance is annoying at times. Specifically, the code examples are fraught with inconsistent indenting and bracketing that can make them very difficult to read. Also, the inclusion of the JVISION tool on the CD-ROM would have been welcome (or even a URL where it could be found) as the text makes frequent use JVISION produced UML diagrams. A demo version of JVISION can be downloaded from www.object-insight.com. To clarify an issue raised by a previous reviewer, an Appendix A, mentioned in the preface, does not exist, but its content, a JFC tutorial, is covered in Section 5 of the text -- another minor, but avoidable, mistake. If you are waiting for the perfect design patterns book then Java Design Patterns will disappoint, but you are probably in for a very long wait. This book gets you over the hurdle of initial understanding and for that it should be praised.
Rating:
Summary: Kind of disappointing...
Review: When I viewed this book's description and contents on this site, it seemed like a promising companion to the original Design Patterns text by Gamma, et. al. Unfortunately, IT REALLY MISSED: - The chapters are short, choppy, and focused on minor code details rather than the big ideas. - There are no complete programs in the text itself. Nearly all of each chapter is spent discussing code fragments that are inscrutable without a copy of the corresponding program from the disc. -I don't think this book was edited...The Preface promises a tutorial on the JFC in "Appendix A" - this DOESN'T EXIST! Most of the chapters contain annoying typographical and logical errors. The chapters are so short...why couldn't someone read through them before putting forth a book with a nearly fifty dollar price tag! My overall advice: keep waiting for a book that truly meets the challenge of presenting design patterns from a Java perspective... this ain't it!
Rating:
Summary: Stops short of Excellent
Review: First, the laurels: I'm only about 1/3 into the book, but I've already learned more from this book in three days than from the GoF book since I bought it over a year ago. No academic hand-waving here. Targeted for those of us who actually need to get something accomplished. Great idea to exactly parallel the GoF book. The source code are minimalist, unlike the rambling examples I've too often come across. Now the Darts: 1) the author tends to pick problem domains that are foreign to some of us (I'm not a competitive swimmer, and I'm not interested in knowing how seeding is done) 2) The first code sample I dove into (Prototype) would not compile. The offending class was missing an 'abstract' keyword. I spent fifteen minutes debugging before realizing that the class was extraneous and could be deleted -- the rest of the example did not depend it! 3) in an effort to keep the chapters short, the author's explanations tended to be jumpy and fragmented, often spending too little time on key concepts, and too much time on obvious ones. The result is that you really should print out and walk through the code *before* trying to read the chapter.
Rating:
Summary: Not bad but swamped with typos
Review: The other two sources on design patterns that I have seen have been the two volume Java patterns book by Mark Grand and, of course, the Gang of Four's "Design Patterns". The Grand books have gotten nothing but flamingly terrible reviews and the GoF's book tends to be a bit theoretical and abstract. What I was hoping to get out of this book was a less formal treatment of the topic of design patterns using Java, a language I am more familiar with. The book partially delivers on this but it is absolutely loaded with typos and errors in the book text and source code. Additionally, I was surprised that the CD did not come with the JDK or any trial software, such as the UML Modeling tool JVISION which is used extensively throughout the book. All in all though, I think this book is a decent introduction to design patterns using the Java language but you will need the GoF's book also if you want the the complete story.
| 
