Factory Pattern

Defining Factory Pattern: A Basic Overview

• Defining a method in a class.
• Declaring the method “factory method” because it creates other objects.
• Allowing subclasses to redefine which class to instantiate.

 
class Factory {
    createProduct (type) {
        let product;
        if (type === "Type1") {
            product = new ConcreteProduct1();
        } else if (type === "Type2") {
            product = new ConcreteProduct2();
        }
        return product;
    }
}

The Role of Factory Pattern in Object-Oriented Programming

• Offers a way to encapsulate a group of individual classes with a common goal into a single unified function.
• It promotes loose-coupling by eliminating the need to bind application-specific classes into the code. The code interacts solely with the resultant interfaces.
• Provides a simple way of extending and re-utilizing the code.

Real Life Factory Pattern Examples in Programming

class NotificationFactory {
    createNotification(type) {
        if (type === 'SMS') {
            return new SMSNotification();
        } else if (type === 'Email') {
            return new EmailNotification();
        } else if (type === 'Push') {
            return new PushNotification();
        }
        return null;
    }
}

Digging Deep into Factory Design Pattern

Importance of Factory Design Pattern in Programming

• It provides a simple way of creating objects without exposing the instantiation logic to the client.
• It provides a layer of abstraction that decouples the client code from the concrete classes.
• There is a clear separation of responsibilities. This pattern clearly separates the construction logic of complex objects from the objects themselves.

class Creator {
    factoryMethod() {
        return new Product();
    } 
}

class Product {}

Differentiating between Factory Pattern and Abstract Factory Pattern

• Factory Method is a creation through inheritance: object creation is deferred to subclasses that implement the factory method to create objects.
• Abstract Factory is a creation through composition: object creation is implemented in methods exposed in the factory interface.

Factory Design Pattern: Practical Applications

 
class PacketFactory {
    createPacket(type) {
        if (type === 'DATA') {
            return new DataPacket();
        } else if (type === 'ACK') {
            return new AckPacket();
        } 
        return null;
    }
}

Exploring the Factory Pattern in Java

Introduction to Factory Pattern Java

• Super Class: An abstract class specifying object creation methods
• Sub Classes: They provide the implementation for the super class’s creation method
• Factory Class: This class interfaces with the client and provides access to the best subclass based on input parameters

Factory Pattern Java: Code Examples

abstract class Shape {
    abstract void draw();
}

class Circle extends Shape {
    void draw() { /* Circle drawing logic */ }
}

class Rectangle extends Shape {
    void draw() { /* Rectangle drawing logic */ }
}

class ShapeFactory {
    static Shape getShape(String type) {
        if (type.equals("Circle")) {
            return new Circle();
        } else if (type.equals("Rectangle")) {
            return new Rectangle();
        }
        return null;
    }
}

Tips and Tricks for Implementing Factory Pattern in Java

• Identify the scenarios where the application needs to create an object of different types based on some conditions.
• Define an interface or an abstract class which will be the return type of our factory method.
• Create subclasses that implement the interface or extend the abstract class, and encapsulate them in a factory class.
• Replace all explicit object creation in the application code with calls to the factory method.

Advantages and Complexity of Factory Pattern

Understanding Factory Pattern Complexity

abstract class Product {
    abstract void operation();
}

class ConcreteProductA extends Product {
    void operation() { /* Logic of ConcreteProductA */ }
}

class ConcreteProductB extends Product {
    void operation() { /* Logic of ConcreteProductB */ }
}

Advantages of Using Factory Pattern in Programming

class Factory {
    createProduct(type) {
        switch (type) {
            case 'A':
                return new ConcreteProductA();
            case 'B':
                return new ConcreteProductB();
        }
    }
}

Minimising Complexity with the Factory Pattern

• It avoids tight coupling between product classes and the client code.
• It separates the responsibilities of object creation and object usage, aiding code organization and clarity.
• It improves code reusability and makes it more straightforward to add new product types, fostering code extendibility.

Further Exploring Factory Method Design Pattern

What is the Factory Method Design Pattern?

abstract class AbstractProduct {
    public abstract void operation();
}

abstract class Creator {
    public abstract AbstractProduct factoryMethod();
}

class ConcreteProductA extends AbstractProduct {
    public void operation() { /* Implementation of the operation for ConcreteProductA. */ }
}

class ConcreteCreatorA extends Creator {
    public AbstractProduct factoryMethod() { return new ConcreteProductA(); }
}

Factory Method Design Pattern vs Factory Pattern: The Difference

Implementing the Factory Method Design Pattern: A Comprehensive Guide

public abstract class AbstractCreator {
    public abstract AbstractProduct factoryMethod();
}

public class ConcreteCreatorA extends AbstractCreator {
    public AbstractProduct factoryMethod() {
        return new ConcreteProductA();
    }
}

AbstractCreator creator = new ConcreteCreatorA();
AbstractProduct product = creator.factoryMethod();
product.operation();  // Executes ConcreteProductA's operation.