Creational design patterns deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. They increase flexibility in deciding which objects need to be created for a given use case. Some of the most commonly used creational design patterns include:
Abstract Factory: Creates an instance of several families of classes.
Builder: Separates object construction from its representation, always creates the same type of object.
Factory Method: Creates an instance of several derived classes.
Prototype: A fully initialized instance to be copied or cloned.
Singleton: A class of which only a single instance can exist.
Abstract factory pattern: This pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.
Builder pattern: This pattern separates the construction of a complex object from its representation, allowing the same construction process to create various representations.
Factory method pattern: This pattern defines an interface for creating an object, but allows subclasses to alter the type of objects that will be created.
Prototype pattern: This pattern specifies the kind of objects to create using a prototypical instance, and creates new objects by copying this prototype.
Singleton pattern: This pattern ensures that a class has only one instance and provides a global point of access to it.
It's important to note that, the best pattern to use depends on the specific situation, and it's important to weigh the trade-offs between the different options before implementing one.
