Achieve Ultimate Excellence

Abstract Factory Design Pattern - Creating Object Families Without Concrete Classes

5 min read

Introduction

In software development, designing flexible and maintainable systems is crucial for long-term success. One way to achieve this is through design patterns. The Abstract Factory pattern is one such creational pattern that helps create families of related or dependent objects without relying on specific concrete classes. By providing an interface for object creation and delegating the responsibility to concrete factory subclasses, this pattern promotes the independence of the system's objects from their creation, composition, and representation. In this blog, we will delve into the Abstract Factory pattern, its components, and provide a Java example to better understand its practical implementation.

Understanding the Abstract Factory Pattern

The Abstract Factory pattern falls under the creational design patterns category, which focuses on object creation. Its primary objective is to provide an interface or abstract class for creating families of related objects, without explicitly specifying their concrete implementations. By doing so, it decouples the client code from the object creation process, making the codebase more flexible and adaptable to changes in the future.

Components of the Abstract Factory Pattern

The Abstract Factory pattern consists of the following components:

Abstract Factory: An interface or abstract class that declares a set of creation methods for each type of product in the family. It acts as a contract for all concrete factory implementations.
Concrete Factory: Concrete subclasses that implement the Abstract Factory interface and are responsible for creating specific families of products.
Abstract Product: An interface or abstract class that declares the common interface for all products created by the Abstract Factory.
Concrete Product: Concrete classes that implement the Abstract Product interface and define the individual products created by concrete factories.
Client: The client code that interacts with the Abstract Factory to create families of related products. It remains decoupled from the specific product implementations.

Java Example - Creating Abstract Factory for Shape and Color

Let's consider a scenario where we want to create a drawing application that can draw different shapes and fill them with various colors. We will implement the Abstract Factory pattern to achieve this.

Step 1: Define the Abstract Product Interfaces

 // Abstract Product: Shape
public interface Shape {
    void draw();
}

// Abstract Product: Color
public interface Color {
    void fill();
}

The above code defines two abstract product interfaces, Shape and Color. These interfaces will act as blueprints for different types of shapes and colors that our drawing application can handle.

Step 2: Implement Concrete Product Classes

// Concrete Product: Circle
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

// Concrete Product: Square
public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Square");
    }
}

// Concrete Product: Red
public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with Red color");
    }
}

// Concrete Product: Blue
public class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with Blue color");
    }
}

The code above contains concrete classes that represent specific shapes and colors. We have two shapes, Circle and Square, and two colors, Red and Blue.

Step 3: Create the Abstract Factory Interface

// Abstract Factory
public interface AbstractFactory {
    Shape createShape();
    Color createColor();
}

In this step, we define an abstract factory interface named AbstractFactory. It declares two methods, createShape() and createColor(), responsible for creating shapes and colors, respectively.

Step 4: Implement Concrete Factories

// Concrete Factory: ShapeFactory
public class ShapeFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return new Circle(); // or new Square();
    }

    @Override
    public Color createColor() {
        return null; // Not used in this factory
    }
}

// Concrete Factory: ColorFactory
public class ColorFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return null; // Not used in this factory
    }

    @Override
    public Color createColor() {
        return new Red(); // or new Blue();
    }
}

In this step, we implement two concrete factories: ShapeFactory and ColorFactory. Each factory is responsible for creating objects of the corresponding product family.

Step 5: Implement the Client Code

public class DrawingApplication {
    public static void main(String[] args) {
        // Using the ShapeFactory to create a shape
        AbstractFactory shapeFactory = new ShapeFactory();
        Shape shape = shapeFactory.createShape();
        shape.draw(); // Output: Drawing Circle

        // Using the ColorFactory to create a color
        AbstractFactory colorFactory = new ColorFactory();
        Color color = colorFactory.createColor();
        color.fill(); // Output: Filling with Red color
    }
}

In the final step, we implement the client code in the DrawingApplication class. It will interact with the abstract factory to create shapes and colors without knowing the specific implementations.

Conclusion

The Abstract Factory pattern provides an elegant solution for creating families of related objects in a flexible and decoupled manner. By utilizing interfaces and abstract classes, it promotes code reusability and scalability. In the Java example provided, we demonstrated how the Abstract Factory pattern helps our drawing application create different shapes and colors without knowing the specific product implementations. This pattern is especially useful when designing systems that should be independent of how their objects are created, composed, and represented, making it an essential tool in the developer's design pattern arsenal.

Article By,