Java Design Patterns

• Singleton Pattern:

The Singleton Pattern guarantees that a class has only one instance and offers a global access point to it. It is ideal for scenarios where a single object must be shared across the entire application.
Example in Java:

public class Singleton {
private static Singleton instance;
private Singleton() {}

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

• Factory Pattern:

The Factory Pattern separates object creation from the client code and provides a common interface to produce various objects. It enhances flexibility and reduces code duplication.
Example in Java:

interface Product {
void create();
}

class ConcreteProductA implements Product {
@Override
public void create() {
System.out.println(“Creating Product A”);
}
}

class ConcreteProductB implements Product {
@Override
public void create() {
System.out.println(“Creating Product B”);
}
}

class ProductFactory {
public static Product createProduct(String type) {
if (“A”.equals(type)) return new ConcreteProductA();
else if (“B”.equals(type)) return new ConcreteProductB();
return null;
}
}

• Observer Pattern:

The Observer Pattern establishes a one-to-many dependency among objects, allowing automatic updates when the subject’s state changes.
Example in Java:

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

interface Observer {
void update(String message);
}

class ConcreteObserver implements Observer {
private String name;

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

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

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

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

public void removeObserver(Observer observer) {
observers.remove(observer);
}

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