Mahmoud Abas, Full-Stack Software Engineer & AI

System Design & Design Patterns - Part 2: Structural Design Patterns

In the print dialog, choose "Save as PDF" as the destination.

Part 2: Structural Design Patterns

Adapter, Decorator, and Facade

Structural Patterns: Purpose

Deal with object composition and relationships between entities
Three patterns covered: Adapter, Decorator, Facade
Each reshapes how objects relate, not how they're created

Adapter Pattern

Adapter Pattern: Allows incompatible interfaces to work together, like a power adapter that lets you plug your device into a different outlet.

Wraps an existing class behind a new, expected interface

Client

expects a Target interface

request()

Adapter

implements Target

specificRequest()

Adaptee

e.g. OldPrinter

Adapter Pattern: When to Use

Integrating third-party libraries with different interfaces
Legacy code integration without modifying it
Making incompatible classes work together
When you can't modify the existing classes
Creating reusable classes that work with unrelated classes

Adapter Pattern: Code Example

python

class OldPrinter:
    def old_print(self, text):
        return f"Old printer: {text}"

class PrinterAdapter:
    def __init__(self, old_printer):
        self.old_printer = old_printer

    def print(self, text):
        return self.old_printer.old_print(text)

adapter = PrinterAdapter(OldPrinter())
print(adapter.print("Hello World"))

Decorator Pattern

Decorator Pattern: Adds new functionality to objects dynamically, without altering their structure.

Like adding accessories to a phone case, one layer at a time

SimpleCoffee

the wrapped object

Milk

adds cost + description

Sugar

wraps Milk the same way

Decorator Pattern: When to Use

Adding responsibilities to objects dynamically at runtime
When subclassing would cause an explosion of classes
Extending functionality without modifying existing code
When you need different combinations of behaviors
Creating configurable object behavior

Decorator Pattern: Code Example

python

class SimpleCoffee(Coffee):
    def cost(self): return 2.0
    def description(self): return "Simple coffee"

class Milk(CoffeeDecorator):
    def cost(self):
        return self._coffee.cost() + 0.5
    def description(self):
        return self._coffee.description() + ", milk"

coffee = Milk(SimpleCoffee())
print(f"{coffee.description()}: ${coffee.cost()}")
# Simple coffee, milk: $2.5

Facade Pattern

Facade Pattern: Provides a simplified interface to a complex subsystem.

Like a TV remote that hides the internal complexity of the TV
One clean entry point instead of many moving parts

Client

watch_movie()

Facade

e.g. HomeTheaterFacade

Subsystem

DVDPlayer

Subsystem

SoundSystem

Subsystem

Projector

Facade Pattern: When to Use

Simplifying complex APIs or subsystems
Providing a unified interface to a set of interfaces
Decoupling clients from complex subsystems
Creating layers of abstraction
When you want to hide implementation details

Facade Pattern: Code Example

python

class HomeTheaterFacade:
    def __init__(self):
        self.dvd = DVDPlayer()
        self.sound = SoundSystem()
        self.projector = Projector()

    def watch_movie(self, movie):
        self.projector.on()
        self.sound.on()
        self.dvd.on()
        self.dvd.play(movie)

theater = HomeTheaterFacade()
theater.watch_movie("The Matrix")

Key Takeaways

Adapter: makes incompatible interfaces work together without modifying existing code
Decorator: adds behavior dynamically, avoiding subclass explosion
Facade: hides subsystem complexity behind one simple interface
All three reshape how objects relate to each other, not how they're created
Structural patterns are key to integrating legacy code and simplifying complex systems

Open this lesson

Mahmoud AbasPart 2: Structural Design Patterns

class OldPrinter: def old_print(self, text): return f"Old printer: {text}" class PrinterAdapter: def __init__(self, old_printer): self.old_printer = old_printer def print(self, text): return self.old_printer.old_print(text) adapter = PrinterAdapter(OldPrinter()) print(adapter.print("Hello World"))

class SimpleCoffee(Coffee): def cost(self): return 2.0 def description(self): return "Simple coffee" class Milk(CoffeeDecorator): def cost(self): return self._coffee.cost() + 0.5 def description(self): return self._coffee.description() + ", milk" coffee = Milk(SimpleCoffee()) print(f"{coffee.description()}: ${coffee.cost()}") # Simple coffee, milk: $2.5

class HomeTheaterFacade: def __init__(self): self.dvd = DVDPlayer() self.sound = SoundSystem() self.projector = Projector() def watch_movie(self, movie): self.projector.on() self.sound.on() self.dvd.on() self.dvd.play(movie) theater = HomeTheaterFacade() theater.watch_movie("The Matrix")