Blog

Introduction

Welcome to our series on low-level design patterns for tech interview preparation! In this installment, we’ll explore the Decorator Design Pattern, a flexible alternative to subclassing for extending functionality. By the end of this article, you’ll have a solid understanding of this pattern and be ready to impress your interviewer with your expertise in low-level design. We’ll use Java for our code examples, as it’s a common language in many tech interviews.

What is the Decorator Design Pattern?

The Decorator Design Pattern is a structural pattern that allows behavior to be added to an individual object, either statically or dynamically, without affecting the behavior of other objects from the same class. It’s a flexible alternative to subclassing for extending functionality and is crucial for creating maintainable and extensible software designs.

Key Components

1. Component: An interface defining the methods that will be implemented by concrete components and decorators.
2. Concrete Component: A class implementing the Component interface, defining a basic object to which additional responsibilities can be added.
3. Decorator: An abstract class that implements the Component interface and contains a reference to a Component object.
4. Concrete Decorator: A class extending the Decorator class, adding new behaviors or modifying existing ones.

A Practical Example: Document Formatting System

Let’s implement a document formatting system using the Decorator Design Pattern in Java. Our system will allow us to add various formatting options to a basic text document.

Step 1: Define the Component Interface

public interface TextComponent {
    String getContent();
}

Step 2: Implement the Concrete Component

public class PlainText implements TextComponent {
    private String content;

    public PlainText(String content) {
        this.content = content;
    }

    @Override
    public String getContent() {
        return content;
    }
}

Step 3: Create the Decorator Class

public abstract class TextDecorator implements TextComponent {
    protected TextComponent textComponent;

    public TextDecorator(TextComponent textComponent) {
        this.textComponent = textComponent;
    }

    @Override
    public String getContent() {
        return textComponent.getContent();
    }
}

Step 4: Implement Concrete Decorators

public class BoldDecorator extends TextDecorator {
    public BoldDecorator(TextComponent textComponent) {
        super(textComponent);
    }

    @Override
    public String getContent() {
        return "<b>" + super.getContent() + "</b>";
    }
}

public class ItalicDecorator extends TextDecorator {
    public ItalicDecorator(TextComponent textComponent) {
        super(textComponent);
    }

    @Override
    public String getContent() {
        return "<i>" + super.getContent() + "</i>";
    }
}

public class UnderlineDecorator extends TextDecorator {
    public UnderlineDecorator(TextComponent textComponent) {
        super(textComponent);
    }

    @Override
    public String getContent() {
        return "<u>" + super.getContent() + "</u>";
    }
}

Step 5: Using the Decorator Pattern

public class DocumentFormatter {
    public static void main(String[] args) {
        TextComponent plainText = new PlainText("Hello, World!");
        System.out.println("Plain text: " + plainText.getContent());

        TextComponent boldText = new BoldDecorator(plainText);
        System.out.println("Bold text: " + boldText.getContent());

        TextComponent italicBoldText = new ItalicDecorator(new BoldDecorator(plainText));
        System.out.println("Italic bold text: " + italicBoldText.getContent());

        TextComponent fancyText = new UnderlineDecorator(new ItalicDecorator(new BoldDecorator(plainText)));
        System.out.println("Fancy text: " + fancyText.getContent());
    }
}

Output

Plain text: Hello, World!
Bold text: <b>Hello, World!</b>
Italic bold text: <i><b>Hello, World!</b></i>
Fancy text: <u><i><b>Hello, World!</b></i></u>

How the Pattern Works

1. The TextComponent interface defines the method that all concrete components and decorators must implement.
2. PlainText is our basic component, implementing the TextComponent interface.
3. TextDecorator is an abstract class that implements TextComponent and holds a reference to another TextComponent object.
4. Concrete decorators (BoldDecorator, ItalicDecorator, and UnderlineDecorator) extend TextDecorator and add their specific formatting.
5. We can create complex combinations by nesting decorators, as shown in the fancyText example.

Key Takeaways for Your Low-Level Design Interview

1. Open-Closed Principle: The Decorator Pattern follows the open-closed principle. You can extend a class’s behavior without altering its existing code.
2. Flexibility: It provides a more flexible alternative to subclassing for extending functionality.
3. Composition over Inheritance: It uses object composition to achieve flexibility in adding new behaviors.
4. Single Responsibility Principle: Each decorator class has a specific responsibility, adhering to the Single Responsibility Principle.
5. Runtime Behavior Modification: You can add or remove responsibilities from an object at runtime.

Interview Tips

When discussing the Decorator Pattern in a low-level design interview:

1. Explain how it differs from simple inheritance and why it’s more flexible.
2. Highlight how it allows for dynamic, runtime composition of behaviors.
3. Discuss its real-world applications, such as Java I/O classes (e.g., BufferedReader, InputStreamReader) or GUI component libraries.
4. Be prepared to implement a simple example in Java, like the document formatting system, or adapt it to a domain relevant to the company you’re interviewing with.
5. Mention potential drawbacks, such as the possibility of creating many small classes and the complexity it can add to your code.
6. Discuss how this pattern relates to other design principles and patterns, showing your broader understanding of software design.

Conclusion

The Decorator Design Pattern is a powerful tool for extending object functionality in a flexible and reusable way. By understanding and implementing this pattern, you’ll demonstrate your ability to create extensible and maintainable low-level designs, a crucial skill for any software engineer.

Remember to practice implementing this pattern and be ready to discuss its pros and cons in the context of larger system designs. Good luck with your low-level design interview preparation!