Design Patterns Java? Workbook [With CDROM]

by Steven John Metsker

Book Overview

Aimed at the intermediate or advanced Java developer, Design Patterns Java Workbook provides an in-depth and challenging look at 23 "classic" software patterns illustrated with Java examples.This... This description may be from another edition of this product.

• Format: Paperback
• Language: English
• ISBN: 0201743973
• ISBN13: 9780201743975
• Release Date: April 2002
• Publisher: Addison-Wesley Professional
• Length: 496 Pages
• Weight: 2.60 lbs.
• Dimensions: 1.2" x 8.0" x 10.0"

Customer Reviews

A Very Parctical Design Pattern Book

I have definitely found this book useful because unlike most other books that we read, we tend to forget a lot of the details and the author in this book uses very interesting questions (Challenges) that really make you think about the design pattern..making the whole activity of reading a more thought provoking and engaging process.I really liked the way the author inroduces the patters in a lot more "real world " way than the typical bookish ways..also the summary section at teh end of each design pattern really helps drive down the essence of teh design pattern.I have found this book extremely useful and would definately recommend it to others

Perfect companion to the GoF classic

Unlike so many other books on this subject, "Design Patterns Java Workbook" is very careful and precise in its usage of words, it is considerably insightful, it is fun to read, and has a unique style that does not try to immitate the GoF book. The challenges are also a great way to keep you on your toes.This is, hands down, the best design patterns book for java developers that I've come across so far and now sits right next to GoF in my library.

Excellent Workbook, Not a Reference

This book is not for the faint of heart or beginner. This book assumes some background in patterns or, at the very least, the reader has some other reference texts at hand. I would recommend owning and/or pre-reading the definitive 'gang of four' treatise on this subject "Design Patterns, Elements of Reusable Object-Oriented Software". Other helpful texts include "Applied Java Patterns" and "Design Patterns Explained: A New Perspective on Object-Oriented Design".You will need to make a reasonable commitment to this book. If you are a pattern neophyte, this book will only assist in your understanding of patterns, as mentioned above; you must have other resources available to you. This text does not stand on its own unless you are already very familiar with the subject. The book is relentless with its challenges to the reader. If you follow the author's style you will give your brain quite a workout. You may want to consider working through the book with another developer or two. The insight gained from having more than just your own understanding of the concepts would go a long way towards developing a firm handle on the patterns outlined.The case study used in the book is definitely unique and makes for very engaging reading. The code examples are clear and concise (don't cheat yourself by looking at the solutions in the back until you have completed the assignment). I particularly think that the use of UML throughout the text was very well executed. This book is long overdue and a 'must-have' for anyone serious about developing a clear understanding of software design patterns.

Best practices come forward.

This book is a much needed update to the classic "Design Patterns, Elements of Reusable Object-Oriented Software" (GOF.) There is no longer a need to translate Smalltalk or C++ into Java. The categories that each pattern belongs to (Construction, Extension, etc. ) diverges from the GOF teachings. Although this is unexpected, it does provoke additional critical thought.The implementation of some patterns is subtly changed by the Java interface. There is a chapter dedicated to interfaces, and the UML descriptions that accompany each pattern have been updated to account for them. Special attention is paid to the details of Java throughout. "Design Patterns Java Workbook" also does an excellent job with UML. It demonstrates that an idea can be easily shared without overdoing the documentation.The use of Flyweight in a language that relieves its users of the details of memory management proves for an interesting read. The use of Mediator to maintain relational integrity is down right insightful.The authors style is unassuming, and the fireworks discussions (his examples) are entertaining. The challenges spread throughout this book keep the reader engaged, and thinking deep thoughts. It could easily be used in a classroom setting, or for personal skills building.

Crystal Ball Says: Instant Classic (with a few reservations)

If you are old enough to remember Tony Hansen's incredible 'The C++ Answer Book', this is the same thing for Patterns, and in Java. In a lot of ways, I feel like it would be sacrosanct to say anything against this book at all because it truly is something that has been needed for so long. Vlissides' book 'Pattern Hatching' reads like Byron's Manfred: brooding, intellectual, meandering, and at its worst, kind of fussy (but still a great book). This book is the other end of the spectrum. It bends over backwards to constantly recontextualize the discussion and yet it still has the depth to consider trade-offs and challenges in working through implementations. Even though the author recommends Grand's 'Patterns in Java, Vol 1', I recommend this instead. The Grand book is really inconsistent and sloppy, though it has some good parts.My only reservations is that it teeters into the juvenile at times in ways that are so bizarre, you think, wait a second, a minute ago I was pushing through a paragraph that might keep me thinking for a week and now I feel like an imbecile, being told how method dispatching works in OO languages and how that is the basis of polymorphism (I actually had to fish my thumb out of my mouth during that section).While the appendices are very smartly laid out, this book isn't quite as meticulous as the Hansen book so some may look at this and say I don't know what I'm talking about. Maybe for that reason, this will end up fading away faster than it might have if the author had spent a little more time trying to work up material that was a bit more challenging. One final good point: he uses a very good technique in here where he talks about different parts of familiar code that are examples of various Gang of Four patterns. It really is an effective way to get people to realize that patterns aren't an esoteric, academic pursuit. We're all already swimming in them and coders who are not up on them enough to recognize them are probably not going to produce really good code.