11.3.2. Factory Method Pattern

Defines an interface for creating an object but lets subclasses alter the type of objects that will be created.

The Factory Method Pattern is a design pattern that establishes a common interface for creating objects, while allowing subclasses to provide the specific implementation of the object being created. This pattern is beneficial when a class does not know the exact class of objects it needs to create, or when it wants its subclasses to determine which class to instantiate. It encapsulates the object creation process and promotes loose coupling.

Imagine a bakery that uses a factory to produce cakes. The bakery has a general method for producing cakes (the interface), but depending on the occasion, the specific type of cake (like a chocolate cake or vanilla cake) can vary. Each type of cake has its own recipe (subclass), but they all share the same baking process (interface). This way, the bakery can easily switch between different cake types without changing the overall baking process.

interface Shape { void draw(); }

In this code snippet, we define an interface called 'Shape' that declares a method 'draw()'. This interface serves as a blueprint for any shape that needs to be created. By using an interface, we ensure that any class implementing this interface will provide its own version of the draw method, adhering to a common contract. This contributes to polymorphism, allowing the system to work with different shapes without knowing the specific class.

Think of the Shape interface like a set of instructions for a drawing competition. Every participant (class) must follow these instructions on how to draw (implement the draw method), but each participant can choose their own style or technique, leading to unique creations while still conforming to the same guidelines.

class Circle implements Shape { public void draw() { System.out.println("Drawing Circle"); } }

Here, we have a concrete implementation of the Shape interface named 'Circle'. The Circle class implements the 'draw()' method defined in the Shape interface, providing its specific behavior by printing 'Drawing Circle' to the console. This implementation shows how we can define a specific type of shape and its behavior while still being able to use the Shape interface elsewhere in the program.

Consider the Circle class like a specific participant who enters the drawing competition with their unique interpretation of how to draw a circle. Just as this artist follows the competition rules but infuses their own flair into the final piece, the Circle class adheres to the Shape interface while providing its personalized draw function.

class ShapeFactory { public Shape getShape(String type) { if (type.equalsIgnoreCase("circle")) return new Circle(); return null; } }

The ShapeFactory class plays the role of the factory in the Factory Method Pattern. It contains a method called 'getShape' that takes a string parameter 'type' to determine which shape object to create. If the type is 'circle', it returns a new instance of Circle. Otherwise, it returns null. This method abstracts the object creation process, allowing the rest of the application to request shapes without needing to know about the specific classes involved.

Think of the ShapeFactory as the ordering desk at the bakery. When a customer requests a cake (shape), the desk (factory) checks the order details (type) and decides which cake to bake (create). If the order is for a chocolate cake, the desk instructs the kitchen to produce it, simplifying the selection process for the customer!

--