Design Patterns in Software Engineering with Examples

In software engineering, design patterns are reusable solutions to common problems that occur during software design. They are best practices that can be used to solve recurring issues in software design and architecture. Understanding design patterns helps developers create more efficient and maintainable software. This article delves into the various types of design patterns, their benefits, and practical examples of each.

1. Creational Patterns

Creational patterns deal with object creation mechanisms. They aim to create objects in a manner that is suitable to the situation. These patterns abstract the instantiation process, making it easier to manage complex object creation.

• Singleton Pattern

  • Description: Ensures that a class has only one instance and provides a global point of access to it.
  • Example: The Logger class is a common example. In a logging system, having multiple instances of the logger class can lead to inconsistency. Using the Singleton pattern ensures that there is only one logger instance throughout the application.

  python
  class SingletonLogger:
      _instance = None
      
      @staticmethod
      def get_instance():
          if SingletonLogger._instance is None:
              SingletonLogger()
          return SingletonLogger._instance
      
      def __init__(self):
          if SingletonLogger._instance is not None:
              raise Exception("This class is a singleton!")
          else:
              SingletonLogger._instance = self
  

• Factory Method Pattern

  • Description: Provides an interface for creating objects but allows subclasses to alter the type of objects that will be created.
  • Example: In a Document processing application, different types of documents (e.g., PDF, Word) might need different processing methods. The Factory Method pattern helps in creating the correct type of document based on user input.

  python
  class Document:
      def create_document(self):
          pass
  
  class PDFDocument(Document):
      def create_document(self):
          return "PDF Document Created"
  
  class WordDocument(Document):
      def create_document(self):
          return "Word Document Created"
  
  class DocumentFactory:
      def get_document(self, doc_type):
          if doc_type == "PDF":
              return PDFDocument()
          elif doc_type == "Word":
              return WordDocument()
          else:
              return None
  

2. Structural Patterns

Structural patterns deal with object composition, creating relationships between objects to form larger structures.

• Adapter Pattern

  • Description: Allows objects with incompatible interfaces to work together. It acts as a bridge between two incompatible interfaces.
  • Example: If you have a LegacySystem that expects data in a certain format and a NewSystem that produces data in a different format, the Adapter pattern can convert the data format between these two systems.

  python
  class LegacySystem:
      def specific_request(self):
          return "Data from Legacy System"
  
  class NewSystem:
      def request(self):
          return "Data from New System"
  
  class Adapter:
      def __init__(self, new_system):
          self.new_system = new_system
      
      def specific_request(self):
          return self.new_system.request()
  

• Decorator Pattern

  • Description: Adds additional functionality to an object dynamically without altering its structure. This pattern is used to extend the behavior of objects.
  • Example: In a Graphical User Interface (GUI) application, you might want to add scroll bars or borders to a window dynamically. The Decorator pattern allows you to do this without modifying the core window class.

  python
  class Window:
      def render(self):
          return "Rendering Window"
  
  class WindowDecorator:
      def __init__(self, window):
          self.window = window
  
      def render(self):
          return self.window.render()
  
  class ScrollBarDecorator(WindowDecorator):
      def render(self):
          return f"{self.window.render()} with ScrollBar"
  
  class BorderDecorator(WindowDecorator):
      def render(self):
          return f"{self.window.render()} with Border"
  

3. Behavioral Patterns

Behavioral patterns focus on communication between objects, what goes on between objects and how they operate together.

• Observer Pattern

  • Description: Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
  • Example: In a Weather Monitoring application, you may have multiple displays (e.g., TemperatureDisplay, HumidityDisplay) that need to be updated whenever the weather changes. The Observer pattern helps in maintaining these dependencies.

  python
  class WeatherStation:
      def __init__(self):
          self.observers = []
          self.temperature = 0
  
      def add_observer(self, observer):
          self.observers.append(observer)
  
      def remove_observer(self, observer):
          self.observers.remove(observer)
  
      def notify_observers(self):
          for observer in self.observers:
              observer.update(self.temperature)
  
      def set_temperature(self, temp):
          self.temperature = temp
          self.notify_observers()
  
  class TemperatureDisplay:
      def update(self, temperature):
          print(f"Temperature Display: {temperature}°C")
  

• Strategy Pattern

  • Description: Defines a family of algorithms, encapsulates each algorithm, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.
  • Example: In a Payment Processing system, you might want to offer multiple payment methods (e.g., CreditCard, PayPal). The Strategy pattern allows you to choose a payment method dynamically.

  python
  class PaymentStrategy:
      def pay(self, amount):
          pass
  
  class CreditCardPayment(PaymentStrategy):
      def pay(self, amount):
          print(f"Paid {amount} using Credit Card")
  
  class PayPalPayment(PaymentStrategy):
      def pay(self, amount):
          print(f"Paid {amount} using PayPal")
  
  class PaymentContext:
      def __init__(self, strategy):
          self.strategy = strategy
      
      def execute_payment(self, amount):
          self.strategy.pay(amount)
  

Conclusion

Design patterns provide a way to solve common software design problems through established solutions. They make it easier to manage code complexity, improve code readability, and enhance maintainability. By understanding and applying these patterns, developers can produce more robust and adaptable software systems.