What is Decorator Pattern?
The Decorator pattern is a structural design pattern that allows adding new functionality to an object dynamically without modifying its structure. It is widely used in object-oriented programming to enhance the behavior of objects at runtime. This pattern is particularly useful when you want to add functionality to an object without affecting other objects of the same class or when you want to add functionality that is not available in the original class.
In simple terms, the Decorator pattern wraps an object with another object to add new functionality. This is achieved by creating a decorator class that implements the same interface as the original class. The decorator class contains an instance of the original class and delegates the calls to it. By adding new methods or modifying existing ones, the decorator can change the behavior of the original object.
Understanding the Components of Decorator Pattern
To understand the Decorator pattern better, let’s take a look at its main components:
1. Component: This is the base class that defines the common interface for objects that can be decorated. It can be a concrete class or an abstract class.
2. Concrete Component: This is a class that implements the Component interface and represents the object to be decorated. It provides the default implementation for the methods defined in the Component interface.
3. Decorator: This is an abstract class that implements the Component interface and maintains a reference to a Component object. It provides additional functionality by wrapping the original object and delegating calls to it.
4. Concrete Decorator: This is a class that extends the Decorator class and implements the additional functionality. It adds new methods or modifies existing ones to change the behavior of the decorated object.
How Decorator Pattern Works
The Decorator pattern works by creating a decorator object that wraps the original object. When a method is called on the decorator, it either delegates the call to the wrapped object or adds new functionality before or after the call. This way, the decorator can change the behavior of the original object without modifying its structure.
Here’s a simple example to illustrate the Decorator pattern:
“`java
// Component interface
interface Component {
void operation();
}
// Concrete Component
class ConcreteComponent implements Component {
public void operation() {
System.out.println(“ConcreteComponent operation”);
}
}
// Decorator abstract class
abstract class Decorator implements Component {
protected Component component;
public Decorator(Component component) {
this.component = component;
}
public void operation() {
component.operation();
}
}
// Concrete Decorator
class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
public void operation() {
super.operation();
// Add new functionality
System.out.println(“ConcreteDecoratorA additional operation”);
}
}
// Usage
public class Main {
public static void main(String[] args) {
Component concreteComponent = new ConcreteComponent();
Component decoratedComponent = new ConcreteDecoratorA(concreteComponent);
decoratedComponent.operation();
}
}
“`
In this example, the `ConcreteDecoratorA` class extends the `Decorator` class and adds new functionality to the `operation()` method. When the `operation()` method is called on the `decoratedComponent`, it first calls the `operation()` method of the `ConcreteComponent` and then adds the additional functionality defined in the `ConcreteDecoratorA` class.
The Decorator pattern is a powerful tool for enhancing the functionality of objects at runtime. By using this pattern, you can create flexible and extensible code that is easy to maintain and modify.
