Delegation (objektorienteret programmering) - Delegation (object-oriented programming)

For anden anvendelse, se Delegation (computing) .
For ikke at forveksle med Forwarding (objektorienteret programmering) .

I objektorienteret programmering , uddelegering betegner vurdere et element ( ejendom eller metode ) af den ene objekt (modtageren) i forbindelse med en anden original objekt (afsenderen). Delegering kan udføres eksplicit ved at sende det sendende objekt til det modtagende objekt, hvilket kan udføres på ethvert objektorienteret sprog ; eller implicit ved hjælp af medlemsopslagets regler i sproget, hvilket kræver sprogunderstøttelse af funktionen. Implicit delegering er den grundlæggende metode til adfærdsgenbrug i prototype-baseret programmering , svarende til arv i klassebaseret programmering . De mest kendte sprog at støtte delegation på sproglige niveau er Self , som inkorporerer begrebet delegation gennem sin opfattelse af foranderlige forælder slots , der bruges på metode opslag på selvstændige opkald og JavaScript ; se JavaScript -delegering .

Begrebet delegation bruges også løst om forskellige andre relationer mellem objekter; se delegation (programmering) for mere. Ofte forvirrede begreber bruger simpelthen et andet objekt, mere præcist omtalt som konsultation eller aggregering ; og evaluering af et element på et objekt ved at evaluere det tilsvarende element på et andet objekt, især i sammenhæng med det modtagende objekt, som mere præcist omtales som videresendelse (når et indpakningsobjekt ikke passerer sig selv til det indpakkede objekt). Den delegation mønster er et design pattern til implementering uddelegering, selv om dette udtryk også bruges løst til konsultation eller videresendelse.

Oversigt

Denne følelse af delegation som programmeringssprogsfunktion, der gør brug af metodeopslagningsreglerne til afsendelse af såkaldte selvopkald, blev defineret af Lieberman i sit papir fra 1986 "Brug af prototypiske objekter til at implementere delt adfærd i objektorienterede systemer".

Delegation er afhængig af dynamisk binding , da det kræver, at et givet metodeopkald kan påkalde forskellige segmenter af kode ved runtime. Det bruges i hele macOS (og dets forgænger NeXTStep ) som et middel til at tilpasse programkomponenternes adfærd. Det muliggør implementeringer som f.eks. At bruge en enkelt OS-leveret klasse til at styre vinduer, fordi klassen tager en delegeret, der er programspecifik, og kan tilsidesætte standardadfærd efter behov. Når brugeren f.eks. Klikker på lukningsfeltet, sender vindueshåndtereren delegerede et windowShouldClose: call, og delegerede kan forsinke lukningen af ​​vinduet, hvis der er ikke -gemte data repræsenteret af vinduets indhold.

Delegation kan karakteriseres (og adskilles fra videresendelse ) som sen binding af mig selv :

... meddelelser sendt til self(eller this) variablen i forælderen vil "vende tilbage" til det objekt, der oprindeligt modtog meddelelsen.

Det vil sige, at selfen metode -definition i det modtagende objekt ikke er statisk bundet til objektet på definitionstidspunktet (f.eks. Kompileringstid eller når funktionen er knyttet til et objekt), men snarere på evalueringstidspunktet , er det bundet til originalen objekt.

Det er blevet argumenteret for, at delegation i nogle tilfælde kan foretrækkes frem for arv for at gøre programkode mere læsbar og forståelig. På trods af at eksplicit delegation er ret udbredt, implementerer relativt få større programmeringssprog delegering som en alternativ model til arv. Det præcise forhold mellem delegering og arv er kompliceret; nogle forfattere betragter dem som ækvivalente, eller den ene er et specielt tilfælde af den anden.

Sprogstøtte til delegation

På sprog, der understøtter delegering via metodeopslagningsregler, defineres metodeforsendelse, som den er defineret for virtuelle metoder i arv: Det er altid den mest specifikke metode, der vælges under metodeopslag. Derfor er det den oprindelige modtagerenhed, der er starten på metodeopslag, selvom den har videregivet kontrollen til et andet objekt (gennem et delegationslink, ikke en objektreference).

Delegation har den fordel, at den kan finde sted på løbetid og kun påvirke en delmængde af enheder af en eller anden type og kan endda fjernes på løbetid. Arv er derimod typisk målrettet mod typen snarere end instanserne og er begrænset til kompileringstid. På den anden side kan arv være statisk typekontrolleret, mens delegation generelt ikke kan være uden generika (selvom en begrænset version af delegering kan være statisk typesikker). Delegering kan betegnes "arvetid for bestemte objekter".

Her er et pseudokodeeksempel i et C# / Java -lignende sprog: 

class A {
  void foo() {
    // "this" also known under the names "current", "me" and "self" in other languages
    this.bar();
  }

  void bar() {
    print("a.bar");
  }
};

class B {
  private delegate A a; // delegation link

  public B(A a) {
    this.a = a;
  }

  void foo() {
    a.foo(); // call foo() on the a-instance
  }

  void bar() {
    print("b.bar");
  }
};

a = new A();
b = new B(a); // establish delegation between two objects

Opkald b.foo()vil resultere i, at a.bar udskrives, da det thisrefererer til det originale modtagerobjekt binden for rammerne af a. Den resulterende uklarhed thisomtales som objektskizofreni .

Når det implicitte oversættes thistil en eksplicit parameter, oversættes opkaldet (i B, med aen delegeret) a.foo()til A.foo(b), ved hjælp af typen afor metodeopløsning, men delegeringsobjektet bfor thisargumentet.

Ved hjælp af arv er den analoge kode (ved hjælp af store bogstaver for at understrege, at opløsning er baseret på klasser, ikke objekter): 

class A {
  void foo() {
    this.bar();
  }

  void bar() {
    print("A.bar");
  }
};

class B extends A {
  public B() {}

  void foo() {
    super.foo(); // call foo() of the superclass (A)
  }

  void bar() {
    print("B.bar");
  }
};

b = new B();

Opkald b.foo()resulterer i B.bar . I dette tilfælde thiser det entydigt: der er et enkelt objekt ,, bog this.bar()løser metoden på underklassen.

Programmeringssprog generelt understøtter ikke denne usædvanlige form for delegation som sprogkoncept, men der er nogle få undtagelser.

Dobbelt arv

Hvis sproget understøtter både delegering og arv, kan man gøre dobbelt arv ved at udnytte begge mekanismer på samme tid som i 

class C extends A {
  delegationlink D d;
}

Dette kræver yderligere regler for metodeopslag, da der nu potentielt er to metoder, der kan betegnes som de mest specifikke (på grund af de to opslagsveje).

Relaterede områder

Delegation kan beskrives som en mekanisme på lavt niveau til deling af kode og data mellem enheder. Således bygger det fundamentet for andre sprogkonstruktioner. Navnlig rolleorienterede programmeringssprog har brugt delegering, men især de ældre brugte faktisk aggregering, mens de hævdede at bruge delegation. Dette bør ikke betragtes som snyd, blot flertalsdefinitionerne af, hvad delegation betyder (som beskrevet ovenfor).

For nylig er der også blevet arbejdet med distribution af delegation, så f.eks. Klienter på en søgemaskine (finde billige hotelværelser) kan bruge en delt enhed ved hjælp af delegation til at dele de bedste hits og generel genanvendelig funktionalitet.

Delegation er også blevet foreslået til rådsopløsning i aspektorienteret programmering af Ernst og Lorenz i 2003.

Se også

Skelne:

Noter

Referencer

eksterne links