Factory Pattern

In object-oriented programming, a factory is an object for creating other objects; formally, it is a function or method that returns objects of a varying prototype or class from some method call, which is assumed to be "new". More broadly, a subroutine that returns a "new" object may be referred to as a "factory", as in ''factory method'' or ''factory function''. The factory pattern is the basis for a number of related software design patterns.

Motivation

In class-based programming, a factory is an abstraction of a constructor of a class, while in prototype-based programming a factory is an abstraction of a prototype object. A constructor is concrete in that it creates objects as instances of a single class, and by a specified process (class instantiation), while a factory can create objects by instantiating various classes, or by using other allocation schemes such as an object pool. A prototype object is concrete in that it is used to create objects by being cloned, while a factory can create objects by cloning various prototypes, or by other allocation schemes.

A factory may be implemented in various ways. Most often it is implemented as a method, in which case it is called a ''factory method''. Sometimes it is implemented as a function, in which case it is called a ''factory function''. In some languages, constructors are themselves factories. However, in most languages they are not, and constructors are invoked in a way that is idiomatic to the language, such as by using the keyword new, while a factory has no special status and is invoked via an ordinary method call or function call. In these languages, a factory is an abstraction of a constructor, but not strictly a generalization, as constructors are not themselves factories.

Terminology

Terminology differs as to whether the concept of a factory is itself a design pattern – in '' Design Patterns'' there is no "factory pattern", but instead two patterns (factory method pattern and abstract factory pattern) that use factories. Some sources refer to the concept as the factory pattern,Factory Pattern

OODesign.com
/ref> while others consider the concept itself a programming idiom,Chapter 4. The Factory Pattern: Baking with OO Goodness

The Simple Factory defined
reserving the term "factory pattern" or "factory patterns" to more complicated patterns that use factories, most often the factory method pattern; in this context, the concept of a factory itself may be referred to as a simple factory. In other contexts, particularly the Python language, "factory" itself is used, as in this article. More broadly, "factory" may be applied not just to an object that returns objects from some method call, but to a '' subroutine'' that returns objects, as in a ''factory function'' (even if functions are not objects) or ''factory method.'' Because in many languages factories are invoked by calling a method, the general concept of a factory is often confused with the specific factory method pattern design pattern.

Use

OOP provides polymorphism on object ''use'' by method dispatch, formally subtype polymorphism via single dispatch determined by the type of the object on which the method is called. However, this does not work for constructors, as constructors ''create'' an object of some type, rather than ''use'' an existing object. More concretely, when a constructor is called, there is no object yet on which to dispatch.

Using factories instead of constructors or prototypes allows one to use polymorphism for object creation, not only object use. Specifically, using factories provides encapsulation, and means the code is not tied to specific classes or objects, and thus the class hierarchy or prototypes can be changed or refactored without needing to change code that uses them – they abstract from the class hierarchy or prototypes.

More technically, in languages where factories generalize constructors, factories can usually be used anywhere constructors can be, meaning that interfaces that accept a constructor can also in general accept a factory – usually one only need something that creates an object, rather than needing to specify a class and instantiation.

For example, in Python, the collections.defaultdict class has a constructor which creates an object of type defaultdict whose default values are produced by invoking a factory. The factory is passed as an argument to the constructor, and can itself be a constructor, or any thing that behaves like a constructor – a callable object that returns an object, i.e., a factory. For example, using the list constructor for lists:

# collections.defaultdict( efault_factory[,_...)
d_=_defaultdict(list)

_Object_creation

Factory_objects_are_used_in_situations_where_getting_hold_of_an_object_of_a_particular_kind_is_a_more_complex_process_than_simply_creating_a_new_object,_notably_if_complex_allocation_or_initialization_is_desired._Some_of_the_processes_required_in_the_creation_of_an_object_include_determining_which_object_to_create,_managing_the_lifetime_of_the_object,_and_managing_specialized_build-up_and_tear-down_concerns_of_the_object._The_factory_object_might_decide_to_create_the_object's_efault_factory[,_...)
d_=_defaultdict(list)

_Object_creation

Factory_objects_are_used_in_situations_where_getting_hold_of_an_object_of_a_particular_kind_is_a_more_complex_process_than_simply_creating_a_new_object,_notably_if_complex_allocation_or_initialization_is_desired._Some_of_the_processes_required_in_the_creation_of_an_object_include_determining_which_object_to_create,_managing_the_lifetime_of_the_object,_and_managing_specialized_build-up_and_tear-down_concerns_of_the_object._The_factory_object_might_decide_to_create_the_object's_class_(computer_science)">class_

Class_or_The_Class_may_refer_to:

__Common_uses_not_otherwise_categorized
*__Class_(biology),_a_taxonomic_rank
*__Class_(knowledge_representation),_a_collection_of_individuals_or_objects
*_Class_(philosophy),_an_analytical_concept_used_differentl_...
_(if_applicable)_dynamically,_return_it_from_an_object_pool_
The_object_pool_pattern_is_a_software__creational_design_pattern_that_uses_a_set_of_initialized__objects_kept_ready_to_use_–_a_"pool"_–_rather_than_allocating_and_destroying_them_on_demand._A_client_of_the_pool_will_request_an_object_from_the_p_...