Java Design Patterns Cheat Sheet

Shows implementations of core Gang of Four design patterns including Singleton, Factory Method, Builder, and Observer in Java.

3 PagesIntermediateApr 5, 2026

Singleton

Ensure a class has only one instance with global access.

java

public class ConfigManager {    private static volatile ConfigManager instance;    private ConfigManager() {}    public static ConfigManager getInstance() {        if (instance == null) {            synchronized (ConfigManager.class) {                if (instance == null) {                    instance = new ConfigManager();  // double-checked locking                }            }        }        return instance;    }}// Simplest thread-safe form: enum singletonpublic enum Config { INSTANCE; }

Factory Method

Delegate object creation to subclasses via a common interface.

java

interface Notification {    void send(String message);}class EmailNotification implements Notification {    public void send(String message) { System.out.println("Email: " + message); }}class SmsNotification implements Notification {    public void send(String message) { System.out.println("SMS: " + message); }}class NotificationFactory {    static Notification create(String type) {        return switch (type) {            case "EMAIL" -> new EmailNotification();            case "SMS" -> new SmsNotification();            default -> throw new IllegalArgumentException("Unknown type: " + type);        };    }}

Builder

Construct complex objects step by step with a fluent API.

java

public class Pizza {    private final String size;    private final boolean cheese;    private final boolean pepperoni;    private Pizza(Builder b) {        this.size = b.size;        this.cheese = b.cheese;        this.pepperoni = b.pepperoni;    }    public static class Builder {        private String size = "medium";        private boolean cheese;        private boolean pepperoni;        public Builder size(String size) { this.size = size; return this; }        public Builder cheese(boolean v) { this.cheese = v; return this; }        public Builder pepperoni(boolean v) { this.pepperoni = v; return this; }        public Pizza build() { return new Pizza(this); }    }}Pizza pizza = new Pizza.Builder().size("large").cheese(true).build();

Observer

Notify multiple dependents automatically when subject state changes.

java

interface Observer { void update(String event); }class EventBus {    private final List<Observer> observers = new ArrayList<>();    void subscribe(Observer o) { observers.add(o); }    void unsubscribe(Observer o) { observers.remove(o); }    void publish(String event) {        for (Observer o : observers) o.update(event);    }}EventBus bus = new EventBus();bus.subscribe(event -> System.out.println("Received: " + event));bus.publish("user.created");

Common Patterns at a Glance

Quick reference to widely used GoF patterns beyond the ones shown above.

Singleton- Ensures a class has only one instance and provides a global access point to it.
Factory Method- Lets subclasses decide which concrete class to instantiate behind a common interface.
Builder- Separates complex object construction from its representation using a fluent, step-by-step API.
Observer- Defines a one-to-many dependency so observers are notified automatically when a subject changes.
Strategy- Encapsulates interchangeable algorithms behind a common interface, selectable at runtime.
Adapter- Converts one interface into another that a client expects, without modifying either.
Decorator- Adds responsibilities to an object dynamically by wrapping it, as an alternative to subclassing.
Command- Encapsulates a request as an object, enabling queuing, logging, and undoable operations.

Pro Tip

Favor composition-based patterns like Strategy over subclassing for interchangeable behavior - it lets you swap logic at runtime without an explosion of subclasses for every combination.

Was this cheat sheet helpful?

Java Hibernate Cheat Sheet

Java Records Cheat Sheet