Java Design Patterns: A Complete Guide to Writing Better Code

Design patterns are very fundamental in the field of software engineering. They proffer ready-made solutions to reoccurring issues experienced in the cause of software development. Learning and applying design patterns helps Java developers to write codes that are efficient, scalable, and easy to maintain. In this article, we shall look at the most common design patterns used in Java and how these patterns are classified and their benefits to the code written. All right! Let’s go on! ??

What Are Design Patterns?

Before we jump into the specifics, let’s quickly clarify what design patterns are.

Design patterns are general, reusable solutions to common software design challenges. They aren’t specific pieces of code that you can copy and paste but are instead like blueprints or templates for solving particular problems in a certain way. They help developers avoid reinventing the wheel every time they face a familiar challenge.

The key idea behind design patterns is to promote code that is clean, organized, and easy to modify.

Categories of Design Patterns in Java

There are three primary categories of design patterns:

1. Creational Patterns — Deals with object creation mechanisms.
2. Structural Patterns — Focuses on how classes and objects can be combined.
3. Behavioral Patterns — Focuses on communication and interaction between objects.

Now, let’s break down the most popular patterns in each category.

1. Creational Design Patterns

Creational patterns are all about how objects are created. They give you the flexibility to decide how and when objects should be instantiated.

a. Singleton Pattern

Problem: Sometimes you want only one instance of a class throughout your application. You need a way to ensure that no matter how many times you try to create an object, you always get the same one.

Solution: The Singleton pattern ensures that a class has only one instance and provides a global point of access to that instance.

public class Singleton {
    private static Singleton instance;

    private Singleton() { }

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

b. Factory Pattern

Problem: You need to create objects, but you don’t want to expose the logic to the client. You also want to avoid tight coupling between the client and the specific classes being instantiated.

Solution: The Factory pattern creates objects without exposing the creation logic to the client. Instead, it relies on a method to determine which object to return.

class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}        

c. Builder Pattern

Problem: You want to construct complex objects step-by-step but without needing multiple constructors or exposing the object’s internal details.

Solution: The Builder pattern separates the construction of a complex object from its representation.

class House {
    private String foundation;
    private String structure;
    private String roof;

    private House(HouseBuilder builder) {
        this.foundation = builder.foundation;
        this.structure = builder.structure;
        this.roof = builder.roof;
    }

    public static class HouseBuilder {
        private String foundation;
        private String structure;
        private String roof;

        public HouseBuilder buildFoundation(String foundation) {
            this.foundation = foundation;
            return this;
        }

        public HouseBuilder buildStructure(String structure) {
            this.structure = structure;
            return this;
        }

        public HouseBuilder buildRoof(String roof) {
            this.roof = roof;
            return this;
        }

        public House build() {
            return new House(this);
        }
    }
}        

2. Structural Design Patterns

Structural patterns explain how to assemble objects and classes into larger structures while keeping these structures flexible and efficient.

a. Adapter Pattern

Problem: You have two incompatible interfaces that you want to work together. For example, you’re working with two libraries that don’t match up perfectly.

Solution: The Adapter pattern bridges the gap between two incompatible interfaces, allowing them to work together.

interface MediaPlayer {
    void play(String audioType, String fileName);
}

class AudioPlayer implements MediaPlayer {
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp3")) {
            System.out.println("Playing mp3 file: " + fileName);
        }
    }
}        

b. Facade Pattern

Problem: You have a complex system with lots of moving parts, and you want to simplify how clients interact with it.

Solution: The Facade pattern provides a simplified interface to a complex subsystem, making the system easier to use.

class Computer {
    public void start() {
        CPU.start();
        Memory.load();
        HardDrive.readData();
    }
}        

c. Decorator Pattern

Problem: You want to add new functionality to an object, but subclassing isn’t flexible enough.

Solution: The Decorator pattern adds functionality to objects dynamically, without modifying their structure.

interface Shape {
    void draw();
}

class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

class RedShapeDecorator implements Shape {
    private Shape decoratedShape;

    public RedShapeDecorator(Shape decoratedShape) {
        this.decoratedShape = decoratedShape;
    }

    public void draw() {
        decoratedShape.draw();
        setRedBorder();
    }

    private void setRedBorder() {
        System.out.println("Border Color: Red");
    }
}        

3. Behavioral Design Patterns

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

a. Observer Pattern

Problem: You want to notify many objects when the state of one object changes.

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

interface Observer {
    void update();
}

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

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

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

b. Strategy Pattern

Problem: You have different algorithms that you want to be interchangeable at runtime. For instance, you might have multiple ways to calculate a discount, but the method can vary depending on the situation.

Solution: The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable.

interface PaymentStrategy {
    void pay(int amount);
}

class CreditCardPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid with credit card: " + amount);
    }
}

class PayPalPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid with PayPal: " + amount);
    }
}        

Conclusion

Java design patterns are an essential tool for creating clean, organized, and maintainable code. Whether you’re dealing with object creation, structuring your code, or managing complex object interactions, there’s a design pattern that can help.