Creational Design Patterns Overview

# CHAPTER 5

Creational Design Patterns Overview #

1. Introduction #

2. Learning Objectives #

• Define the purpose and scope of Creational Design Patterns.

• Understand the architectural dangers of hardcoding the new keyword.

• Differentiate between class-creation patterns and object-creation patterns.

• Identify the five primary Creational Patterns defined by the Gang of Four.

• Understand the concept of "Dependency Management" through object creation.

3. The Problem with the "new" Keyword #

• The Anti-Pattern: Imagine a ReportGenerator class that says $db = new MySQLDatabase(). The ReportGenerator is now permanently glued to MySQL. It cannot be tested independently, and it cannot be reused with PostgreSQL.

• The Creation Logic: Objects often require complex setup. If a Car object requires you to first instantiate an Engine, four Tires, and a Chassis, forcing the client code to write 10 lines of setup every time they want a Car duplicates logic and causes errors.

• The Creational Goal: Hide the complexity of creation. The client code should just ask for a Car, and the Creational Pattern handles the messy assembly behind the scenes.

4. The Gang of Four Categories Overview #

1. 1. Creational Patterns: Deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. (Our current focus).

1. 2. Structural Patterns: Deal with object composition, identifying simple ways to realize relationships between different entities (e.g., Adapter, Facade).

1. 3. Behavioral Patterns: Deal with communication and the assignment of responsibilities between objects (e.g., Observer, Strategy).

5. The Five Creational Patterns #

1. 1. Singleton: Ensures a class only has one instance, and provides a global point of access to it. (e.g., A shared configuration manager).

1. 2. Factory Method: Defines an interface for creating an object, but lets subclasses decide which class to instantiate. (e.g., A Logistics app deciding between creating a Truck or a Ship).

1. 3. Abstract Factory: Provides an interface for creating *families* of related or dependent objects without specifying their concrete classes. (e.g., Creating Mac UI buttons vs. Windows UI buttons).

1. 4. Builder: Separates the construction of a complex object from its representation, allowing the same construction process to create different representations. (e.g., Building a complex SQL query step-by-step).

1. 5. Prototype: Specifies the kinds of objects to create using a prototypical instance, and creates new objects by copying this prototype. (e.g., Cloning an enemy character in a video game to save memory).

6. Dependency Management #

7. Diagrams/Visual Suggestions #

[ How do I ensure only ONE object exists? ] ----> Singleton
[ How do I let subclasses create objects? ] ----> Factory Method
[ How do I create families of objects? ] -------> Abstract Factory
[ How do I build a complex object in steps? ] --> Builder
[ How do I create an object by cloning? ] ------> Prototype

8. Best Practices #

• Hide the Constructor: When implementing patterns like the Factory or Singleton, a standard practice is to make the actual class constructor private or protected. This physically forces other developers to use your Factory method to get the object, preventing them from accidentally using the new keyword and bypassing your architectural rules.

9. Common Mistakes #

• Over-Engineering Creation: A developer writes a massive StringFactory just to create basic string variables. *The Failure:* This is absurd over-engineering. Creational patterns should only be used when the object creation process is complex, involves heavy configuration, or requires dynamic polymorphism. For simple Data Transfer Objects (DTOs), the new keyword is perfectly fine.

10. Mini Project: Identify the Pattern #

1. 1. *Scenario:* We need a single, shared connection to the Redis cache that every file in our app can access without opening a new connection. -> Singleton

1. 2. *Scenario:* We are building a maze game. We need a way to construct complex rooms with varying amounts of doors, monsters, and treasure chests step-by-step. -> Builder

1. 3. *Scenario:* A user clicks "Export". Based on their settings, we either need to generate a PDFDocument or an ExcelDocument. -> Factory Method

11. Practice Exercises #

1. 1. Explain why relying heavily on the new keyword throughout a codebase creates tightly coupled architecture.

1. 2. List the three main categories of the Gang of Four (GoF) design patterns, and define the primary focus of the Creational category.

12. MCQs with Answers #

13. Interview Questions #

• Q: Explain the concept of tightly coupled code in relation to object instantiation. How do Creational patterns resolve this coupling?

• Q: Walk me through the high-level differences between a Factory Method, a Builder, and a Prototype pattern. What specific object creation problem does each solve?

• Q: Why might an architect choose to make a class constructor private? How does an external client instantiate the class if the constructor is locked?

14. FAQs #

15. Summary #

16. Next Chapter Recommendation #