Suppleant (designmönster)

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 10 juli 2018; kontroller kräver 9 redigeringar .
Vice
ombud
Sorts strukturell
Ändamål Tillhandahåller ett surrogatobjekt som styr åtkomst till ett annat objekt.
fördelar
  •  fjärrersättning;
  •  den virtuella proxyn kan utföra optimeringen;
  •  skyddande substitut;
  • "smart" länk;
Minus
  • dramatisk ökning av svarstid.
Beskrivs i Design Patterns Ja

Proxy ( Eng.  Proxy ) är ett strukturellt designmönster som tillhandahåller ett objekt som kontrollerar åtkomst till ett annat objekt, som avlyssnar alla anrop (utför funktionen av en container ).

Syfte

Problem

Tillgången till objektet måste kontrolleras utan att klientens beteende ändras. 

Det är nödvändigt att komma åt objektet på ett sådant sätt att du inte skapar riktiga objekt direkt, utan genom ett annat objekt som kan ha ytterligare funktionalitet.

Lösning

Skapa ett surrogat för ett riktigt objekt. Proxyn lagrar en referens som låter proxyn hänvisa till det verkliga subjektet (ett objekt i klassen Proxy kan hänvisa till ett objekt i klassen Subject om gränssnitten för det verkliga subjektet och subjektet är samma). Eftersom "Real Subject" -gränssnittet är identiskt med "Subject"-gränssnittet, så att "Ersättaren" kan ersätta "Real Subject", kontrollerar tillgången till "Real Subject", kan ansvara för att skapa eller ta bort " Verkligt ämne". "Ämne" definierar ett gemensamt gränssnitt mellan "Real Subject" och "Proxy" så att "Proxy" kan användas varhelst "Real Subject" förväntas. Vid behov kan förfrågningar vidarebefordras av "ställföreträdaren" till "verkliga subjektet".

Art

Fördelar och nackdelar med att använda

Fördelar

Nackdelar

Omfattning

Proxymönstret kan användas när man arbetar med en nätverksanslutning, med ett stort objekt i minnet (eller på disken), eller med någon annan resurs som är svår eller svår att kopiera. Ett välkänt användningsfall är ett objekt som räknar antalet referenser.

Proxy och relaterade mönster [1]

Implementeringsexempel

Java

Implementeringsexempel offentlig klass Main { public static void main ( String [] args ) { // Create math proxy IMath p = new MathProxy (); // Gör mattesystemet . ut . println ( "4 + 2 = " + s . add ( 4 , 2 )); System . ut . println ( "4 - 2 = " + p . sub ( 4 , 2 )); System . ut . println ( "4 * 2 = " + p . mul ( 4 , 2 )); System . ut . println ( "4 / 2 = " + p . div ( 4 , 2 )); } } /** * "Ämne" */ offentligt gränssnitt IMath { public double add ( dubbel x , dubbel y ); offentlig dubbelsub ( dubbel x , dubbel y ) ; offentlig dubbel mul ( dubbel x , dubbel y ); offentlig dubbel div ( dubbel x , dubbel y ); } /** * "Real Subject" */ offentlig klass Math implementerar IMath { public double add ( double x , double y ) { return x + y ; } public double sub ( double x , double y ) { return x - y ; } offentlig dubbel mul ( dubbel x , dubbel y ) { return x * y ; } public double div ( double x , double y ) { return x / y ; } } /** * "Proxy Object" */ public class MathProxy implementerar IMath { privat matematik matematik ; public double add ( double x , double y ) { lazyInitMath (); returnera matematik . add ( x , y ); } public double sub ( double x , double y ) { lazyInitMath (); returnera matematik . sub ( x , y ); } public double mul ( double x , double y ) { lazyInitMath (); returnera matematik . mul ( x , y ); } public double div ( double x , double y ) { lazyInitMath (); returnera matematik . div ( x , y ); } private void lazyInitMath () { if ( matte == null ) { matte = ny matematik (); } } }

scala

Implementeringsexempel object Main utökar App { val p : IMath = nytt MathProxy System . ut . println ( "4 + 2 = " + s . add ( 4 , 2 )) System . ut . println ( "4 - 2 = " + p . sub ( 4 , 2 )) System . ut . println ( "4 * 2 = " + p . mul ( 4 , 2 )) System . ut . println ( "4 / 2 = " + p . div ( 4 , 2 )) } /** * "Ämne" */ egenskap IMath { def add ( x : Double , y : Double ): Double def sub ( x : Dubbel , y : Dubbel ): Dubbel def mul ( x : Dubbel , y : Dubbel ): Dubbel def div ( x : Dubbel , y : Dubbel ): Dubbel } /** * "Real Subject" */ klass Math utökar IMath { def add ( x : Double , y : Double ) = x + y def sub ( x : Dubbel , y : Dubbel ) = x - y def mul ( x : Dubbel , y : Dubbel ) = x * y def div ( x : Dubbel , y : Dubbel ) = x / y } /** * "Proxyobjekt" */ klass MathProxy utökar IMath { privat lazy val math = new Math def add ( x : Double , y : Double ) = matte . lägg till ( x , y ) def sub ( x : Dubbel , y : Dubbel ) = matematik . sub ( x , y ) def mul ( x : Dubbel , y : Dubbel ) = matematik . mul ( x , y ) def div ( x : Dubbel , y : Dubbel ) = matematik . div ( x , y ) }

C++

Implementeringsexempel /** * "Ämne" */ klass IMath { offentliga : virtuell dubbel addera ( dubbel , dubbel ) = 0 ; virtuell dubbelsub ( dubbel , dubbel ) = 0 ; _ virtuell dubbel mul ( dubbel , dubbel ) = 0 ; virtuell dubbel div ( dubbel , dubbel ) = 0 ; }; /** * "Riktigt ämne" */ klass matematik : public IMath { offentliga : virtual double add ( double x , double y ) { returnera x + y _ } virtuell dubbelsub ( dubbel x , dubbel y ) { _ returnera x - y ; } virtuell dubbel mul ( dubbel x , dubbel y ) { returnera x * y _ } virtuell dubbel div ( dubbel x , dubbel y ) { returnera x / y _ } }; /** * "Proxyobjekt" */ klass MathProxy : public IMath { offentliga : MathProxy () { matte = ny matematik (); } virtuell ~ MathProxy () { ta bort matematik ; } virtual double add ( double x , double y ) { returnera matematik -> lägg till ( x , y ); } virtuell dubbelsub ( dubbel x , dubbel y ) { _ return math -> sub ( x , y ); } virtuell dubbel mul ( dubbel x , dubbel y ) { returnera matematik -> mul ( x , y ); } virtuell dubbel div ( dubbel x , dubbel y ) { returnera matematik -> div ( x , y ); } privat : IMath * matematik ; }; #include <iostream> använder std :: cout ; använder std :: endl ; int main () { // Skapa matematisk proxy IMath * proxy = ny MathProxy (); // Gör matteräkningen << "4 + 2 = " << proxy -> add ( 4 , 2 ) << endl ; cout << "4 - 2 = " << proxy -> sub ( 4 , 2 ) << endl ; cout << "4 * 2 = " << proxy -> mul ( 4 , 2 ) << endl ; cout << "4 / 2 = " << proxy -> div ( 4 , 2 ) << endl ; ta bort proxy ; returnera 0 ; }

C#

Implementeringsexempel använder System ; använder System.Threading ; class MainApp { static void Main () { // Create math proxy IMath p = new MathProxy (); // Gör mattekonsolen . WriteLine ( "4 + 2 = " + p . Lägg till ( 4 , 2 )); Konsol . WriteLine ( "4 - 2 = " + p . Sub ( 4 , 2 )); Konsol . WriteLine ( "4 * 2 = " + p . Mul ( 4 , 2 )); Konsol . WriteLine ( "4 / 2 = " + p . Div ( 4 , 2 )); // Vänta på användarkonsolen . läs (); } } /// <summary> /// Ämne - ämne /// </summary> /// <remarks> /// <li> /// <lu> definierar en gemensam för <see cref="Math"/> och <see cref="Proxy"/> gränssnitt så att klass /// <see cref="Proxy"/> kan användas var som helst <see cref="Math"/></lu> /// </ li> / // </remarks> offentligt gränssnitt IMath { double Add ( double x , double y ); dubbel Sub ( dubbel x , dubbel y ); dubbel Mul ( dubbel x , dubbel y ); dubbel Div ( dubbel x , dubbel y ); } /// <summary> /// RealSubject - real object /// </summary> /// <remarks> /// <li> /// <lu>definierar det verkliga objektet som representeras av proxyn</lu> // / </li> /// </remarks> klass Math : IMath { public Math () { Console . WriteLine ( "Skapa objekt Math. Vänta..." ); tråd . Sömn ( 1000 ); } public double Add ( double x , double y ){ return x + y ;} public double Sub ( double x , double y ) { return x - y ;} public double Mul ( double x , double y ) { return x * y ; } public double Div ( double x , double y ) { return x / y ;} } /// <sammanfattning> /// Proxy är en proxy /// </summary> /// <remarks> /// <li> /// <lu> lagrar en referens som låter proxyn referera till den verkliga /// ämne . Klassobjekt <see cref="MathProxy"/> kan referera till klassobjekt /// <see cref="IMath"/> om klassgränssnitt <see cref="Math"/> och <see cref="IMath"/ > är desamma;</lu> /// <lu>tillhandahåller ett gränssnitt som är identiskt med det för <see cref="IMath"/>, så att en proxy /// alltid kan tillhandahållas istället för det verkliga ämnet;</ lu> /// < lu>kontrollerar åtkomsten till det verkliga ämnet och kan vara ansvarigt för att skapa /// och ta bort det;</lu> /// <lu>andra uppgifter beror på typen av proxy: /// < li> /// <lu><b >fjärrproxy</b> är ansvarig för att koda begäran och dess argument /// och skicka den kodade begäran till det verkliga ämnet /// i ett annat adressutrymme;</lu > /// <lu><b>virtuell proxy</b> kan cachelagra ytterligare /// information om det verkliga föremålet för att fördröja dess skapande.</lu> /// <lu><b>skyddande proxy</b > kontrollerar om den som ringer /// har nödvändiga behörigheter för att göra begäran; </lu> /// </li> /// </lu> /// </li> /// < /remarks> class MathProxy : IMath { Math math ; public MathProxy () { math = null ; } /// <summary> /// Snabb operation - kräver inte ett riktigt ämne /// </summary> /// <param name="x"></param> /// <param name="y" >< /param> /// <returns></returns> public double Add ( double x , double y ) { return x + y ; } public double Sub ( dubbel x , dubbel y ) { retur x - y ; } /// <summary> /// Långsam operation - kräver att ett verkligt ämne skapas /// </summary> /// <param name="x"></param> /// <param name="y" >< /param> /// <returns></returns> public double Mul ( double x , double y ) { if ( math == null ) math = new Math (); returnera matematik . Mul ( x , y ); } public double Div ( double x , double y ) { if ( matte == null ) matte = ny matematik (); returnera matematik . Div ( x , y ); } }

JavaScript

Implementeringsexempel /* Ämne */ klass IMath { add ( x , y ) {} sub ( x , y ) {} } /* Real Subject */ class RMath utökar IMath { add ( x , y ) { return x + y ; } sub ( x , y ) { returnera x - y ; } } /* Proxy */ class MathProxy utökar IMath { math = new RMath () add ( x , y ) { returnera detta . matte . add ( x , y ) } sub ( x , y ) { returnera detta . matte . sub ( x , y ) } } const test = new MathProxy () alert ( test . add ( 3 , 2 )) // 5 alert ( test . sub ( 3 , 2 )) // 1

Ruby

Implementeringsexempel modul ProxyPattern # Proxy har samma gränssnitt som ett Real Subject # Real Subject class Account attr_reader :saldo def initiera ( balans = 0 ) @balans = balans slut def insättning ( belopp ) @saldo += belopp slut def draw ( belopp ) @saldo -= belopp slut slut modul Skydd # Ytterligare funktionalitet för att kontrollera åtkomsten till realSubject # Proxyklass KontoProxy def initialisera ( ämne , aktuell_användare ) @ ämne = ämne @aktuell_användare = aktuell_användare @saldo = 0 slut def insättning ( belopp ) @subject . insättning ( belopp ) om auktorisation slut def dra ut ( belopp ) @subject . dra tillbaka ( belopp ) om auktorisation avslutas def balans @ämne . balans slut privat def auktorisera sätter 'Åtkomst nekad' om inte @current_user == ' admin' @current_user == ' admin ' slutslut def själv . kör sätter '=> Proxy::Protection' sätter 'som användare' protected_account = AccountProxy . nytt ( Konto . nytt , 'användare' ) protected_account . insättning ( 20 ) protected_account . dra ut ( 10 ) sätter protected_account . balans sätter 'som admin' protected_account = AccountProxy . nytt ( Konto . nytt , 'admin' ) protected_account . insättning ( 20 ) protected_account . dra ut ( 10 ) sätter protected_account . balans sätter ' ' slutslut modul Virtuell # Fördröjning av verklig Ämnesladdning (lat laddning) # Proxyklass AccountProxy def initialize ( local_balance = 0 ) @local_balance = local_balance end def insättning ( belopp ) @local_balance += belopp slut def uttag ( belopp ) @local_balance -= belopp slut def balans ämne . balans slut def subject @subject ||= Konto . ny ( @local_balance ) _ _ def själv . kör sätter '=> Proxy::Virtual' local_account = AccountProxy . nytt lokalt_konto . insättning ( 20 ) local_account . dra ut ( 10 ) local_account . insättning ( 15 ) local_account . draw ( 5 ) sätter 'Inget riktigt konto ännu:' sätter local_account . inspektera lokalt_konto . saldo sätter 'Riktigt konto skapades:' sätter local_account . inspektera sätter ' ' slutslut def själv . kör skydd . runVirtual . _ köra slutet slutet

PHP5

Implementeringsexempel <?php /// Ämne - ämne /// definierar ett gränssnitt gemensamt mellan Math och "Proxy", så att /// "Proxy"-klassen kan användas var som helst gränssnitt IMath { function Add ( $x , $y ); funktion Sub ( $x , $y ); funktion Mul ( $x , $y ); funktion Div ( $x , $y ); } /// RealSubject - det verkliga objektet /// definierar det verkliga objektet som representeras av proxyn class Math implementerar IMath { public function __construct () { print ( "Skapa objekt Math. Vänta..." ); sömn ( 5 ); } public function Add ( $x , $y ){ return $x + $y ;} public function Sub ( $x , $y ){ return $x - $y ;} public function Mul ( $x , $y ){ return $x * $y ;} offentlig funktion Div ( $x , $y ){ return $x / $y ;} } /// Proxy - proxy /// lagrar en länk som låter proxyn referera till det verkliga /// ämnet. Klassobjektet "MathProxy" kan komma åt klassobjektet "Math" /// om gränssnitten för klasserna "Math" och "IMath" är desamma; /// tillhandahåller ett gränssnitt som är identiskt med "IMath"-gränssnittet, så en proxy /// kan alltid tillhandahållas i stället för det verkliga ämnet; /// kontrollerar åtkomst till det verkliga ämnet och kan vara ansvarigt för att skapa /// och ta bort det; /// andra uppgifter beror på typen av proxy: /// fjärrproxyn är ansvarig för att koda begäran och dess argument /// och skicka den kodade begäran till det verkliga subjektet /// i ett annat adressutrymme; /// Den virtuella proxyn kan cachelagra ytterligare /// information om det verkliga ämnet för att fördröja dess skapande. /// den skyddande proxyn kontrollerar om den som ringer /// har nödvändiga behörigheter för att utföra begäran; class MathProxy implementerar IMath { protected $math ; offentlig funktion __construct () { $this -> math = null ; } /// Snabb operation - kräver inte en offentlig funktion för verkligt ämne Add ( $x , $y ) { return $x + $y ; } public function Sub ( $x , $y ) { return $x - $y ; } /// Långsam operation - kräver skapandet av en verkligt ämne offentlig funktion Mul ( $x , $y ) { if ( $this -> math == null ) $this -> math = new Math (); returnera $this -> matte -> Mul ( $x , $y ); } public function Div ( $x , $y ) { if ( $this -> math == null ) $this -> matte = new Math (); return $this -> math -> Div ( $x , $y ); } } $p = ny MathProxy ; // Gör matteutskriften ( " 4 + 2 = " . $p -> Lägg till ( 4 , 2 )); print ( "4 - 2 = " . $p -> Sub ( 4 , 2 )); print ( "4 * 2 = " . $p -> Mul ( 4 , 2 )); print ( "4 / 2 = " . $p -> Div ( 4 , 2 )); ?>

ActionScript

Implementeringsexempel //file IMath.as paket { public interface IMath { function add ( a : Number , b : Number ) : Number ; function sub ( a : Number , b : Number ) : Number ; funktion mul ( a : Tal , b : Tal ) : Tal ; funktion div ( a : Tal , b : Tal ) : Tal ; } } //file MathSubject.as package { public class MathSubject implementerar IMath { public function add ( a : Number , b : Number ) : Number { retur a + b ; } public function sub ( a : Number , b : Number ) : Number { retur a - b ; } offentlig funktion mul ( a : Tal , b : Tal ) : Tal { retur a * b ; } public function div ( a : Number , b : Number ) : Number { retur a / b ; } } } //file MathProxy.as paket { public class MathProxy implementerar IMath { private var math : MathSubject ; offentlig funktion MathProxy () { matte = nytt MathSubject (); } public function add ( a : Number , b : Number ) : Number { return math . addera ( a , b ); } public function sub ( a : Number , b : Number ) : Number { return math . sub ( a , b ); } offentlig funktion mul ( a : Tal , b : Tal ) : Tal { return math . mul ( a , b ); } offentlig funktion div ( a : Tal , b : Tal ) : Tal { if ( b != 0 ) returnerar matematik . div ( a , b ); else { trace ( "Division med noll." ); returnummer . _ POSITIVE_INFINITY ; } } } } //file Main.as- paket { import flash.display.Sprite ; public class Main utökar Sprite { public function Main () { playWithMath ( nytt MathSubject ()); playWithMath ( ny MathProxy ()); } public function playWithMath ( matte : IMath ) : void { trace ( math . add ( 5 , 0 )); spåra ( matte . sub ( 5 , 0 )); spåra ( matte . mul ( 5 , 0 )); spåra ( matte . div ( 5 , 0 )); } } }

Python

Implementeringsexempel # -*- kodning: utf-8 -*- class IMath : """Gränssnitt för proxy och verkligt ämne""" def add ( self , x , y ): raise NotImplementedError () def sub ( self , x , y ): höj NotImplementedError () def mul ( själv , x , y ): höj NotImplementedError () def div ( själv , x , y ): höj NotImplementedError () klass Math ( IMath ): """Riktigt ämne""" def add ( själv , x , y ): returnera x + y def sub ( själv , x , y ): returnera x - y def mul ( själv , x , y ): returnera x * y def div ( själv , x , y ): returnera x / y class Proxy ( IMath ): """Proxy""" def __init__ ( self ): self . matte = matte () def add ( själv , x , y ): returnera x + y def sub ( själv , x , y ): returnera x - y def mul ( själv , x , y ): returnera själv . matte . mul ( x , y ) def div ( själv , x , y ): returnera flytande ( 'inf' ) om y == 0 annat själv . matte . div ( x , y ) p = Proxy () x , y = 4 , 2 print '4 + 2 = ' + str ( p . add ( x , y )) print '4 - 2 = ' + str ( p . sub ( x , y )) print '4 * 2 = ' + str ( p . mul ( x , y )) print '4 / 2 = ' + str ( p . div ( x , y ))

VB.NET

Implementeringsexempel Importerar System.Threading Klass MainApp Shared Sub Main () ' Skapa matteproxy Dim p As IMath = New MathProxy () " Gör mattekonsolen . WriteLine ( "4 + 2 = " & s . Lägg till ( 4 , 2 )) Konsol . WriteLine ( "4-2 = " & p . Subtr ( 4 , 2 )) Konsol . WriteLine ( "4 * 2 = " & p . Mul ( 4 , 2 )) Konsol . WriteLine ( "4 / 2 = " & p . Div ( 4 , 2 )) " Vänta på användarkonsolen . Läs () End Sub End Class ''' <summary> ''' Ämne - ämnet för ''' </summary> ''' <remarks> ''' <li> ''' <lu> definierar gemensamt för <see cref="Math"/ > och <see cref="Proxy"/> gränssnitt så att klassen ''' <see cref="Proxy"/> kan användas var som helst <see cref="Math"/></lu> ''' </ li> ''' </remarks> Public Interface IMath Funktion Lägg till ( ByVal x As Double , ByVal y As Double ) As Double Function Subtr ( ByVal x As Double , ByVal y As Double ) As Double Function Mul ( ByVal x As Double , ByVal y As Double ) Som dubbelfunktions Div ( ByVal x As Double , ByVal y As Double ) Som Double End Interface _ ''' <summary> ''' RealSubject - det verkliga objektet ''' </summary> ''' <remarks> ''' <li> ''' <lu>identifierar det verkliga objektet som representeras av proxyn</lu > '' ' </li> ''' </remarks> Class Math implementerar IMath Public Sub New () Console . WriteLine ( "Skapa objekt Math. Vänta..." ) Tråd . Sleep ( 1000 ) End Sub Public Function Add ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Lägg till retur x + y slutfunktion Public Function Subtr ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Subtr Return x - y Slutfunktion _ Public Function Mul ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Mul Return x * y Slutfunktion _ Public Function Div ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Div Return x / y Slutfunktion _ slutklass _ ''' <summary> ''' Proxy proxy ''' </summary> ''' <remarks> ''' <li> ''' <lu> lagrar en referens som gör att proxyn kan referera till den riktiga '' ' ämne. Ett objekt av klassen <see cref="MathProxy"/> kan referera till ett objekt av klassen ''' <see cref="IMath"/> om klassen gränssnitt <see cref="Math"/> och <see cref= "IMath"/ > är desamma;</lu> ''' <lu>tillhandahåller ett gränssnitt som är identiskt med det för <see cref="IMath"/>, så att platshållaren ''' alltid kan tillhandahållas istället för verkligt ämne;</lu> ''' < lu>kontrollerar åtkomsten till det verkliga ämnet och kan vara ansvarigt för att det skapas ''' och raderas;</lu> ''' <lu>andra uppgifter beror på typen av proxy : ''' <li> ''' <lu><b >fjärrproxy</b> är ansvarig för att koda begäran och dess argument ''' och skicka den kodade begäran till det verkliga ämnet i ett annat adressutrymme '' ';</lu> ''' <lu><b>virtuell proxy</b> kan cachelagra ytterligare information ''' om det verkliga föremålet för att fördröja skapandet.</lu> ''' <lu><b> protecting proxy</b> kontrollerar om den som ringer ''' har nödvändiga behörigheter för att göra begäran; </lu> ''' </li> ''' </lu> ''' </li> ''' < /anmärkningar> Klass MathProxy implementerar IMath Privat matematik Som Math = Ingenting ''' <summary> ''' Snabb operation - kräver inte ett riktigt ämne ''' </summary> Offentlig funktion Lägg till ( ByVal x As Double , ByVal y As Double ) As Double Implementerar IMath . Lägg till retur x + y slutfunktion Public Function Subtr ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Subtr Return x - y Slutfunktion _ ''' <summary> ''' Långsam operation - kräver att ett verkligt ämne skapas ''' </summary> Public Function Mul ( ByVal x As Double , ByVal y As Double ) As Double Implementerar IMath . Mul Om matte är ingenting Då matte = Ny matte () End If Return matte . Mul ( x , y ) Slutfunktion _ Public Function Div ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Div Om matte är ingenting Då matte = Ny matte () End If Return matte . Div ( x , y ) Slutfunktion Slutklass _ _

Swift

Implementeringsexempel // ämnesprotokoll match { func add ( x : Int , y : Int ) -> Int func sub ( x : Int , y : Int ) -> Int func mul ( x : Int , y : Int ) -> Int func div ( x : Int , y : Int ) -> Int } // Real Subject class MatchImp : Match { func add ( x : Int , y : Int ) -> Int { return x + y } func sub ( x : Int , y : Int ) -> Int { return x - y } func mul ( x : Int , y : Int ) -> Int { return x * y } func div ( x : Int , y : Int ) -> Int { return x / y } } // Proxyklass MatchProxy : Matcha { private let math = MatchImp () func add ( x : Int , y : Int ) -> Int { return math . lägg till ( x : x , y : y ) } func sub ( x : Int , y : Int ) -> Int { return math . sub ( x : x , y : y ) } func mul ( x : Int , y : Int ) -> Int { return math . mul ( x : x , y : y ) } func div ( x : Int , y : Int ) -> Int { return math . div ( x : x , y : y ) } } // Använd proxy låt proxy = MatchProxy () skriva ut ( "7 * 8 = \( proxy . mul ( x : 8 , y : 7 )) " )

Se även

  • Post-objekt programmering

Anteckningar

  1. ↑ Utvecklarens dagböcker // Proxy (nedlänk) . Hämtad 26 maj 2010. Arkiverad från originalet 14 maj 2010. 

Litteratur

  • CodeLIB.YOURS // Proxy arkiverad 14 maj 2010 på Wayback Machine
  • E. Gamma, R. Helm, R. Johnson, J. Vlissides . Tekniker för objektorienterad design. Design Patterns.=Design Patterns.Element av återanvändbar objektorienterad programvara. - St Petersburg. : Peter, 2001. - 368 sid. — ISBN 5-272-00355-1 .
  • Eric Freeman, Elizabeth Freeman, Kathy Siera, Bert Bates. Design mönster. - St Petersburg. : Peter, 2012. - 656 sid. - ISBN 978-5-459-00435-9 .

Länkar