delegation pattern

In software engineering, the delegation pattern is a design pattern in object-orientated programming where an object, instead of performing one of its stated tasks, delegates that task to an associated helper object. It passes the buck, so to speak (technically, an Inversion of Responsibility). The helper object is called the delegate. The delegation pattern is one of the fundamental abstraction patterns that underlie other software patterns such as composition (also referred to as aggregation), mixins and aspects.

 

Simple Java example

In this Java example, the Printer class has a print method. This print method, rather than performing the print itself, delegates to class RealPrinter. To the outside world it appears that the Printer class is doing the print, but RealPrinter class is the one actually doing the work.

 class RealPrinter { // the "delegate"
void print() { 
System.out.print("something"); 
}
}

class Printer { // the "delegator"
     RealPrinter p = new RealPrinter(); // create the delegate 
void print() { 
       p.print(); // delegation
} 
}

public class Main {
// to the outside world it looks like Printer actually prints.
public static void main(String[] args) {
         Printer printer = new Printer();
         printer.print();
}
}

[edit] Complex Java example

By using interfaces, delegation can be made more flexible and typesafe. In this example, class C can delegate to either class A or class B. Class C has methods to switch between classes A and B. Including the implements clauses improves type safety, because each class must implement the methods in the interface. The main tradeoff is more code.

 interface I {
void f();
void g();
}

class A implements I {
public void f() { System.out.println("A: doing f()"); }
public void g() { System.out.println("A: doing g()"); }
}

class B implements I {
public void f() { System.out.println("B: doing f()"); }
public void g() { System.out.println("B: doing g()"); }
}

class C implements I {
// delegation
     I i = new A();

public void f() { i.f(); }
public void g() { i.g(); }

// normal attributes
void toA() { i = new A(); }
void toB() { i = new B(); }
}


public class Main {
public static void main(String[] args) {
         C c = new C();
         c.f();     // output: A: doing f()
         c.g();     // output: A: doing g()
         c.toB();
         c.f();     // output: B: doing f()
         c.g();     // output: B: doing g()
}
}

转载于:https://www.cnblogs.com/guoxu/articles/1700192.html