- Paperback: 308 pages
- Publisher: For Dummies; 1 edition (May 8, 2006)
- Language: English
- ISBN-10: 0471798541
- ISBN-13: 978-0471798545
- Product Dimensions: 7.5 x 0.7 x 9.3 inches
- Shipping Weight: 1 pounds (View shipping rates and policies)
- Average Customer Review: 13 customer reviews
Amazon Best Sellers Rank:
#1,177,445 in Books (See Top 100 in Books)
- #1258 in Books > Computers & Technology > Programming > Software Design, Testing & Engineering > Object-Oriented Design
- #1273 in Books > Textbooks > Computer Science > Software Design & Engineering
- #2859 in Books > Computers & Technology > Programming > Software Design, Testing & Engineering > Software Development
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Design Patterns For Dummies 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.
If you're a seller, Fulfillment by Amazon can help you increase your sales. We invite you to learn more about Fulfillment by Amazon .
Frequently bought together
Customers who viewed this item also viewed
Customers who bought this item also bought
From the Back Cover
There's a pattern here, and here's how to use it!
Find out how the 23 leading design patterns can save you time and trouble
Ever feel as if you've solved this programming problem before? You — or someone — probably did, and that's why there's a design pattern to help this time around. This book shows you how (and when) to use the famous patterns developed by the "Gang of Four," plus some new ones, all designed to make your programming life easier.
Discover how to:
- Simplify the programming process with design patterns
- Make the most of the Decorator, Factory, and Adapter patterns
- Identify which pattern applies
- Reduce the amount of code needed for a task
- Create your own patterns
About the Author
Steve Holzner is the award-winning author of 100 books on computing. He’s a former contributing editor for PC Magazine, and has been on the faculty of Cornell University and MIT. In addition to his busy writing schedule, he gives programming classes to corporate programmers around the country and runs his own training company, which you can find at http://www.onsiteglobal.com/.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
Design patterns have fallen out of style as SE (software engineering) has gone from (strict)waterfall to (freeform)agile; it's still useful to know and recognize some of the patterns as the modelling of a solution will typically be the same and already completed by some other devs.
Borrow, adapt and put into production :)
The author sounds like he researched patterns to write the book, but I don't think he is a design pattern expert.
Part 1 - Getting to Know Patterns: Congratulations, Your Problem Has Already Been Solved; Putting Plans into Action with the Strategy Pattern; Creating and Extending Objects with the Decorator and Factory Patterns; Watch What's Going On with the Observer and Chain of Responsibility Patterns; From One to Many - The Singleton and Flyweight Patterns
Part 2 - Becoming an OOP Master: Fitting Round Pegs into Square Holes with the Adapter and Facade Patterns; Mass Producing Objects with the Template Method and Builder Patterns; Handling Collections with the Iterator and Composite Patterns; Getting Control of Your Objects with the State and Proxy Patterns; Coordinating Your Objects with the Command and Mediator Patterns
Part 3 - The Part of Tens: Ten More Design Patterns; Ten Easy Steps to Create Your Own Patterns
The problem I've always had with patterns is that they seem to always be discussed in general terms. I have a hard time visualizing exactly what they mean unless I can see real code. Holzner uses a humorous "pattern consultant" storyline throughout each chapter, and relates a "business requirement" to actual Java code. He starts with a typical solution that doesn't implement the pattern, and shows how that approach can lead to problems down the road. He then refactors the solution to implement the patterns being discussed, and suddenly it's easy to understand exactly how that pattern looks in code. In fact, you may find yourself recognizing techniques you already use, but didn't know they were pattern solutions. I ended up thinking "oh, so *that's* what that pattern does" a number of times throughout this book. There's only been one other pattern book that I got that from, and it's a shame that something so valuable ends up being so obscured in theory and generalities.
While it's advisable to get the GoF book if you are really going to dive into patterns, it's also advisable to get a book that gets into practical, concrete examples. Between the two, you'll know everything you'll need to know about patterns. Design Patterns For Dummies definitely fits the bill for the practical volume you'll need...
I got this book, and quite frankly I only read one chapter, the one about Flyweights. Now if like me you work in the video game industry, you know full well how important Flyweights are in game dev, and one of the patterns you probably know, like me, in depth.
I couldn't believe what I was reading. This chapter is not merely misleading, it is dead wrong. The code example doesn't show at all what a Flyweight is. Now the damage was done: how can I learn from patterns I have difficulties with, if that one I know full well is so wrong?
I returned the book, did some research and got the one from Christopher Lasater instead. If you want to understand the most cryptic parts of the GoF book, avoid that dummy book and go straight to the Lasater one.
This book uses Java which is an excellent choice because C# programmers and even VB.NET programmers can understand with relative ease the premise of these patterns from Java.
This book is very easy to understand and probably should be the starting point for those just learning patterns. (Or "Head First Design Patterns", which is also excellent and very entertaining). The writing style of the author is very encouraging and I think beginners to patterns will find it a great starting point.
You have to start somewhere and this book fills the gap for beginners in learning the terminology, methodology and practical use of patterns.