Head First Design Patterns

Head First Design Patterns

Head First Design Patterns Rating:
List Price: $44.95
Sale Price: $29.67
Availability: Usually ships in 24 hours
Eligible For Free Shipping

Product Description

You're not alone.

At any given moment, somewhere in the world someone struggles with the same software design problems you have. You know you don't want to reinvent the wheel (or worse, a flat tire), so you look to Design Patterns--the lessons learned by those who've faced the same problems. With Design Patterns, you get to take advantage of the best practices and experience of others, so that you can spend your time on... something else. Something more challenging. Something more complex. Something more fun.

You want to learn about the patterns that matter--why to use them, when to use them, how to use them (and when NOT to use them). But you don't just want to see how patterns look in a book, you want to know how they look "in the wild". In their native environment. In other words, in real world applications. You also want to learn how patterns are used in the Java API, and how to exploit Java's built-in pattern support in your own code.

You want to learn the real OO design principles and why everything your boss told you about inheritance might be wrong (and what to do instead). You want to learn how those principles will help the next time you're up a creek without a design paddle pattern.

Most importantly, you want to learn the "secret language" of Design Patterns so that you can hold your own with your co-worker (and impress cocktail party guests) when he casually mentions his stunningly clever use of Command, Facade, Proxy, and Factory in between sips of a martini. You'll easily counter with your deep understanding of why Singleton isn't as simple as it sounds, how the Factory is so often misunderstood, or on the real relationship between Decorator, Facade and Adapter.

With Head First Design Patterns, you'll avoid the embarrassment of thinking Decorator is something from the "Trading Spaces" show. Best of all, in a way that won't put you to sleep! We think your time is too important (and too short) to spend it struggling with academic texts.

If you've read a Head First book, you know what to expect - a visually-rich format designed for the way your brain works. Using the latest research in neurobiology, cognitive science, and learning theory, Head First Design Patterns will load patterns into your brain in a way that sticks. In a way that lets you put them to work immediately. In a way that makes you better at solving software design problems, and better at speaking the language of patterns with others on your team.


  • ISBN13: 9780596007126
  • Condition: New
  • Notes: BUY WITH CONFIDENCE, Over one million books sold! 98% Positive feedback. Compare our books, prices and service to the competition. 100% Satisfaction Guaranteed


  1. Adi Barda says


    So far i bought about 30 computer books from amazon. This is the BEST!!!!!! First book that explains something real good but doesn’t assume that you (the reader) actualy understood it so they re-explain it and attack the problem from a deferent point of view. I bought steven mezger’s design patterns with c# book and read it cover to cover. It doesn’t even come close to this piece of art although this is wrriten for java programers. I read “decorator” pattern in mezger’s book more than 5 times and didn’t actualy understand it. First time i read it in this book and i feel like a design patterns master! I’m thinking a lot about their teaching style. Its briliant! If you realy want to understand design patterns even if you are a c# or c++ programmer, By this book!


    Adi Barda

  2. Gary K. Evans says


    I got involved with design patterns in 1995 with the GoF book. I have learned them and used them on numerous consulting projects, and I feel I understand them pretty well. Recently I was asked to teach a Design Patterns course. The course material was excellent and very comprehensive, but I felt I needed an complementary approach for teaching that was a little lighter than the student manual. I picked up the Head First Design Patterns book, and started reading it on the flight to where I was teaching. The time flew by, and so did the pages. When I got off the plane I had read almost 300 pages. It is a really easy read. I was seriously impressed with the quality of the book’s coverage, and its really excellent examples to motivate why and how each pattern can be useful. As an object modeler and architect I see way too many examples of developers using either the wrong pattern, or using a pattern just to say “I used the Strategy pattern!”. The GoF book is the “bible” on DPs, but this Head First book is a superb introduction for beginners, and for veterans like me to learn something new. At the end of that DP class, several students shared that they had tried to get through the GoF book but just couldn’t stay with it. After I showed them several of the examples in this book, they said they were eager to read the GoF book to get more depth.

  3. Jack D. Herrington says


    At first I didn’t understand how they would apply the Head First formula to design patterns. I’d read two head first before this one and I was impressed with those so I took a look and now, not only is it clear how they approached the topic, it’s also clear to me that this is the best way to learn design patterns.

    The Gang of Four book laid out the basics. Here is the pattern, here are some examples. The head first book goes a lot further. They show you good and bad examples of the pattern. They give solid reasoning behind the pattern. It’s great.

    There are times when I would look at a piece of code and have the author explain to me that it was based on one of the GoF patterns. I would come away thinking, if that’s the pattern, then that pattern sucks. It’s clear that patterns can be misapplied. So understanding the the how design patterns are applied, and how they are commonly applied wrongly, or to an extreme, is just as important as understanding the basic mechanics of the pattern itself.

    The example code is in Java, but I think this is an ideal book for anyone passionate about patterns.

  4. MCSD for Microsoft .Net says


    I am quite impressed with this book’s explanations of design patterns. The authors start each chapter explaining a problem and then showing how a given implementation or two isn’t flexible. Then the text presents a design pattern and shows how to use it and how it solves certain issues. Along the way, the reader is given general design ideas to keep in mind while architecting or refactoring a system.

    Because key concepts are repeated throughout the book using different phrasing and examples, I found learning/reviewing each pattern to be straightforward and easy. I haven’t used Java since ’98, but with C# skills I found the code examples fairly simple to understand.

    Also note that this book doesn’t explain in detail all the patterns explicated in the Gamma et al. text. Instead, you will learn the Strategy, Observer, Decorator, Factory, Singleton, Command, Adaptor, Facade, Template Method, Iterator, Composite, State, and Proxy patterns will full explanations and code examples. Other patterns (e.g., Bridge, Builder, Chain of Responsibility, etc.) receive only a brief overview in the back of the book. The authors feel that those patterns aren’t used as often and consequently necessitate less coverage.

    If you’re looking for no-nonsense writing that delivers design pattern facts in a most direct manner, then choose the original Gang of Four Design Patterns book instead. But for a much friendlier introduction and explanation of patterns, pick up Head First Design Patterns right away and use Design Patterns by Gamma et al. as a reference. Highly recommended.

  5. Slavisa Nesic says


    Soon after the Gang of Four published their book about basics of Design Patterns, I bought the book and read it very carefully. About that time I was busy doing other engineering work so I could not put the patterns in immediate use in some practical project. Maybe that contributed to my troubles understanding it.

    While reading the GoF book I found it very complicated to memorize the pattern. After reading so many books on programming, so many technical and other books every year in several decades in the past, I thought I have a very strong and sound learning techniques from books. But GoF book simply was out of my reach from some reason. The problem was this: when reading about a pattern, I could understand every sentence, every paragraph, and most of the time the whole chapter about that particular pattern; but it seemed hard to keep in mind that pattern, and soon afterwards, I could hardly implement the pattern in my programs. It was as if you are keeping the slippery fish in your hands, and just when you think you caught it, it slips from your hands back into the water.

    Finally after this book (it is still in reading) I found what I was searching for:

    1) the crystal sound explanation of Design Patterns – why you use any of them;

    2) what is important and what is not important in pattern. Actually the authors of HeadFirst does not speak much about it explicitly, but when they explain the pattern you do not have to think what I was constantly thinking when reading GoF book: what is the most important part of the pattern and which part of pattern can be changed for specific use. With HeadFirst book you get the right measure of all parts of pattern explanation.

    3) I could memorize, reproduce and implement the patterns with ease!

    Second, the book is astonishingly new, refreshing and perfect in the presentation sense. It is full of pictures and with hand-written comments. Everybody who was ever involved in the presentation material would tell how hard is to achieve such a great presentation level with so many diverse visual effects and putting them in perfect shape like this book achieves. I think this was the problem for one of the very rare reviewers of this book to give this beautiful book such a bad grade. I think he was wrong to falling under the first-impression opinion and misjudged the book greatly.

    The truth is the HeadFirst Design Patterns deserves the highest possible marks – I do not give it only 5 stars, but I give it the Oscar for Design Patterns. And that is final even before I read the last page of it. Authors of this book, if you ever read this comment here is the message for you: my sincere complements for your hard work, you has been terrifically good, and I mean it!

  6. E. Wuehler says


    Usually when reading through a book or article on design patterns I’d have to occasionally stick myself in the eye with something just to make sure I was paying attention. Not with this book. Odd as it may sound, this book makes learning about design patterns fun.

    The first thing you notice is the pages are not paragraph after paragraph of information. There isn’t a single page that doesn’t contain a doodle, a sidebar, a picture, or something different. While at times it can be a little distracting, it’s in a good way (at least I don’t have to poke myself with something sharp anymore).

    The chapters cover various design patterns and along the way have exercises such as crossword puzzles or match games to test your understanding. The answers are also included at the end of the chapters – so you don’t need to purchase a “Teacher’s Edition” on the black market. =)

    Other books on design patterns are saying, “Buehler… Buehler… Buehler…” while this book is on the float belting out “Shake it up, baby!”

  7. C. M. Lowry says


    If your previous attempts to learn design patterns have induced bouts of narcolepsy, Head First has a better idea. Using their now familiar and very effective teaching style, the design patterns are presented with fun and humor. Off-beat coding examples in Java are used to illustrate the problems that the patterns are to solve and the pattern-influenced solutions. For those of us who are micro-confined, the C# version is available from the website.

    Rather than teach just the design patterns, the underlying object-oriented principles are taught, for example “Favor composition over inheritance”. Not only does this reinforce the understanding of the pattern, but also it better enables the developer to apply the pattern appropriately. Emphasis is also placed in understanding the differences between similar patterns or patterns that support similar principles.

    The depth of coverage that the book delivers requires that the focus is on the most frequently used patterns with the rest of the GOF patterns being briefly mentioned in the appendix.

    When I first saw the book, I was curious about how this would work out. After all, everything that I had seen on design patterns had not been the least bit amusing, but not to fear the Head First team has created a real gem. Maybe the Head First crew could tackle UML or Test Driven Development for us and make them fun to learn, also. We can only hope.

  8. Patrick Thompson says


    Head first books tend to polarize readers I feel: you either love the unique methodology of the books or you hate it. They are extremely visual, often hilarious, and require you to do various activities to engage more fully with the content. This is similar to the traditional teaching methdology in mathematics: motivating example -> theory -> example -> your turn. This I find as a teacher, is a strong (pedagogical approach) methodology, particularly if you can make it fun, interesting and engaging. I, like the masses, like Head First Books (I have Servlets & JSP as well as this one. I have also read tracts of Java).

    Anyway, that aside, the book provides a solid inroduction to selected design patterns- it doesn’t cover all the GoF patterns. It contains (in order)

    * Strategy

    * Observer

    * Decorator

    * Factory

    * Singleton

    * Command

    * Adapter and Facade

    * Template

    * Iterator and Composite

    * State

    * Proxy

    * Compound Patterns

    * Living better with Patterns

    If you have no experience with patterns, I recommend this as a good Intro to the MasterWork by the GoF-> Design Patterns, Elements of reusuable Oject-oriented software IBSN: 0201633612. From personal experience, I found after reading the Head First pattern, I could pick up the GoF book, look at the same pattern and understand it with virtually no problems.

    I have no hesitation recommending this book, if you like the Head First way, championed by Kathy Sierra. If you don’t like apparent frivolity (I say apparent because there is an ulterior motive to this frivolity-> engagement. Basically, cognitive psychology says the more deeply you engage, the more you learn, retain and understand), then maybe this isn’t for you.

    Slight criticism-> you may notice this book uses some ‘old’ java syntax like using iterators for collections like arrayLists, rather than the new for (object j: collection) and no generics in sight in declaring such arrayLists: they use ArrayList name=new ArrayList(), not ArrayListname=new ArrayList(); But these are ‘very’ minor criticisms. Likewise, it’s usefulness as a comprehensive reference like the GoF book may be questionable. But then, if you approach it as a learning tool and a means to mastery rather than a reference, this shouldn’t be an issue (you can always resell it when you’re done!).

    Anyway, in conclusion, two thumbs up. Read it, do the work, enjoy it and you’ll be well on the way to the GoF’s MasterWork in design patterns. All the 5 star reviews don’t lie! This is a five star book.

    As an aside I recommend, in addition to this and GoF, reading Streamlined Object Modeling- patterns, rules and implementation- ISBN: 0130668397 for higher level OO system design (OO system architecture). And just so you don’t fell excluded from the vernacular (and didn’t know this): GoF=Gang of Four (Gamma, Helm, Johnson, Vlissides)

  9. Mims H. Wright says


    I know what you’re thinking: “This can’t be serious”, “What’s with the clip art”, or maybe “This isn’t the GoF book!” but dispite the silly cover, this is one of the best and most informative books on computer programming I have ever read.

    If you’re looking to refine your development skills but just don’t have the patience for a BS in Computer Science, this book is just the thing for you. HFIDP covers the very abstract and difficult to understand concept of Design Patterns in an engaging and fun way. By employing several different styles of teaching and visualization (including challenging questions, real world examples, and humour that isn’t overly cheesy) it’s nearly impossible not to learn something. There is even a section on how to retain information while reading!

    This is a Java oriented book, but I have found it to be very useful for ActionScript 2.0 programming as well.

  10. Rating

    I have to admit: I was skeptical, at first. I stumbled on a Head First book a year or two ago, flipped through the pages, and put it back on the shelf: it seemed too simplistic for me.

    A few weeks ago I was browsing computer books at a local Borders and stumbled on a lineup of several “Head First” titles. “If O’Reilly keeps publishing this stuff, someone must be buying it”, I thought. I picked up one of them, started reading… I could not put the book down: it is rare when a computer book is so much fun and yet so informative and mature!

    This book possess the magic of making you to learn without you really noticing it. Yeah, I know, “No pain, no gain.” Well, somehow the authors manage to keep you engaged, even with such an abstract material. What I am trying to say is that you don’t feel like you need to concentrate on the reading because all the action keeps you focused. In each chapter the authors in a quite unimposing and subtle manner introduce a problem, so you almost don’t see it coming. Most importantly, you don’t feel that you are studying, but still, you are learning!

    Authors by the means of visualization and conversations of quite a few characters — the Master and the Student, the Guru and the Developer, and others — make you learn the material almost “by the way”. Why? I think because these characters represent familiar voices in your head that sound surprised, sarcastic, annoyed, excited, and frustrated when you are trying to digest new material. They force you to look at the problems and patterns in many different ways, and this is the essence of internalizing. The questions and answers are flying right in front of you, and they are neither boring nor trivial, so you are not falling asleep. Pictures make it even more real, and plenty of coded examples add necessary precision. Most importantly, using this style of writing the authors increase internalization of somewhat complex and abstract material much faster than others that I am familiar with.

    The “Head First: Design Patterns” book covers the familiar GOF patterns, but unlike many of the patterns books, it does not have a separate condensed patterns catalog. The patterns appear as natural solutions to natural problems. What’s remarkable is that they seem just one of the courses in this feast of object-oriented thinking. Indeed, this book talks about the wisdom of object-oriented design as about the design patterns themselves. This feels natural: the patterns do represent some of the best practices in the object-oriented design.

    The only complaint I have is about the Appendix: the authors cramped in almost as many design patterns in its 20 pages as they did in the preceding 600. I understand that to cover the rest of the patterns could take another book and another year, but I’d rather wait for the sequel.

    I believe that both experienced and novice readers will benefit from this enjoyable and engaging book, but you definitely will be more perceptive to the wisdom of this writing if you have matured through developing, maintaining, and extending of object-oriented systems. All in all, I love this book and can’t wait to start reading another “Head First” pearl.