1.

Creational Patterns

1.1 Singleton Pattern

Description: Ensures a class has only one instance and provides a global point of access to it.

Real-World Example: A database connection pool where only one connection pool object exists
throughout the application.

Java Example:

public class DatabaseConnection {

private static DatabaseConnection instance;

private DatabaseConnection() {}

public static synchronized DatabaseConnection getInstance() {

if (instance == null) {

instance = new DatabaseConnection();

return instance;

public void connect() {

System.out.println("Connected to the database.");

1.2 Factory Method Pattern

Description: Defines an interface for creating objects, but allows subclasses to alter the type of
objects that will be created.

Real-World Example: A document editor that can create different types of documents (e.g.,
Word, PDF) based on user selection.
interface Document {

void open();

class WordDocument implements Document {

public void open() {

System.out.println("Opening Word document.");

class PdfDocument implements Document {

public void open() {

System.out.println("Opening PDF document.");

abstract class DocumentCreator {

public abstract Document createDocument();

public void openDocument() {

Document doc = createDocument();

doc.open();

class WordDocumentCreator extends DocumentCreator {

public Document createDocument() {

return new WordDocument();

}
}

class PdfDocumentCreator extends DocumentCreator {

public Document createDocument() {

return new PdfDocument();

1.3 Abstract Factory Pattern

Description: Provides an interface for creating families of related or dependent objects without
specifying their concrete classes.

Real-World Example: A GUI toolkit that can create buttons and checkboxes for different
operating systems (e.g., Windows, Mac).

// Abstract products

interface Button {

void paint();

interface Checkbox {

void paint();

// Concrete products for Windows

class WindowsButton implements Button {

public void paint() {

System.out.println("Painting Windows button.");

class WindowsCheckbox implements Checkbox {

 public void paint() {

System.out.println("Painting Windows checkbox.");

// Concrete products for Mac

class MacButton implements Button {

public void paint() {

System.out.println("Painting Mac button.");

class MacCheckbox implements Checkbox {

public void paint() {

System.out.println("Painting Mac checkbox.");

// Abstract factory

interface GUIFactory {

Button createButton();

Checkbox createCheckbox();

// Concrete factories

class WindowsFactory implements GUIFactory {

public Button createButton() {

return new WindowsButton();

}
 public Checkbox createCheckbox() {

return new WindowsCheckbox();

class MacFactory implements GUIFactory {

public Button createButton() {

return new MacButton();

public Checkbox createCheckbox() {

return new MacCheckbox();

1.4 Builder Pattern

Description: Separates the construction of a complex object from its representation so that the
same construction process can create different representations.

Real-World Example: Building a car with different options (e.g., color, engine type) using a car
builder.

class Car {

private String color;

private String engineType;

public void setColor(String color) {

this.color = color;

}
 public void setEngineType(String engineType) {

this.engineType = engineType;

@Override

public String toString() {

return "Car [color=" + color + ", engineType=" + engineType + "]";

class CarBuilder {

private Car car;

public CarBuilder() {

car = new Car();

public CarBuilder setColor(String color) {

car.setColor(color);

return this;

public CarBuilder setEngineType(String engineType) {

car.setEngineType(engineType);

return this;

public Car build() {

return car;
 }

2. Structural Patterns

2.1 Adapter Pattern

Description: Allows an interface to be used in a way that it was not originally intended by
adapting it to a different interface.

Real-World Example: A power adapter that allows devices from different countries to be used
with different electrical outlets.

// Target interface

interface Voltage {

void connect();

// Adaptee

class OldVoltage {

public void connectToOldSocket() {

System.out.println("Connecting to old socket.");

// Adapter

class VoltageAdapter implements Voltage {

private OldVoltage oldVoltage;

public VoltageAdapter(OldVoltage oldVoltage) {

this.oldVoltage = oldVoltage;

}
 public void connect() {

oldVoltage.connectToOldSocket();

2.2 Bridge Pattern

Description: Separates an abstraction from its implementation so that the two can vary
independently.

Real-World Example: A remote control that can work with different types of devices (e.g., TV,
stereo).

Java Example:

// Abstraction

abstract class RemoteControl {

protected Device device;

public RemoteControl(Device device) {

this.device = device;

public abstract void powerOn();

// RefinedAbstraction

class AdvancedRemoteControl extends RemoteControl {

public AdvancedRemoteControl(Device device) {

super(device);

public void powerOn() {

 device.turnOn();

// Implementor

interface Device {

void turnOn();

// ConcreteImplementor

class Television implements Device {

public void turnOn() {

System.out.println("Turning on the television.");

class Stereo implements Device {

public void turnOn() {

System.out.println("Turning on the stereo.");

2.3 Composite Pattern

Description: Allows individual objects and compositions of objects to be treated uniformly.

Real-World Example: A file system where both files and directories are treated as file system
objects.

import java.util.ArrayList;

import java.util.List;
// Component

interface FileSystemComponent {

void showDetails();

// Leaf

class File implements FileSystemComponent {

private String name;

public File(String name) {

this.name = name;

public void showDetails() {

System.out.println("File: " + name);

// Composite

class Directory implements FileSystemComponent {

private String name;

private List<FileSystemComponent> children = new ArrayList<>();

public Directory(String name) {

this.name = name;

public void add(FileSystemComponent component) {

children.add(component);
 }

public void showDetails() {

System.out.println("Directory: " + name);

for (FileSystemComponent component : children) {

component.showDetails();

2.4 Decorator Pattern

Description: Adds new functionality to an object dynamically without altering its structure.

Real-World Example: Adding extra features to a coffee, such as milk or sugar, in a coffee shop.

// Component

interface Coffee {

String getDescription();

double cost();

// ConcreteComponent

class SimpleCoffee implements Coffee {

public String getDescription() {

return "Simple coffee";

public double cost() {

return 5.0;

}
}

// Decorator

abstract class CoffeeDecorator implements Coffee {

protected Coffee coffee;

public CoffeeDecorator(Coffee coffee) {

this.coffee = coffee;

public String getDescription() {

return coffee.getDescription();

public double cost() {

return coffee.cost();

// ConcreteDecorator

class MilkDecorator extends CoffeeDecorator {

public MilkDecorator(Coffee coffee) {

super(coffee);

public String getDescription() {

return coffee.getDescription() + ", milk";

}
 public double cost() {

return coffee.cost() + 1.0;

3. Behavioral Patterns

3.1 Strategy Pattern

Description: Defines a family of algorithms, encapsulates each one, and makes them
interchangeable.

Real-World Example: A payment system that can switch between different payment methods
(e.g., credit card, PayPal).

Java Example:

// Strategy

interface PaymentStrategy {

void pay(int amount);

// ConcreteStrategy

class CreditCardPayment implements PaymentStrategy {

public void pay(int amount) {

System.out.println("Paid " + amount + " using credit card.");

// ConcreteStrategy

class PayPalPayment implements PaymentStrategy {

public void pay(int amount) {

System.out.println("Paid " + amount + " using PayPal.");

 }

// Context

class PaymentContext {

private PaymentStrategy strategy;

public PaymentContext(PaymentStrategy strategy) {

this.strategy = strategy;

public void executePayment(int amount) {

strategy.pay(amount);

3.2 Observer Pattern

Description: Defines a one-to-many dependency between objects so that when one object
changes state, all its dependents are notified and updated automatically.

Real-World Example: A news agency that notifies all subscribers when a new article is
published.

Java Example:

import java.util.ArrayList;

import java.util.List;

// Observer

interface Observer {

void update(String news);

}

// ConcreteObserver

class NewsSubscriber implements Observer {

private String name;

public NewsSubscriber(String name) {

this.name = name;

public void update(String news) {

System.out.println(name + " received news: " + news);

// Subject

class NewsAgency {

private List<Observer> observers = new ArrayList<>();

private String latestNews;

public void addObserver(Observer observer) {

observers.add(observer);

public void removeObserver(Observer observer) {

observers.remove(observer);

public void setNews(String news) {

 this.latestNews = news;

notifyObservers();

private void notifyObservers() {

for (Observer observer : observers) {

observer.update(latestNews);

3.3 Command Pattern

Description: Encapsulates a request as an object, thereby allowing parameterization of clients

with queues, requests, and operations.

Real-World Example: A remote control that can execute different commands (e.g., turn on
lights, change TV channel).

Java Example:

// Command

interface Command {

void execute();

// ConcreteCommand

class LightOnCommand implements Command {

private Light light;

public LightOnCommand(Light light) {

this.light = light;
 }

public void execute() {

light.turnOn();

// Receiver

class Light {

public void turnOn() {

System.out.println("Light is on.");

// Invoker

class RemoteControl {

private Command command;

public void setCommand(Command command) {

this.command = command;

public void pressButton() {

command.execute();

3.4 State Pattern

Description: Allows an object to alter its behavior when its internal state changes.

Real-World Example: A document editor with states like "Editing," "Read-Only," and
"Locked."

Java Example:

// State

interface State {

void handleRequest();

// ConcreteState

class EditingState implements State {

public void handleRequest() {

System.out.println("Document is in editing state.");

// ConcreteState

class ReadOnlyState implements State {

public void handleRequest() {

System.out.println("Document is in read-only state.");

// Context

class Document {

private State state;

public void setState(State state) {

 this.state = state;

public void request() {

state.handleRequest();

3.5 Template Method Pattern

Description: Defines the skeleton of an algorithm in the superclass but lets subclasses override
specific steps of the algorithm without changing its structure.

Real-World Example: A recipe with fixed steps where specific ingredients or cooking times can
be customized.

Java Example:

abstract class CoffeeTemplate {

public final void makeCoffee() {

boilWater();

brew();

pourInCup();

addCondiments();

protected abstract void brew();

protected abstract void addCondiments();

private void boilWater() {

System.out.println("Boiling water.");

}
 private void pourInCup() {

System.out.println("Pouring coffee into cup.");

class Tea extends CoffeeTemplate {

protected void brew() {

System.out.println("Steeping the tea.");

protected void addCondiments() {

System.out.println("Adding lemon.");

class Coffee extends CoffeeTemplate {

protected void brew() {

System.out.println("Dripping coffee through filter.");

protected void addCondiments() {

System.out.println("Adding sugar and milk.");

3.6 Iterator Pattern

Description: Provides a way to access the elements of an aggregate object sequentially without
exposing its underlying representation.
Real-World Example: An iterator over a playlist of songs where you can move through each
song one by one.

Java Example:

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

// Aggregate

interface Aggregate {

Iterator<String> createIterator();

// ConcreteAggregate

class SongCollection implements Aggregate {

private List<String> songs = new ArrayList<>();

public void addSong(String song) {

songs.add(song);

public Iterator<String> createIterator() {

return songs.iterator();

3.7 Mediator Pattern

Description: Defines an object that encapsulates how a set of objects interact.

Real-World Example: A flight control tower managing interactions between multiple planes.

Java Example:
// Mediator

interface Mediator {

void sendMessage(String message, Colleague colleague);

// ConcreteMediator

class ConcreteMediator implements Mediator {

private ColleagueA colleagueA;

private ColleagueB colleagueB;

public void setColleagueA(ColleagueA colleagueA) {

this.colleagueA = colleagueA;

public void setColleagueB(ColleagueB colleagueB) {

this.colleagueB = colleagueB;

public void sendMessage(String message, Colleague colleague) {

if (colleague == colleagueA) {

colleagueB.receiveMessage(message);

} else {

colleagueA.receiveMessage(message);

// Colleague

abstract class Colleague {

 protected Mediator mediator;

public Colleague(Mediator mediator) {

this.mediator = mediator;

// ConcreteColleagueA

class ColleagueA extends Colleague {

public ColleagueA(Mediator mediator) {

super(mediator);

public void sendMessage(String message) {

mediator.sendMessage(message, this);

public void receiveMessage(String message) {

System.out.println("ColleagueA received: " + message);

// ConcreteColleagueB

class ColleagueB extends Colleague {

public ColleagueB(Mediator mediator) {

super(mediator);

public void receiveMessage(String message) {

 System.out.println("ColleagueB received: " + message);

3.8 Chain of Responsibility Pattern

Description: Allows passing of requests along a chain of handlers.

Real-World Example: A help desk system where requests are passed from a junior support
agent to a senior one if the issue is not resolved.

Java Example:

abstract class Handler {

protected Handler nextHandler;

public void setNextHandler(Handler handler) {

this.nextHandler = handler;

public abstract void handleRequest(String request);

class ConcreteHandlerA extends Handler {

public void handleRequest(String request) {

if (request.equals("A")) {

System.out.println("Handler A processing request.");

} else if (nextHandler != null) {

nextHandler.handleRequest(request);

}
class ConcreteHandlerB extends Handler {

public void handleRequest(String request) {

if (request.equals("B")) {

System.out.println("Handler B processing request.");

} else if (nextHandler != null) {

nextHandler.handleRequest(request);

3.9 Visitor Pattern

Description: Allows adding new operations to objects without modifying the objects themselves.

Real-World Example: A tax calculation system that applies different tax rules to different types
of items (e.g., books, electronics).

Java Example:

// Visitor

interface Visitor {

void visit(Book book);

void visit(Electronic electronic);

// Element

interface Element {

void accept(Visitor visitor);

// ConcreteElement

class Book implements Element {

 public void accept(Visitor visitor) {

visitor.visit(this);

// ConcreteElement

class Electronic implements Element {

public void accept(Visitor visitor) {

visitor.visit(this);

// ConcreteVisitor

class TaxVisitor implements Visitor {

public void visit(Book book) {

System.out.println("Tax for book: $5");

public void visit(Electronic electronic) {

System.out.println("Tax for electronic: $15");