mirror of
https://github.com/tiennm99/java-design-patterns.git
synced 2026-05-16 02:59:21 +00:00
Ilkka Seppälä
120 lines
3.3 KiB
Markdown
120 lines
3.3 KiB
Markdown
---
|
|
title: Delegation
|
|
category: Structural
|
|
language: en
|
|
tag:
|
|
- Decoupling
|
|
---
|
|
|
|
## Also known as
|
|
Proxy Pattern
|
|
|
|
## Intent
|
|
It is a technique where an object expresses certain behavior to the outside but in
|
|
reality delegates responsibility for implementing that behaviour to an associated object.
|
|
|
|
## Explanation
|
|
|
|
Real-world example
|
|
|
|
> Imagine that we have adventurers who fight monsters with different weapons depending on their
|
|
> abilities and skills. We must be able to equip them with different ones without having to
|
|
> modify their source code for each one. The delegation pattern makes it possible by delegating
|
|
> the dynamic work to a specific object implementing an interface with relevant methods.
|
|
|
|
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`.
|
|
|
|
```java
|
|
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.
|
|
```java
|
|
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.
|
|
|
|
```java
|
|
private static final String MESSAGE_TO_PRINT = "hello world";
|
|
|
|
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:
|
|
|
|
```java
|
|
HP Printer : hello world
|
|
Canon Printer : hello world
|
|
Epson Printer : hello world
|
|
```
|
|
|
|
## Class diagram
|
|
|
|
|
|
## Applicability
|
|
Use the Delegate pattern in order to achieve the following
|
|
|
|
* Reduce the coupling of methods to their class
|
|
* Components that behave identically, but realize that this situation can change in the future.
|
|
|
|
## Credits
|
|
|
|
* [Delegate Pattern: Wikipedia ](https://en.wikipedia.org/wiki/Delegation_pattern)
|
|
* [Proxy Pattern: Wikipedia ](https://en.wikipedia.org/wiki/Proxy_pattern)
|