DEV Community: Aditya

Want to be a better developer? Give yourself every excuse to write code!

Aditya — Wed, 17 Sep 2025 10:18:48 +0000

Design Patterns in Java- A simplified Guide #3

Aditya — Thu, 05 Dec 2024 16:23:08 +0000

Welcome to this 3-part guide. In this post, I'll provide a basic introduction to design patterns, along with examples.

This specific post will cover what design patterns are, why we should know about them, the types of design patterns, and behavioral patterns.

Quick links:

What are Design Patterns?

Design patterns are proven solutions to common problems in software development. They help developers solve complex tasks in a structured way and allow them to reuse successful solutions, making their code easier to understand and maintain. Think of design patterns as blueprints for solving typical problems that occur when building software.

Why Should We Know About Them?

Knowing about design patterns helps developers solve common problems in a structured and efficient way, making code more reusable, maintainable, and scalable.

Think of a restaurant kitchen. The chef follows a recipe (design pattern) to prepare a dish. Instead of reinventing the process each time, the chef uses proven steps to consistently deliver the same quality dish. Similarly, design patterns help developers efficiently solve problems without reinventing solutions each time.

Types of Design Patterns:

In Java, design patterns are categorized into three main groups:

1. Creational Patterns: These patterns help with creating objects in a flexible and reusable way.
2. Structural Patterns: These patterns focus on how objects are arranged and connected to form larger systems.
3. Behavioral Patterns: These patterns deal with how objects interact and communicate with each other.

Behavioral Patterns

Behavioral patterns are concerned with how objects interact and communicate with each other.

Chain of Responsibility:

In an order processing system, you might have different levels of approval for orders (e.g., small orders go to a clerk, large orders go to a manager). The chain of responsibility pattern lets you pass the request along a chain of handlers until one handles it.

abstract class OrderHandler {
    protected OrderHandler nextHandler;

    public void setNextHandler(OrderHandler handler) {
        this.nextHandler = handler;
    }

    public abstract void handleOrder(int amount);
}

class ClerkHandler extends OrderHandler {
    public void handleOrder(int amount) {
        if (amount < 500) {
            System.out.println("Clerk handling order");
        } else if (nextHandler != null) {
            nextHandler.handleOrder(amount);
        }
    }
}

class ManagerHandler extends OrderHandler {
    public void handleOrder(int amount) {
        if (amount >= 500) {
            System.out.println("Manager handling order");
        } else if (nextHandler != null) {
            nextHandler.handleOrder(amount);
        }
    }
}

Command:

In a text editor, the command pattern can be used to define actions like copy, paste, and undo, so that each action can be encapsulated as an object.

interface Command {
    void execute();
}

class CopyCommand implements Command {
    private TextEditor editor;

    public CopyCommand(TextEditor editor) {
        this.editor = editor;
    }

    public void execute() {
        editor.copyText();
    }
}

class TextEditor {
    public void copyText() {
        System.out.println("Text copied");
    }
}

Observer:

In a weather monitoring system, multiple devices (e.g., mobile apps, weather stations) need to be updated whenever there is a change in the weather conditions.

interface Observer {
    void update(String weather);
}

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

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void notifyObservers(String weather) {
        for (Observer observer : observers) {
            observer.update(weather);
        }
    }
}

class WeatherApp implements Observer {
    public void update(String weather) {
        System.out.println("Weather update: " + weather);
    }
}

Strategy:

You can use different strategies for calculating shipping costs (e.g., regular shipping, expedited shipping). The strategy pattern allows you to switch between these strategies dynamically.

interface ShippingStrategy {
    double calculateShippingCost(double weight);
}

class RegularShipping implements ShippingStrategy {
    public double calculateShippingCost(double weight) {
        return weight * 2;
    }
}

class ExpeditedShipping implements ShippingStrategy {
    public double calculateShippingCost(double weight) {
        return weight * 5;
    }
}

Template Method:

In a game, you might have different types of characters that follow a similar set of steps for attacking, but the specific details differ. The template method lets you define a general algorithm while allowing subclasses to override certain steps.

abstract class GameCharacter {
    public void attack() {
        moveToTarget();
        performAttack();
        celebrate();
    }

    protected void moveToTarget() {
        System.out.println("Moving to target...");
    }

    protected abstract void performAttack();

    protected void celebrate() {
        System.out.println("Celebrating after attack...");
    }
}

class Warrior extends GameCharacter {
    protected void performAttack() {
        System.out.println("Warrior performs sword attack!");
    }
}

Design Patterns in Java- A simplified Guide #2

Aditya — Thu, 05 Dec 2024 16:22:22 +0000

Welcome to this 3-part guide. In this post, I'll provide a basic introduction to design patterns, along with examples.

This specific post will cover what design patterns are, why we should know about them, the types of design patterns, and structural patterns.

Quick links:

What are Design Patterns?

Why Should We Know About Them?

Knowing about design patterns helps developers solve common problems in a structured and efficient way, making code more reusable, maintainable, and scalable.

Types of Design Patterns:

In Java, design patterns are categorized into three main groups:

Structural Patterns

Structural patterns focus on how to organize and connect objects to form larger, more complex systems.

Adapter:

If you are using an old database API in a new application, you can use an adapter pattern to make the old API work with the new system.

interface NewDatabase {
    void fetchData();
}

class OldDatabase {
    public void getData() {
        System.out.println("Fetching data from old database");
    }
}

class OldDatabaseAdapter implements NewDatabase {
    private OldDatabase oldDatabase;

    public OldDatabaseAdapter(OldDatabase oldDatabase) {
        this.oldDatabase = oldDatabase;
    }

    public void fetchData() {
        oldDatabase.getData();
    }
}

Bridge:

You have a drawing application that can draw different shapes. The bridge pattern lets you separate the shape (abstraction) from the drawing implementation (implementation).

interface DrawingAPI {
    void drawCircle(double x, double y, double radius);
}

class Circle {
    private double x, y, radius;
    private DrawingAPI drawingAPI;

    public Circle(double x, double y, double radius, DrawingAPI drawingAPI) {
        this.x = x;
        this.y = y;
        this.radius = radius;
        this.drawingAPI = drawingAPI;
    }

    public void draw() {
        drawingAPI.drawCircle(x, y, radius);
    }
}

Composite:

In a file system, a folder can contain both files and other folders. The composite pattern allows you to treat both files and folders in the same way.

interface FileSystemComponent {
    void showDetails();
}

class File implements FileSystemComponent {
    private String name;

    public File(String name) {
        this.name = name;
    }

    public void showDetails() {
        System.out.println("File: " + name);
    }
}

class Folder implements FileSystemComponent {
    private List<FileSystemComponent> components = new ArrayList<>();

    public void add(FileSystemComponent component) {
        components.add(component);
    }

    public void showDetails() {
        for (FileSystemComponent component : components) {
            component.showDetails();
        }
    }
}

Decorator:

You want to add new functionality to a Car class without modifying the original Car. The decorator pattern lets you add features such as sunroof or leather seats dynamically.

interface Car {
    void assemble();
}

class BasicCar implements Car {
    public void assemble() {
        System.out.println("Basic car assembled.");
    }
}

class CarDecorator implements Car {
    protected Car car;

    public CarDecorator(Car car) {
        this.car = car;
    }

    public void assemble() {
        this.car.assemble();
    }
}

class SunroofDecorator extends CarDecorator {
    public SunroofDecorator(Car car) {
        super(car);
    }

    public void assemble() {
        super.assemble();
        System.out.println("Adding sunroof.");
    }
}

Design Patterns in Java- A simplified Guide #1

Aditya — Thu, 05 Dec 2024 16:21:40 +0000

Welcome to this 3-part guide. In this post, I'll provide a basic introduction to design patterns, along with examples.

This specific post will cover what design patterns are, why we should know about them, the types of design patterns, and creational patterns.

Quick links:

What are Design Patterns?

Why Should We Know About Them?

Knowing about design patterns helps developers solve common problems in a structured and efficient way, making code more reusable, maintainable, and scalable.

Types of Design Patterns:

In Java, design patterns are categorized into three main groups:

Creational Patterns

Creational patterns focus on object creation and make it easier to create objects in a flexible, reusable way. These patterns help ensure that the object creation process is independent of the system using it.

Abstract Factory:

Imagine a game where you can choose between different "themes" (e.g., medieval, sci-fi). The abstract factory can be used to create related sets of objects (like characters, weapons, and settings) specific to the selected theme without changing the game’s core logic.

interface GameFactory {
    Character createCharacter();
    Weapon createWeapon();
}

class MedievalFactory implements GameFactory {
    public Character createCharacter() {
        return new Knight();
    }
    public Weapon createWeapon() {
        return new Sword();
    }
}

class SciFiFactory implements GameFactory {
    public Character createCharacter() {
        return new Robot();
    }
    public Weapon createWeapon() {
        return new LaserGun();
    }
}

Builder:

Think of building a complex sandwich where you can customize the ingredients (e.g., type of bread, meat, veggies). The builder pattern helps in assembling these ingredients step-by-step.

class Sandwich {
    private String bread;
    private String meat;
    private String cheese;

    public void setBread(String bread) { this.bread = bread; }
    public void setMeat(String meat) { this.meat = meat; }
    public void setCheese(String cheese) { this.cheese = cheese; }
}

class SandwichBuilder {
    private Sandwich sandwich = new Sandwich();

    public SandwichBuilder addBread(String bread) {
        sandwich.setBread(bread);
        return this;
    }
    public SandwichBuilder addMeat(String meat) {
        sandwich.setMeat(meat);
        return this;
    }
    public SandwichBuilder addCheese(String cheese) {
        sandwich.setCheese(cheese);
        return this;
    }

    public Sandwich build() {
        return sandwich;
    }
}

Singleton:

You only need one instance of a connection to a database throughout the application. The singleton pattern ensures that only a single instance of the database connection is created.

class DatabaseConnection {
    private static DatabaseConnection instance;

    private DatabaseConnection() {} // Private constructor

    public static DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }
}

Prototype:

Imagine duplicating complex objects like a “high-level” document template that contains various elements. Instead of creating it from scratch, you can copy a prototype of the document and modify it.

abstract class DocumentPrototype {
    abstract DocumentPrototype clone();
}

class Document extends DocumentPrototype {
    private String content;

    public Document(String content) {
        this.content = content;
    }

    public DocumentPrototype clone() {
        return new Document(this.content);
    }
}

Object Pool:

Suppose you have a limited number of printer objects in a printing system. Instead of creating new printer objects each time, an object pool helps manage and reuse printers efficiently.

class Printer {
    public void print() {
        System.out.println("Printing document...");
    }
}

class ObjectPool {
    private List<Printer> availablePrinters = new ArrayList<>();

    public Printer getPrinter() {
        if (availablePrinters.isEmpty()) {
            return new Printer();
        }
        return availablePrinters.remove(0);
    }

    public void releasePrinter(Printer printer) {
        availablePrinters.add(printer);
    }
}

Factory Method:

You are building a system that needs different types of vehicles. The factory method pattern allows you to decide which vehicle to create based on certain conditions.

interface Vehicle {
    void drive();
}

class Car implements Vehicle {
    public void drive() {
        System.out.println("Driving a car");
    }
}

class Bike implements Vehicle {
    public void drive() {
        System.out.println("Riding a bike");
    }
}

abstract class VehicleFactory {
    abstract Vehicle createVehicle();
}

class CarFactory extends VehicleFactory {
    public Vehicle createVehicle() {
        return new Car();
    }
}

class BikeFactory extends VehicleFactory {
    public Vehicle createVehicle() {
        return new Bike();
    }
}