Helyettes (tervezési minta)

Az oldal jelenlegi verzióját még nem ellenőrizték tapasztalt közreműködők, és jelentősen eltérhet a 2018. július 10-én felülvizsgált verziótól ; az ellenőrzések 9 szerkesztést igényelnek .
Helyettes
meghatalmazott
Típusú szerkezeti
Célja Olyan helyettesítő objektumot biztosít, amely vezérli a hozzáférést egy másik objektumhoz.
profik
  •  távhelyettesítő;
  •  a virtuális proxy végrehajthatja az optimalizálást;
  •  védő helyettesítő;
  • "okos" link;
Mínuszok
  • a válaszidő drámai növekedése.
Leírása: Tervezési minták Igen

A proxy ( Eng.  Proxy ) egy szerkezeti tervezési minta , amely egy objektumot biztosít, amely vezérli a hozzáférést egy másik objektumhoz, elfogva minden hívást ( konténer funkcióját látja el ).

Cél

Probléma

Az objektumhoz való hozzáférést az ügyfél viselkedésének megváltoztatása nélkül kell szabályozni. 

Az objektumhoz úgy kell hozzáférni, hogy ne közvetlenül hozzon létre valódi objektumokat, hanem egy másik objektumon keresztül, amely esetleg további funkcionalitással rendelkezik.

Megoldás

Hozzon létre helyettesítőt egy valódi tárgyhoz. A Proxy egy hivatkozást tárol, amely lehetővé teszi a Proxy számára, hogy a valós alanyra hivatkozzon (a Proxy osztály objektumai hivatkozhatnak a Tárgy osztály objektumaira, ha a Valódi Alany és az Alany interfészei megegyeznek). Mivel a "valódi alany" felület megegyezik a "Tárgy" felülettel, így a "Póttag" helyettesíthető a "valódi alany"-val, szabályozza a "valódi alanyhoz" való hozzáférést, felelős lehet a "valódi alany" létrehozásáért vagy törléséért. Valódi alany". A „Tárgy” egy közös interfészt határoz meg a „valódi alany” és a „proxy” között, így a „Proxy” mindenhol használható, ahol „valódi alany” várható. Szükség esetén a kérelmeket a „helyettes” továbbíthatja a „valóságos alanynak”.

Faj

. használatának előnyei és hátrányai

Előnyök

Hátrányok

Hatókör

A Proxy minta akkor használható, ha hálózati kapcsolattal, hatalmas objektummal a memóriában (vagy lemezen), vagy bármilyen más nehezen vagy nehezen másolható erőforrással dolgozik. A jól ismert használati eset egy olyan objektum, amely megszámolja a hivatkozások számát.

Proxy és kapcsolódó minták [1]

Megvalósítási példák

Java

Megvalósítási példa public class Fő { public static void main ( String [] args ) { // Math proxy létrehozása IMath p = new MathProxy (); // Végezze el a matematikai rendszert . ki . println ( "4 + 2 = " + p . add ( 4 , 2 )); Rendszer . ki . println ( "4 - 2 = " + p . sub ( 4 , 2 )); Rendszer . ki . println ( "4 * 2 = " + p . mul ( 4 , 2 )); Rendszer . ki . println ( "4/2 = " + p . div ( 4 , 2 )); } } /** * "Tárgy" */ nyilvános felület IMath { public double add ( double x , double y ); public double sub ( double x , double y ); public double mul ( double x , double y ); public double div ( double x , double y ); } /** * "Real Subject" */ public class Math implements IMath { 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 ; } } /** * "Proxy Object" */ public class MathProxy implements IMath { magán Math matek ; public double add ( double x , double y ) { lazyInitMath (); vissza a matematikát . add ( x , y ); } public double sub ( double x , double y ) { lazyInitMath (); vissza a matematikát . al ( x , y ); } public double mul ( double x , double y ) { lazyInitMath (); vissza a matematikát . mul ( x , y ); } public double div ( double x , double y ) { lazyInitMath (); vissza a matematikát . div ( x , y ); } private void lazyInitMath () { if ( math == null ) { math = new Math (); } } }

scala

Megvalósítási példa object Main extends App { val p : IMath = new MathProxy System . ki . println ( "4 + 2 = " + p . add ( 4 , 2 )) Rendszer . ki . println ( "4 - 2 = " + p . sub ( 4 , 2 )) Rendszer . ki . println ( "4 * 2 = " + p . mul ( 4 , 2 )) Rendszer . ki . println ( "4/2 = " + p . div ( 4 , 2 )) } /** * "Tárgy" */ trait IMAth { def add ( x : Double , y : Double ): Double def sub ( x : Double , y : Double ): Dupla def mul ( x : Double , y : Double ): Double def div ( x : Double , y : Double ): Double } /** * "Real Subject" */ class Math extends IMath { def add ( x : Double , y : Double ) = x + y def sub ( x : Double , y : Double ) = x - y def mul ( x : Double , y : Double ) = x * y def div ( x : dupla , y : dupla ) = x / y } /** * "Proxy Object" */ class MathProxy extends IMath { private lazy val math = new Math def add ( x : Double , y : Double ) = math . add ( x , y ) def sub ( x : Double , y : Double ) = math . al ( x , y ) def mul ( x : Double , y : Double ) = math . mul ( x , y ) def div ( x : Double , y : Double ) = math . div ( x , y ) }

C++

Megvalósítási példa /** * "Tárgy" */ osztály IMath { nyilvános : virtuális dupla összeadás ( double , double ) = 0 ; virtuális double sub ( double , double ) = 0 ; virtuális double mul ( double , double ) = 0 ; virtuális double div ( double , double ) = 0 ; }; /** * "Valódi alany" */ osztály matematika : public IMath { nyilvános : virtual double add ( double x , double y ) { vissza x + y _ } virtual double sub ( double x , double y ) { vissza x - y ; } virtual double mul ( double x , double y ) { vissza x * y _ } virtual double div ( double x , double y ) { vissza x / y _ } }; /** * "Proxy Object" */ class MathProxy : public IMath { nyilvános : MathProxy () { math = new Math (); } virtuális ~ MathProxy () { matek törlése ; } virtual double add ( double x , double y ) { return math -> add ( x , y ); } virtual double sub ( double x , double y ) { return math -> sub ( x , y ); } virtual double mul ( double x , double y ) { return math -> mul ( x , y ); } virtual double div ( double x , double y ) { return math -> div ( x , y ); } privát : IMath * math ; }; #include <iostream> std :: cout használatával ; std használatával :: endl ; int main () { // Math proxy létrehozása IMath * proxy = new MathProxy (); // Végezze el a math cout << "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 ; proxy törlése ; return 0 ; }

C#

Megvalósítási példa a rendszer használatával ; a System.Threading használatával ; class MainApp { static void Main () { // Math proxy létrehozása IMath p = new MathProxy (); // Végezze el a matematikai konzolt . WriteLine ( "4 + 2 = " + p . Add ( 4 , 2 )); Konzol . WriteLine ( "4 - 2 = " + p . Sub ( 4 , 2 )); Konzol . WriteLine ( "4 * 2 = " + p . Mul ( 4 , 2 )); Konzol . WriteLine ( "4 / 2 = " + p . Div ( 4 , 2 )); // Várja meg a felhasználói konzolt . olvasni (); } } /// <summary> /// Tárgy - tárgy /// </summary> /// <remarks> /// <li> /// <lu> meghatároz egy közös értéket a következőhöz: <see cref="Math"/> és <lásd cref="Proxy"/> interfész, így az osztály /// <see cref="Proxy"/> bárhol használható <see cref="Math"/></lu> /// </ li> / // </remarks> public interface IMath { double Add ( double x , double y ); double Sub ( double x , double y ); double Mul ( double x , double y ); double Div ( double x , double y ); } /// <summary> /// RealSubject - valós objektum /// </summary> /// <remarks> /// <li> /// <lu>meghatározza a proxy által képviselt valós objektumot</lu> // / </li> /// </remarks> class Math : IMath { public Math () { Konzol . WriteLine ( "Matek objektum létrehozása. Várj..." ); szál . Alvás ( 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 ;} } /// <summary> /// A proxy egy proxy /// </summary> /// <remarks> /// <li> /// <lu> olyan hivatkozást tárol, amely lehetővé teszi a proxy számára, hogy a valódira hivatkozzon /// tárgy . A <lásd cref="MathProxy"/> osztályobjektum hivatkozhat az osztályobjektumra /// <lásd cref="IMath"/>, ha az osztályinterfészek <lásd a cref="Math"/> és a <see cref="IMath"/> azonosak;</lu> /// <lu>azonos interfészt biztosít, mint a <see cref="IMath"/>, így mindig proxy /// biztosítható a valódi alany helyett;</ lu> /// < lu>szabályozza a valós alanyhoz való hozzáférést, és felelős lehet /// létrehozásáért és törléséért;</lu> /// <lu>egyéb feladatok a proxy típusától függenek: /// < li> /// <lu><b >távoli proxy</b> felelős a kérés és argumentumai kódolásáért /// és a kódolt kérés elküldése a valós alanynak /// egy másik címtérben;</lu > /// A <lu><b>virtuális proxy</b> további /// információkat tárolhat el a valós alanyról, ami késlelteti annak létrehozását.</lu> /// <lu><b>proxy védelme</b > ellenőrzi, hogy a hívó /// rendelkezik-e a kérés benyújtásához szükséges engedélyekkel; </lu> /// </li> /// </lu> /// </li> /// < /remarks> class MathProxy : IMath { Math math ; public MathProxy () { math = null ; } /// <summary> /// Gyors működés - nem igényel valós alanyt /// </summary> /// <param name="x"></param> /// <param name="y" >< /param> /// <returns></returns> public double Add ( double x , double y ) { return x + y ; } public double Sub ( double x , double y ) { return x - y ; } /// <summary> /// Lassú működés – valós alany létrehozása szükséges /// </summary> /// <param name="x"></param> /// <param name="y" >< /param> /// <returns></returns> public double Mul ( double x , double y ) { if ( math == null ) math = new Math (); vissza a matematikát . mul ( x , y ); } public double Div ( double x , double y ) { if ( math == null ) math = new Math (); vissza a matematikát . Div ( x , y ); } }

JavaScript

Megvalósítási példa /* Tárgy */ class IMAth { add ( x , y ) {} sub ( x , y ) {} } /* Valódi alany */ class RMath extends IMath { add ( x , y ) { return x + y ; } sub ( x , y ) { return x - y ; } } /* Proxy */ class MathProxy kiterjeszti az IMath { math = new RMath () add ( x , y ) { return this . matek . add ( x , y ) } sub ( x , y ) { return this . matek . al ( x , y ) } } const teszt = new MathProxy () alert ( test . add ( 3 , 2 )) // 5 alert ( test . sub ( 3 , 2 )) // 1

Ruby

Megvalósítási példa modul ProxyPattern # A proxy ugyanazzal a felülettel rendelkezik, mint a valódi alany # Valódi tantárgy osztály Számla attr_reader :balance def inicializálás ( egyenleg = 0 ) @egyenleg = egyensúly vége def befizetés ( összeg ) @egyenleg += összeg vége def visszavonás ( összeg ) @egyenleg -= összeg vége vége modul Védelem # Kiegészítő funkciók a realSubject-hez való hozzáférés szabályozásához # Proxy osztály AccountProxy def inicializálás ( tárgy , jelenlegi_felhasználó ) @ tárgy = tárgy @ jelenlegi_felhasználó = jelenlegi_felhasználó @egyenleg = 0 vége def befizetés ( összeg ) @tárgy . letét ( összeg ) , ha az engedélyezés vége def visszavonni ( összeg ) @tárgy . visszavonja ( összeg ) , ha az engedélyezés vége def balance @subject . egyensúly vége magán A def authorize a 'Hozzáférés megtagadva' értéket adja, kivéve ha @current_user == ' admin' @current_user == 'admin' end end def self . a run a '=> Proxy::Protection' parancsot tartalmazza behelyezi a 'as user'-t protected_account = AccountProxy . new ( Fiók . új , 'felhasználó' ) protected_account . letét ( 20 ) védett_számla . visszavonja ( 10 ) a védett_fiókot helyezi el . egyensúly puts 'as admin' protected_account = AccountProxy . new ( Fiók . új , 'admin' ) protected_account . letét ( 20 ) védett_számla . visszavonja ( 10 ) a védett_fiókot helyezi el . egyensúly „ véget ” tesz modul Virtuális # Késlelteti a realSubject betöltését (lusta betöltés) # Proxy osztály AccountProxy def inicializálás ( local_balance = 0 ) @local_balance = local_balance vége def befizetés ( összeg ) @local_balance += összeg vége def visszavonása ( összeg ) @local_balance -= összeg vége def balance alany . egyensúly vége def tárgy @subject ||= Fiók . új ( @local_balance ) _ _ def self . a run a '=> Proxy::Virtual' parancsot tartalmazza local_account = AccountProxy . új helyi_fiók . letét ( 20 ) helyi_számla . visszavonja ( 10 ) local_account . letét ( 15 ) helyi_számla . A visszavonás ( 5 ) a 'Még nincs valódi számla:' értéket teszi a local_account . vizsgálja meg helyi_fiók . egyenleg elhelyezi a 'Valódi fiók létrehozva:' értéket a local_account . vizsgálja meg „ véget ” tesz def self . futtassa a védelmet . RunVirtual . _ futás vége vége

PHP5

Megvalósítási példa <?php /// Tárgy - tárgy /// meghatároz egy közös interfészt a Math és a "Proxy" között, így /// "Proxy" osztály bárhol használható interfész IMath { function Add ( $x , $y ); függvény Sub ( $x , $y ); függvény Mul ( $x , $y ); függvény Div ( $x , $y ); } /// RealSubject - a valós objektum /// a proxy által képviselt valós objektumot határozza meg class Math implements IMath { public function __construct () { print ( "Matek objektum létrehozása. Várj..." ); alvás ( 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 ;} public function Div ( $x , $y ){ return $x / $y ;} } /// Proxy - proxy /// olyan hivatkozást tárol, amely lehetővé teszi a proxy számára, hogy a valódi /// alanyra hivatkozzon. A "MathProxy" osztály objektum hozzáférhet a "Math" /// osztály objektumhoz, ha a "Math" és az "IMath" osztályok interfészei megegyeznek; /// az "IMath" interfésszel azonos felületet biztosít, így proxy /// mindig adható a valós alany helyére; /// szabályozza a valós alanyhoz való hozzáférést, és felelős lehet /// létrehozásáért és törléséért; /// egyéb feladatok a proxy típusától függenek: /// a távoli proxy felelős a kérés és argumentumai kódolásáért /// és a kódolt kérés elküldése a valós alanynak /// más címtérben; /// A virtuális proxy további információkat /// gyorsítótárazhat a valós alanyról, hogy késleltesse a létrehozását. /// a védőproxy ellenőrzi, hogy a hívó /// rendelkezik-e a kérés végrehajtásához szükséges engedélyekkel; class MathProxy implementálja az IMath-ot { protected $math ; public function __construct () { $this -> math = null ; } /// Gyors művelet - nem igényel valós alanyt public function Add ( $x , $y ) { return $x + $y ; } public function Sub ( $x , $y ) { return $x - $y ; } /// Lassú művelet - valós alany public function létrehozása szükséges Mul ( $x , $y ) { if ( $this -> math == null ) $this -> math = new Math (); return $this -> math -> Mul ( $x , $y ); } public function Div ( $x , $y ) { if ( $this -> math == null ) $this -> math = new Math (); return $this -> math -> Div ( $x , $y ); } } $p = új MathProxy ; // Végezzük el a matematikai nyomtatást ( "4 + 2 = " . $p -> Add ( 4 , 2 )); print ( "4 - 2 = " . $p -> Sub ( 4 , 2 )); print ( "4 * 2 = " . $p -> Mul ( 4 , 2 )); print ( "4 / 2 = " . $p -> Div ( 4 , 2 )); ?>

ActionScript

Megvalósítási példa //file IMath.as package { public interface IMath { function add ( a : Szám , b : Szám ) : Szám ; függvény al ( a : Szám , b : Szám ) : Szám ; függvény mul ( a : Szám , b : Szám ) : Szám ; függvény div ( a : szám , b : szám ) : szám ; } } //file MathSubject.as package { public class MathSubject implements IMath { public function add ( a : Number , b : Number ) : Number { return a + b ; } public function sub ( a : Szám , b : Szám ) : Szám { return a - b ; } public function mul ( a : Szám , b : Szám ) : Szám { return a * b ; } public function div ( a : Szám , b : Szám ) : Szám { return a / b ; } } } //file MathProxy.as package { public class MathProxy implements IMath { private var math : MathSubject ; public function MathProxy () { math = new MathSubject (); } public function add ( a : Szám , b : Szám ) : Szám { return math . add ( a , b ); } public function al ( a : Szám , b : Szám ) : Szám { return math . al ( a , b ); } public function mul ( a : Szám , b : Szám ) : Szám { return math . mul ( a , b ); } public function div ( a : Szám , b : Szám ) : Szám { if ( b != 0 ) return math . div ( a , b ); else { trace ( "Osztás nullával." ); visszatérési szám _ POSITIVE_INFINITY ; } } } } //fájl Main.as package { import flash.display.Sprite ; public class Main extends Sprite { public function Main () { playWithMath ( new MathSubject ()); playWithMath ( új MathProxy ()); } public function playWithMath ( math : IMath ) : void { trace ( math . add ( 5 , 0 )); nyom ( math . sub ( 5 , 0 )); nyom ( math . mul ( 5 , 0 )); nyomkövetés ( math . div ( 5 , 0 )); } } }

Python

Megvalósítási példa # -*- kódolás: utf-8 -*- class IMath : """Interfész proxyhoz és valós alanyhoz""" def add ( self , x , y ): emelés NotImplementedError () def sub ( self , x , y ): emelje a NotImplementedError () def mul ( self , x , y ): raise NotImplementedError () def div ( self , x , y ): emelés NotImplementedError () osztály Math ( IMath ): """Real tantárgy""" def add ( self , x , y ): return x + y def sub ( self , x , y ): return x - y def mul ( self , x , y ): return x * y def div ( self , x , y ): return x / y osztály Proxy ( IMath ): """ Proxy""" def __init__ ( self ): self . matematika = matematika () def add ( self , x , y ): return x + y def sub ( self , x , y ): return x - y def mul ( self , x , y ): önmagát adja vissza . matek . mul ( x , y ) def div ( self , x , y ): return float ( 'inf' ) , ha y == 0 else self . matek . 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

Megvalósítási példa Import rendszer.Threading Osztály MainApp Shared Sub Main () ' Matematikai proxy létrehozása Dim p As IMath = Új MathProxy () Csináld a matematikai konzolt . WriteLine ( "4 + 2 = " & p . Add ( 4 , 2 )) Konzol . WriteLine ( "4 - 2 = " & p . Subtr ( 4 , 2 )) Konzol . WriteLine ( "4 * 2 = " & p . Mul ( 4 , 2 )) Konzol . WriteLine ( "4/2 = " & p . Div ( 4 , 2 )) Várja meg a felhasználói konzolt . Olvassa el () End Sub End Class '''' <summary> '''' Tárgy - a ''' tárgya </summary> ''' <remarks> ''' <li> ''' A <lu> a <see cref="Math"/ számára közös > és <lásd a cref="Proxy"/> felületet, így a ''' osztály <see cref="Proxy"/> bárhol használható <see cref="Math"/></lu> ''' </ li> ''' </remarks> Nyilvános interfész IMath függvény Add ( ByVal x As Double , ByVal y As Double ) As Double Function Subtr ( ByVal x As Double , ByVal y As Double ) Mint Dupla függvény Mul ( ByVal x As Double , ByVal y ) As Double ) As Double Function Div ( ByVal x As Double , ByVal y As Double ) As Double End Interface '''' <summary> ''' RealSubject - a valós objektum ''' </summary> ''' <remarks> ''' <li> ''' <lu>a proxy által képviselt valós objektumot azonosítja</lu > '' ' </li> ''' </remarks> Az Osztály Math az IMAth -t valósítja meg Nyilvános Sub Új () Konzol . WriteLine ( "Matek objektum létrehozása. Várj..." ) Szál . Alvás ( 1000 ) Vége Sub Public Function Add ( ByVal x As Double , ByVal y As Double ) As Double Implements IMath . Adja hozzá a Return x + y End függvényt Public Function Subtr ( ByVal x As Double , ByVal y As Double ) As Double Implements IMath . Subtr Return x - y End Function Public Function Mul ( ByVal x As Double , ByVal y As Double ) As Double Implements IMath . Mul Return x * y End Function Public Function Div ( ByVal x As Double , ByVal y As Double ) As Double Implements IMath . Div Return x / y End Function végi osztály '''' <summary> '''' Proxy proxy ''' </summary> ''' <remarks> ''' <li> ''' <lu> olyan hivatkozást tárol, amely lehetővé teszi a proxy számára, hogy a valódi '' ' tárgyat . A <see cref="MathProxy"/> osztály objektumai hivatkozhatnak a ''' osztályba tartozó objektumokra <lásd cref="IMath"/>, ha az osztály interfészei <see cref="Math"/> és <lásd cref= Az "IMath"/ > megegyezik;</lu> '' <lu>azonos felületet biztosít, mint a <see cref="IMath"/>, így a ''' helyőrző mindig megadható a valódi alany;</lu> ''' < lu>szabályozza a valós alanyhoz való hozzáférést, és felelős lehet annak létrehozásáért ''' és törléséért;</lu> ''' <lu>egyéb feladatok a proxy típusától függenek : ''' <li> ''' <lu><b >távoli proxy</b> felelős a kérés és argumentumai ''' kódolásáért, valamint a kódolt kérés elküldéséért a valós alanynak egy másik címtérben '' ';</lu> '' A <lu><b>virtuális proxy</b> további információkat ''' gyorsítótárazhat a valódi alanyról, hogy késleltesse a létrehozását.</lu> ''' <lu><b> a proxy védelme</b> ellenőrzi, hogy a hívó '''' rendelkezik-e a kérés benyújtásához szükséges engedélyekkel; </lu> ''' </li> ''' </lu> ''' </li> ''' < /remarks> Az osztály MathProxy az IMath privát matematikát valósítja meg matematikaként = semmi '''' <summary> ''' Gyors művelet – nem igényel valós alanyt ''' </summary> Public Function Add ( ByVal x As Double , ByVal y As Double ) As Double Implements IMath . Adja hozzá a Return x + y End függvényt Public Function Subtr ( ByVal x As Double , ByVal y As Double ) As Double Implements IMath . Subtr Return x - y End Function '''' <summary> ''' Lassú művelet – valós alany létrehozása szükséges ''' </summary> Public Function Mul ( ByVal x As Double , ByVal y As Double ) As Double Implements IMath . Mul Ha a matek semmi , akkor matek = Új matematika () End If Return math . Mul ( x , y ) Végfüggvény _ Public Function Div ( ByVal x As Double , ByVal y As Double ) As Double Implements IMath . Div If math is Nothing then math = Új matematika () End If Return math . Div ( x , y ) Végfüggvény Végosztály _ _

Swift

Megvalósítási példa // tárgy protokoll egyezés { 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 } // Valódi tantárgy osztály 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 } } // Proxy osztály MatchProxy : Match { privát let math = MatchImp () func add ( x : Int , y : Int ) -> Int { return math . add ( x : x , y : y ) } func sub ( x : Int , y : Int ) -> Int { return math . al ( 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 ) } } // Proxy használata legyen proxy = MatchProxy () print ( "7 * 8 = \( proxy . mul ( x : 8 , y : 7 )) " )

Lásd még

  • Objektum utáni programozás

Jegyzetek

  1. ↑ Fejlesztői naplók // Proxy (downlink) . Letöltve: 2010. május 26. Az eredetiből archiválva : 2010. május 14.. 

Irodalom

  • CodeLIB.YOURS // Proxy archiválva : 2010. május 14. a Wayback Machine -nél
  • E. Gamma, R. Helm, R. Johnson, J. Vlissides . Objektumorientált tervezés technikái. Design Patterns.=Tervezési minták. Az újrafelhasználható objektum-orientált szoftver elemei. - Szentpétervár. : Péter, 2001. - 368 p. — ISBN 5-272-00355-1 .
  • Eric Freeman, Elizabeth Freeman, Kathy Siera, Bert Bates. Tervezési minták. - Szentpétervár. : Péter, 2012. - 656 p. - ISBN 978-5-459-00435-9 .

Linkek