Design Patterns Java

Below are examples of some common design patterns in Java along with brief explanations of each.

1. Singleton Pattern

   - Ensures that a class has only one instance and provides a global point of access to it.

   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 an object, but leaves the choice of its type to the subclasses, creating the instance of the class.

   interface Product {
       void create();
   }

   class ConcreteProductA implements Product {
       public void create() {
           System.out.println("Product A created");
       }
   }

   class ConcreteProductB implements Product {
       public void create() {
           System.out.println("Product B created");
       }
   }

   interface Creator {
       Product factoryMethod();
   }

   class ConcreteCreatorA implements Creator {
       public Product factoryMethod() {
           return new ConcreteProductA();
       }
   }

   class ConcreteCreatorB implements Creator {
       public Product factoryMethod() {
           return new ConcreteProductB();
       }
   }

3. Observer Pattern

   - Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

   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;
       }

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

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

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

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

4. Decorator Pattern

   - Attaches additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.

   interface Component {
       void operation();
   }

   class ConcreteComponent implements Component {
       public void operation() {
           System.out.println("Basic operation");
       }
   }

   class Decorator implements Component {
       private Component component;

       public Decorator(Component component) {
           this.component = component;
       }

       public void operation() {
           component.operation();
       }
   }

   class ConcreteDecorator extends Decorator {
       public ConcreteDecorator(Component component) {
           super(component);
       }

       public void operation() {
           super.operation();
           System.out.println("Additional operation");
       }
   }

These are just a few examples, and there are many more design patterns with various use cases. Implementing and understanding these patterns can lead to more maintainable and scalable software designs.