Singleton Design Pattern

The Singleton design pattern is categorized as a creational pattern, specifically aimed at ensuring that a class has only one instance while providing a global access point to that instance. Here are the primary components and characteristics of the Singleton pattern:

• Private Constructor: The constructor is private, preventing external instantiation.
• Static Instance: A static member variable within the class holds the sole instance of the class.
• Static Method: A public static method allows access to this instance, typically creating it upon the first call and returning the same instance on subsequent calls.
• Lazy Initialization (optional): Instances can be created when first requested (lazy initialization), or during class loading (eager initialization). Lazy initialization is often preferred for resource management.

Example implementation:

public class Singleton {

private static Singleton instance;

// Private constructor to prevent instantiation

private Singleton() {

}

// Public static method to retrieve the instance

public static Singleton getInstance() {

if (instance == null) {

instance = new Singleton(); // Lazy initialization

}

return instance;

}

}

Common use cases for the Singleton pattern include:

• Database Connections: Managing a single database connection to avoid unnecessary resource consumption.
• Thread Pools: Creating a centralized thread pool for concurrent processing.
• Logging: Centralizing logging activities to allow consistent event and error recording throughout the application.

Factory Design Pattern

The Factory Design Pattern is another important creational design pattern that provides a structured approach to object creation, particularly useful when an application needs to manage multiple types of objects.

Here's a basic example with an abstract Shape interface:

public interface Shape {

void draw();

}

Concrete implementations of the Shape interface include Circle, Rectangle, and Triangle:

public class Circle implements Shape {

@Override

public void draw() {

System.out.println("Drawing a Circle");

}

}

public class Rectangle implements Shape {

@Override

public void draw() {

System.out.println("Drawing a Rectangle");

}

}

public class Triangle implements Shape {

@Override

public void draw() {

System.out.println("Drawing a Triangle");

}

}

The ShapeFactory class is responsible for creating different shapes based on user input or other criteria:

public class ShapeFactory {

public Shape getShape(String shapeType) {

if (shapeType == null) {

return null;

}

if (shapeType.equalsIgnoreCase("CIRCLE")) {

return new Circle();

} else if (shapeType.equalsIgnoreCase("RECTANGLE")) {

return new Rectangle();

} else if (shapeType.equalsIgnoreCase("TRIANGLE")) {

return new Triangle();

}

return null;

}

}

The factory simplifies the creation process, abstracting the details of shape instantiation.

The second video discusses the steps and resources necessary for beginners to learn Low-Level Design, further illustrating the principles of the Factory pattern.

Builder Design Pattern

The Builder Design Pattern is a creational pattern designed to construct complex objects incrementally. This pattern allows for creating various configurations of the same object type, enhancing flexibility and readability.

Consider the Phone class, which represents a complex object with attributes such as OS, RAM, and battery capacity:

public class Phone {

private String OS;

private int ram;

private int battery;

public Phone(String OS, int ram, int battery) {

this.OS = OS;

this.ram = ram;

this.battery = battery;

}

// Getters and setters omitted for brevity

}

Initially, a Phone object may be created with hardcoded values:

public class Shop {

public static void main(String[] args) {

Phone myPhone = new Phone("Android", 4, 3000);

// Print phone details

}

}

However, a PhoneBuilder class can streamline the creation of Phone objects:

public class PhoneBuilder {

private String OS;

private int ram;

private int battery;

public PhoneBuilder setOS(String OS) {

this.OS = OS;

return this;

}

public PhoneBuilder setRam(int ram) {

this.ram = ram;

return this;

}

public PhoneBuilder setBattery(int battery) {

this.battery = battery;

return this;

}

public Phone getPhone() {

return new Phone(OS, ram, battery);

}

}

This allows for a more readable construction process:

public class Shop {

public static void main(String[] args) {

PhoneBuilder phoneBuilder = new PhoneBuilder();

Phone myPhone = phoneBuilder

.setOS("Android")

.setRam(4)

.setBattery(3000)

.getPhone(); // Build the Phone object

}

}

Advantages of the Builder approach include:

• Improved Readability: The builder's descriptive method names enhance clarity.
• Elimination of Order Dependency: Attributes can be set in any order, reducing confusion.
• Optional Parameters Handling: Optional attributes can be managed cleanly.
• Reduced Constructor Overloads: Simplifies code management by avoiding multiple constructors.
• Facilitates Complex Object Creation: Simplifies the construction of objects requiring many parameters.

Strategy Design Pattern

The Strategy Design Pattern is a behavioral pattern that defines a family of algorithms, encapsulates each one, and makes them interchangeable. This allows clients to select an algorithm at runtime without modifying existing code.

Components of the Strategy Pattern include:

• Context: The class that holds a reference to the strategy interface and invokes its methods.
• Strategy: The interface that defines the family of algorithms.
• ConcreteStrategy: Classes implementing the Strategy interface, each providing a unique algorithm.

Here’s a simple Java example demonstrating the Strategy Pattern with a payment system:

interface PaymentStrategy {

void pay(int amount);

}

class CreditCardPayment implements PaymentStrategy {

@Override

public void pay(int amount) {

System.out.println("Paid " + amount + " using Credit Card.");

}

}

class PayPalPayment implements PaymentStrategy {

@Override

public void pay(int amount) {

System.out.println("Paid " + amount + " using PayPal.");

}

}

class ShoppingCart {

private PaymentStrategy paymentStrategy;

public void setPaymentStrategy(PaymentStrategy paymentStrategy) {

this.paymentStrategy = paymentStrategy;

}

public void checkout(int amount) {

paymentStrategy.pay(amount);

}

}

In the client code:

public class StrategyPatternExample {

public static void main(String[] args) {

ShoppingCart cart = new ShoppingCart();

cart.setPaymentStrategy(new CreditCardPayment());

cart.checkout(100);

cart.setPaymentStrategy(new PayPalPayment());

cart.checkout(150);

}

}

This pattern fosters flexibility by enabling new algorithms to be added without altering existing code.