Abstract Factory and Factory Method

1. Abstract Factoryand Factory Method CS 124 Reference: Gamma et al(“Gang-of-4”), Design Patterns

2. Intent of both patterns • Separate the implementation of objects from their use by defining an interface for creating the objects without specifying their concrete classes • Abstract Factory: focus is on allowing multiple implementations of a product • Factory Method: focus is on generalizing the creator-product relationship • Abstract Factory uses the Factory Method pattern

3. Abstract Factory • Intent: provide an interface for creating objects without specifying their concrete classes • Example: Stacks, Queues, and other data structures • Want users to not know or care how these structures are implemented (separation) • Example: UI toolkit to support multiple look-and-feel standards, e.g., Motif, PM • Abstract class for widget, supporting class for specific platform widget

4. Solutions in C++ • Use of header file (class declarations) and implementation file (method definitions) ok but limited • Header file usually contains private declarations which are technically part of the implementation • Change in implementation requires that the application using the data structure be recompiled • Alternative: create an abstract superclass with (pure) virtual data structure methods

5. Design Solution for Abstract Factory Factory createProduct() AbstractProduct virtual methods Client ConcreteProdA methods ConcreteProdB methods Note: this is an abbreviated design

6. Participants • Factory • implements the operations to create concrete product objects • actual pattern includes abstract and concrete factory classes that generalizes the relationship between factory and product • (Abstract) Product: declares an interface for a type of product object • Concrete Product • defines a product object to be created by the corresponding concrete factory • implements the abstract product interface • Client: uses only Factory and Abstract Product

7. Stack Example return new ArrayStack(); StackFactory createStack() Stack push(), pop() Client ArrayStack push(), pop() LinkedStack Push(), pop() … Stack s; s = StackFactory.createStack(); … s.pop(); …

8. Stack Example (C++) • Stack class defines virtual methods • push(), pop(), etc. • ArrayStack and LinkedStack are derived classes of Stack and contain concrete implementations • StackFactory class defines a createStack() method that returns a ptr to a concrete stack • Stack *createStack() { return new ArrayStack(); } • Client programs need to be aware of Stack and StackFactory classes only • No need to know about ArrayStack()

9. Factories in Java • Stack is an Interface • ArrayStack and LinkedStack implement Stack • StackFactory returns objects of type Stack through its factory methods • Select class of the concrete prodcut it supplies to client objects • If using info from requesting client, can hardcode selection logic and choice of factory objects • Can separate selection logic for concrete factories from the data it uses to make the selection

10. Abstract FactoryConsequences • Factory class or method can be altered without affecting the application • Concrete classes are isolated • Factory class can be responsible for creating different types of objects • e.g., DataStructure factory that returns stacks, queues, lists, etc. • “product families” • Promotes product consistency

11. Factory Method • Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory method lets a class defer instantiation to subclasses • Example: Generalizing the relationship between an application and the documents it processes • Generalization: Application creates Documents • Concretized by: MS Paint creates Gifs, MS Word creates Word Documents, MS Excel creates spreadsheets

12. Design Solution forFactory Method Factory factoryMethod() Product virtual methods ConcreteFactory factoryMethod() ConcreteProduct methods

13. Application-Document Example Application createDoc() Document virtual methods MyApplication createDoc() MyDocument methods return new MyDocument();

14. Factory Method Consequences • Separation of interface from implementation, providing implementation flexibility • Connects parallel hierarchies for consistency