Design Pattern 02. Abstract Factory Pattern

The Abstract Factory pattern is a design pattern that provides an interface for creating related objects, separating the responsibility of object creation. This pattern is useful when multiple objects that are related to each other need to be created, and it allows creating objects without depending on specific classes.

Overview

The Abstract Factory pattern allows clients to create objects through an abstract factory interface instead of directly creating them. The abstract factory provides an interface for a set of related objects, and concrete factory classes implement this interface to create actual objects. This allows clients to create objects without directly depending on concrete classes.

Example Code

// Abstract Product A
public interface AbstractProductA {
    void performAction();
}

// Abstract Product B
public interface AbstractProductB {
    void performAction();
}

// Concrete Product A1
public class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void performAction() {
        System.out.println("Performing action in ConcreteProductA1");
    }
}

// Concrete Product A2
public class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void performAction() {
        System.out.println("Performing action in ConcreteProductA2");
    }
}

// Concrete Product B1
public class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void performAction() {
        System.out.println("Performing action in ConcreteProductB1");
    }
}

// Concrete Product B2
public class ConcreteProductB2 implements AbstractProductB {
    @Override
    public void performAction() {
        System.out.println("Performing action in ConcreteProductB2");
    }
}

// Abstract Factory interface
public interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

// Concrete Factory A
public class ConcreteFactoryA implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// Concrete Factory B
public class ConcreteFactoryB implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// Client code
public class Client {
    private AbstractProductA productA;
    private AbstractProductB productB;

    public Client(AbstractFactory factory) {
        productA = factory.createProductA();
        productB = factory.createProductB();
    }

    public void performActions() {
        productA.performAction();
        productB.performAction();
    }

    public static void main(String[] args) {
        AbstractFactory factoryA = new ConcreteFactoryA();
        Client clientA = new Client(factoryA);
        clientA.performActions();
        // Output:
        // Performing action in ConcreteProductA1
        // Performing action in ConcreteProductB1

        AbstractFactory factoryB = new ConcreteFactoryB();
        Client clientB = new Client(factoryB);
        clientB.performActions();
        // Output:
        // Performing action in ConcreteProductA2
        // Performing action in ConcreteProductB2
    }
}

Advantages

Provides a consistent interface for creating related objects, separating the responsibility of object creation.
Clients can create objects without directly depending on concrete classes.
Maintains consistency and compatibility among objects.
Allows creating different object configurations by adding new concrete factory

Comparison between Factory Pattern and Abstract Factory Pattern

As mentioned in the previous article about the Factory pattern, excessive use of the Factory pattern can lead to decreased code readability due to unnecessary branching. The following example demonstrates a case where the excessive use of the Factory pattern affects code readability:

// Animal interface
public interface Animal {
    void makeSound();
}

// Cat class
public class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}

// Dog class
public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof");
    }
}

// Bird class
public class Bird implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Chirp");
    }
}

// AnimalFactory class for creating Animal objects
public class AnimalFactory {
    public static Animal createAnimal(String type) {
        if (type.equalsIgnoreCase("Cat")) {
            return new Cat();
        } else if (type.equalsIgnoreCase("Dog")) {
            return new Dog();
        } else if (type.equalsIgnoreCase("Bird")) {
            return new Bird();
        } else if (type.equalsIgnoreCase("Rabbit")) {
            return new Rabbit();
        } else if (type.equalsIgnoreCase("Snake")) {
            return new Snake();
        }
        return null;
    }
}

// Rabbit class
public class Rabbit implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Hop hop");
    }
}

// Snake class
public class Snake implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Hiss");
    }
}

// Client code
public class Client {
    public static void main(String[] args) {
        Animal cat = AnimalFactory.createAnimal("Cat");
        cat.makeSound(); // Output: "Meow"

        Animal dog = AnimalFactory.createAnimal("Dog");
        dog.makeSound(); // Output: "Woof"

        Animal bird = AnimalFactory.createAnimal("Bird");
        bird.makeSound(); // Output: "Chirp"

        Animal rabbit = AnimalFactory.createAnimal("Rabbit");
        rabbit.makeSound(); // Output: "Hop hop"

        Animal snake = AnimalFactory.createAnimal("Snake");
        snake.makeSound(); // Output: "Hiss"
    }
}

By using the Abstract Factory pattern, we can refactor the code as follows:

// Animal interface
public interface Animal {
    void makeSound();
}

// Cat class
public class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}

// Dog class
public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof");
    }
}

// Bird class
public class Bird implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Chirp");
    }
}

// Abstract Animal Factory
public interface AnimalFactory {
    Animal createAnimal();
}

// Cat Factory
public class CatFactory implements AnimalFactory {
    @Override
    public Animal createAnimal() {
        return new Cat();
    }
}

// Dog Factory
public class DogFactory implements AnimalFactory {
    @Override
    public Animal createAnimal() {
        return new Dog();
    }
}

// Bird Factory
public class BirdFactory implements AnimalFactory {
    @Override
    public Animal createAnimal() {
        return new Bird();
    }
}

// Client code
public class Client {
    public static void main(String[] args) {
        AnimalFactory catFactory = new CatFactory();
        Animal

 cat = catFactory.createAnimal();
        cat.makeSound(); // Output: "Meow"

        AnimalFactory dogFactory = new DogFactory();
        Animal dog = dogFactory.createAnimal();
        dog.makeSound(); // Output: "Woof"

        AnimalFactory birdFactory = new BirdFactory();
        Animal bird = birdFactory.createAnimal();
        bird.makeSound(); // Output: "Chirp"
    }
}

Of course, excessive use of the Abstract Factory pattern can lead to similar issues as the Factory pattern, so it’s important to use it appropriately based on the given situation and the desired direction of resolution.

Patterns that complement the Abstract Factory Pattern

One pattern that complements the Abstract Factory pattern is the Singleton pattern. By using the Singleton pattern to ensure that the Factory class has a single instance, consistent object creation can be guaranteed.

That concludes the article on the Abstract Factory pattern. It also mentions scenarios where it can be used in conjunction with other patterns or situations where it might be misused. I hope this helps!