Design Patterns in Java

Design patterns in Java are categorized into three main types:

1. Creational Patterns

These deal with object creation, ensuring flexibility and control.

Singleton Pattern: Ensures only one instance of a class is created.

Example: A class to manage a database connection pool.

  public class DatabaseConnection {
      private static DatabaseConnection instance;

      private DatabaseConnection() {
          // private constructor to prevent instantiation
      }

      public static DatabaseConnection getInstance() {
          if (instance == null) {
              instance = new DatabaseConnection();
          }
          return instance;
      }
  }

  public class Main {
      public static void main(String[] args) {
          DatabaseConnection connection1 = DatabaseConnection.getInstance();
          DatabaseConnection connection2 = DatabaseConnection.getInstance();
          System.out.println(connection1 == connection2); // true
      }
  }

Builder Pattern: Simplifies the creation of complex objects by separating construction and representation.

Example: Building a Car object with optional features.

  public class Car {
      private String engine;
      private String color;
      private boolean sunroof;

      private Car(CarBuilder builder) {
          this.engine = builder.engine;
          this.color = builder.color;
          this.sunroof = builder.sunroof;
      }

      public static class CarBuilder {
          private String engine;
          private String color;
          private boolean sunroof;

          public CarBuilder setEngine(String engine) {
              this.engine = engine;
              return this;
          }

          public CarBuilder setColor(String color) {
              this.color = color;
              return this;
          }

          public CarBuilder setSunroof(boolean sunroof) {
              this.sunroof = sunroof;
              return this;
          }

          public Car build() {
              return new Car(this);
          }
      }
  }

  public class Main {
      public static void main(String[] args) {
          Car car = new Car.CarBuilder()
                          .setEngine("V8")
                          .setColor("Red")
                          .setSunroof(true)
                          .build();
          System.out.println("Car built with: " + car);
      }
  }

Factory Pattern: Provides a way to create objects without specifying the exact class.

Example: A ShapeFactory that creates different shapes.

  public interface Shape {
      void draw();
  }

  public class Circle implements Shape {
      public void draw() {
          System.out.println("Drawing a Circle");
      }
  }

  public class Square implements Shape {
      public void draw() {
          System.out.println("Drawing a Square");
      }
  }

  public class ShapeFactory {
      public Shape getShape(String shapeType) {
          if (shapeType == null) return null;
          if (shapeType.equalsIgnoreCase("CIRCLE")) return new Circle();
          if (shapeType.equalsIgnoreCase("SQUARE")) return new Square();
          return null;
      }
  }

  public class Main {
      public static void main(String[] args) {
          ShapeFactory factory = new ShapeFactory();
          Shape circle = factory.getShape("CIRCLE");
          circle.draw();
          Shape square = factory.getShape("SQUARE");
          square.draw();
      }
  }

2. Structural Patterns

These focus on the composition of classes and objects.

Example: Adapter Pattern

Converts an interface into another interface a client expects.

  public interface MediaPlayer {
      void play(String audioType, String fileName);
  }

  public class AdvancedMediaPlayer {
      public void playMp4(String fileName) {
          System.out.println("Playing MP4 file: " + fileName);
      }
  }

  public class MediaAdapter implements MediaPlayer {
      private AdvancedMediaPlayer advancedMediaPlayer = new AdvancedMediaPlayer();

      @Override
      public void play(String audioType, String fileName) {
          if (audioType.equalsIgnoreCase("MP4")) {
              advancedMediaPlayer.playMp4(fileName);
          }
      }
  }

  public class Main {
      public static void main(String[] args) {
          MediaPlayer player = new MediaAdapter();
          player.play("MP4", "example.mp4");
      }
  }

3. Behavioral Patterns

These are about object collaboration and responsibilities.

Example: Observer Pattern

Defines a dependency between objects so that when one changes state, others are notified.

  import java.util.ArrayList;
  import java.util.List;

  public interface Observer {
      void update(String message);
  }

  public class User implements Observer {
      private String name;

      public User(String name) {
          this.name = name;
      }

      @Override
      public void update(String message) {
          System.out.println(name + " received: " + message);
      }
  }

  public class NotificationService {
      private List<Observer> observers = new ArrayList<>();

      public void subscribe(Observer observer) {
          observers.add(observer);
      }

      public void notifyObservers(String message) {
          for (Observer observer : observers) {
              observer.update(message);
          }
      }
  }

  public class Main {
      public static void main(String[] args) {
          NotificationService service = new NotificationService();
          User user1 = new User("Alice");
          User user2 = new User("Bob");

          service.subscribe(user1);
          service.subscribe(user2);

          service.notifyObservers("New Notification");
      }
  }

Real-Life Example: API Request Builder

In a real-world scenario, you might build complex API requests using the builder pattern. Here's a Request class:

With Lombok:

import lombok.Builder;
import lombok.ToString;

@Builder
@ToString
public class Request {
    private String url;
    private String method;
    private String body;
}

// Main Class
public class Main {
    public static void main(String[] args) {
        Request request = Request.builder()
                                .url("https://api.example.com")
                                .method("GET")
                                .body(null)
                                .build();

        System.out.println(request);
    }
}

Why Use Lombok’s Builder in Real Life?

Reduced Boilerplate: Eliminates the need to manually write builder classes.
Readability: Keeps the code concise and easier to maintain.
Clarity: Clearly conveys the intent of creating objects with multiple optional parameters.
Efficiency: Ideal for projects with many data models requiring builder patterns.

Real-Life Scenario for Factory Pattern

Imagine you are developing a Payment Processing System that supports multiple payment methods like Credit Card, PayPal, and Google Pay. Depending on the type of payment, your system needs to create and use the appropriate payment processor.

The Factory Pattern is ideal for this scenario because it can dynamically create the required processor without exposing the client to the concrete implementation details.

Using the Factory Pattern, the code becomes more flexible and easier to extend for new payment methods.

Step 1: Create a common interface for payment processors

public interface PaymentProcessor {
    void processPayment(double amount);
}

Step 2: Implement specific payment processors

public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing credit card payment of $" + amount);
    }
}

public class PayPalProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing PayPal payment of $" + amount);
    }
}

public class GooglePayProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing Google Pay payment of $" + amount);
    }
}

Step 3: Create the Factory Class

The factory will decide which PaymentProcessor to create based on input.

public class PaymentProcessorFactory {
    public static PaymentProcessor getPaymentProcessor(String type) {
        if (type == null) {
            throw new IllegalArgumentException("Payment type cannot be null");
        }
        switch (type.toUpperCase()) {
            case "CREDITCARD":
                return new CreditCardProcessor();
            case "PAYPAL":
                return new PayPalProcessor();
            case "GOOGLEPAY":
                return new GooglePayProcessor();
            default:
                throw new IllegalArgumentException("Unknown payment type: " + type);
        }
    }
}

Step 4: Use the Factory in the Client Code

The client code does not need to know the details of each payment processor.

public class PaymentService {
    public static void main(String[] args) {
        // Dynamically decide the payment method
        PaymentProcessor processor = PaymentProcessorFactory.getPaymentProcessor("PAYPAL");
        processor.processPayment(150.0);
// Output: Processing PayPal payment of $150.0

        PaymentProcessor anotherProcessor = PaymentProcessorFactory.getPaymentProcessor("CREDITCARD");
        anotherProcessor.processPayment(200.0);
// Output: Processing credit card payment of $200.0
    }
}

Benefits of Using the Factory Pattern

Encapsulation: The client code doesn’t need to know about the details of each PaymentProcessor implementation.
Extensibility: Adding a new payment method (e.g., Apple Pay) only requires creating a new class and updating the factory method.
Single Responsibility: The creation logic is centralized in the PaymentProcessorFactory, reducing duplication in the client code.