Chapter 1. Creational Patterns

The creational patterns are designed to deal with the object creation mechanism in software designing. A system using these patterns becomes independent of how objects are created, which means it is independent of how concrete classes are instantiated.

These patterns encapsulate the use of concrete classes and favor the use of interfaces in the relationship between objects, allowing to have better abstraction of the global system conception.

Thus, if we analyze the singleton pattern, a pattern designed to instantiate only one instance of a class, we find that the mechanism that controls the unique access to this instance is fully encapsulated in the class, which means that this is completely transparent to the client consuming the instance of the class.

In this chapter, we will introduce you to the five creational patterns and discuss how we can use them with Swift:

• The prototype pattern
• The factory method pattern
• The singleton pattern
• The abstract factory pattern
• The builder pattern

The objectives of these patterns are described in the following table:

Pattern	Objective
The prototype pattern	This pattern allows you to create new objects by duplicating existing objects called prototypes. This pattern has the cloning capability.
The factory method pattern	This pattern introduces you to an abstract method that allows you to create an object by telling its subclasses about the effective creation of the object.
The singleton pattern	This pattern ensures that a class has only one instance. This class provides a unique point of access that returns this instance.
The abstract factory pattern	This pattern allows you to create an object that is grouped in families by hiding the concrete classes that are needed to create these objects.
The builder pattern	This pattern allows you to separate the creation of complex objects from their implementation. This permits a client to create complex objects having different representations.