Introduction to Creational Patterns

Introduction

In software design, creational patterns are a category of design patterns that deal with the process of object creation. They provide solutions to problems related to how objects are created and managed in an application. The primary goal of creational patterns is to encapsulate the instantiation logic of classes, making it easier to manage dependencies and promote flexibility.

Creational patterns help in managing the lifecycle of objects, ensuring that they are instantiated in a controlled manner. This leads to more maintainable and scalable code, especially in large systems where object creation can become complex.

Concept

What Are Creational Patterns?

Creational patterns focus on the process of creating objects. They provide mechanisms for creating objects without specifying the exact class of object that will be created. This abstraction allows for greater flexibility and decoupling between the client code and the concrete classes.

There are several creational patterns, each addressing different aspects of object creation:

1. Singleton Pattern: Ensures a class has only one instance and provides a global point of access to it.
2. Factory Method Pattern: Defines an interface for creating an object, but lets subclasses decide which class to instantiate.
3. Abstract Factory Pattern: Provides an interface for creating families of related or dependent objects without specifying their concrete classes.
4. Builder Pattern: Separates the construction of a complex object from its representation so that the same construction process can create different representations.
5. Prototype Pattern: Creates objects by cloning existing objects, which is useful when dealing with complex object creation processes.

Why Use Creational Patterns?

• Encapsulation: Hides the instantiation logic from the client code, making it easier to manage and modify.
• Flexibility: Allows for easy introduction of new classes without modifying existing client code.
• Decoupling: Reduces dependencies between classes by abstracting object creation.
• Scalability: Facilitates the management of complex object hierarchies.

Examples

Singleton Pattern Example

The Singleton pattern ensures that a class has only one instance and provides a global point of access to it. This is useful when exactly one object is needed to coordinate actions across the system.

1class Singleton {
2static instance = null;
3 
4constructor() {
5  if (Singleton.instance) {
6    return Singleton.instance;
7  }
8  Singleton.instance = this;
9}
10 
11someMethod() {
12  console.log('This is a method of the Singleton class.');
13}
14}
15 
16// Usage
17const singleton1 = new Singleton();
18const singleton2 = new Singleton();
19 
20console.log(singleton1 === singleton2); // true
21singleton1.someMethod(); // This is a method of the Singleton class.

Factory Method Pattern Example

The Factory Method pattern defines an interface for creating an object but lets subclasses decide which class to instantiate. This pattern promotes flexibility and decoupling.

1class Product {
2use() {
3  console.log('Using a product.');
4}
5}
6 
7class ConcreteProductA extends Product {
8use() {
9  console.log('Using ConcreteProductA.');
10}
11}
12 
13class ConcreteProductB extends Product {
14use() {
15  console.log('Using ConcreteProductB.');
16}
17}
18 
19class Creator {
20factoryMethod() {
21  return new Product();
22}
23 
24someOperation() {
25  const product = this.factoryMethod();
26  product.use();
27}
28}
29 
30class ConcreteCreatorA extends Creator {
31factoryMethod() {
32  return new ConcreteProductA();
33}
34}
35 
36class ConcreteCreatorB extends Creator {
37factoryMethod() {
38  return new ConcreteProductB();
39}
40}
41 
42// Usage
43const creatorA = new ConcreteCreatorA();
44creatorA.someOperation(); // Using ConcreteProductA.
45 
46const creatorB = new ConcreteCreatorB();
47creatorB.someOperation(); // Using ConcreteProductB.

What's Next?

In the next section, we will delve deeper into the Singleton Pattern, exploring its use cases and variations. Understanding the Singleton pattern is crucial as it forms the foundation for many other design patterns and architectural principles.

Stay tuned!