Creational Design Patterns: Singleton, Factory, Builder

Java’s Singleton, Factory, and Builder patterns are essential creational design patterns that streamline object creation. They enhance code flexibility, maintainability, and scalability.

In modern Java development, efficient object creation is crucial. These patterns provide structured solutions, making code more adaptable and easier to maintain.

Quick Summary of Creational Design Pattern

Pattern	Purpose	Use Case Example
Singleton	Ensures a class has only one instance	Database connection manager
Factory	Creates objects without specifying exact class	GUI component creation
Builder	Constructs complex objects step by step	Meal preparation in a restaurant

What are Creational Patterns?

Creational patterns are one of the three main categories of design patterns—alongside structural and behavioral. They deal with object creation mechanisms, making systems more flexible and decoupled. Instead of hardcoding object instantiation, these patterns provide abstraction layers that decide when, how, and what to create. This approach improves code scalability and simplifies maintenance, especially in large applications where multiple components depend on shared resources or variable configurations.

Singleton Pattern

What is Singleton?
The Singleton pattern ensures that a class has only one instance throughout the application and provides a global point of access to it.

When / Why to Use Singleton
Use Singleton when you need a single shared resource, such as a configuration manager, logger, or database connection pool. It helps maintain consistency and avoids redundant instances.

Implementation Concerns: Thread Safety, Lazy vs. Eager Initialization

Eager Initialization: Instance is created at class loading. Simple but may waste memory if unused.
Lazy Initialization: Instance is created only when needed. Requires thread safety mechanisms in multi-threaded environments.

Example (Python)

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

# Usage
obj1 = Singleton()
obj2 = Singleton()
print(obj1 is obj2)  # True

Pitfalls / Limitations

Hidden dependencies make testing difficult.
Tight coupling with global state can lead to maintenance issues.

Not ideal for concurrent environments without synchronization.

Factory Pattern

What is the Factory Pattern?
The Factory pattern encapsulates object creation, letting subclasses or dedicated methods decide which class to instantiate. It comes in variations:

Simple Factory: Centralized method that returns instances based on input.

Factory Method: Defines an interface for creating objects but lets subclasses decide the class type.
Abstract Factory: Creates families of related objects without specifying their concrete classes.

Motivation
Factories promote loose coupling by separating object creation logic from business logic. This is useful when a class can’t anticipate which type of objects it must create.

Example (Python)

class Shape:
    def draw(self): pass

class Circle(Shape):
    def draw(self): print("Drawing Circle")

class Square(Shape):
    def draw(self): print("Drawing Square")

class ShapeFactory:
    def get_shape(self, shape_type):
        if shape_type == "circle":
            return Circle()
        elif shape_type == "square":
            return Square()

factory = ShapeFactory()
shape = factory.get_shape("circle")
shape.draw()  # Drawing Circle

Variations and When to Choose Each

Simple Factory: Use for small applications.

Factory Method: Use when subclasses need control over instance creation.
Abstract Factory: Use for complex families of related objects (e.g., UI themes).

Difference vs Singleton
Singleton manages one instance, while Factory manages which class instance to create. They solve distinct problems but can complement each other.

Builder Pattern

Definition & Intent
The Builder pattern simplifies constructing complex objects step by step, especially when many optional parameters or configurations exist.

Use Cases

When an object has multiple optional fields.

When constructors become lengthy or hard to read.
When objects need to be immutable once built.

Example (Python, Fluent Style)

class Computer:
    def __init__(self, cpu=None, gpu=None, ram=None):
        self.cpu = cpu
        self.gpu = gpu
        self.ram = ram

class ComputerBuilder:
    def __init__(self):
        self.computer = Computer()

    def set_cpu(self, cpu):
        self.computer.cpu = cpu
        return self

    def set_gpu(self, gpu):
        self.computer.gpu = gpu
        return self

    def set_ram(self, ram):
        self.computer.ram = ram
        return self

    def build(self):
        return self.computer

# Usage
pc = (ComputerBuilder()
      .set_cpu("Intel i9")
      .set_gpu("NVIDIA RTX 4080")
      .set_ram("32GB")
      .build())

print(pc.__dict__)

Benefits

Clean, readable code with fluent syntax.
Better control over object construction.

Supports immutability and code reuse.

When Not to Use
Avoid Builder for simple objects—it adds unnecessary complexity.

How These Patterns Work Together

Creational patterns can complement each other:

Factory with Singleton: A factory may use a singleton instance for configuration or object caching.
Builder with Factory: Builders can use factories internally to assemble parts dynamically.
Composite Use Cases: For example, a game engine might use a Singleton for settings, a Factory for game entities, and a Builder for complex game levels.

When to Pick One Over Another

Use Singleton for single shared resources.
Use Factory when object creation depends on runtime parameters or class hierarchies.

Use Builder when creating complex objects with optional parts or multiple configurations.

Practical Uses of Creational Design Patterns

Embarking on the journey of coding can often feel overwhelming. If you’re just starting or want to enhance your programming skills, understanding core concepts like “Creational Design Patterns” is essential. Yes, it might sound fancy, but trust me, it’s simpler than it seems. Creational Design Patterns deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. Let’s explore how popular companies use these patterns in real-life coding scenarios.

Microsoft and Singleton Pattern:
Microsoft often incorporates the Singleton pattern, ensuring a class has only one instance while providing a global point of access to it. This is particularly useful in application configurations or logging.
```
    class Logger {
        private static Logger instance;
        private Logger() {}
        public static Logger getInstance() {
            if (instance == null) {
                instance = new Logger();
            }
            return instance;
        }
    }
    
```
Output: Enhanced performance and streamlined configurations without redundancy. Microsoft can ensure consistency across applications using this singular access point.

Netflix and Factory Method Pattern:
Netflix utilizes the Factory Method pattern to handle the myriad of content – movies, TV shows, and documentaries – efficiently by delegating object creation to subclasses, ensuring flexible code architecture.


    interface Content {
        void play();
    }
    class Movie implements Content {
        public void play() { System.out.println("Playing a movie"); }
    }
    class TvShow implements Content {
        public void play() { System.out.println("Playing a TV show"); }
    }
    class ContentFactory {
        static Content getContent(String type) {
            if (type.equals("movie")) {
                return new Movie();
            } else if (type.equals("tvshow")) {
                return new TvShow();
            }
            return null;
        }
    }

Output: Netflix achieves a scalable and maintainable codebase, allowing easy extension when new content types need to be supported.

Understanding these patterns can open up a world of efficient design solutions, making your coding journey smoother and more rewarding.

Pros & Cons: Creational Design

Pattern	Pros	Cons
Singleton	Controlled access to single instance	Difficult to subclass, global state issues
Factory	Decouples object creation, flexible	Can lead to complex code with many classes
Builder	Handles complex object creation, readable code	Can be overkill for simple objects

Creational Patterns Q&A

What are the basic principles behind Creational Design Patterns, and why are they important in software development?
Creational Design Patterns focus on how objects are created, ensuring flexibility and scalability. They solve common object creation issues by decoupling the client code from the actual creation process. These patterns are vital because they enhance code reusability and maintainability by reducing code duplication and making it easier to manage changes in code.

How does the Singleton pattern ensure that a class has only one instance, and what are its common use cases?
The Singleton pattern restricts a class instantiation to a single object. It’s often used in situations where a single instance of a class is needed to coordinate actions. For instance, managing a connection pool, a logger, or a configuration manager.
```
class Singleton {
  private static Singleton instance;
  
  private Singleton() {}
  
  public static Singleton getInstance() {
    if (instance == null) {
      instance = new Singleton();
    }
    return instance;
  }
}
```

Can you explain the Factory Method pattern and provide a real-world analogy?
The Factory Method pattern defines an interface to create objects but allows subclasses to alter the type of objects that will be created. Think of a restaurant where the kitchen (the factory) decides the specific dish’s recipe, but the waiter (the factory’s method) presents the dish to the customer.

Why might someone choose the Builder pattern over the traditional constructor method?
The Builder pattern is chosen over the traditional constructor because it allows for the construction of complex objects step-by-step, which can be particularly useful for objects with numerous attributes. It enhances code clarity and readability by breaking down the object’s creation process and can also facilitate object validation before final creation.

What’s the purpose of the Prototype pattern, and when is it particularly useful?

The Prototype pattern enables object cloning, allowing for new instances to be created by copying an existing one. It’s particularly useful when object creation is costly or complex, and creating a copy is more efficient.

How does the Abstract Factory pattern differ from the Factory Method pattern?

While both patterns deal with object creation, the Abstract Factory pattern provides an interface for creating sets of related objects without specifying their concrete class. Meanwhile, Factory Methods delegate the instantiation to subclasses. Consider Abstract Factory as a toolkit for creating families of related products.

Could you highlight an application of the Object Pool pattern and its advantages?

The Object Pool pattern manages the reuse of object instances to avoid the expensive overhead of creating and destroying objects frequently. It’s advantageous in scenarios like database connections or thread pools, where resource management can boost performance significantly.

Is Lazy Initialization relevant in creational patterns, and how does it benefit software design?

Yes, Lazy Initialization is related to creational patterns and involves delaying object creation until it’s needed. This can improve application performance and resource use by not allocating resources upfront, which is particularly useful in large applications.

Our AI-powered java online compiler revolutionises the way you code. It allows users to instantly write, run, and test their code, making coding more efficient than ever. Let AI handle the heavy lifting while you focus on honing your programming skills with ease and confidence.

Conclusion

Creational Design Patterns enhance your coding repertoire, leading to efficient code and a deeper understanding of sophisticated programming techniques. Embrace these patterns to elevate your skills. Curious to explore further? Visit Newtum for insightful resources on Java, Python, C, C++, and more programming languages.

Edited and Compiled by

This article was compiled and edited by @rasikadeshpande, who has over 4 years of experience in writing. She’s passionate about helping beginners understand technical topics in a more interactive way.