Decorator vs Proxy Pattern
Decorator vs Proxy pattern compared — adding behavior dynamically vs controlling access to an object — with Java code examples.
Expected Interview Answer
The Decorator pattern wraps an object to add new responsibilities or behavior on top of what it already does, while the Proxy pattern wraps an object to control access to it, without changing or adding to its core behavior.
Both share the same structural shape — a wrapper implementing the same interface as the wrapped object and holding a reference to it — but their intent diverges sharply. Decorators are typically stacked, each one layering additional behavior (logging, compression, formatting) transparently, and the client usually knows it is composing decorators intentionally. Proxies are usually singular and transparent by design, standing in for the real object to add access control, lazy initialization, caching, or remote communication, and the client often does not know a proxy is involved at all. A useful heuristic: Decorator answers “what more should happen,” Proxy answers “who is allowed to make this happen, or when.”
- Decorator adds behavior without subclassing or modifying the original class
- Proxy adds access control, caching, or lazy loading transparently
- Both preserve the original interface for client code
- Both avoid bloating the wrapped class with unrelated concerns
AI Mentor Explanation
Decorator is like adding gear on top of a base player — pads, then gloves, then a helmet — each layer adding a new capability while the player is still fundamentally the same batter underneath. Proxy is like a team manager who screens every request to speak with a star player, deciding whether the interview happens now, later, or not at all, without changing anything about what the player actually says. One stacks new abilities on top of the original; the other gatekeeps access to the original without altering it.
Step-by-Step Explanation
Step 1
Identify the intent
Decorator adds new behavior; Proxy controls access to existing behavior without changing it.
Step 2
Decorator: implement the same interface and wrap
The decorator holds a reference to the wrapped object, delegates the original call, and adds behavior before or after.
Step 3
Proxy: implement the same interface and gate access
The proxy checks permissions, lazily creates the real object, or caches results, then delegates to the real subject.
Step 4
Check composability
Decorators are usually meant to be stacked in varying combinations; a proxy typically stands alone in front of one real subject.
What Interviewer Expects
- Correct statement of intent: adding behavior vs controlling access
- Recognition that both share the same wrapper structural shape
- Awareness that decorators are commonly stacked while proxies usually are not
- A concrete example of each (e.g. InputStream decorators vs a lazy-loading proxy)
Common Mistakes
- Saying Decorator and Proxy are the same pattern because both wrap an object
- Claiming Proxy is meant to add new features to the wrapped object
- Forgetting that a client is often unaware a Proxy exists, unlike Decorator
- Not knowing java.io streams are a canonical real-world Decorator example
Best Answer (HR Friendly)
“Decorator wraps an object to add extra behavior on top of what it already does, like layering pedals on a guitar signal. Proxy wraps an object to control access to it — checking permissions, delaying expensive creation, or caching results — without adding new behavior of its own. Both use the same wrapping structure, but Decorator is about enhancing, and Proxy is about gatekeeping.”
Code Example
interface Coffee {
double cost();
}
class SimpleCoffee implements Coffee {
public double cost() { return 2.0; }
}
abstract class CoffeeDecorator implements Coffee {
protected Coffee wrapped;
CoffeeDecorator(Coffee wrapped) { this.wrapped = wrapped; }
}
class MilkDecorator extends CoffeeDecorator {
MilkDecorator(Coffee wrapped) { super(wrapped); }
public double cost() { return wrapped.cost() + 0.5; }
}
Coffee order = new MilkDecorator(new SimpleCoffee());
System.out.println(order.cost()); // 2.5interface Image {
void display();
}
class RealImage implements Image {
private String fileName;
RealImage(String fileName) {
this.fileName = fileName;
loadFromDisk();
}
private void loadFromDisk() { System.out.println("Loading " + fileName); }
public void display() { System.out.println("Displaying " + fileName); }
}
class ImageProxy implements Image {
private RealImage realImage;
private String fileName;
ImageProxy(String fileName) { this.fileName = fileName; }
public void display() {
if (realImage == null) {
realImage = new RealImage(fileName); // lazy creation
}
realImage.display();
}
}Follow-up Questions
- What is a virtual proxy and how does it differ from a protection proxy?
- Can Decorator and Proxy be combined in the same object graph?
- Why are java.io stream classes considered a Decorator example?
- How does Proxy relate to dynamic proxies in Java reflection?
MCQ Practice
1. Decorator pattern is primarily used to?
Decorator wraps an object to add new behavior or responsibilities without subclassing.
2. A key use case for Proxy pattern is?
A virtual proxy defers creation of an expensive real object until it is actually needed.
3. Which best distinguishes the two patterns?
Decorator enhances behavior; Proxy manages access to the real subject without changing its behavior.
Flash Cards
Decorator in one line? — Wraps an object to add new behavior dynamically, same interface preserved.
Proxy in one line? — Wraps an object to control access to it — no new behavior added.
Which is typically stacked? — Decorator — multiple decorators can wrap one another.
Real-world Java Decorator example? — java.io stream classes like BufferedInputStream wrapping InputStream.