Design Patterns Introduction

Welcome to your journey into the world of software design patterns! In this lesson, we'll explore what design patterns are, why they matter, and how to use them effectively. Let's get started! 🎯

What are Design Patterns?

Design patterns are reusable solutions to common software design problems. They're not a set of pre-written code, but rather a blueprint that guides developers in solving problems in a consistent and efficient manner.

💡 Pro Tip: Design patterns help us build more maintainable, scalable, and flexible software by solving common problems that arise during software design and development.

Why Use Design Patterns?

Reusability: Design patterns allow us to reuse proven solutions, reducing the time and effort required to solve similar problems in the future.
Reliability: Since design patterns are widely-used and well-tested, they help ensure that our solutions are reliable and robust.
Readability: By adhering to established design patterns, our code becomes more readable and easier to understand, making it simpler for others to work with our code.
Maintainability: Design patterns help us write code that is easier to maintain and update, reducing the cost and effort associated with software maintenance.

Types of Design Patterns

There are three main categories of design patterns:

Creational Patterns (📝 Note: These patterns deal with object creation mechanisms, trying to create objects in a manner suitable to the situation.)
- Singleton: Ensures a class has only one instance, providing a global point of access to it.
- Factory: Provides an interface for creating objects, but allows subclasses to alter the type of objects that will be created.
- Abstract Factory: Provides an interface for creating families of related or dependent objects without specifying their concrete classes.
- Builder: Separates the construction of a complex object from its representation, allowing the same construction process to create different representations.
- Prototype: A way to create new objects by copying existing ones.
Structural Patterns (📝 Note: These patterns deal with object composition, focusing on how entities can be composed to obtain new forms and to define how they relate to one another.)
- Adapter: Allows classes with incompatible interfaces to work together by wrapping one interface within another.
- Bridge: Decouples an abstraction from its implementation so the two can be developed and changed independently.
- Composite: Composes objects into tree structures to represent whole-part hierarchies, enabling clients to treat individual objects and compositions uniformly.
- Decorator: Attaches additional responsibilities to an object dynamically, without altering its structure.
- Facade: Provides a simplified interface to a complex system, reducing its complexity and making it more accessible.
- Flyweight: A way to support large numbers of fine-grained objects by sharing as many as possible and storing only shared objects in memory.
Behavioral Patterns (📝 Note: These patterns deal with communication between objects, focusing on how a group of objects interact.)
- Chain of Responsibility: Allows requests to be passed between a chain of objects until one of them handles it.
- Command: Encapsulates a request as an object, allowing it to be passed as a method argument, delayed, or queued.
- Interpreter: Defines a grammar for a language and provides operations that interpret a sentence in the language.
- Iterator: Provides a way to access the elements of an aggregate object sequentially, without exposing its underlying structure.
- Mediator: Defines an object that manages how a set of objects interact with each other.
- Memento: Without violating encapsulation, captures and externalizes an object's internal state so the object can be restored to its original state later.
- Observer: Defines a one-to-many dependency between objects, so that when one object changes, all its dependents are notified and updated automatically.
- State: Allows an object to alter its behavior when its internal state changes. The object will appear to change its class.
- Strategy: Defines a family of algorithms, encapsulates each one, and makes them interchangeable. Clients can select an algorithm at runtime.
- Template Method: Defines the skeleton of an algorithm in a base class and lets subclasses redefine certain steps of the algorithm.
- Visitor: Represents an operation to be performed on the elements of an object structure.

Code Examples

Let's take a look at two examples to help you understand the power of design patterns.

Example 1: Singleton Pattern

Here's an example of the Singleton pattern in action:

python

class Database:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super().__new__(cls, *args, **kwargs)
        return cls._instance

    def connect(self):
        print("Connecting to database...")

# The only instance of the Database class
db = Database()
db2 = Database()

db.connect()  # Connecting to database...
print(db is db2)  # True

In this example, the Database class ensures that there is only one instance of the class, providing a global point of access to it.

Example 2: Strategy Pattern

Here's an example of the Strategy pattern in action:

python

class SortStrategy:
    def compare(self, a, b):
        raise NotImplementedError

class SortByName(SortStrategy):
    def compare(self, a, b):
        return a.name.lower() < b.name.lower()

class SortByAge(SortStrategy):
    def compare(self, a, b):
        return a.age - b.age

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

def sort_people(people, strategy):
    people.sort(key=lambda person: strategy.compare(person, people[1]))

people = [
    Person("John", 25),
    Person("Sara", 23),
    Person("Mike", 22),
    Person("Emma", 27)
]

sort_people(people, SortByName())
print(people)

sort_people(people, SortByAge())
print(people)

In this example, the SortStrategy interface defines a compare method that will be used to sort a list of Person objects. The SortByName and SortByAge classes implement this interface, allowing us to sort the list in different ways at runtime.

Quiz

Now that you've learned about design patterns, it's time to start using them in your projects to make your code more maintainable, scalable, and flexible!

📝 Note: Practice using design patterns in real-world projects to reinforce your understanding and make the most of their benefits.

Happy coding! 💡