Java Design Patterns: Singleton & Factory Patterns

Design Patterns: Singleton Pattern and Factory Pattern

Design patterns are solutions to solve recurring issues faced during software development. They offer practical ways of solving problems encountered in programming. Among these, the Singleton pattern and the Factory pattern are two widely used creational design patterns in Java, aimed at addressing unique issues related to object creation.

Singleton Pattern

The Singleton pattern ensures that exactly one instance of a class is created. It is useful when you want a single instance of a particular class across your application. One example of using the Singleton pattern is for a logger class, where only one logger should be allowed for logging purposes. To implement this pattern, you need to ensure that the constructor of the class is marked as private, preventing direct instantiation of the class. Additionally, you should provide a public static method that returns the existing instance of the class to other parts of the application.

Advantages of Singleton Pattern

• Ensures memory efficiency by avoiding duplicate instances of the class.
• Promotes code reusability by sharing the same instance among different parts of the system.

Here's an example of implementing the Singleton pattern in Java:

public class Logger {
    private static Logger INSTANCE = null;
    
    private Logger() {};
    
    public static Logger getLogger() {
        if (INSTANCE == null) {
            synchronized (this) {
                if (INSTANCE == null) {
                    INSTANCE = new Logger();
                }
            }
        }
        return INSTANCE;
    }
}

Factory Pattern

On the other hand, the Factory pattern is used to create objects without explicitly specifying their implementation. It allows you to defer the decision of object creation until runtime. The factory pattern provides a factory method that takes certain parameters and decides which concrete product to instantiate.

You can achieve this by defining an interface that represents the products to be created and creating separate concrete classes that implement the interface. The factory class contains the factory method that creates the desired product based on the parameters passed to it.

An example of the Factory pattern in Java:

interface Product {
    void operation();
}

class ConcreteProductA implements Product {
    @Override
    public void operation() {
        // implementation of operation A
    }
}

class ConcreteProductB implements Product {
    @Override
    public void operation() {
        // implementation of operation B
    }
}

class Factory {
    public static Product getProduct(boolean condition) {
        if (condition) {
            return new ConcreteProductA();
        } else {
            return new ConcreteProductB();
        }
    }
}

Advantages of Factory Pattern

• Provides a central place to manage the object creation process.
• Allows decoupling of the client from the creation process.
• Simplifies the process of adding new products without changing the client code.

In summary, both the Singleton pattern and the Factory pattern are valuable design patterns to be aware of when developing in Java. The Singleton pattern helps maintain a single instance of a class throughout your application, promoting memory efficiency and code reuse. Meanwhile, the Factory pattern enables flexible object creation decisions at runtime, simplifying the process of adding new types of objects without modifying the existing client code.