Head First Design Patterns: A Brain-Friendly Guide

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).

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.