Structural Design Pattern: Definition, Example, and Use Cases

A structural design pattern helps organize classes and objects to form larger structures while keeping them flexible and easy to manage. It focuses on how parts fit together, like building blocks, to create efficient and reusable systems.

How It Works

Structural design patterns work like organizing furniture in a room. Imagine you want to arrange chairs, tables, and shelves so the room looks good and is easy to use. Instead of putting everything randomly, you follow a plan that shows how each piece connects and supports others.

In software, these patterns help combine simple objects or classes into bigger structures. They make sure the parts fit well and can change without breaking the whole system. This way, developers can reuse code and keep the system easy to understand and update.

Example

This example shows the Adapter pattern, a common structural pattern that lets incompatible interfaces work together by wrapping one class with another.

javascript

class OldPrinter {
    printText(text) {
        return `Old Printer: ${text}`;
    }
}

class NewPrinter {
    print(text) {
        return `New Printer: ${text}`;
    }
}

// Adapter to use NewPrinter where OldPrinter is expected
class PrinterAdapter {
    constructor(newPrinter) {
        this.newPrinter = newPrinter;
    }

    printText(text) {
        return this.newPrinter.print(text);
    }
}

// Usage
const oldPrinter = new OldPrinter();
console.log(oldPrinter.printText("Hello"));

const newPrinter = new NewPrinter();
const adapter = new PrinterAdapter(newPrinter);
console.log(adapter.printText("Hello"));

Output

Old Printer: Hello
New Printer: Hello

When to Use

Use structural design patterns when you want to build complex systems by combining simple parts without making the system hard to change. They help when:

• You need to connect classes with different interfaces.
• You want to add new features by wrapping existing objects.
• You want to simplify complex relationships between objects.

For example, in a graphic app, you might use the Composite pattern to treat single shapes and groups of shapes the same way. Or use Decorator to add new behaviors to objects without changing their code.

Key Points

• Structural patterns organize classes and objects into larger structures.
• They improve code reuse and flexibility.
• Common patterns include Adapter, Decorator, Composite, and Proxy.
• They help connect incompatible interfaces and add responsibilities dynamically.

Key Takeaways

Structural design patterns help build flexible and reusable software structures.

They focus on how objects and classes fit together like building blocks.

Use them to connect incompatible interfaces or add features without changing existing code.

Common examples include Adapter, Decorator, and Composite patterns.