I purchased this book about a year ago and devoted a number of hours each week going through it. I am a software developer by trade, but never took a computer science course in my life, mostly because I was self-taught as a kid and all of this pre-dated the Web by about 20 years.

In any event, one area where I knew I was lacking was a formal understanding of design patterns. I was in the middle of a fairly large enterprise application, and while I was fully versed in Object Oriented Programming (and had even taught it in the past), I realized that everyone we were hiring out of college "spoke" a different language than I did, talking about singletons, factories, MVC, etc.

This book covers those and many, many more, in a completely involving and revolutionary way. It's basically designed with the Java language in mind, but I'm a .Net developer, never having learned Java. However, the book is so thorough and intuitive, that I decided to do all of the examples in C# (close enough to Java that in many cases, there's almost a 1-to-1 relationship between my home-grown example and the one in the book.

So for me, the book's benefit was two-fold: exposure to both design patterns and the Java language. In many cases, I was able to ".Net-ify" the examples to take advantage of specific features of .Net. A good example was in the Observer pattern where you have an object that changes over time, and other objects ("observers") need to be aware of this change. The book presents a language-agnostic approach, where the observable object registers all of its observers, and cycles through them notifying each one that it has changed. With .Net, it's much easier (and more appropriate) to implement this using events, where the observable object doesn't care who's watching, it just announces "I've changed!" and each observer can then decide how to handle that event.

But I digress... ultimately, I just threw myself into this book, doing every example as written, and then modifying those examples to function with the .Net mentality. I even did all the pencil exercises, puzzles, etc. It's all part of the learning process, right?

So, in a nutshell, if you need to learn design patterns, get this book. It's a lot of fun, and chock full of great information and examples that you'll be able to apply to your own projects right away.

Since design patterns are about ways of organizing code in order to make it easier to understand and to manage, it should not be all that strange that the authors are also intersted in how to organize a book along the same principles.

Still I was a bit skeptical. This is the first book that I have seen in the Head First series. I have seen other books with cute graphics and came away disappointed because I felt I was being talked down to or because I thought the authors were not very knowledgeable.

I am happy to report that my fears were not realized. As the authors make clear in the introduction, they put a lot of work into making this book accessible. They succeeded immensely. It is also clear that they know whereof they speak with regard to the material covered. I have had trouble getting through the dry material on design patterns in other books. This book was a real eye opener. I higly recommend it to others who are having trouble understanding patterns. I can now see what all the fuss has been about and why it is so important for programmers to understand this material.

One criticism that I have is the code presented for the composite design pattern. If you read through it, it will be clear that it is too verbose and it will not work. To rectify this problem I give here in its entirety my version of the MoveNext method for a composite design pattern class, which I successfully tested on my computer.

Public Function MoveNext() As Boolean Implements IEnumerator.MoveNext

Dim iterator As IEnumerator

While True

' Try to get next item from iterator at top of stack

While Not CType(stck.Peek, IEnumerator).MoveNext

stck.Pop() ' Remove empty iterator from top of stack

If stck.Count = 0 Then ' No more iterators

Return False

End If

End While

iterator = stck.Peek

currentItem = iterator.Current

'If current item is a list then push its iterator onto stack

If enumType.IsInstanceOfType(currentItem) Then ' Next item is a list

stck.Push(CType(currentItem, IEnumerable).GetEnumerator())

Else ' Current item is not a list

Return True

End If

End While ' while True

End Function

Along with this book I would recommend reading the Wikipedia article on design patterns at [...]

They give a good compact description of the main patterns.

This book aims to teach us how to reuse design patterns that have been used over and over again. While this book does not cover all patterns in detail, it covers the patterns that are commonly used according to the authors' mind. In overall, this is the book you want to buy as a starting point to learn design patterns.

To begin with, before reading this book, you have to know about Java programming language along with the object-oriented features such as encapsulation, inheritance, and polymorphism. Bear in mind that by having solid object-oriented knowledge does not make you a good object-oriented designer. I thought the opposite until I read this book. For those who do not know the language and/or the object oriented feature, they should study them first before attempting to read this book.

When reading this book, please note that the primary intention of this book is to teach you about design patterns. Therefore, if you find the examples are not what you expected (too simple, childish, imaginary, and so on), you need to know that the examples are made as simple as possible so you can concentrate on learning design patterns. Unfortunately, some people just do not understand this approach. They probably want examples that have hundreds line of code to explain each patterns and I am very sure if this was the case, they would give bad review anyway by arguing that the examples are too complex.

The only negative thing is the fact that not all 23 patterns are covered. I wish all of them were covered in a single book and even if the price were twice as much I would certainly buy it. I do not know why the authors did so. They covered only around 13 and cramp the others in 20 pages in the appendix.

In my personal experience, after reading this book, it changed my paradigm toward object-oriented design and made me ask myself, "Why I didn't buy this book earlier?" Had I bought it earlier, my campus projects would have gone easier. In addition, ever since I read this book, I often think about the pattern(s) that can be applied in the other programming books' code example, especially when the examples have too many if and if else statements as they could be refactored using state pattern or command pattern. The reason some programming books do not bother with design patterns (even though the authors probably know about it) is because not their focus in their books. That is why this book is useful. Also, please be aware that in this book source code, the instance variables are not declared private. In reality you have to make it private according to the principle of the least privilege.

Finally, I highly recommend this book to anyone who already knows Java and its object-oriented features as it helps you to learn commonly used patterns and to design better using best design principles (open closed principle, encapsulate what varies, etc).

This is an excellent introductory book on patterns. They start out with the assumption that the reader does not really know what design patterns are or what they are good for. Developers who have been around awhile know about patterns, but overall I think their assumption is not a bad one: I think many of us have some ideas about patterns, and think we know some patterns, but don't really understand them. The book shines in its presentation of the patterns, even the ones we already "know," as extrapolations of basic OO design principles. The authors deserve very high marks for that.

They also have a lot of quirky, fun stuff in the book. It is, as another reviewer mentioned, almost insufferably cute. It's for the geek like me who wants to pretend we're not geeks, wink wink. Actually, I don't have any trouble with the humor, especially because sometimes it serves the valuable didactic purpose of helping one remember the points.

The negative points I have about the book are not primarily that the examples are simple; my main gripe is that the examples sometimes made things more confusing than they were before. For example, they spend an excellent first chapter discussing basic OO principles like "Favor Composition over Inheritance" and show how the Strategy pattern embodies them, and show a truly awful design in chapter 2 for Starbuzz Coffee (haha!) neglecting those principles, with a resulting explosion of classes. Very well.

But then, in chapter 4, they demonstrate the Factory pattern by eschewing composition in favor of inheritance, and creating an explosion of classes with all the varieties of pizza styles. Huh? Why are we suddenly dropping the principles that we've spent so much time on? Why not use composition with dependency injection as done in the "SimplePizzaFactory" example? Why not have a Pizza class that favors composition over inheritance? Now, there may in fact be good reasons, but they never discuss them. We're left wondering what's going on.

One more example: in discussing the Decorator pattern, they give what seems to me to be one of the worst uses of that pattern imaginable. "Condiments" are not "Beverages", and having a Beverage that chains to other Beverages seems very non-intuitive. Not at all a good example of "IS-A" relationships. Again, it's an illustration of the pattern, but a very jarring one that breaks reading continuity.

So, buy the book, read the book, "get" the patterns; but when you think some of the examples don't make sense, you're not alone.

Head First Design Patterns is an excellent introductory text for design patterns, plus object oriented design in general. Each chapter in the main part of the book covers one or two of the most common design patterns in great depth, including motivation, sample code, exercises, as well as answering many of the questions a reader is likely to have. Additionally, one of the things that makes the book great is that each chapter uses the context of the design pattern to introduce one or two important object oriented design principles such as the Open-Closed Principle and the Principle of Least Knowledge. Less common patterns are covered in the appendix, although in much less depth.

I bought this book for my 17-year-old nephew -- who is in the second year of a high school computer programming course -- as a companion to the Gang of Four book. I think the two books work well together, with Head First Design Patterns working as a more accessible introduction to design patterns, and the Gang of Four book serving as a reference for later on. He definitely finds the Head First book easier to read as a beginner. Even I, with a college degree in Computer Science and 20 years in the software development industry, find it valuable, at least as a review.

For those wondering about which edition they will get, I bought this book through Amazon and received the tenth anniversary edition, updated for Java 8. The main difference is that it takes advantage of the newly-introduced Lambda Expressions. Although the book uses Java throughout, C# developers will have little if any trouble with the examples. In many cases, the code is identical.

Slight nitpick: Some of the patterns in the appendix are given short shrift in the interest of space. For example, the section on the Visitor Pattern leaves out the important fact that one of the main motivations for the pattern is to overcome the limitations of languages that support only single dispatch. Said another way, the Visitor Pattern is trivial to implement in languages that support multiple dispatch. For more detail on these design patterns, I recommend the Gang of Four book, or online resources.

I've been writing object-oriented programs for the last 20 years, and have used many of the patterns listed in this book during that interval. Some of these were picked up through exposure to frameworks that employed them, some from books, and some just re-invented because they made sense for my particular application.

This book collects all of these patterns in one place, including some that I haven't used, and then explores and explains them from a variety of perspectives.

The book is a collaboration between technical experts and experts in learning theory. The result is that motivation for learning the material is thoroughly integrated into the formal content. Rather than just describing the "what" of a pattern, the book starts by dialoguing with the reader about the "why," so that by the time it gets into the "how" in more depth the reader is interested enough to explore all of the nuances of the various approaches to applying the technique. It attempts to anticipate objections the reader might raise regarding the importance of a given pattern, while at the same time throwing light upon the pattern by showing how it addresses real needs.

The presentation and examples are superior to most other books that I've read. There's a fair amount of repetition, but from different perspectives, so that at least one of the facets presented should resonate with the needs and experiences of the reader. In its presentation of the decorator pattern, for instance, the first example was a concocted coffee cost computation program that left me feeling that a critical aspect of that pattern, the building of more specialized functionality by wrapping more basic and fungible functionality, had not been adequately explored. But they followed up immediately with a real-world example from the java.io package that not only explored that aspect of Decorator, but also referenced code that I had already personally encountered and understood.

Another praiseworthy aspect of this book is the way in which it integrates general design principles like programming to an interface (rather than to an implementation) with more specific patterns like the Strategy pattern. This gives the reader a lower level base to fall back upon if a specific pattern cannot be found, or if an existing pattern needs to be specialized for a particular purpose.

This book arrived while I was designing a new application, and upon scanning through the various patterns for additional places within my application where patterns could be applied, I found a couple right away.

All in all, this book represents a raising of the bar for content, presentation and pedagogy in a technical manual.

I was kind of uneasy buying this book, I have NEVER bought a head first book...I've seen them at some of the larger book retailers and I've thumbed through them and quickly dismissed them as a gimmick and "for kids" due to all the illustrations and goofy quotes...I feel very sorry about that now, I have a TRUE FEELING that I would have a much deeper understanding of C++, Java, and PHP if all of Head First's books are written as well as this one...this book DOES make lots of use of "out of the ordinary" techniques when it comes to a software development book. It DOES NOT give detailed "cook book" code samples, and it DOES NOT promise to teach you EVERYTHING there is to know about Design Patterns. I wouldn't even say it gives you MANY "REAL WORlD" examples, nothing that you code in this book is OVERLY COMPLEX. What this book DOES DO, is offer a SIMPLE, VERY EASY TO UNDERSTAND, VERY INFORMATIVE, AND ENTERTAINING way to LEARN the most useful design patterns. This book is everything I wanted and more, it is not a Book's job to teach me how to be creative, or how to implement their exact code into my client's software...it does do EXACTLY what it should and presents the information in an EASY to grasp way without wasting your time. I would BUY THIS BOOK NOW.

WARNING: If you don't have a strong OO background before getting this book you may be making a mistake, the authors do an OK job trying to explain OO principles but if you don't understand some of the more common terms (or haven't looked at them in quite a while) it really helps to brush up prior to reading this book. I HIGHLY recrommend Object-Oriented Thought Process by Matt Weisfeld as an introduction or refresher, it is a FANTASTIC read on OO.

This might be a good college text book on the subject since you have a whole semester to complete the book. But for professionals and busy people, this is way too verbose. Imagine an experienced carpenter who bought a well-hyped replacement tool for a hammer. He would open the `how to' manual of that tool to quickly learn how to use it. But the manual is flooded with things like "why you don't want to use the hammer anymore", "the physics and mathematics behind the replacement tool", "analogy of the replacement tool and a crocodile", "why the earth is round", "why am I stupid to buy this tool", so much that the carpenter just can't use the tool right away. In other words, I agree with the 1-star reviewers. But I still give a 3-star because this is better than the "for dummies" book on the same subject. (I noticed that negative reviews of this book got lots of `not-useful' votes. So I expect this review to also have lots of those. Ultimately, the buyers are the one to decide.)

The book says you may still use the book even if you do not know java but knows c#. I disagree. Many java implementations of the gang of four patterns are different from the corresponding c# implementation as far as optimization goal is concerned. For example, take the popular singleton pattern. You may use a similar java approach for c# but the optimum way to implement it in c# is different (see Microsoft's Enterprise Solution Patterns using Microsoft .Net, to see how to implement singleton in c#). Also take the observer pattern. In c#, it is a simple subscription to an event by a client object from the publishing object.

If you are new on the subject, shop for a more concise book. True, repetition helps you learn, but talking about books, isn't it that you can always re-read the portion you do not understand?

Additionally, shop for similar books that have examples in the language you are using.

Se state cercando un libro che vi introduce al mondo dei Design Patterns questa è la scelta perfetta; nonostante sia stato scritto quasi 20 anni fa rimane una guida indispensabile.

Si fa sentire l'età per quel che riguarda il codice JAVA presente, anche se sul sito di riferimento c'è una versione parzialmente aggiornata.

Ma lo stile è davvero impagabile: ogni pattern è presentato in maniera colloquiale con esempi semplici e concreti, che fanno capire subito le potenzialità e i difetti di ogni soluzione.

Da ich mich hauptsächlich mit Embedded-Entwicklung in prozeduralen Sprachen befasse, war mir das Thema Design-Patterns bisher relativ unbekannt. Im Web findet man einiges zu diesem Thema, allerdings meist sehr trocken und in Form von Pattern-Katalogen ohne konkreten Praxisbezug. Meist wird lediglich ein Beispiel in diversen Programmiersprachen umgesetzt und fertig. Über die Hintergründe, die zur Entwicklung eines Patterns geführt haben, findet man meist eher wenig Informationen.

Nach einigem Stöbern bei Amazon fand ich dieses Buch, und ich muss sagen, dass sich die Anschaffung voll und ganz gelohnt hat. Keine sture Auflistung möglichst vieler Patterns, stattdessen eine didaktisch eigenwillig, aber äußerst effektiv gestaltete Reise in die fiktive Stadt Objectville, deren Bewohner mit allzu bekannten Problemen bei der Software-Entwicklung zu kämpfen haben. Jedes Kapitel widmet sich einem Pattern, wobei eine sinnvolle Auswahl aus den GoF-Patterns getroffen wurde. Beginnend mit einer Problemstellung werden die Patterns Schritt für Schritt erarbeitet, wobei auch Irrwege gezeigt und erläutert werden. Zwischendurch sorgen kleine Aufgaben für eine Festigung des Gelernten.

Der Schreibstil ist locker, das Layout gezielt ungewöhnlich, um das Gehirn zur Mitarbeit anzuregen statt mit ewigen Textmengen zu langweilen. Für mich geht dieses Konzept auf, man kann das Buch regelrecht verschlingen, und trotzdem bleibt der Stoff "hängen". Zweiflern empfehle ich "Pragmatisches Denken und Lernen" von Andy Hunt, das einige Einblicke in die Hintergründe solcher Lehrmethoden bringt.

Gute Englischkenntnisse sollten natürlich vorhanden sein, was allerdings bei der angesprochenen Zielgruppe heutzutage wohl ohnehin unerlässlich sein dürfte.

Nachtrag: Meine Java-Kenntnisse würde ich maximal als "grundlegend" bezeichnen. Trotzdem hatte ich keine Probleme mit dem Verständnis der erarbeiteten Code-Beispiele, da es in diesem Buch nicht um das Ausreizen aller Sprachfeinheiten von Java geht, sondern eben um Software-Design und Struktur.

Es un libro que todo desarrollador debería leer, vale mucho y es una joya. Son claros y concisos al momento de explicar los temas además siempre mencionan las variantes de los patrones y en muchos casos muestran como lo hace Java y si existe alguna falta en la manera en que java ha implementado ciertos patrones de diseño.

This is a must have book for any beginner or mid level software engineer. This book makes complex topic of design pattern very easy. 10 on 10 for this book for innovative way of story telling and pictorial depiction of design pattern. Once read and understood, Second and third readings are very easy to read and revise. I recommend this book highly if you are preparing for job interviews. Although JAVA is used in all the code examples these patterns are equally applicable to all mainstream programming languages, such as C++, C# etc.

If you are serious design patterns, I would still recommend reading this book before you jump on to GoF book. This gives you a head start and very good milage in all the important design patterns before you dive in to more detailed GoF patterns.

とてもしっかりしてる良本