This guide condenses the essentials from Design Patterns: Elements of Reusable Object-Oriented Software (GoF) and Head First Design Patterns. It’s designed to give you a solid understanding without the full books’ length. Each pattern includes an overview, the problem it solves, the solution structure, code examples (primarily Java from Head First, with notes on GoF C++ where relevant), and real-world uses. Aim for quick reads—about 3 “pages” per pattern in print terms.
1. Strategy
Overview
Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.
Problem
Your code has conditional logic for selecting different behaviors at runtime (e.g., different sorting algorithms or animal behaviors like flying/no flying). Hard-coding with if-else makes it rigid, hard to maintain, and violates open-closed principle (open for extension, closed for modification).
Solution
Extract behaviors into a strategy interface with concrete implementations. The context class holds a reference to the strategy and delegates to it. Change strategies dynamically for flexibility. Consequences: Promotes reuse, isolates algorithms, but increases object count.
Code Examples
From Head First (Duck simulation):
// Strategy interface
public interface FlyBehavior {
void fly();
}
// Concrete strategies
public class FlyWithWings implements FlyBehavior {
public void fly() {
System.out.println("I'm flying!");
}
}
public class FlyNoWay implements FlyBehavior {
public void fly() {
System.out.println("I can't fly");
}
}
// Context
public abstract class Duck {
FlyBehavior flyBehavior;
public void performFly() {
flyBehavior.fly();
}
public void setFlyBehavior(FlyBehavior fb) {
flyBehavior = fb;
}
}
// Usage
Duck mallard = new MallardDuck(); // Initially sets FlyWithWings
mallard.performFly(); // Outputs: I'm flying!
mallard.setFlyBehavior(new FlyNoWay());
mallard.performFly(); // Outputs: I can't fly
GoF uses C++ for similar family of algorithms, like sorting.
Real-world Engineering Uses
- Sorting libraries (e.g., Java’s Collections.sort with Comparator strategies).
- Payment processing (switch between credit card, PayPal strategies).
- Game AI behaviors (e.g., aggressive vs. defensive strategies in RTS games).
- Compression algorithms in file systems (ZIP vs. GZIP).
2. Observer
Overview
Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
Problem
Multiple objects need to react to changes in one object (e.g., UI views updating when data changes). Tight coupling with direct calls makes it hard to add/remove observers or change subjects without breaking code.
Solution
Subject maintains a list of observers and notifies them of changes. Observers implement an update method. Use push (send data) or pull (observers query subject). Consequences: Loose coupling, supports broadcast, but can lead to unexpected updates if not managed.
Code Examples
From Head First (Weather station):
// Subject interface
public interface Subject {
void registerObserver(Observer o);
void removeObserver(Observer o);
void notifyObservers();
}
// Concrete subject
public class WeatherData implements Subject {
private List<Observer> observers = new ArrayList<>();
private float temperature, humidity, pressure;
public void registerObserver(Observer o) { observers.add(o); }
public void removeObserver(Observer o) { observers.remove(o); }
public void notifyObservers() {
for (Observer o : observers) o.update(temperature, humidity, pressure);
}
public void measurementsChanged() { notifyObservers(); }
public void setMeasurements(float t, float h, float p) {
temperature = t; humidity = h; pressure = p;
measurementsChanged();
}
}
// Observer interface
public interface Observer {
void update(float temp, float humidity, float pressure);
}
// Concrete observer
public class CurrentConditionsDisplay implements Observer {
public void update(float temp, float humidity, float pressure) {
System.out.println("Current conditions: " + temp + "F degrees and " + humidity + "% humidity");
}
}
// Usage
WeatherData weatherData = new WeatherData();
CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay();
weatherData.registerObserver(currentDisplay);
weatherData.setMeasurements(80, 65, 30.4f); // Triggers update
GoF uses C++ for similar subject-observer setup, like clock timer notifying clocks.
Real-world Engineering Uses
- Event listeners in GUIs (e.g., button clicks notifying handlers).
- Stock market apps (price changes notifying subscribers).
- MVC frameworks (model changes updating views).
- Reactive programming (RxJava observables).
3. Decorator
Overview
Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.
Problem
You need to add features/behaviors to objects at runtime (e.g., coffee with varying condiments), but subclassing for every combination explodes the class hierarchy (e.g., MochaWithWhipAndSoy).
Solution
Wrap the core object with decorator classes that implement the same interface and forward calls, adding behavior. Chain decorators for multiple additions. Consequences: Flexible, pay-as-you-go, but can lead to many small objects.
Code Examples
From Head First (Beverage with condiments):
// Component interface
public abstract class Beverage {
String description = "Unknown Beverage";
public String getDescription() { return description; }
public abstract double cost();
}
// Concrete component
public class Espresso extends Beverage {
public Espresso() { description = "Espresso"; }
public double cost() { return 1.99; }
}
// Decorator
public abstract class CondimentDecorator extends Beverage {
Beverage beverage;
public abstract String getDescription();
}
// Concrete decorator
public class Mocha extends CondimentDecorator {
public Mocha(Beverage beverage) { this.beverage = beverage; }
public String getDescription() { return beverage.getDescription() + ", Mocha"; }
public double cost() { return beverage.cost() + 0.20; }
}
// Usage
Beverage beverage = new Espresso();
beverage = new Mocha(beverage);
beverage = new Whip(beverage); // Chain decorators
System.out.println(beverage.getDescription() + " $" + beverage.cost()); // Espresso, Mocha, Whip $2.28
GoF uses C++ for visual components adding borders/scrollbars.
Real-world Engineering Uses
- Java I/O streams (BufferedInputStream wraps FileInputStream).
- GUI components (adding borders/scrollbars to windows).
- Pricing systems (base product + add-ons).
- Logging wrappers around services.
4. Factory Method
Overview
Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
Problem
Code depends on concrete classes for object creation, making it hard to switch implementations or extend (e.g., creating different pizza styles in different stores).
Solution
Define a factory method in a base class that subclasses override to return concrete products. Client uses the base class. Consequences: Parallel hierarchies for creators/products, promotes loose coupling.
Code Examples
From Head First (Pizza stores):
// Product
public abstract class Pizza {
public void prepare() { /* ... */ }
public void bake() { /* ... */ }
// etc.
}
// Concrete products
public class NYStyleCheesePizza extends Pizza { /* NY specifics */ }
public class ChicagoStyleCheesePizza extends Pizza { /* Chicago specifics */ }
// Creator
public abstract class PizzaStore {
public Pizza orderPizza(String type) {
Pizza pizza = createPizza(type); // Factory method
pizza.prepare(); pizza.bake(); /* etc. */
return pizza;
}
protected abstract Pizza createPizza(String type); // Factory method
}
// Concrete creator
public class NYPizzaStore extends PizzaStore {
protected Pizza createPizza(String item) {
if (item.equals("cheese")) return new NYStyleCheesePizza();
// other types
return null;
}
}
// Usage
PizzaStore nyStore = new NYPizzaStore();
Pizza pizza = nyStore.orderPizza("cheese"); // Gets NY style
GoF uses C++ for document apps creating app-specific documents.
Real-world Engineering Uses
- JDBC drivers (DriverManager.getConnection defers to subclasses).
- Logging frameworks (Logger.getLogger for different loggers).
- Game object spawners (enemy factories for different levels).
- UI toolkit widgets (platform-specific buttons).
5. Abstract Factory
Overview
Provide an interface for creating families of related or dependent objects without specifying their concrete classes.
Problem
Need to create related objects (e.g., ingredients for pizza) that vary by family (NY vs. Chicago style), but code tightly coupled to concretes makes switching families hard.
Solution
Abstract factory interface with methods for each product type. Concrete factories implement for specific families. Client uses factory reference. Consequences: Isolates concretes, easy to swap families, enforces consistency.
Code Examples
From Head First (Pizza ingredients):
// Abstract products
public interface Dough { /* ... */ }
public interface Sauce { /* ... */ }
// Concrete products
public class ThinCrustDough implements Dough { /* ... */ }
public class MarinaraSauce implements Sauce { /* ... */ }
public class ThickCrustDough implements Dough { /* ... */ }
public class PlumTomatoSauce implements Sauce { /* ... */ }
// Abstract factory
public interface PizzaIngredientFactory {
Dough createDough();
Sauce createSauce();
// other ingredients
}
// Concrete factory
public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
public Dough createDough() { return new ThinCrustDough(); }
public Sauce createSauce() { return new MarinaraSauce(); }
// etc.
}
// Usage
PizzaIngredientFactory nyFactory = new NYPizzaIngredientFactory();
Dough dough = nyFactory.createDough(); // ThinCrustDough
GoF uses C++ for widget kits (Motif vs. PM widgets).
Real-world Engineering Uses
- GUI toolkits (Abstract factories for Windows/Mac widgets).
- Database connectors (factories for SQL vs. NoSQL families).
- Cloud services (AWS vs. Azure resource factories).
- Game asset loaders (2D vs. 3D asset families).
6. Singleton
Overview
Ensure a class only has one instance, and provide a global point of access to it.
Problem
Need exactly one instance (e.g., global config, thread pool), but globals are bad for testing/maintenance, and multiple instances cause issues.
Solution
Private constructor, static instance variable, static getInstance method that lazily creates/returns it. Consequences: Controlled access, reduces namespace pollution, allows subclassing.
Code Examples
From Head First (Chocolate boiler):
public class ChocolateBoiler {
private boolean empty;
private boolean boiled;
private static ChocolateBoiler uniqueInstance;
private ChocolateBoiler() {
empty = true;
boiled = false;
}
public static ChocolateBoiler getInstance() {
if (uniqueInstance == null) {
uniqueInstance = new ChocolateBoiler();
}
return uniqueInstance;
}
// Methods like fill, boil, drain
}
// Usage
ChocolateBoiler boiler = ChocolateBoiler.getInstance(); // Always same instance
GoF uses C++ for similar global access, like app config.
Real-world Engineering Uses
- Logging classes (single logger instance).
- Database connections (connection pool manager).
- Configuration managers.
- Runtime environments (Java’s Runtime.getRuntime()).
7. Command
Overview
Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.
Problem
Need to issue requests without knowing the receiver/action (e.g., menu items invoking actions, undo/redo). Direct calls couple invoker to receiver.
Solution
Command interface with execute/undo. Concrete commands hold receiver and action. Invoker calls execute. Consequences: Decouples invoker/receiver, supports undo/queuing, composable (macros).
Code Examples
From Head First (Remote control):
// Command interface
public interface Command {
void execute();
void undo();
}
// Concrete command
public class LightOnCommand implements Command {
Light light;
public LightOnCommand(Light light) { this.light = light; }
public void execute() { light.on(); }
public void undo() { light.off(); }
}
// Invoker
public class RemoteControl {
Command slot;
public void setCommand(Command command) { slot = command; }
public void buttonWasPressed() { slot.execute(); }
}
// Usage
Light livingRoomLight = new Light();
Command lightOn = new LightOnCommand(livingRoomLight);
RemoteControl remote = new RemoteControl();
remote.setCommand(lightOn);
remote.buttonWasPressed(); // Turns light on
GoF uses C++ for menu commands.
Real-world Engineering Uses
- Undo/redo in editors.
- Job queues (commands as tasks).
- Transaction logs in databases.
- GUI buttons/menus.
8. Adapter
Overview
Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces.
Problem
You have an existing class with useful functionality, but its interface doesn’t match what the client expects (e.g., adapting a third-party library).
Solution
Create an adapter that implements the target interface and wraps the adaptee, forwarding calls. Class adapter (inheritance) or object adapter (composition). Consequences: Allows reuse, adds indirection.
Code Examples
From Head First (Turkey adapting to Duck):
// Target interface
public interface Duck {
void quack();
void fly();
}
// Adaptee
public class WildTurkey {
public void gobble() { System.out.println("Gobble gobble"); }
public void fly() { System.out.println("I'm flying a short distance"); }
}
// Adapter
public class TurkeyAdapter implements Duck {
WildTurkey turkey;
public TurkeyAdapter(WildTurkey turkey) { this.turkey = turkey; }
public void quack() { turkey.gobble(); }
public void fly() {
for (int i = 0; i < 5; i++) turkey.fly(); // Turkey flies short, so call multiple times
}
}
// Usage
Duck duck = new TurkeyAdapter(new WildTurkey());
duck.quack(); // Gobble gobble
duck.fly(); // Flies short 5 times
GoF uses C++ for drawing text with different APIs.
Real-world Engineering Uses
- Legacy system integration.
- Java I/O adapters (InputStreamReader adapts Reader).
- Database drivers adapting to JDBC.
- Third-party API wrappers.
9. Facade
Overview
Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.
Problem
Subsystem has many classes, leading to complex usage and tight coupling for clients (e.g., home theater with amp, DVD, projector).
Solution
Facade class delegates to subsystem classes, providing simple methods. Clients use facade. Consequences: Simplifies usage, reduces coupling, layers subsystems.
Code Examples
From Head First (Home theater):
// Subsystem classes
public class Amplifier { public void on() { /* ... */ } /* more */ }
public class DvdPlayer { public void on() { /* ... */ } /* more */ }
// etc. for Tuner, Projector, Lights, Screen, PopcornPopper
// Facade
public class HomeTheaterFacade {
Amplifier amp;
DvdPlayer dvd;
// other components
public HomeTheaterFacade(Amplifier amp, DvdPlayer dvd /* etc. */) {
this.amp = amp; this.dvd = dvd; // etc.
}
public void watchMovie(String movie) {
lights.dim(10);
screen.down();
projector.on();
amp.on();
dvd.on();
dvd.play(movie);
}
public void endMovie() { /* shutdown sequence */ }
}
// Usage
HomeTheaterFacade homeTheater = new HomeTheaterFacade(amp, dvd /* etc. */);
homeTheater.watchMovie("Raiders of the Lost Ark");
GoF uses C++ for compiler facade.
Real-world Engineering Uses
- API gateways in microservices.
- Database facades (wrapping JDBC complexity).
- Home automation systems.
- Compiler front-ends.
10. Template Method
Overview
Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure.
Problem
Algorithms have common structure but vary in details (e.g., making tea vs. coffee). Duplicating code in subclasses violates DRY.
Solution
Base class has template method calling abstract/primitive steps. Subclasses implement them. Hooks for optional behavior. Consequences: Code reuse, inversion of control.
Code Examples
From Head First (Beverage preparation):
// Abstract class with template
public abstract class CaffeineBeverage {
final void prepareRecipe() { // Template method
boilWater();
brew();
pourInCup();
addCondiments();
}
abstract void brew();
abstract void addCondiments();
void boilWater() { System.out.println("Boiling water"); }
void pourInCup() { System.out.println("Pouring into cup"); }
}
// Concrete subclass
public class Coffee extends CaffeineBeverage {
void brew() { System.out.println("Dripping Coffee through filter"); }
void addCondiments() { System.out.println("Adding Sugar and Milk"); }
}
// Usage
CaffeineBeverage myCoffee = new Coffee();
myCoffee.prepareRecipe(); // Executes the steps with Coffee specifics
GoF uses C++ for application frameworks.
Real-world Engineering Uses
- Servlet doGet/doPost template in Java EE.
- Game loops (update/render hooks).
- Sorting frameworks (compareTo as hook).
- Build processes (pre/post-build steps).
11. Iterator
Overview
Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
Problem
Need to traverse collections (list, array, tree) without knowing structure, or support multiple traversals.
Solution
Iterator interface with hasNext/next. Concrete iterators for specific collections. Consequences: Hides implementation, supports polymorphism, easy to add new traversals.
Code Examples
From Head First (Menu items):
// Iterator interface
public interface Iterator {
boolean hasNext();
MenuItem next();
}
// Aggregate
public class DinerMenu {
MenuItem[] menuItems;
public Iterator createIterator() {
return new DinerMenuIterator(menuItems);
}
}
// Concrete iterator
public class DinerMenuIterator implements Iterator {
MenuItem[] items;
int position = 0;
public DinerMenuIterator(MenuItem[] items) { this.items = items; }
public MenuItem next() { return items[position++]; }
public boolean hasNext() { return position < items.length; }
}
// Usage
DinerMenu dinerMenu = new DinerMenu();
Iterator iterator = dinerMenu.createIterator();
while (iterator.hasNext()) {
MenuItem menuItem = iterator.next();
// process item
}
GoF uses C++ for list iterators.
Real-world Engineering Uses
- Java Collections (list.iterator()).
- Database cursors.
- File system traversal.
- XML parsers.
12. Composite
Overview
Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.
Problem
Need to treat single objects and groups the same (e.g., menu items and submenus). Separate classes lead to type checks.
Solution
Component interface for leaves/composites. Composites hold children, forward calls. Consequences: Uniform treatment, easy to add components, but can overgeneralize.
Code Examples
From Head First (Menus):
// Component
public abstract class MenuComponent {
public void add(MenuComponent menuComponent) { throw new UnsupportedOperationException(); }
public void remove(MenuComponent menuComponent) { throw new UnsupportedOperationException(); }
public MenuComponent getChild(int i) { throw new UnsupportedOperationException(); }
public void print() { throw new UnsupportedOperationException(); }
}
// Leaf
public class MenuItem extends MenuComponent {
String name;
public MenuItem(String name) { this.name = name; }
public void print() { System.out.println(name); }
}
// Composite
public class Menu extends MenuComponent {
List<MenuComponent> menuComponents = new ArrayList<>();
String name;
public Menu(String name) { this.name = name; }
public void add(MenuComponent menuComponent) { menuComponents.add(menuComponent); }
public void remove(MenuComponent menuComponent) { menuComponents.remove(menuComponent); }
public MenuComponent getChild(int i) { return menuComponents.get(i); }
public void print() {
System.out.println(name);
for (MenuComponent component : menuComponents) component.print();
}
}
// Usage
MenuComponent allMenus = new Menu("ALL MENUS");
allMenus.add(new Menu("DINER MENU"));
allMenus.print(); // Prints hierarchy
GoF uses C++ for graphics.
Real-world Engineering Uses
- File systems (files/folders).
- GUI components (panels containing buttons).
- Organizational hierarchies (employees/managers).
- XML/JSON parsers.
13. State
Overview
Allow an object to alter its behavior when its internal state changes. The object will appear to change its class.
Problem
Object behavior changes based on state, leading to large conditionals (e.g., TCP connection states).
Solution
State interface with methods for behaviors. Concrete states implement. Context delegates to current state, changes state as needed. Consequences: Localizes state behavior, eliminates conditionals, but increases classes.
Code Examples
From Head First (Gumball machine):
// State interface
public interface State {
void insertQuarter();
void ejectQuarter();
void turnCrank();
void dispense();
}
// Concrete state
public class NoQuarterState implements State {
GumballMachine gumballMachine;
public NoQuarterState(GumballMachine gumballMachine) { this.gumballMachine = gumballMachine; }
public void insertQuarter() { System.out.println("You inserted a quarter"); gumballMachine.setState(gumballMachine.getHasQuarterState()); }
// other methods do nothing or error
}
// Context
public class GumballMachine {
State soldOutState, noQuarterState, hasQuarterState, soldState;
State state = soldOutState;
int count = 0;
public GumballMachine(int numberGumballs) {
// init states
count = numberGumballs;
if (count > 0) state = noQuarterState;
}
public void insertQuarter() { state.insertQuarter(); }
// other delegations
public void setState(State state) { this.state = state; }
// getters for states
}
// Usage
GumballMachine gumballMachine = new GumballMachine(5);
gumballMachine.insertQuarter(); // Transitions to hasQuarterState
GoF uses C++ for TCP states.
Real-world Engineering Uses
- Workflow engines (states like pending/approved).
- Game character states (idle/walking/attacking).
- UI wizards (steps as states).
- Protocol handlers (TCP states).
14. Proxy
Overview
Provide a surrogate or placeholder for another object to control access to it.
Problem
Need to add lazy loading, access control, or logging to an object without changing it (e.g., loading expensive images on demand).
Solution
Proxy implements same interface as real subject, delegates with added behavior (virtual for lazy, remote for network, protection for access). Consequences: Adds indirection, transparent to client.
Code Examples
From Head First (Gumball monitor proxy):
// Subject interface
public interface GumballMachineRemote extends Remote {
int getCount() throws RemoteException;
String getLocation() throws RemoteException;
State getState() throws RemoteException;
}
// Real subject
public class GumballMachine implements GumballMachineRemote {
// implementation
}
// Proxy
public class GumballMonitor {
GumballMachineRemote machine;
public GumballMonitor(GumballMachineRemote machine) { this.machine = machine; }
public void report() {
try {
System.out.println("Gumball Machine: " + machine.getLocation());
System.out.println("Current inventory: " + machine.getCount() + " gumballs");
System.out.println("Current state: " + machine.getState());
} catch (RemoteException e) { e.printStackTrace(); }
}
}
// Usage (with RMI for remote)
GumballMachineRemote machine = (GumballMachineRemote) Naming.lookup("//" + location + "/gumballmachine");
GumballMonitor monitor = new GumballMonitor(machine);
monitor.report(); // Accesses remote via proxy
GoF uses C++ for image proxies (virtual proxy for lazy loading).
Real-world Engineering Uses
- Lazy loading (virtual proxies for images/DB queries).
- Remote proxies (RMI/EJB).
- Security proxies (access control).
- Smart references (reference counting).
15. Builder
Overview
Separate the construction of a complex object from its representation so that the same construction process can create different representations.
Problem
Creating complex objects with many parts/options (e.g., building mazes with different rooms). Direct construction in client couples to representation.
Solution
Builder interface for steps. Concrete builders implement for representations. Director uses builder. Consequences: Isolates construction, easy to vary products.
Code Examples
From Head First (Vacation planner, but adapted from GoF maze):
// Product
public class Maze { /* rooms, etc. */ }
// Builder interface
public abstract class MazeBuilder {
public abstract void buildMaze();
public abstract void buildRoom(int room);
public abstract void buildDoor(int roomFrom, int roomTo);
public abstract Maze getMaze();
}
// Concrete builder
public class StandardMazeBuilder extends MazeBuilder {
private Maze currentMaze;
public void buildMaze() { currentMaze = new Maze(); }
public void buildRoom(int room) { /* add room to maze */ }
public void buildDoor(int roomFrom, int roomTo) { /* add door */ }
public Maze getMaze() { return currentMaze; }
}
// Director
public class MazeGame {
public Maze createMaze(MazeBuilder builder) {
builder.buildMaze();
builder.buildRoom(1);
builder.buildRoom(2);
builder.buildDoor(1, 2);
return builder.getMaze();
}
}
// Usage
MazeBuilder builder = new StandardMazeBuilder();
MazeGame game = new MazeGame();
Maze maze = game.createMaze(builder);
GoF uses C++ for RTF document builders.
Real-world Engineering Uses
- StringBuilder in Java (builds strings efficiently).
- Meal builders in food apps (combo meals).
- Configuration builders (step-by-step setup).
- Game level generators.
Enjoyed this? Get new posts in your inbox.
Occasional dev notes and stories. No spam, unsubscribe anytime.
