Skip to main content


StructuralDecouplingAbout 1 min

Also known as

Proxy Pattern


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.


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.

public interface Printer {
  void print(final String message);

public class CanonPrinter implements Printer {
  public void print(String message) {"Canon Printer : {}", message);

public class EpsonPrinter implements Printer {
  public void print(String message) {"Epson Printer : {}", message);

public class HpPrinter implements Printer {
  public void print(String message) {"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;
  public void print(String message) {

Now on the client code printer controllers can print messages differently depending on the
object they're delegating that work to.

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());


Program output:

HP Printer : hello world
Canon Printer : hello world
Epson Printer : hello world

Class diagram

alt text


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.