Creational Patterns

Creational patterns are design patterns that focus on object creation mechanisms, promoting flexibility and efficiency in the instantiation process.

Creational patterns are crucial in software design, as they provide methods to create objects in a controlled manner. This section introduces key creational patterns, including the Singleton, Factory Method, Abstract Factory, Builder, and Prototype patterns, each with its specific application and implementation in Java.

Creational Patterns in Java

Creational patterns are a subset of design patterns dedicated to the creation of objects in software applications. These patterns are designed to abstract the instantiation process, providing various means for creating objects, which can help promote system flexibility and ease of maintenance. By using creational patterns, developers can manage the complexities and variations that arise when creating object instances.

In Java, the following key creational patterns are discussed:

1. Singleton Pattern: Ensures a class can only have one instance and provides a global access point to that instance. This is especially useful for managing shared resources like database connections or logging.

   Java

   Try it yourself

   public class Singleton {
       private static Singleton instance;
       private Singleton() { }
       public static Singleton getInstance() {
           if (instance == null) {
               instance = new Singleton();
           }
           return instance;
       }
   }

2. Factory Method Pattern: Defines an interface for creating objects and allows subclasses to alter the type of created objects. This pattern encourages loose coupling in the code.

   Java

   Try it yourself

   interface Shape {
       void draw();
   }
   class Circle implements Shape {
       public void draw() {
           System.out.println("Drawing Circle");
       }
   }
   class ShapeFactory {
       public Shape getShape(String type) {
           if (type.equalsIgnoreCase("circle")) return new Circle();
           return null;
       }
   }

3. Abstract Factory Pattern: Provides an interface for creating families of related or dependent objects without specifying their concrete classes. It's useful for creating variations of products.

   Java

   Try it yourself

   interface GUIFactory {
       Button createButton();
       Checkbox createCheckbox();
   }
   class WinFactory implements GUIFactory {
       public Button createButton() {
           return new WinButton();
       }
       public Checkbox createCheckbox() {
           return new WinCheckbox();
       }
   }

4. Builder Pattern: Facilitates the step-by-step construction of complex objects. It’s particularly effective for objects with many parameters.

   Java

   Try it yourself

   class Computer {
       private String CPU;
       private String RAM;
       public static class Builder {
           private String CPU;
           private String RAM;
           public Builder setCPU(String CPU) {
               this.CPU = CPU;
               return this;
           }
           public Builder setRAM(String RAM) {
               this.RAM = RAM;
               return this;
           }
           public Computer build() {
               Computer c = new Computer();
               c.CPU = this.CPU;
               c.RAM = this.RAM;
               return c;
           }
       }
   }

5. Prototype Pattern: Used to create duplicate objects while keeping performance in mind, allowing for easy replication of objects while maintaining their original structure.

   Java

   Try it yourself

   class Shape implements Cloneable {
       public Object clone() throws CloneNotSupportedException {
           return super.clone();
       }
   }

Understanding and implementing these creational patterns effectively enhances code modularity, readability, and maintainability, aligning with best practices in software development.