Implementing object-oriented design patterns in Java

15 Sep 2023

designpatterns

Object-oriented design patterns are reusable software design solutions that help in solving common programming challenges. They provide a structured approach to designing and organizing code, improving code reusability, maintainability, and scalability. In this article, we will explore some popular object-oriented design patterns and how to implement them in Java.

1. Singleton Pattern

The Singleton pattern ensures that only one instance of a class is created throughout the application’s lifecycle. This is useful in scenarios where you need to have global access to a single instance, such as database connections or logging systems.

public class Singleton {
    private static Singleton instance;
    
    private Singleton() {
        // private constructor to prevent instantiation
    }
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
    
    // other methods and attributes
}

Usage:

Singleton singleton = Singleton.getInstance();

2. Factory Pattern

The Factory pattern provides an interface for creating objects while hiding the logic of object creation. It allows the client code to work with objects without knowing how they are created, providing flexibility and easy maintenance.

public interface Product {
    void doSomething();
}

public class ProductA implements Product {
    @Override
    public void doSomething() {
        // implementation for Product A
    }
}

public class ProductB implements Product {
    @Override
    public void doSomething() {
        // implementation for Product B
    }
}

public class ProductFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ProductA();
        } else if (type.equals("B")) {
            return new ProductB();
        }
        throw new IllegalArgumentException("Invalid product type");
    }
}

Usage:

Product productA = ProductFactory.createProduct("A");
productA.doSomething();
Product productB = ProductFactory.createProduct("B");
productB.doSomething();

These are just a few examples of object-oriented design patterns that can greatly improve the structure and organization of your Java code. By using these patterns, you can create more maintainable and scalable applications.

#java #designpatterns