Reviews for Design Patterns in Java (Software Patterns)

1. Lucid coverage of all 23 GoF patterns

   Rated 4 out of 5 stars, May 12th, 2006

   The authors state in the preface that this is effectively a second edition of Steve Metsker's Design Patterns Java Workbook, and it covers the same material as his Design Patterns in C# book, so if you have either of these, you probably don't want this book.
   
   Unlike many other design patterns books in Java, it covers all 23 GoF patterns, which is a major plus. The only other Java-specific book I've read that covers all the patterns is Holub On Patterns, which, while entertaining and an excellent resource for examples of the application of patterns, is not the best place to learn them. Before tackling this, you will need to be comfortable with Java, Swing and the usual OOP jargon and concepts. A brief appendix on UML is provided.
   
   The explanations of the patterns in this book are for the most part very clear and concise. They are discussed within the context of object oriented design and Java language features, similarly to the approach taken by Design Patterns Explained. This provides plenty of implementation-level insight that helps clarify the intent of the patterns. That said, there are a few places where a reader new to design patterns could get confused.
   
   A firework factory is used as a common example through the text, which feels a bit forced and artificial in many places. The most egregious example is in the Facade chapter, where it is applied to a small Swing application showing the trajectory of a firework. This necessitates a three page digression on parametric equations, a questionable authorial decision.
   
   More annoyingly, 'challenges' are interspersed regularly through the book, in the form of code to be completed, or questions. While the intention is admirable, I quickly became irritated by having to constantly flick back and forth to the answers. Also, many of the UML diagrams in the main text are unfinished, as filling them in is part of the challenge. They're given in full at the back of the book, but not near the text, where you need them. As this format has survived from the first edition, clearly the authors are convinced this is a good idea, but it isn't. For an example of how quizzes and questions work well to support the material, consult Head First Design Patterns.
   
   A minor disappointment is that Java 5 is only referred to in a few places, and generics and autoboxing are not used in the examples. With Java 6 looming on the horizon, it is a pity that the new language features are treated as special cases rather than the default.
   
   I would not recommend this as the only book on design patterns in Java that you'll ever need, but it would make an excellent second book for covering the less well-covered design patterns (e.g. Prototype, Memento, Mediator), and for reinforcing your knowledge of the basics. A previously-prepared reader will then be able to see the wood for the trees in some of the less successful chapters, e.g. the unfortunate Facade example.
   
   The premier book on design patterns in Java is still Head First Design Patterns, but as that doesn't cover everything in the GoF book, this is currently the book I would recommend to fill the gap.