Mastering the Decorator Pattern in Java: Dynamic Object Extension Explained

Definition

The Decorator pattern (object structural pattern) allows adding responsibilities to objects dynamically, offering more flexibility than creating subclasses.

Roles

Component Interface : defines the object interface that can be extended.

ConcreteComponent : the original object implementing the component interface.

Decorator : abstract class that also implements the component interface and holds a reference to a component.

ConcreteDecorator : subclasses of Decorator that add specific behavior.

Code Example

Interface and classes:

public interface Window {
    public void draw();
    public String getDescription();
}

public class SimpleWindow implements Window {
    public void draw() {
        // draw window
    }
    public String getDescription() {
        return "simple window";
    }
}

public abstract class WindowDecorator implements Window {
    protected Window decoratedWindow;
    public WindowDecorator(Window decoratedWindow) {
        this.decoratedWindow = decoratedWindow;
    }
    @Override
    public void draw() {
        decoratedWindow.draw();
    }
    @Override
    public String getDescription() {
        return decoratedWindow.getDescription();
    }
}

public class VerticalScrollBar extends WindowDecorator {
    public VerticalScrollBar(Window windowToBeDecorated) {
        super(windowToBeDecorated);
    }
    @Override
    public void draw() {
        super.draw();
        drawVerticalScrollBar();
    }
    private void drawVerticalScrollBar() {
        // Draw the vertical scrollbar
    }
    @Override
    public String getDescription() {
        return super.getDescription() + ", including vertical scrollbars";
    }
}

public class HorizontalScrollBar extends WindowDecorator {
    public HorizontalScrollBar(Window windowToBeDecorated) {
        super(windowToBeDecorated);
    }
    @Override
    public void draw() {
        super.draw();
        drawHorizontalScrollBar();
    }
    private void drawHorizontalScrollBar() {
        // Draw the horizontal scrollbar
    }
    @Override
    public String getDescription() {
        return super.getDescription() + ", including horizontal scrollbars";
    }
}

Advantages

Dynamic, transparent addition of functionality to a single object without affecting others.

Allows adding or removing features at runtime, often via configuration.

Improves maintainability by keeping classes loosely coupled, adhering to the Open/Closed principle.

Disadvantages

Creates many small objects and decorator classes, increasing system complexity.

More flexible than inheritance but also more error‑prone; debugging layered decorations can be cumbersome.

Applicable Scenarios

When you need to add responsibilities to individual objects dynamically and transparently.

When features must be added or removed at runtime.

When inheritance would lead to an explosion of subclasses or is impossible (e.g., final classes).

Extension Guidelines

The decorator’s interface must match the component’s interface so clients can treat decorated and undecorated objects uniformly. Keep concrete components lightweight; let decorators handle additional logic and state.

Decorators can be combined in various orders to produce rich behavior, and both concrete components and concrete decorators can evolve independently.