Generative Design Patterns - Factory Method

шаблоны проектирования, abstract, cpp

Goals

• We define an interface for creating an object, but let the subclasses decide which class to create. A factory method allows you to instantiate a class for subclasses.
• Definition of a "virtual" constructor.
• The new operator is harmful.

Problems

The design structure should standardize the architectural model across a range of applications, but allows individual applications to define their own objects and provide their own rules for creating objects while maintaining a consistent object creation interface.

Discussion

The factory method is to create objects as a template method to implement the object creation algorithm. The superclass defines all the default and generic behavior (using pure virtual "methods" to implement the object creation steps) and then delegates the object creation details to subclasses that are exposed to clients.

The factory method makes application design more customizable and only slightly more complex. Other design patterns require new classes, while Factory Method only requires a new operation.

People often use the Factory Method as the standard way to create objects; but this is not necessary if: the instance of the class that was created never changes, or the instantiation is created in an operation that subclasses can easily override (such as an initialization operation).

A factory method is similar to an abstract factory, but without the focus on the object family.

Factory methods are typically defined by the architecture and then implemented by the user of the framework.

Structure

The implementation of the Factory Method discussed in Gang of Four is largely the same as the implementation of the Abstract Factory. For this reason, the presentation in this article focuses on the approach that has become popular since then.

An increasingly popular definition of a factory method is a static class method that returns an object of that class's type. But unlike a constructor, the actual object it returns can be an instance of a subclass. Unlike a constructor, an existing object can be reused instead of a newly created object. Unlike a constructor, factory methods can have different and more descriptive names (for example, Color.make_RGB_color (float red, float green, float blue) and Color.make_HSB_color (float hue, float saturation, float brightness).

The client is completely separated from the implementation details of the derived classes. It is now possible to use polymorphism.

Example

A factory method defines an interface for creating objects, but allows subclasses to decide which classes to create. Injection molds show this pattern. Plastic toy manufacturers process plastic molding powder and inject the plastic into molds with desired characteristics. The class of toys (car, action figure, etc.) is determined by the shape.

Control List

1. If you have an inheritance hierarchy that does polymorphism, consider adding the ability to create polymorphic objects by defining a static factory method in the base class.
2. Develop arguments for the factory method. What qualities or characteristics are necessary and sufficient to identify the correct derived class to instantiate?
3. Consider creating an internal "object pool" that allows objects to be reused instead of being created from scratch.
4. Consider making all constructors private or protected

Rules of thumb

• Abstract Factory classes are often implemented using Factory Methods, but they can be implemented using Prototype.
• Factory methods are usually called in template methods.
• Factory Method: creation through inheritance. Prototype: creation via delegation.
• Often projects start with Factory Method (less complex, customizable, subclasses proliferate) and evolve towards Abstract Factory, Prototype, or Builder (more flexible, more complex) as the developer finds more flexibility is needed.
• Prototype does not require subclasses, but it does require an initialization operation. Factory Method requires subclassing but does not require initialization.
• The benefit of a Factory Method is that it may return the same instance multiple times, or it may return a subclass rather than an object of that exact type.
• Some factory method proponents recommend that, in terms of language design (or style, for that matter), absolutely all constructors should be private or protected.
• The new operator is considered harmful. There is a difference between requesting an object and creating it. The new operator always creates an object and cannot encapsulate object creation. The Factory Method takes advantage of this encapsulation and allows you to query for an object without being tied to the act of creation.