LearningTree
Design Patterns
All 20 Gang of Four design patterns with UML class diagrams, detailed descriptions, and implementations in Java, Python & C# — organised by Creational, Structural, and Behavioral categories.
Design patterns are reusable solutions to recurring design problems. The Gang of Four (GoF) catalogued 23 patterns in three categories. This page covers the 20 most essential patterns with UML diagrams and tri-language code examples.
| Category | Patterns | Focus |
|---|---|---|
| Creational (5) | Singleton, Factory Method, Abstract Factory, Builder, Prototype | Object creation mechanisms |
| Structural (7) | Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy | Object composition & structure |
| Behavioral (8) | Observer, Strategy, Command, Template Method, Chain of Responsibility, State, Mediator, Visitor | Object communication & responsibility |
01
Chapter One · Object Creation
Creational Patterns
Creational patterns abstract the instantiation process — they make a system independent of how its objects are created, composed, and represented.
Singleton
- One instance, global access
Factory Method
- Subclass-driven creation
Abstract Factory
- Product family creation
Builder
- Step-by-step construction
Prototype
- Clone-based instantiation
Singleton
Ensures a class has only one instance and provides a global point of access to it.
When to use: Use when exactly one instance is needed — loggers, config managers, thread pools, caches.
| Component | Role |
|---|---|
| Static Instance | Holds the single instance |
| Private Constructor | Prevents external instantiation |
| getInstance() | Returns the sole instance |
Singleton — Class Diagram
Factory Method
Defines an interface for creating objects, letting subclasses decide which class to instantiate.
When to use: Use when a class cannot anticipate the type of objects it needs to create.
| Component | Role |
|---|---|
| Creator | Declares the factory method |
| ConcreteCreator | Overrides factory method |
| Product | Interface for objects |
| ConcreteProduct | Specific implementation |
Factory Method — Class Diagram
Abstract Factory
Provides an interface for creating families of related objects without specifying concrete classes.
When to use: Use when products come in families that must be used together (e.g. cross-platform UI).
| Component | Role |
|---|---|
| AbstractFactory | Interface for creating families |
| ConcreteFactory | Creates specific family |
| AbstractProduct | Interface per product type |
| Client | Uses only abstract interfaces |
Abstract Factory — Class Diagram
Builder
Separates the construction of a complex object from its representation, allowing step-by-step creation.
When to use: Use when constructing complex objects with many optional parameters.
| Component | Role |
|---|---|
| Builder | Step-by-step interface |
| ConcreteBuilder | Builds the product |
| Director | Orchestrates order |
| Product | Complex object built |
Builder — Class Diagram
Prototype
Creates new objects by cloning an existing instance, avoiding costly creation from scratch.
When to use: Use when object creation is expensive or you need copies with slight variations.
| Component | Role |
|---|---|
| Prototype | Interface with clone() |
| ConcretePrototype | Implements cloning |
| Client | Requests clones |
Prototype — Class Diagram
📋 Chapter 1 — Summary
- Singleton — one instance, global access (use sparingly)
- Factory Method — subclasses decide which class to instantiate
- Abstract Factory — create families of related objects
- Builder — construct complex objects step by step
- Prototype — clone existing objects to avoid costly creation
02
Chapter Two · Object Composition
Structural Patterns
Structural patterns deal with object composition — how classes and objects are assembled to form larger structures while keeping them flexible and efficient.
Adapter
- Interface conversion
Bridge
- Abstraction / impl split
Composite
- Tree structures
Decorator
- Dynamic behaviour
Facade
- Simple interface
Flyweight
- Memory sharing
Proxy
- Access control
Adapter
Converts the interface of a class into another interface clients expect.
When to use: Use when you want to use an existing class but its interface is incompatible.
| Component | Role |
|---|---|
| Target | Interface client expects |
| Adapter | Bridges target and adaptee |
| Adaptee | Existing incompatible class |
Adapter — Class Diagram
Bridge
Decouples an abstraction from its implementation so they can vary independently.
When to use: Use when you want to avoid a permanent binding between abstraction and implementation.
| Component | Role |
|---|---|
| Abstraction | High-level interface |
| Implementor | Low-level interface |
| RefinedAbstraction | Extended abstraction |
| ConcreteImplementor | Specific implementation |
Bridge — Class Diagram
Composite
Composes objects into tree structures to represent part-whole hierarchies.
When to use: Use when clients should treat individual objects and compositions uniformly.
| Component | Role |
|---|---|
| Component | Common interface |
| Leaf | Primitive element |
| Composite | Has children components |
Composite — Class Diagram
Decorator
Attaches additional responsibilities to an object dynamically without altering its structure.
When to use: Use to add behaviour to objects without subclass explosion.
| Component | Role |
|---|---|
| Component | Interface |
| ConcreteComponent | Base object |
| Decorator | Wraps component |
| ConcreteDecorator | Adds behaviour |
Decorator — Class Diagram
Facade
Provides a simplified interface to a complex subsystem.
When to use: Use to reduce coupling between clients and a complex library or subsystem.
| Component | Role |
|---|---|
| Facade | Simple unified interface |
| Subsystem classes | Complex internal components |
Facade — Class Diagram
Flyweight
Shares common state among many objects to reduce memory usage.
When to use: Use when many similar objects consume too much memory (text editors, game particles).
| Component | Role |
|---|---|
| Flyweight | Shared intrinsic state |
| FlyweightFactory | Manages shared instances |
| Client | Provides extrinsic state |
Flyweight — Class Diagram
Proxy
Provides a surrogate or placeholder for another object to control access.
When to use: Use for lazy loading, access control, logging, or caching.
| Component | Role |
|---|---|
| Subject | Common interface |
| RealSubject | Actual object |
| Proxy | Controls access to real subject |
Proxy — Class Diagram
📋 Chapter 2 — Summary
- Adapter — convert one interface to another
- Bridge — separate abstraction from implementation
- Composite — treat individual and composite objects uniformly
- Decorator — add behaviour without subclassing
- Facade — simplify complex subsystem interfaces
- Flyweight — share state to reduce memory
- Proxy — control access to an object
03
Chapter Three · Communication
Behavioral Patterns
Behavioral patterns are concerned with communication between objects — how responsibilities are assigned and how algorithms are encapsulated.
Observer
- Event notification
Strategy
- Swap algorithms
Command
- Encapsulate requests
Template Method
- Algorithm skeleton
Chain of Resp.
- Handler pipeline
State
- State-based behaviour
Mediator
- Central coordination
Visitor
- Add operations
Observer
Defines a one-to-many dependency so that when one object changes state, all dependents are notified.
When to use: Use for event systems, pub/sub, reactive UI updates.
| Component | Role |
|---|---|
| Subject | Maintains observer list |
| Observer | Interface for notification |
| ConcreteObserver | Reacts to changes |
Observer — Class Diagram
Strategy
Defines a family of algorithms, encapsulates each one, and makes them interchangeable.
When to use: Use when you need to switch algorithms at runtime (sorting, payment, routing).
| Component | Role |
|---|---|
| Strategy | Algorithm interface |
| ConcreteStrategy | Specific algorithm |
| Context | Uses a strategy |
Strategy — Class Diagram
Command
Encapsulates a request as an object, allowing parameterization and queuing.
When to use: Use for undo/redo, task queuing, macro recording.
| Component | Role |
|---|---|
| Command | Interface with execute() |
| ConcreteCommand | Binds receiver to action |
| Invoker | Triggers command |
| Receiver | Performs the work |
Command — Class Diagram
Template Method
Defines the skeleton of an algorithm, deferring some steps to subclasses.
When to use: Use when multiple classes share the same algorithm but differ in specific steps.
| Component | Role |
|---|---|
| AbstractClass | Template with hook methods |
| ConcreteClass | Overrides specific steps |
Template Method — Class Diagram
Chain of Responsibility
Passes a request along a chain of handlers until one handles it.
When to use: Use for middleware pipelines, event bubbling, approval workflows.
| Component | Role |
|---|---|
| Handler | Interface with next handler |
| ConcreteHandler | Handles or passes along |
Chain of Responsibility — Class Diagram
State
Allows an object to alter its behaviour when its internal state changes.
When to use: Use when an object has many conditional behaviours that depend on its state.
| Component | Role |
|---|---|
| Context | Maintains current state |
| State | Interface for behaviours |
| ConcreteState | State-specific behaviour |
State — Class Diagram
Mediator
Defines an object that encapsulates how a set of objects interact, promoting loose coupling.
When to use: Use when many objects communicate in complex ways (chat rooms, UI components).
| Component | Role |
|---|---|
| Mediator | Coordination interface |
| ConcreteMediator | Implements coordination |
| Colleague | Communicates via mediator |
Mediator — Class Diagram
Visitor
Lets you add new operations to existing classes without modifying them.
When to use: Use when you need to perform many unrelated operations on an object structure.
| Component | Role |
|---|---|
| Visitor | Declares visit methods |
| ConcreteVisitor | Implements operations |
| Element | Accepts visitors |
Visitor — Class Diagram
📋 Chapter 3 — Summary
- Observer — notify dependents when state changes
- Strategy — swap algorithms at runtime
- Command — encapsulate requests as objects (undo/redo)
- Template Method — define algorithm skeleton, defer steps
- Chain of Responsibility — pass request along handler chain
- State — change behaviour when state changes
- Mediator — centralise complex communication
- Visitor — add operations without modifying classes
Summary — 20 Design Patterns at a Glance
01 · Creational
Object Creation
- Singleton — one global instance
- Factory Method — subclass decides
- Abstract Factory — product families
- Builder — step-by-step
- Prototype — clone instances
02 · Structural
Object Composition
- Adapter — interface conversion
- Bridge — abstraction split
- Composite — tree structures
- Decorator — dynamic behaviour
- Facade — simple interface
- Flyweight — memory sharing
- Proxy — access control
03 · Behavioral
Communication
- Observer — event notification
- Strategy — swap algorithms
- Command — encapsulate requests
- Template Method — algorithm skeleton
- Chain of Resp. — handler pipeline
- State — state-based behaviour
- Mediator — central coordination
- Visitor — add operations
Singleton
Java
public class Singleton {
private static volatile Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null)
instance = new Singleton();
}
}
return instance;
}
}
Python
class Singleton:
_instance = None def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
C#
public sealed class Singleton {
private static readonly Lazy<Singleton> _inst
= new(() => new Singleton());
private Singleton() {}
public static Singleton Instance => _inst.Value;
}
Factory Method
Java
interface Product { void use(); }
abstract class Creator {
abstract Product factoryMethod();
}
class ConcreteCreator extends Creator {
Product factoryMethod() {
return new ConcreteProduct();
}
}
Python
from abc import ABC, abstractmethod
class Creator(ABC):
@abstractmethod
def factory_method(self): ...
class ConcreteCreator(Creator):
def factory_method(self):
return ConcreteProduct()
C#
public abstract class Creator {
public abstract IProduct FactoryMethod();
}
public class ConcreteCreator : Creator {
public override IProduct FactoryMethod()
=> new ConcreteProduct();
}
Abstract Factory
Java
interface GUIFactory {
Button createButton();
Window createWindow();
}
class WinFactory implements GUIFactory {
public Button createButton() { return new WinButton(); }
public Window createWindow() { return new WinWindow(); }
}
Python
class GUIFactory(ABC):
@abstractmethod
def create_button(self): ...
@abstractmethod
def create_window(self): ...
class WinFactory(GUIFactory):
def create_button(self): return WinButton()
def create_window(self): return WinWindow()
C#
public interface IGUIFactory {
IButton CreateButton();
IWindow CreateWindow();
}
public class WinFactory : IGUIFactory {
public IButton CreateButton() => new WinButton();
public IWindow CreateWindow() => new WinWindow();
}
Builder
Java
class Car { String engine, wheels; }
class CarBuilder {
private Car car = new Car();
CarBuilder engine(String e) { car.engine=e; return this; }
CarBuilder wheels(String w) { car.wheels=w; return this; }
Car build() { return car; }
}
Python
class CarBuilder:
def __init__(self): self._car = Car()
def engine(self, e): self._car.engine=e; return self
def wheels(self, w): self._car.wheels=w; return self
def build(self): return self._car
C#
public class CarBuilder {
private Car _car = new();
public CarBuilder Engine(string e) { _car.Engine=e; return this; }
public CarBuilder Wheels(string w) { _car.Wheels=w; return this; }
public Car Build() => _car;
}
Prototype
Java
class Shape implements Cloneable {
String type;
public Shape clone() {
try { return (Shape) super.clone(); }
catch (CloneNotSupportedException e) { return null; }
}
}
Python
import copy
class Shape:
def clone(self):
return copy.deepcopy(self)
C#
public class Shape : ICloneable {
public string Type { get; set; }
public object Clone() => MemberwiseClone();
}
Adapter
Java
interface Target { void request(); }
class Adaptee { void specificRequest() {} }
class Adapter implements Target {
private Adaptee adaptee;
public void request() { adaptee.specificRequest(); }
}
Python
class Adaptee:
def specific_request(self): ...
class Adapter:
def __init__(self, adaptee): self._adaptee = adaptee
def request(self): self._adaptee.specific_request()
C#
public class Adapter : ITarget {
private readonly Adaptee _adaptee;
public void Request() => _adaptee.SpecificRequest();
}
Bridge
Java
interface DrawAPI { void draw(); }
abstract class Shape {
protected DrawAPI api;
abstract void draw();
}
class Circle extends Shape {
void draw() { api.draw(); }
}
Python
class Shape:
def __init__(self, api): self._api = api
def draw(self): self._api.draw()
C#
public abstract class Shape {
protected IDrawAPI _api;
public abstract void Draw();
}
Composite
Java
interface Component { void operation(); }
class Leaf implements Component {
public void operation() { /* leaf work */ }
}
class Composite implements Component {
List<Component> children = new ArrayList<>();
public void operation() {
children.forEach(Component::operation);
}
}
Python
class Composite:
def __init__(self): self.children = []
def add(self, c): self.children.append(c)
def operation(self):
for c in self.children: c.operation()
C#
public class Composite : IComponent {
private List<IComponent> _children = new();
public void Add(IComponent c) => _children.Add(c);
public void Operation() { _children.ForEach(c => c.Operation()); }
}
Decorator
Java
interface Coffee { double cost(); }
class SimpleCoffee implements Coffee {
public double cost() { return 1.0; }
}
class MilkDecorator implements Coffee {
private Coffee wrapped;
public double cost() { return wrapped.cost() + 0.5; }
}
Python
class MilkDecorator:
def __init__(self, coffee): self._coffee = coffee
def cost(self): return self._coffee.cost() + 0.5
C#
public class MilkDecorator : ICoffee {
private readonly ICoffee _coffee;
public double Cost() => _coffee.Cost() + 0.5;
}
Facade
Java
class HomeTheaterFacade {
private Amplifier amp;
private DVDPlayer dvd;
public void watchMovie() {
amp.on(); dvd.play();
}
}
Python
class HomeTheaterFacade:
def watch_movie(self):
self.amp.on()
self.dvd.play()
C#
public class HomeTheaterFacade {
public void WatchMovie() {
_amp.On(); _dvd.Play();
}
}
Flyweight
Java
class TreeType { // Flyweight (shared) String name, color, texture;
}
class TreeFactory {
static Map<String,TreeType> types = new HashMap<>();
static TreeType getType(String n, String c) {
return types.computeIfAbsent(n+c, k -> new TreeType(n,c));
}
}
Python
class TreeFactory:
_types = {}
@staticmethod
def get_type(name, color):
key = name + color
if key not in TreeFactory._types:
TreeFactory._types[key] = TreeType(name, color)
return TreeFactory._types[key]
C#
public class TreeFactory {
static Dictionary<string,TreeType> _types = new();
public static TreeType GetType(string n, string c) {
var key = n+c;
if (!_types.ContainsKey(key)) _types[key] = new(n,c);
return _types[key];
}
}
Proxy
Java
interface Image { void display(); }
class RealImage implements Image {
public void display() { /* heavy render */ }
}
class ProxyImage implements Image {
private RealImage real;
public void display() {
if (real == null) real = new RealImage();
real.display();
}
}
Python
class ProxyImage:
def __init__(self): self._real = None def display(self):
if self._real is None:
self._real = RealImage()
self._real.display()
C#
public class ProxyImage : IImage {
private RealImage? _real;
public void Display() {
_real ??= new RealImage();
_real.Display();
}
}
Observer
Java
interface Observer { void update(String msg); }
class EventManager {
List<Observer> listeners = new ArrayList<>();
void notify(String msg) {
listeners.forEach(o -> o.update(msg));
}
}
Python
class EventManager:
def __init__(self): self._listeners = []
def subscribe(self, o): self._listeners.append(o)
def notify(self, msg):
for o in self._listeners: o.update(msg)
C#
public class EventManager {
private List<IObserver> _listeners = new();
public void Notify(string msg) {
_listeners.ForEach(o => o.Update(msg));
}
}
Strategy
Java
interface SortStrategy { void sort(int[] arr); }
class QuickSort implements SortStrategy {
public void sort(int[] arr) { /* quicksort */ }
}
class Sorter {
private SortStrategy strategy;
void sort(int[] arr) { strategy.sort(arr); }
}
Python
class Sorter:
def __init__(self, strategy): self._strategy = strategy
def sort(self, arr): self._strategy.sort(arr)
C#
public class Sorter {
private ISortStrategy _strategy;
public void Sort(int[] arr) => _strategy.Sort(arr);
}
Command
Java
interface Command { void execute(); }
class LightOnCommand implements Command {
private Light light;
public void execute() { light.on(); }
}
class RemoteControl {
private Command cmd;
void press() { cmd.execute(); }
}
Python
class LightOnCommand:
def __init__(self, light): self._light = light
def execute(self): self._light.on()
C#
public class LightOnCommand : ICommand {
private readonly Light _light;
public void Execute() => _light.On();
}
Template Method
Java
abstract class DataMiner {
final void mine() {
openFile(); extractData(); parseData();
}
abstract void openFile();
abstract void extractData();
void parseData() { /* default impl */ }
}
Python
class DataMiner(ABC):
def mine(self):
self.open_file()
self.extract_data()
@abstractmethod
def open_file(self): ...
@abstractmethod
def extract_data(self): ...
C#
public abstract class DataMiner {
public void Mine() {
OpenFile(); ExtractData();
}
protected abstract void OpenFile();
protected abstract void ExtractData();
}
Chain of Responsibility
Java
abstract class Handler {
protected Handler next;
void setNext(Handler h) { this.next = h; }
abstract void handle(Request r);
}
Python
class Handler:
def __init__(self): self._next = None def set_next(self, h): self._next = h; return h
def handle(self, req):
if self._next: self._next.handle(req)
C#
public abstract class Handler {
protected Handler? Next;
public void SetNext(Handler h) => Next = h;
public abstract void Handle(Request r);
}
State
Java
interface State { void handle(Context ctx); }
class LockedState implements State {
public void handle(Context ctx) {
ctx.setState(new ReadyState());
}
}
Python
class LockedState:
def handle(self, ctx):
ctx.state = ReadyState()
C#
public class LockedState : IState {
public void Handle(Context ctx) =>
ctx.State = new ReadyState();
}
Mediator
Java
interface Mediator {
void notify(Component sender, String event);
}
class Dialog implements Mediator {
public void notify(Component s, String e) {
if (e.equals("click")) { /* coordinate */ }
}
}
Python
class Dialog:
def notify(self, sender, event):
if event == "click": ...
C#
public class Dialog : IMediator {
public void Notify(Component s, string e) {
if (e == "click") { /* coordinate */ }
}
}
Visitor
Java
interface Visitor {
void visit(Circle c);
void visit(Rectangle r);
}
interface Shape {
void accept(Visitor v);
}
class Circle implements Shape {
public void accept(Visitor v) { v.visit(this); }
}
Python
class Circle:
def accept(self, visitor):
visitor.visit_circle(self)
C#
public class Circle : IShape {
public void Accept(IVisitor v) => v.Visit(this);
}