Factory Pattern: Creating Objects the Right Way

The Factory pattern is a creational design pattern that provides an interface for creating objects without specifying their exact classes.

What is the Factory Pattern?

The Factory pattern uses a factory method to create objects without exposing the instantiation logic to the client. The client refers to the newly created object through a common interface.

Types of Factory Patterns

1. Simple Factory

public class SimpleFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            default:
                throw new IllegalArgumentException("Unknown product type");
        }
    }
}

2. Factory Method Pattern

// Product interface
interface Product {
    void use();
}

// Concrete Products
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using Product A");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using Product B");
    }
}

// Creator abstract class
abstract class Creator {
    public abstract Product createProduct();
    
    public void someOperation() {
        Product product = createProduct();
        product.use();
    }
}

// Concrete Creators
class ConcreteCreatorA extends Creator {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

class ConcreteCreatorB extends Creator {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

3. Abstract Factory Pattern

// Abstract Factory
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// Concrete Factories
class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }
    
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

When to Use?

• When you don't know beforehand the exact types and dependencies of objects
• When you want to provide a library of products and reveal only their interfaces
• When you want to extend your code to work with new products
• When you want to decouple the creation of objects from their usage

Benefits

• Loose coupling between creator and concrete products
• Single Responsibility Principle
• Open/Closed Principle
• Easy to extend with new product types

Real-World Examples

• JDBC connection factories
• Spring Framework bean factories
• UI component factories
• Document parsers

Conclusion

The Factory pattern is essential for creating flexible, maintainable code. Choose the right variant based on your specific needs.