Design Patterns are proven solutions to common software design problems. They provide reusable templates for solving recurring design challenges in object-oriented programming.

1. Creational Patterns

1.1 Singleton Pattern

Ensures a class has only one instance and provides a global point of access.

public class Singleton { // 1. Eager Initialization public static class EagerSingleton { private static final EagerSingleton INSTANCE = new EagerSingleton(); private EagerSingleton() { // Private constructor to prevent instantiation } public static EagerSingleton getInstance() { return INSTANCE; } public void showMessage() { System.out.println("Eager Singleton instance: " + this); } } // 2. Lazy Initialization with Double-Checked Locking public static class LazySingleton { private static volatile LazySingleton instance; private LazySingleton() { // Prevent reflection attacks if (instance != null) { throw new IllegalStateException("Instance already created"); } } public static LazySingleton getInstance() { if (instance == null) { synchronized (LazySingleton.class) { if (instance == null) { instance = new LazySingleton(); } } } return instance; } public void showMessage() { System.out.println("Lazy Singleton instance: " + this); } } // 3. Bill Pugh Singleton (Most Recommended) public static class BillPughSingleton { private BillPughSingleton() { // Private constructor } private static class SingletonHelper { private static final BillPughSingleton INSTANCE = new BillPughSingleton(); } public static BillPughSingleton getInstance() { return SingletonHelper.INSTANCE; } public void showMessage() { System.out.println("Bill Pugh Singleton instance: " + this); } } // 4. Enum Singleton (Thread-safe and serialization-safe) public enum EnumSingleton { INSTANCE; public void showMessage() { System.out.println("Enum Singleton instance: " + this); } } } // Usage class SingletonDemo { public static void main(String[] args) { // Eager Singleton Singleton.EagerSingleton eager1 = Singleton.EagerSingleton.getInstance(); Singleton.EagerSingleton eager2 = Singleton.EagerSingleton.getInstance(); eager1.showMessage(); System.out.println("Same instance: " + (eager1 == eager2)); // Lazy Singleton Singleton.LazySingleton lazy1 = Singleton.LazySingleton.getInstance(); Singleton.LazySingleton lazy2 = Singleton.LazySingleton.getInstance(); lazy1.showMessage(); System.out.println("Same instance: " + (lazy1 == lazy2)); // Enum Singleton Singleton.EnumSingleton enum1 = Singleton.EnumSingleton.INSTANCE; Singleton.EnumSingleton enum2 = Singleton.EnumSingleton.INSTANCE; enum1.showMessage(); System.out.println("Same instance: " + (enum1 == enum2)); } }

1.2 Factory Method Pattern

Creates objects without specifying the exact class of object that will be created.

// Product Interface interface Notification { void send(String message); } // Concrete Products class EmailNotification implements Notification { @Override public void send(String message) { System.out.println("Sending Email: " + message); } } class SMSNotification implements Notification { @Override public void send(String message) { System.out.println("Sending SMS: " + message); } } class PushNotification implements Notification { @Override public void send(String message) { System.out.println("Sending Push Notification: " + message); } } // Creator Abstract Class abstract class NotificationFactory { // Factory method public abstract Notification createNotification(); public void sendNotification(String message) { Notification notification = createNotification(); notification.send(message); } } // Concrete Creators class EmailNotificationFactory extends NotificationFactory { @Override public Notification createNotification() { return new EmailNotification(); } } class SMSNotificationFactory extends NotificationFactory { @Override public Notification createNotification() { return new SMSNotification(); } } class PushNotificationFactory extends NotificationFactory { @Override public Notification createNotification() { return new PushNotification(); } } // Usage class FactoryMethodDemo { public static void main(String[] args) { NotificationFactory emailFactory = new EmailNotificationFactory(); emailFactory.sendNotification("Hello via Email!"); NotificationFactory smsFactory = new SMSNotificationFactory(); smsFactory.sendNotification("Hello via SMS!"); NotificationFactory pushFactory = new PushNotificationFactory(); pushFactory.sendNotification("Hello via Push!"); } }

1.3 Abstract Factory Pattern

Provides an interface for creating families of related objects without specifying their concrete classes.

// Abstract Products interface Button { void render(); void onClick(); } interface Checkbox { void render(); void onCheck(); } // Concrete Products for Windows class WindowsButton implements Button { @Override public void render() { System.out.println("Rendering Windows-style button"); } @Override public void onClick() { System.out.println("Windows button clicked"); } } class WindowsCheckbox implements Checkbox { @Override public void render() { System.out.println("Rendering Windows-style checkbox"); } @Override public void onCheck() { System.out.println("Windows checkbox checked"); } } // Concrete Products for Mac class MacButton implements Button { @Override public void render() { System.out.println("Rendering Mac-style button"); } @Override public void onClick() { System.out.println("Mac button clicked"); } } class MacCheckbox implements Checkbox { @Override public void render() { System.out.println("Rendering Mac-style checkbox"); } @Override public void onCheck() { System.out.println("Mac checkbox checked"); } } // Abstract Factory interface GUIFactory { Button createButton(); Checkbox createCheckbox(); } // Concrete Factories class WindowsFactory implements GUIFactory { @Override public Button createButton() { return new WindowsButton(); } @Override public Checkbox createCheckbox() { return new WindowsCheckbox(); } } class MacFactory implements GUIFactory { @Override public Button createButton() { return new MacButton(); } @Override public Checkbox createCheckbox() { return new MacCheckbox(); } } // Client class Application { private Button button; private Checkbox checkbox; public Application(GUIFactory factory) { this.button = factory.createButton(); this.checkbox = factory.createCheckbox(); } public void render() { button.render(); checkbox.render(); } public void interact() { button.onClick(); checkbox.onCheck(); } } // Usage class AbstractFactoryDemo { public static void main(String[] args) { // Windows application GUIFactory windowsFactory = new WindowsFactory(); Application windowsApp = new Application(windowsFactory); windowsApp.render(); windowsApp.interact(); System.out.println(); // Mac application GUIFactory macFactory = new MacFactory(); Application macApp = new Application(macFactory); macApp.render(); macApp.interact(); } }

1.4 Builder Pattern

Constructs complex objects step by step.

// Product class Computer { private String CPU; private String RAM; private String storage; private String graphicsCard; private String motherboard; private Computer(ComputerBuilder builder) { this.CPU = builder.CPU; this.RAM = builder.RAM; this.storage = builder.storage; this.graphicsCard = builder.graphicsCard; this.motherboard = builder.motherboard; } // Getters public String getCPU() { return CPU; } public String getRAM() { return RAM; } public String getStorage() { return storage; } public String getGraphicsCard() { return graphicsCard; } public String getMotherboard() { return motherboard; } @Override public String toString() { return "Computer{" + "CPU='" + CPU + '\'' + ", RAM='" + RAM + '\'' + ", storage='" + storage + '\'' + ", graphicsCard='" + graphicsCard + '\'' + ", motherboard='" + motherboard + '\'' + '}'; } // Builder public static class ComputerBuilder { private String CPU; private String RAM; private String storage; private String graphicsCard; private String motherboard; public ComputerBuilder setCPU(String CPU) { this.CPU = CPU; return this; } public ComputerBuilder setRAM(String RAM) { this.RAM = RAM; return this; } public ComputerBuilder setStorage(String storage) { this.storage = storage; return this; } public ComputerBuilder setGraphicsCard(String graphicsCard) { this.graphicsCard = graphicsCard; return this; } public ComputerBuilder setMotherboard(String motherboard) { this.motherboard = motherboard; return this; } public Computer build() { return new Computer(this); } } } // Usage with Director class ComputerDirector { public Computer buildGamingComputer() { return new Computer.ComputerBuilder() .setCPU("Intel i9") .setRAM("32GB DDR5") .setStorage("2TB NVMe SSD") .setGraphicsCard("NVIDIA RTX 4090") .setMotherboard("ASUS ROG") .build(); } public Computer buildOfficeComputer() { return new Computer.ComputerBuilder() .setCPU("Intel i5") .setRAM("16GB DDR4") .setStorage("512GB SSD") .setGraphicsCard("Integrated") .setMotherboard("ASUS Prime") .build(); } } // Usage class BuilderDemo { public static void main(String[] args) { // Custom computer Computer customComputer = new Computer.ComputerBuilder() .setCPU("AMD Ryzen 7") .setRAM("16GB DDR4") .setStorage("1TB SSD") .setGraphicsCard("NVIDIA RTX 3060") .setMotherboard("MSI B550") .build(); System.out.println("Custom Computer: " + customComputer); // Using director ComputerDirector director = new ComputerDirector(); Computer gamingComputer = director.buildGamingComputer(); Computer officeComputer = director.buildOfficeComputer(); System.out.println("Gaming Computer: " + gamingComputer); System.out.println("Office Computer: " + officeComputer); } }

1.5 Prototype Pattern

Creates new objects by copying existing objects (prototypes).

import java.util.HashMap; import java.util.Map; // Prototype interface interface Prototype extends Cloneable { Prototype clone(); void display(); } // Concrete Prototypes class Circle implements Prototype { private String color; private int x; private int y; private int radius; public Circle(String color) { this.color = color; } public void setX(int x) { this.x = x; } public void setY(int y) { this.y = y; } public void setRadius(int radius) { this.radius = radius; } @Override public Prototype clone() { Circle circle = new Circle(this.color); circle.setX(this.x); circle.setY(this.y); circle.setRadius(this.radius); return circle; } @Override public void display() { System.out.println("Circle [Color: " + color + ", X: " + x + ", Y: " + y + ", Radius: " + radius + "]"); } } class Rectangle implements Prototype { private String color; private int width; private int height; public Rectangle(String color) { this.color = color; } public void setWidth(int width) { this.width = width; } public void setHeight(int height) { this.height = height; } @Override public Prototype clone() { Rectangle rectangle = new Rectangle(this.color); rectangle.setWidth(this.width); rectangle.setHeight(this.height); return rectangle; } @Override public void display() { System.out.println("Rectangle [Color: " + color + ", Width: " + width + ", Height: " + height + "]"); } } // Prototype Registry class ShapeRegistry { private static Map<String, Prototype> shapes = new HashMap<>(); static { Circle redCircle = new Circle("Red"); redCircle.setRadius(10); shapes.put("RedCircle", redCircle); Rectangle blueRectangle = new Rectangle("Blue"); blueRectangle.setWidth(20); blueRectangle.setHeight(30); shapes.put("BlueRectangle", blueRectangle); } public static Prototype getShape(String type) { return shapes.get(type).clone(); } } // Usage class PrototypeDemo { public static void main(String[] args) { // Get shapes from registry and customize them Prototype circle1 = ShapeRegistry.getShape("RedCircle"); ((Circle) circle1).setX(10); ((Circle) circle1).setY(20); circle1.display(); Prototype circle2 = ShapeRegistry.getShape("RedCircle"); ((Circle) circle2).setX(30); ((Circle) circle2).setY(40); circle2.display(); Prototype rectangle = ShapeRegistry.getShape("BlueRectangle"); rectangle.display(); System.out.println("Are circles same object? " + (circle1 == circle2)); System.out.println("Are circles same type? " + (circle1.getClass() == circle2.getClass())); } }

2. Structural Patterns

2.1 Adapter Pattern

Allows incompatible interfaces to work together.

// Target Interface (Expected by Client) interface MediaPlayer { void play(String audioType, String fileName); } // Adaptee (Existing functionality) class AdvancedMediaPlayer { public void playVlc(String fileName) { System.out.println("Playing vlc file: " + fileName); } public void playMp4(String fileName) { System.out.println("Playing mp4 file: " + fileName); } } // Adapter class MediaAdapter implements MediaPlayer { private AdvancedMediaPlayer advancedMusicPlayer; public MediaAdapter(String audioType) { if (audioType.equalsIgnoreCase("vlc")) { advancedMusicPlayer = new AdvancedMediaPlayer(); } else if (audioType.equalsIgnoreCase("mp4")) { advancedMusicPlayer = new AdvancedMediaPlayer(); } } @Override public void play(String audioType, String fileName) { if (audioType.equalsIgnoreCase("vlc")) { advancedMusicPlayer.playVlc(fileName); } else if (audioType.equalsIgnoreCase("mp4")) { advancedMusicPlayer.playMp4(fileName); } } } // Concrete Target class AudioPlayer implements MediaPlayer { private MediaAdapter mediaAdapter; @Override public void play(String audioType, String fileName) { // Inbuilt support for mp3 if (audioType.equalsIgnoreCase("mp3")) { System.out.println("Playing mp3 file: " + fileName); } // MediaAdapter provides support for other formats else if (audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")) { mediaAdapter = new MediaAdapter(audioType); mediaAdapter.play(audioType, fileName); } else { System.out.println("Invalid media type: " + audioType); } } } // Usage class AdapterDemo { public static void main(String[] args) { AudioPlayer audioPlayer = new AudioPlayer(); audioPlayer.play("mp3", "song.mp3"); audioPlayer.play("mp4", "video.mp4"); audioPlayer.play("vlc", "movie.vlc"); audioPlayer.play("avi", "movie.avi"); } }

2.2 Decorator Pattern

Adds behavior to objects dynamically without affecting other objects.

// Component Interface interface Coffee { double getCost(); String getDescription(); } // Concrete Component class SimpleCoffee implements Coffee { @Override public double getCost() { return 2.0; } @Override public String getDescription() { return "Simple coffee"; } } // Decorator Abstract Class abstract class CoffeeDecorator implements Coffee { protected Coffee decoratedCoffee; public CoffeeDecorator(Coffee coffee) { this.decoratedCoffee = coffee; } @Override public double getCost() { return decoratedCoffee.getCost(); } @Override public String getDescription() { return decoratedCoffee.getDescription(); } } // Concrete Decorators class MilkDecorator extends CoffeeDecorator { public MilkDecorator(Coffee coffee) { super(coffee); } @Override public double getCost() { return super.getCost() + 0.5; } @Override public String getDescription() { return super.getDescription() + ", milk"; } } class SugarDecorator extends CoffeeDecorator { public SugarDecorator(Coffee coffee) { super(coffee); } @Override public double getCost() { return super.getCost() + 0.2; } @Override public String getDescription() { return super.getDescription() + ", sugar"; } } class WhippedCreamDecorator extends CoffeeDecorator { public WhippedCreamDecorator(Coffee coffee) { super(coffee); } @Override public double getCost() { return super.getCost() + 0.7; } @Override public String getDescription() { return super.getDescription() + ", whipped cream"; } } // Usage class DecoratorDemo { public static void main(String[] args) { // Simple coffee Coffee coffee = new SimpleCoffee(); System.out.println(coffee.getDescription() + " $" + coffee.getCost()); // Coffee with milk Coffee milkCoffee = new MilkDecorator(new SimpleCoffee()); System.out.println(milkCoffee.getDescription() + " $" + milkCoffee.getCost()); // Coffee with milk and sugar Coffee milkSugarCoffee = new SugarDecorator(new MilkDecorator(new SimpleCoffee())); System.out.println(milkSugarCoffee.getDescription() + " $" + milkSugarCoffee.getCost()); // Fancy coffee with everything Coffee fancyCoffee = new WhippedCreamDecorator( new SugarDecorator( new MilkDecorator(new SimpleCoffee()) ) ); System.out.println(fancyCoffee.getDescription() + " $" + fancyCoffee.getCost()); } }

2.3 Facade Pattern

Provides a simplified interface to a complex subsystem.

// Complex subsystem classes class CPU { public void start() { System.out.println("CPU starting..."); } public void execute() { System.out.println("CPU executing commands..."); } public void shutdown() { System.out.println("CPU shutting down..."); } } class Memory { public void load() { System.out.println("Memory loading data..."); } public void free() { System.out.println("Memory freeing resources..."); } } class HardDrive { public void read() { System.out.println("HardDrive reading data..."); } public void write() { System.out.println("HardDrive writing data..."); } } // Facade class ComputerFacade { private CPU cpu; private Memory memory; private HardDrive hardDrive; public ComputerFacade() { this.cpu = new CPU(); this.memory = new Memory(); this.hardDrive = new HardDrive(); } public void start() { System.out.println("Computer starting..."); cpu.start(); memory.load(); hardDrive.read(); cpu.execute(); System.out.println("Computer started successfully!"); } public void shutdown() { System.out.println("Computer shutting down..."); hardDrive.write(); memory.free(); cpu.shutdown(); System.out.println("Computer shut down successfully!"); } } // Usage class FacadeDemo { public static void main(String[] args) { ComputerFacade computer = new ComputerFacade(); // Simple interface hides complex subsystem computer.start(); System.out.println(); computer.shutdown(); } }

2.4 Composite Pattern

Composes objects into tree structures to represent part-whole hierarchies.

import java.util.ArrayList; import java.util.List; // Component interface FileSystemComponent { void showDetails(); long getSize(); } // Leaf class File implements FileSystemComponent { private String name; private long size; public File(String name, long size) { this.name = name; this.size = size; } @Override public void showDetails() { System.out.println("File: " + name + " (" + size + " bytes)"); } @Override public long getSize() { return size; } } // Composite class Directory implements FileSystemComponent { private String name; private List<FileSystemComponent> components; public Directory(String name) { this.name = name; this.components = new ArrayList<>(); } public void addComponent(FileSystemComponent component) { components.add(component); } public void removeComponent(FileSystemComponent component) { components.remove(component); } @Override public void showDetails() { System.out.println("Directory: " + name); for (FileSystemComponent component : components) { component.showDetails(); } } @Override public long getSize() { long totalSize = 0; for (FileSystemComponent component : components) { totalSize += component.getSize(); } return totalSize; } } // Usage class CompositeDemo { public static void main(String[] args) { // Create files File file1 = new File("document.txt", 1024); File file2 = new File("image.jpg", 2048); File file3 = new File("video.mp4", 4096); // Create directories Directory root = new Directory("Root"); Directory documents = new Directory("Documents"); Directory media = new Directory("Media"); // Build tree structure documents.addComponent(file1); media.addComponent(file2); media.addComponent(file3); root.addComponent(documents); root.addComponent(media); // Show details root.showDetails(); System.out.println("Total size: " + root.getSize() + " bytes"); } }

2.5 Proxy Pattern

Provides a surrogate or placeholder for another object to control access to it.

// Subject Interface interface Image { void display(); } // Real Subject class RealImage implements Image { private String filename; public RealImage(String filename) { this.filename = filename; loadFromDisk(); } private void loadFromDisk() { System.out.println("Loading image: " + filename); // Simulate heavy operation try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } @Override public void display() { System.out.println("Displaying image: " + filename); } } // Proxy class ProxyImage implements Image { private String filename; private RealImage realImage; public ProxyImage(String filename) { this.filename = filename; } @Override public void display() { if (realImage == null) { realImage = new RealImage(filename); // Lazy initialization } realImage.display(); } } // Protection Proxy Example interface BankAccount { void withdraw(double amount); double getBalance(); } class RealBankAccount implements BankAccount { private double balance; public RealBankAccount(double initialBalance) { this.balance = initialBalance; } @Override public void withdraw(double amount) { if (amount <= balance) { balance -= amount; System.out.println("Withdrawn: $" + amount); } else { System.out.println("Insufficient funds!"); } } @Override public double getBalance() { return balance; } } class BankAccountProxy implements BankAccount { private RealBankAccount realAccount; private String userRole; public BankAccountProxy(double initialBalance, String userRole) { this.realAccount = new RealBankAccount(initialBalance); this.userRole = userRole; } @Override public void withdraw(double amount) { if ("admin".equals(userRole)) { realAccount.withdraw(amount); } else { System.out.println("Access denied! Only admins can withdraw."); } } @Override public double getBalance() { return realAccount.getBalance(); } } // Usage class ProxyDemo { public static void main(String[] args) { // Virtual Proxy System.out.println("=== Virtual Proxy ==="); Image image1 = new ProxyImage("photo1.jpg"); Image image2 = new ProxyImage("photo2.jpg"); // Image loaded only when displayed image1.display(); image1.display(); // Already loaded image2.display(); System.out.println("\n=== Protection Proxy ==="); BankAccount adminAccount = new BankAccountProxy(1000, "admin"); BankAccount userAccount = new BankAccountProxy(1000, "user"); adminAccount.withdraw(500); System.out.println("Admin balance: $" + adminAccount.getBalance()); userAccount.withdraw(500); // Access denied System.out.println("User balance: $" + userAccount.getBalance()); } }

3. Behavioral Patterns

3.1 Observer Pattern

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

import java.util.ArrayList; import java.util.List; // Subject interface Subject { void registerObserver(Observer observer); void removeObserver(Observer observer); void notifyObservers(); } // Concrete Subject class WeatherStation implements Subject { private List<Observer> observers; private float temperature; private float humidity; private float pressure; public WeatherStation() { this.observers = new ArrayList<>(); } @Override public void registerObserver(Observer observer) { observers.add(observer); } @Override public void removeObserver(Observer observer) { observers.remove(observer); } @Override public void notifyObservers() { for (Observer observer : observers) { observer.update(temperature, humidity, pressure); } } public void setMeasurements(float temperature, float humidity, float pressure) { this.temperature = temperature; this.humidity = humidity; this.pressure = pressure; measurementsChanged(); } private void measurementsChanged() { notifyObservers(); } } // Observer interface Observer { void update(float temperature, float humidity, float pressure); } // Concrete Observers class CurrentConditionsDisplay implements Observer { private float temperature; private float humidity; @Override public void update(float temperature, float humidity, float pressure) { this.temperature = temperature; this.humidity = humidity; display(); } public void display() { System.out.println("Current conditions: " + temperature + "°C and " + humidity + "% humidity"); } } class StatisticsDisplay implements Observer { private float maxTemp = 0.0f; private float minTemp = 200; private float tempSum = 0.0f; private int numReadings; @Override public void update(float temperature, float humidity, float pressure) { tempSum += temperature; numReadings++; if (temperature > maxTemp) { maxTemp = temperature; } if (temperature < minTemp) { minTemp = temperature; } display(); } public void display() { System.out.println("Avg/Max/Min temperature = " + (tempSum / numReadings) + "/" + maxTemp + "/" + minTemp); } } // Usage class ObserverDemo { public static void main(String[] args) { WeatherStation weatherStation = new WeatherStation(); CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(); StatisticsDisplay statisticsDisplay = new StatisticsDisplay(); weatherStation.registerObserver(currentDisplay); weatherStation.registerObserver(statisticsDisplay); // Simulate weather changes weatherStation.setMeasurements(25, 65, 1013); weatherStation.setMeasurements(27, 70, 1012); weatherStation.setMeasurements(23, 90, 1014); // Remove one observer weatherStation.removeObserver(statisticsDisplay); weatherStation.setMeasurements(26, 75, 1013); } }

3.2 Strategy Pattern

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

// Strategy Interface interface PaymentStrategy { void pay(int amount); } // Concrete Strategies class CreditCardPayment implements PaymentStrategy { private String name; private String cardNumber; private String cvv; private String expiryDate; public CreditCardPayment(String name, String cardNumber, String cvv, String expiryDate) { this.name = name; this.cardNumber = cardNumber; this.cvv = cvv; this.expiryDate = expiryDate; } @Override public void pay(int amount) { System.out.println(amount + " paid with credit card"); } } class PayPalPayment implements PaymentStrategy { private String email; private String password; public PayPalPayment(String email, String password) { this.email = email; this.password = password; } @Override public void pay(int amount) { System.out.println(amount + " paid using PayPal"); } } class BitcoinPayment implements PaymentStrategy { private String walletAddress; public BitcoinPayment(String walletAddress) { this.walletAddress = walletAddress; } @Override public void pay(int amount) { System.out.println(amount + " paid with Bitcoin"); } } // Context class ShoppingCart { private List<String> items; private PaymentStrategy paymentStrategy; public ShoppingCart() { this.items = new ArrayList<>(); } public void addItem(String item) { items.add(item); } public void removeItem(String item) { items.remove(item); } public void setPaymentStrategy(PaymentStrategy paymentStrategy) { this.paymentStrategy = paymentStrategy; } public void checkout(int amount) { if (paymentStrategy == null) { System.out.println("Please set payment strategy first"); return; } paymentStrategy.pay(amount); } } // Usage class StrategyDemo { public static void main(String[] args) { ShoppingCart cart = new ShoppingCart(); cart.addItem("Laptop"); cart.addItem("Mouse"); // Pay with credit card cart.setPaymentStrategy(new CreditCardPayment( "John Doe", "1234-5678-9012-3456", "123", "12/25" )); cart.checkout(1000); // Pay with PayPal cart.setPaymentStrategy(new PayPalPayment("[email protected]", "password")); cart.checkout(1000); // Pay with Bitcoin cart.setPaymentStrategy(new BitcoinPayment("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa")); cart.checkout(1000); } }

3.3 Command Pattern

Encapsulates a request as an object, thereby allowing for parameterization of clients with different requests.

// Command Interface interface Command { void execute(); void undo(); } // Receiver class Light { public void on() { System.out.println("Light is ON"); } public void off() { System.out.println("Light is OFF"); } } class Stereo { public void on() { System.out.println("Stereo is ON"); } public void off() { System.out.println("Stereo is OFF"); } public void setCD() { System.out.println("Stereo is set for CD input"); } public void setVolume(int volume) { System.out.println("Stereo volume set to " + volume); } } // Concrete Commands class LightOnCommand implements Command { private Light light; public LightOnCommand(Light light) { this.light = light; } @Override public void execute() { light.on(); } @Override public void undo() { light.off(); } } class LightOffCommand implements Command { private Light light; public LightOffCommand(Light light) { this.light = light; } @Override public void execute() { light.off(); } @Override public void undo() { light.on(); } } class StereoOnWithCDCommand implements Command { private Stereo stereo; public StereoOnWithCDCommand(Stereo stereo) { this.stereo = stereo; } @Override public void execute() { stereo.on(); stereo.setCD(); stereo.setVolume(11); } @Override public void undo() { stereo.off(); } } // Invoker class RemoteControl { private Command command; private Command lastCommand; public void setCommand(Command command) { this.command = command; } public void pressButton() { command.execute(); lastCommand = command; } public void pressUndo() { if (lastCommand != null) { lastCommand.undo(); lastCommand = null; } } } // Usage class CommandDemo { public static void main(String[] args) { RemoteControl remote = new RemoteControl(); Light livingRoomLight = new Light(); Stereo livingRoomStereo = new Stereo(); Command lightOn = new LightOnCommand(livingRoomLight); Command lightOff = new LightOffCommand(livingRoomLight); Command stereoOn = new StereoOnWithCDCommand(livingRoomStereo); // Turn on light remote.setCommand(lightOn); remote.pressButton(); // Turn on stereo remote.setCommand(stereoOn); remote.pressButton(); // Undo last command (turn off stereo) remote.pressUndo(); // Turn off light remote.setCommand(lightOff); remote.pressButton(); } }

3.4 Template Method Pattern

Defines the skeleton of an algorithm in a method, deferring some steps to subclasses.

// Abstract Class abstract class Beverage { // Template method - defines the algorithm public final void prepareRecipe() { boilWater(); brew(); pourInCup(); addCondiments(); if (customerWantsCondiments()) { hook(); } } // Common steps private void boilWater() { System.out.println("Boiling water"); } private void pourInCup() { System.out.println("Pouring into cup"); } // Abstract methods to be implemented by subclasses abstract void brew(); abstract void addCondiments(); // Hook - optional override protected void hook() { // Default implementation (can be empty) } // Hook for conditional logic protected boolean customerWantsCondiments() { return true; } } // Concrete Classes class Coffee extends Beverage { @Override void brew() { System.out.println("Dripping coffee through filter"); } @Override void addCondiments() { System.out.println("Adding sugar and milk"); } @Override protected boolean customerWantsCondiments() { // Could get user input here return true; } } class Tea extends Beverage { @Override void brew() { System.out.println("Steeping the tea"); } @Override void addCondiments() { System.out.println("Adding lemon"); } @Override protected void hook() { System.out.println("Adding special tea flavor"); } } class BlackCoffee extends Beverage { @Override void brew() { System.out.println("Dripping coffee through filter"); } @Override void addCondiments() { // No condiments for black coffee } @Override protected boolean customerWantsCondiments() { return false; } } // Usage class TemplateMethodDemo { public static void main(String[] args) { System.out.println("Preparing coffee:"); Beverage coffee = new Coffee(); coffee.prepareRecipe(); System.out.println("\nPreparing tea:"); Beverage tea = new Tea(); tea.prepareRecipe(); System.out.println("\nPreparing black coffee:"); Beverage blackCoffee = new BlackCoffee(); blackCoffee.prepareRecipe(); } }

4. Best Practices and Real-World Examples

Pattern Combinations

// Combining Factory Method with Singleton class LoggerFactory { private static LoggerFactory instance; private LoggerFactory() {} public static LoggerFactory getInstance() { if (instance == null) { instance = new LoggerFactory(); } return instance; } public Logger getLogger(String type) { switch (type.toLowerCase()) { case "file": return new FileLogger(); case "console": return new ConsoleLogger(); case "database": return new DatabaseLogger(); default: throw new IllegalArgumentException("Unknown logger type: " + type); } } } interface Logger { void log(String message); } class FileLogger implements Logger { @Override public void log(String message) { System.out.println("File Logger: " + message); } } class ConsoleLogger implements Logger { @Override public void log(String message) { System.out.println("Console Logger: " + message); } } class DatabaseLogger implements Logger { @Override public void log(String message) { System.out.println("Database Logger: " + message); } } // Usage class PatternCombinationDemo { public static void main(String[] args) { LoggerFactory factory = LoggerFactory.getInstance(); Logger fileLogger = factory.getLogger("file"); Logger consoleLogger = factory.getLogger("console"); fileLogger.log("This is a file log message"); consoleLogger.log("This is a console log message"); } }

Summary

Creational Patterns:

• Singleton: Single instance with global access
• Factory Method: Defer instantiation to subclasses
• Abstract Factory: Create families of related objects
• Builder: Construct complex objects step by step
• Prototype: Create objects by copying existing ones

Structural Patterns:

• Adapter: Make incompatible interfaces work together
• Decorator: Add responsibilities dynamically
• Facade: Provide a simplified interface
• Composite: Treat individual objects and compositions uniformly
• Proxy: Provide a placeholder for another object

Behavioral Patterns:

• Observer: One-to-many dependency between objects
• Strategy: Encapsulate interchangeable algorithms
• Command: Encapsulate requests as objects
• Template Method: Define algorithm skeleton with varying steps

When to Use Which Pattern:

• Need single instance? → Singleton
• Creating complex objects? → Builder
• Need to interface with incompatible systems? → Adapter
• Want to add features dynamically? → Decorator
• Need to notify multiple objects? → Observer
• Have multiple algorithms? → Strategy

Design patterns provide proven solutions to common problems and promote code reusability, maintainability, and flexibility.