Exploring Design Patterns in Java

Design patterns are reusable solutions to common problems that occur in software development. They provide proven architectural solutions that can be implemented in various programming languages, including Java. In this blog post, we will dive into some commonly used design patterns in Java and provide code examples to illustrate their usage.

Singleton Pattern

The Singleton pattern ensures that only one instance of a class is created throughout the execution of an application. This can be useful when you want to restrict the instantiation of a class to a single object.

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // private constructor to prevent instantiation
    }

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

Observer Pattern

The Observer pattern defines a one-to-many dependency between objects, where one object (subject) maintains a list of its dependents (observers) and notifies them automatically of any state changes.

import java.util.ArrayList;
import java.util.List;

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

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }

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

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

public interface Observer {
    void update();
}

Factory Pattern

The Factory pattern provides a way to create objects without specifying the exact class of the object that will be created. It defines an interface for creating objects, but lets subclasses decide which class to instantiate.

public interface Shape {
    void draw();
}

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

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

public class ShapeFactory {
    public Shape createShape(String shapeType) {
        if (shapeType.equalsIgnoreCase("circle")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("square")) {
            return new Square();
        }
        return null;
    }
}

Template Method Pattern

The Template Method pattern defines the skeleton of an algorithm in a method, deferring some steps to subclasses. It allows subclasses to redefine certain steps of an algorithm without changing the algorithm’s structure.

public abstract class Game {
    abstract void initialize();
    abstract void startGame();
    abstract void finishGame();

    public final void play() {
        initialize();
        startGame();
        finishGame();
    }
}

public class Football extends Game {

    @Override
    void initialize() {
        System.out.println("Initializing Football Game");
    }

    @Override
    void startGame() {
        System.out.println("Starting Football Game");
    }

    @Override
    void finishGame() {
        System.out.println("Finishing Football Game");
    }
}

Conclusion

Design patterns are an essential part of software development. They provide proven solutions to common problems and promote reusable and maintainable code. In this blog post, we explored some commonly used design patterns in Java, including the Singleton, Observer, Factory, and Template Method patterns. By applying these design patterns to your Java projects, you can enhance the structure and efficiency of your code.

Remember that design patterns should be used judiciously, and their applicability may vary based on the specific requirements of your project. The examples provided here serve as a starting point, and it’s important to understand the intricacies and potential trade-offs of each pattern before implementing them in your own code. Happy coding!