Creational Design Patterns

In software engineering, creational design patterns are design patterns that deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The basic form of object creation could result in design problems or added complexity to the design. Creational design patterns solve this problem by somehow controlling this object creation. Creational design patterns are composed of two dominant ideas.

1. One is encapsulating knowledge about which concrete classes the system use.
2. Another is hiding how instances of these concrete classes are created and combined.

Creational design patterns are further categorized into Object-creational patterns and Class-creational patterns, where Object-creational patterns deal with Object creation and Class-creational patterns deal with Class-instantiation. In greater details, Object-creational patterns defer part of its object creation to another object, while Class-creational patterns defer its objection creation to subclasses.
Five well-known design patterns that are parts of creational patterns are listed as follows:

Creational design patterns are fundamental to object-oriented design and software development. They focus on object creation mechanisms, aiming to create objects in a manner suitable to a given situation. By providing versatile and reusable solutions, these patterns can help manage complexity, promote consistency, and enhance performance.
Key characteristics of creational design patterns include:

1. Abstraction of the instantiation process: Creational patterns encapsulate the knowledge about which concrete classes the system utilizes. They hide the specifics of object creation and control how objects are created, thereby achieving a higher degree of program abstraction.
2. System decoupling: These patterns provide a way to decouple the client code from the concrete classes instantiated. The client code does not need to know the specific types of objects it works with - only interfaces. This approach increases system modularity and makes the addition of new concrete types easy, without altering the client code.
3. Control over object creation mechanisms: Creational patterns offer more control over the object creation process. Depending on the pattern, they may allow for controlling aspects such as instantiation timing, object sharing and recycling, or varying the type of created objects.
4. Provision of total or partial hiding of the created objects: The creational design patterns can provide either a complete or a partial hiding of the objects that are being created. This characteristic allows for the encapsulation of the complexities that are associated with object creation.
5. Dynamic binding: Creational patterns typically utilize inheritance effectively, letting the subclasses decide which objects should be created. This ensures that the client code gets decoupled from the specifics of the classes that get instantiated.
6. Scalability: The creational patterns allow for easily scalable code. With these patterns, developers can add new classes or objects to the program without affecting the existing code.

The most common creational design patterns include the Singleton, Factory Method, Abstract Factory, Builder, and Prototype patterns. Each of these patterns offers unique approaches to object creation, addressing specific design problems and providing different trade-offs. The choice of which to use will depend on the specific requirements of the software being developed.

1. Abstract factory pattern, which provides an interface for creating related or dependent objects without specifying the objects' concrete classes.
2. Builder pattern, which separates the construction of a complex object from its representation so that the same construction process can create different representation.
3. Factory method pattern, which allows a class to defer instantiation to subclasses.
4. Prototype pattern, which specifies the kind of object to create using a prototypical instance, and creates new objects by cloning this prototype.
5. Singleton pattern, which ensures that a class only has one instance, and provides a global point of access to it.