In der Softwaretechnik ist das Delegationsmuster ein Designmuster in der objektorientierten Programmierung, wo ein Gegenstand, anstatt eine seiner festgesetzten Aufgaben, Delegierte durchzuführen, die die Aufgabe einem verbundenen Helfer einwendet. Es gibt eine Inversion der Verantwortung, in der ein Helfer-Gegenstand, der als ein Delegierter bekannt ist, die Verantwortung gegeben wird, eine Aufgabe für den delegator durchzuführen. Das Delegationsmuster ist eines der grundsätzlichen Abstraktionsmuster, die anderen Softwaremustern wie Zusammensetzung (auch gekennzeichnet als Ansammlung), mixins und Aspekte unterliegen.

Beispiele

Javanische Beispiele

Einfach

In diesem javanischen Beispiel hat die Klasse eine Methode. Diese Druckmethode, anstatt den Druck selbst durchzuführen, delegiert zur Klasse. Zur Außenwelt scheint es, dass die Klasse den Druck tut, aber Klasse ist diejenige, die wirklich die Arbeit tut.

Delegation gibt einfach durch eine Aufgabe zu jemandem/etwas anderem aus. Hier ist ein einfaches Beispiel:

Klasse RealPrinter {//der "Delegierte"

leerer Druck {

System.out.print ("etwas");

}\

}\

Klassendrucker {//der "delegator"

RealPrinter p = neuer RealPrinter ;//schaffen den Delegierten

leerer Druck {

p.print ;//Delegation

}

}\

öffentliche Klasse Wichtiger {\

//zur Außenwelt sieht es aus, dass Drucker wirklich druckt.

öffentliche statische leere Hauptsache (Schnur [] args) {\

Drucker-Drucker = neuer Drucker ;

printer.print ;

}\ }\</Quelle>

Komplex

Indem

sie Schnittstellen verwendet, kann Delegation flexibler und typesafe gemacht werden. "Flexibilität" hier bedeutet, dass sich auf oder in jedem Fall nicht zu beziehen braucht, weil die Schaltung der Delegation davon abstrahiert wird. Selbstverständlich, und zählen Sie als Verweisungen auf nicht und. In diesem Beispiel kann Klasse entweder zur Klasse oder zu Klasse delegieren. Klasse hat Methoden, zwischen Klassen umzuschalten, und. Einschließlich der Klauseln verbessert Typ-Sicherheit, weil jede Klasse die Methoden in der Schnittstelle durchführen muss. Der Hauptumtausch ist mehr Code.

verbinden Sie I {\

Leere f ;

Leere g ;

}\

klassifizieren Sie Werkzeuge I {\

öffentliche Leere f {System.out.println ("A: das Tun f "); }\

öffentliche Leere g {System.out.println ("A: das Tun g "); }\

}\

Klasse B führt I {\durch

öffentliche Leere f {System.out.println ("B: das Tun f "); }\

öffentliche Leere g {System.out.println ("B: das Tun g "); }\

}\

Klasse C führt I {\durch

//Delegation

Ich ich = neu ;

öffentliche Leere f {i.f ; }\

öffentliche Leere g {i.g ; }\

//normale Attribute

öffentliche Leere toA {ich = neu ; }\

öffentliche Leere toB {ich = neuer B ; }\

}\

öffentliche Klasse Wichtiger {\

öffentliche statische leere Hauptsache (Schnur [] args) {\

C c = neuer C ;

c.f ;//Produktion: A: das Tun f

c.g ;//Produktion: A: das Tun g

c.toB ;

c.f ;//Produktion: B: das Tun f

c.g ;//Produktion: B: das Tun g

}\

}\</Quelle>

C# Beispiel

Das ist C# Beispiel des komplizierten javanischen Beispiels oben.

öffentliche Schnittstelle I

{\

Leere F ;

Leere G ;

}\

öffentliche Klasse A: Ich

{\

öffentliche Leere F {System. Konsole. WriteLine ("A: das Tun F "); }\

öffentliche Leere G {System. Konsole. WriteLine ("A: das Tun G "); }\

}\

öffentliche Klasse B: Ich

{\

öffentliche Leere F {System. Konsole. WriteLine ("B: das Tun F "); }\

öffentliche Leere G {System. Konsole. WriteLine ("B: das Tun G "); }\

}\

öffentliche Klasse C: Ich

{\

//Delegation

Ich ich = neu ;

öffentliche Leere F {ich. F ; }\

öffentliche Leere G {ich. G ; }\

//normale Attribute

öffentlicher leerer ToA {ich = neu ; }\

öffentlicher leerer ToB {ich = neuer B ; }\

}\

öffentliches Klassenprogramm

{\

öffentliche statische leere Hauptsache

{\

C c = neuer C ;

c. F ;//Produktion: A: das Tun F

c. G ;//Produktion: A: das Tun G

c. ToB ;

c. F ;//Produktion: B: das Tun F

c. G ;//Produktion: B: das Tun G

}\}\</Quelle>

C ++ Beispiel (Komplex)

Dieses Beispiel ist ein C ++ Version des komplizierten javanischen Beispiels oben. Seitdem C ++ hat keine Schnittstelle-Konstruktion, eine reine virtuelle Klasse spielt dieselbe Rolle. Die Vorteile und Nachteile sind größtenteils dasselbe als im javanischen Beispiel.

1. einschließen

das Verwenden namespace std;

Klasse I {\

Publikum:

virtuelle Leere f = 0;

virtuelle Leere g = 0;

virtueller ~I {}\

};

Klasse A: Publikum I {\

Publikum:

Leere f {cout

Leere g {i-> g ; }\

//normale Attribute

Leere toA {löscht mich; ich = neu ; }\

Leere toB {löscht mich; ich = neuer B ; }\

};

int Hauptsache {\

C c;

c.f ;//A: das Tun f

c.g ;//A: das Tun g

c.toB ;//A: das Aufräumen.

c.f ;//B: das Tun f

c.g ;//B: das Tun g

}\</Quelle>

Beispiel von Eiffel (Komplex)

Dieses Beispiel ist eine Version von Eiffel des komplizierten javanischen Beispiels oben.

aufgeschobene Klasse zeige ich

f aufgeschobenes Ende

g aufgeschobenes Ende

Ende

Klasse A erbt ich zeige

f drucken wirklich ("A: Das Tun f%N") beenden

g drucken wirklich ("A: Das Tun g%N") beenden

Ende

Klasse B erbt ich zeige

f drucken wirklich ("B: Das Tun f%N") beenden

g drucken wirklich ("B: Das Tun g%N") beenden

Ende

Klasse C erbt mich Entwicklung to_a, to_b zeigen

i: Ich

f tun I.f-Ende

g tun I.g-Ende

to_a schaffen wirklich {Einen} ich Ende

to_b schaffen wirklich {B} ich beende

Ende

Klasse HAUPT-Entwicklung Haupteigenschaft

wichtiger

lokaler

c: C

tun Sie

schaffen Sie c.to_a

c.f

c.g

c.to_b

c.f c.g

Ende

Ende</Quelle>

Objektives-C Beispiel

Delegation ist im Kakao-Fachwerk sehr üblich. Das folgende Beispiel ist eine Objektive-C Version des komplizierten javanischen Beispiels oben.

@protocol I

- (Leere) f;

- (Leere) g;

@end

@interface A: NSObject

@end

@implementation Ein

- (Leere) f {

NSLog ("A: das Tun f");

}\

- (Leere) g {

NSLog ("A: das Tun g");

}\@end

@interface B: NSObject

@end

@implementation B

- (Leere) f {

NSLog ("B: das Tun f");

}\- (Leere) g {

NSLog ("B: das Tun g");

}\@end

@interface C: NSObject

id

}\

- (Leere) toA;

- (Leere) toB;

@end

@implementation C

- (Leere) f {

[ich f];

}\- (Leere) g {

[ich g];

}\

- (Leere) toA {

[ich veröffentliche];

i = Ein alloc] init];

}\

- (Leere) toB {

[ich veröffentliche];

i = B alloc] init];

}\

//Konstrukteur

- (id) init {\

wenn (selbst = [fantastischer init]) {\

i = Ein alloc] init];

}\

kehren Sie selbst zurück;

}\

//destructor

- (Leere) dealloc {

[ich veröffentliche];

[fantastischer dealloc];

}\@end

int Hauptsache (interne Nummer argc, const Rotforelle * argv []) {\

NSAutoreleasePool * bilden = NSAutoreleasePool alloc] init] ein Kartell;

C *c = C alloc] init];

[c f];//Produktion: A: das Tun f

[c g];//Produktion: A: das Tun g

[c toB];

[c f];//Produktion: B: das Tun f

[c g];//Produktion: B: das Tun g

[c Ausgabe];

[vereinen Sie Abflussrohr];

kehren Sie 0 zurück;

}\</Quelle>

Perl

verwenden Sie streng;

verwenden Sie Warnungen;

verwenden Sie 5.010_000;

Paket-Beispiel:: Drucker:: Delegierter:: Rolle;

Gebrauch-Elch:: Rolle;

für die Anmerkung

Rollen sind Schnittstellen auf anderen Sprachen ähnlich

aber sind stärker.

Kürzung

verlangt 'print_string'; # ist 'print_string' erforderlich.

für optional_methods

grüßen Sie

Kürzung

Paket-Beispiel:: Drucker:: Delegierter:: A;

verwenden Sie Elch;

mit dem 'Beispiel:: Drucker:: Delegierter:: Rolle';

U-Boot print_string {\

sagen Sie 'Gedruckt von';

}\

Paket-Beispiel:: Drucker:: Delegierter:: B;

verwenden Sie Elch;mit dem 'Beispiel:: Drucker:: Delegierter:: Rolle';U-Boot print_string {\

sagen Sie 'Gedruckt von B';

}\

U-Boot grüßt {\

sagen Sie 'Und hallo zu Ihnen!';

}\

Paket-Beispiel:: Drucker;

verwenden Sie Elch;

hat Delegierten => (

ist => 'rw',

tut => 'Beispiel:: Drucker:: Delegierter:: Rolle',

Prädikat => 'hasDelegate'

);

U-Boot-Druck {\

mein $self = Verschiebung;

# Kontrolle, um zu sehen, wenn ich einen Delegierten habe

wenn ($self-> hasDelegate) {\

mein $delegate = $self-> Delegierter;

# Anruf die Druckmethode des Delegierten. Die Rolle versichert mich das

# besteht print_string.

$delegate-> print_string;

# wollen Wir überprüfen, um zu sehen, ob der Delegierte die grüßen Methode unterstützt.

wenn (kann $delegate-> ('grüßen')), {\

# tut Es so, wollen auch wir Leute grüßen!

$delegate-> grüßen ;

}\

}\

sonst {\

warnen Sie 'Keinen Delegierten!';

}\}\

wichtiges Paket;

verwenden Sie streng;

mein $delegateA = Beispiel:: Drucker:: Delegierter:: A-> neu ;

mein $delegateB = Beispiel:: Drucker:: Delegierter:: B-> neu ;

mein $printer = Beispiel:: Drucker-> neu ;

$printer-> Druck ; # Wird eine Warnung darüber bekommen, einen Delegierten zu nicht haben.

sagen Sie 'Untergehenden Delegierten auf dem Delegierten';

$printer-> Delegierter ($delegateA);

$printer-> Druck ; # wird Das $a's print_string Methode nennen.

sagen Sie 'Untergehenden Delegierten auf dem Delegierten B';

$printer-> Delegierter ($delegateB);

$printer-> Druck ; # wird Das $b's print_string nennen, und Methoden grüßen.

</Quelle>

Pythonschlange-Beispiel (Komplex)

Klasse I (Gegenstand):

def f (selbst): Pass

def g (selbst): Pass

Klasse A (I):

def f (selbst):

drucken Sie "A: das Tun f "

def g (selbst):

drucken Sie "A: das Tun g "

Klasse B (I):

def f (selbst):

drucken Sie "B: das Tun f "

def g (selbst):

drucken Sie "B: das Tun g "

Klasse C (I):

def __ init __ (selbst):

# Delegation

self.i =

def f (selbst):

self.i.f

def g (selbst):

self.i.g

# normale Attribute

def to_a (selbst):

self.i =

def to_b (selbst):

self.i = B

wenn __ __ == '__ wichtig __' nennen:

c = C

c.f # Produktion: A: das Tun f

c.g # Produktion: A: das Tun g

c.to_b

c.f # Produktion: B: das Tun f

c.g # Produktion: B: das Tun g

</Quelle>

Rubinrotes Beispiel (Komplex)

Modul I

def f

stellt "# {self.class}: das Tun f "

Ende

def g

stellt "# {self.class}: das Tun g "

EndeEnde

klassifizieren Sie Einen

schließen Sie mich ein

Ende

Klasse B

schließen Sie mich einEnde

Klasse C

attr_accessor: ich

Delegierter: f: g: zu =>: ich

def initialisieren (klass =)

self.i = klass.new

EndeEnde

c = C.new

c.f # Produktion: A: das Tun f

c.g # Produktion: A: das Tun g

c = C.new (B)

c.f # Produktion: B: das Tun f

c.g # Produktion: B: das Tun g

</Quelle>

Tcl

1. TclOO ist ein Teil von Tcl in 8.6 addon Paket in 8.5

wenn {[Fang {Paket verlangt, dass sich TclOO}] irren! = 0\{\

stellt stderr "Unfähig, Paket zu finden, TclOO passen... Ihren auto_path an!";

}\

oo:: Klasse schafft mich {\

Konstrukteur {} {\

}\

Methode f {} {stellt "Fehler führen Sie bitte durch";};

Methode g {} {stellt "Fehler führen Sie bitte durch";};

}\

oo:: Klasse schafft Einen {\

Superklasse I

Konstrukteur {} {\

als nächstes;

}\

Methode f {} {\

stellt "A: das Tun f "

}\

Methode g {} {\

stellt "A: das Tun g "

}\}\

oo:: Klasse schafft B {\

Superklasse I

Konstrukteur {} {\ als nächstes; }\ Methode f {} {\

stellt "B: das Tun f "

}\ Methode g {} {\

stellt "B: das Tun g "

}\}\

oo:: Klasse schafft C {\

Variable i

Konstrukteur {} {\ # Delegation

gehen Sie i [Ein neuer] unter

}\ Methode f {} {\

$i f

}\ Methode g {} {\

$i g

}

# normale Attribute

Methode to_a {} {\

$i zerstören;

gehen Sie i [Ein neuer] unter

}\

Methode to_b {} {\

$i zerstören;

gehen Sie i [B neu] unter

}\}\

Satz c [C neu]

$c to_a

$c f; # Produktion A: das Tun f

$c g; # Produktion A: das Tun g

$c to_b

$c f; # Produktion B: das Tun f

$c g; # Produktion B: das Tun g

</Quelle>

PHP

}\

öffentliche Funktion printData {\

$this-> Drucker-> printIt ('Einige Schnur-Daten');

}\}\

//Ein anderer kundenspezifischer Gegenstand

Klasse MyOtherObject {\

geschützter $printer;

öffentliche Funktion __ Konstruktion {\

//Satz-Delegierter.

$this-> Drucker = neuer ArrayPrinter;

}\ öffentliche Funktion printData {\

$this-> Drucker-> printIt (Reihe (1,2,3));

}\}\

//...

//Führen Sie es.

$object = neuer MyObject;

$object-> printData ;

//Führen Sie es.

$object = neuer MyOtherObject;

$object-> printData ;</Quelle>

Siehe auch

• Delegation, die (programmiert)
• Designmuster
• Postgegenstand, programmierend

Links

• Delegation auf dem Code von Rosetta