Delegation
Also known as
- Helper
- Surrogate
Intent
The Delegation pattern in Java allows an object to delegate one or more tasks to a helper object. It is a technique where an object expresses certain behavior but actually delegates responsibility for implementing that behavior to an associated helper object.
Explanation
Real-world example
In a restaurant, the head chef delegates tasks to sous-chefs: one manages grilling, another handles salads, and a third is in charge of desserts. Each sous-chef specializes in their area, allowing the head chef to focus on overall kitchen management. This mirrors the Delegation design pattern, where a main object delegates specific tasks to helper objects, each expert in their domain.
Wikipedia says
In object-oriented programming, delegation refers to evaluating a member (property or method) of one object (the receiver) in the context of another original object (the sender). Delegation can be done explicitly, by passing the sending object to the receiving object, which can be done in any object-oriented language; or implicitly, by the member lookup rules of the language, which requires language support for the feature.
Programmatic Example
We have an interface Printer and three implementations CanonPrinter, EpsonPrinter and HpPrinter.
public interface Printer {
void print(final String message);
}
@Slf4j
public class CanonPrinter implements Printer {
@Override
public void print(String message) {
LOGGER.info("Canon Printer : {}", message);
}
}
@Slf4j
public class EpsonPrinter implements Printer {
@Override
public void print(String message) {
LOGGER.info("Epson Printer : {}", message);
}
}
@Slf4j
public class HpPrinter implements Printer {
@Override
public void print(String message) {
LOGGER.info("HP Printer : {}", message);
}
}
The PrinterController can be used as a Printer by delegating any work handled by this
interface to an object implementing it.
public class PrinterController implements Printer {
private final Printer printer;
public PrinterController(Printer printer) {
this.printer = printer;
}
@Override
public void print(String message) {
printer.print(message);
}
}
Now on the client code printer controllers can print messages differently depending on the
object they're delegating that work to.
public class App {
private static final String MESSAGE_TO_PRINT = "hello world";
public static void main(String[] args) {
var hpPrinterController = new PrinterController(new HpPrinter());
var canonPrinterController = new PrinterController(new CanonPrinter());
var epsonPrinterController = new PrinterController(new EpsonPrinter());
hpPrinterController.print(MESSAGE_TO_PRINT);
canonPrinterController.print(MESSAGE_TO_PRINT);
epsonPrinterController.print(MESSAGE_TO_PRINT);
}
}
Program output:
HP Printer:hello world
Canon Printer:hello world
Epson Printer:hello world
Class diagram
Applicability
- When you want to pass responsibility from one class to another without inheritance.
- To achieve composition-based reuse instead of inheritance-based.
- When you need to use several interchangeable helper classes at runtime.
Known Uses
- Java's java.awt.event package, where listeners are often used to handle events.
- Wrapper classes in Java's Collections Framework (java.util.Collections), which delegate to other collection objects.
- In Spring Framework, delegation is used extensively in the IoC container where beans delegate tasks to other beans.
Consequences
Benefits:
- Reduces subclassing: Objects can delegate operations to different objects and change them at runtime, reducing the need for subclassing.
- Encourages reuse: Delegation promotes the reuse of the helper object's code.
- Increases flexibility: By delegating tasks to helper objects, you can change the behavior of your classes at runtime.
Trade-offs:
- Runtime Overhead: Delegation can introduce additional layers of indirection, which may result in slight performance costs.
- Complexity: The design can become more complicated since it involves additional classes and interfaces to manage delegation.
Related Patterns
- Composite: Delegation can be used within a composite pattern to delegate component-specific behavior to child components.
- Strategy: Delegation is often used in the strategy pattern where a context object delegates tasks to a strategy object.
- https://java-design-patterns.com/patterns/proxy/: The proxy pattern is a form of delegation where a proxy object controls access to another object, which it delegates work to.