Abstract Factory Pattern
The Abstract Factory pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes. It encapsulates knowledge about which concrete classes a system uses and hides how they are created and assembled. The pattern is applicable when a system needs to be independent of how product objects are created, created product families can be used independently, and products within a family are usually used together. Common implementations of the pattern include the Factory Method, Prototype, and Builder patterns. The classic Abstract Factory pattern isolates concrete classes but makes exchanging product families and enforcing consistency among products more difficult. Variations like pluggable and extensible factories aim to address these issues but also have tradeoffs around complexity and type safety.
Abstract Factory Pattern
- 1. Abstract Factory Pattern Provide an interface for creating families of related or dependent objects without specifying their concrete classes
- 2. Design Strategies recommended by GoF Design to Interfaces Favour composition over inheritance Find what varies and encapsulate it
- 3. Themes of Creational Patterns Encapsulate Knowledge about which concrete classes the system uses Hide how these classes are created and put together
- 4. Applicability A system independent of how products are created Independent families of products can be used Within a family, sibling products should be use together Reveal Interfaces of class library and hide implementation
- 5. Implementation Factory Method Prototype Builder
- 6. Abstract Factory using Factory Method
- 7. Consequences of Classic Abstract Factory It isolates concrete classes Exchanging product families harder Consistency among products harder to enforce Supporting new kinds of products is difficult
- 8. Pluggable Factory John Vlissides C++ Report, February 1999
- 9. Consequences of Pluggable Factory Class structure is simpler The factory interface tends to be more complex Changing individual product types is easy. Exchanging product families harder Consistency among products harder to enforce
- 10. Implementation - 2 nd Dimension Dedicated Creators Parameterized Creators
- 11. Extensible Factories Timothy R. Culp C++ Report, October 1999
- 12. Consequences of Extensible Factories Supporting new kinds of products is easier Products are returned with same Interface Less type safety Exchanging product families harder Consistency among products harder to enforce