Introduction to DSA

🔹 Design Patterns

**Design Patterns** are reusable solutions to common software design problems. They help in writing structured, maintainable, and scalable code. These patterns are categorized into **Creational, Structural, and Behavioral** patterns.

📌 Why Use Design Patterns?

They provide **best practices** for software development and help in solving common design issues.

✅ **Improves Code Reusability** – Reduces redundancy by following standard templates.
✅ **Enhances Maintainability** – Makes code more modular and easier to manage.
✅ **Provides Scalable Solutions** – Helps in designing software that can evolve over time.

💡 Types of Design Patterns

Design patterns are broadly classified into three categories:

Creational Patterns – Focus on object creation (e.g., Singleton, Factory, Builder).
Structural Patterns – Focus on object composition (e.g., Adapter, Composite, Decorator).
Behavioral Patterns – Focus on object communication (e.g., Observer, Strategy, Command).

🖥️ Example: Factory Design Pattern in Java

The Factory pattern provides a way to create objects without specifying their exact class.


            interface Shape {
                void draw();
            }
            
            class Circle implements Shape {
                public void draw() {
                    System.out.println("Drawing a Circle");
                }
            }
            
            class ShapeFactory {
                public static Shape getShape(String type) {
                    if (type.equals("CIRCLE")) {
                        return new Circle();
                    }
                    return null;
                }
            }
            
            public class Main {
                public static void main(String[] args) {
                    Shape shape = ShapeFactory.getShape("CIRCLE");
                    shape.draw();
                }
            }

🖥️ Example: Observer Pattern in Python

The Observer pattern is useful when one object needs to notify multiple observers about changes.


            class Subject:
                def __init__(self):
                    self.observers = []
                
                def attach(self, observer):
                    self.observers.append(observer)
                
                def notify(self, message):
                    for observer in self.observers:
                        observer.update(message)
            
            class Observer:
                def update(self, message):
                    print(f"Received message: {message}")
            
            subject = Subject()
            observer1 = Observer()
            subject.attach(observer1)
            subject.notify("Hello Observers!")

🎯 Summary