Categories of Design Patterns in Java

In this article, you can get training on the different categories of design patterns, specifically focusing on Java implementations. Design patterns are essential tools in a developer's toolkit, providing proven solutions to common problems in software design. By understanding these patterns, you can enhance the maintainability, scalability, and performance of your applications.

Understanding the Three Main Categories

Design patterns can be broadly classified into three main categories: Creational, Structural, and Behavioral. Each category serves a unique purpose and addresses different aspects of software design.

• Creational Patterns focus on the process of object creation, providing mechanisms to create objects in a manner suitable to the situation.
• Structural Patterns deal with object composition, helping to ensure that if one part of a system changes, the entire system doesn’t need to do the same.
• Behavioral Patterns are all about class's objects communication, defining how objects interact and communicate with each other.

Understanding these categories is crucial for developers who wish to design robust and efficient systems. Let’s delve deeper into each category to see how they can be effectively implemented in Java.

Creational Patterns: An Overview

Creational design patterns are concerned with the way objects are created. In Java, these patterns can simplify the instantiation process and make the system more flexible. Here are some notable creational patterns:

Singleton Pattern

The Singleton pattern ensures that a class has only one instance and provides a global point of access to that instance. This is particularly useful in cases where a single object is needed to coordinate actions across the system.

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

Factory Method Pattern

The Factory Method pattern defines an interface for creating an object but allows subclasses to alter the type of objects that will be created. This promotes loose coupling and greater flexibility.

abstract class Product {
    abstract void use();
}

class ConcreteProductA extends Product {
    void use() {
        System.out.println("Using Product A");
    }
}

class ConcreteProductB extends Product {
    void use() {
        System.out.println("Using Product B");
    }
}

abstract class Creator {
    abstract Product factoryMethod();
}

class ConcreteCreatorA extends Creator {
    Product factoryMethod() {
        return new ConcreteProductA();
    }
}

class ConcreteCreatorB extends Creator {
    Product factoryMethod() {
        return new ConcreteProductB();
    }
}

Builder Pattern

The Builder pattern is used to construct a complex object step by step. It separates the construction of a complex object from its representation so that the same construction process can create different representations.

class Product {
    private String partA;
    private String partB;

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    @Override
    public String toString() {
        return "Product{" +
                "partA='" + partA + '\'' +
                ", partB='" + partB + '\'' +
                '}';
    }
}

class Builder {
    private Product product = new Product();

    public Builder buildPartA(String partA) {
        product.setPartA(partA);
        return this;
    }

    public Builder buildPartB(String partB) {
        product.setPartB(partB);
        return this;
    }

    public Product build() {
        return product;
    }
}

Structural Patterns: Key Concepts

Structural design patterns focus on how classes and objects are composed to form larger structures. They help ensure that if one part of a system changes, the entire system doesn’t need to do so. Below are some common structural patterns:

Adapter Pattern

The Adapter pattern allows incompatible interfaces to work together. It acts as a bridge between two incompatible interfaces.

interface Target {
    void request();
}

class Adaptee {
    void specificRequest() {
        System.out.println("Specific request");
    }
}

class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

Composite Pattern

The Composite pattern is used to treat individual objects and compositions of objects uniformly. This pattern is especially useful for tree structures.

interface Component {
    void operation();
}

class Leaf implements Component {
    @Override
    public void operation() {
        System.out.println("Leaf operation");
    }
}

class Composite implements Component {
    private List<Component> children = new ArrayList<>();

    public void add(Component component) {
        children.add(component);
    }

    @Override
    public void operation() {
        for (Component child : children) {
            child.operation();
        }
    }
}

Decorator Pattern

The Decorator pattern allows behavior to be added to individual objects, either statically or dynamically, without affecting the behavior of other objects from the same class.

interface Coffee {
    String getDescription();
    double cost();
}

class SimpleCoffee implements Coffee {
    @Override
    public String getDescription() {
        return "Simple Coffee";
    }

    @Override
    public double cost() {
        return 1.00;
    }
}

class MilkDecorator implements Coffee {
    private Coffee coffee;

    public MilkDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + ", Milk";
    }

    @Override
    public double cost() {
        return coffee.cost() + 0.50;
    }
}

Behavioral Patterns: What You Need to Know

Behavioral design patterns focus on communication between objects, defining how they interact with one another. They help in improving the flexibility and efficiency of the software design. Here are some notable behavioral patterns:

Observer Pattern

The Observer pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

interface Observer {
    void update(String message);
}

class ConcreteObserver implements Observer {
    private String name;

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

    @Override
    public void update(String message) {
        System.out.println(name + " received message: " + message);
    }
}

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

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

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

Strategy Pattern

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. This pattern lets the algorithm vary independently from clients that use it.

interface Strategy {
    void execute();
}

class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing Strategy A");
    }
}

class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing Strategy B");
    }
}

class Context {
    private Strategy strategy;

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}

Command Pattern

The Command pattern encapsulates a request as an object, thereby allowing for parameterization of clients with queues, requests, and operations.

interface Command {
    void execute();
}

class ConcreteCommand implements Command {
    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.action();
    }
}

class Receiver {
    public void action() {
        System.out.println("Receiver action executed");
    }
}

class Invoker {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void invoke() {
        command.execute();
    }
}

Comparing Different Categories of Patterns

When comparing different categories of design patterns, it’s essential to recognize their distinct roles in software architecture. Creational patterns simplify object creation, allowing for more manageable code and better resource management. Structural patterns help in organizing classes and objects, providing a clear structure and ensuring that changes in one part do not lead to extensive modifications elsewhere. Finally, Behavioral patterns emphasize communication between objects, enabling the development of complex workflows while maintaining clarity and flexibility.

Understanding the nuances of each category can greatly enhance a developer's ability to build efficient, scalable, and maintainable software systems. It also empowers teams to adopt a common vocabulary for discussing design issues and solutions.

Summary

In summary, design patterns are invaluable resources in the toolkit of intermediate and professional developers. This article highlighted the three main categories of design patterns: Creational, Structural, and Behavioral. Each category provides various strategies for managing the complexities of software design, enabling developers to create robust systems in Java.

By mastering these patterns, developers can craft applications that are not only functional but also easier to modify and extend over time. As software continues to evolve, design patterns will remain essential in facilitating better design practices and improving code quality. To further enhance your understanding, consider exploring the official Java documentation and other credible resources that delve deeper into design patterns in Java.

Last Update: 18 Jan, 2025