Homlokzat (tervminta)
Az oldal jelenlegi verzióját még nem ellenőrizték tapasztalt közreműködők, és jelentősen eltérhet a 2020. július 4-én felülvizsgált
verziótól ; az ellenőrzések 5 szerkesztést igényelnek .
A homlokzati minta ( eng. Facade ) egy szerkezeti tervezési minta , amely lehetővé teszi a rendszer összetettségének elrejtését azáltal, hogy az összes lehetséges külső hívást egyetlen objektumra csökkenti , és delegálja azokat a rendszer megfelelő objektumaira.
Leírás
Probléma
Hogyan biztosíthatunk egységes interfészt különböző megvalósításokkal vagy interfészekkel, például egy alrendszerhez, ha nem kívánatos az erős csatolás ahhoz az alrendszerhez, vagy az alrendszer megvalósítása megváltozhat?
Megoldás
Határozzon meg egy interakciós pontot az alrendszerrel - egy homlokzati objektumot, amely közös interfészt biztosít az alrendszerrel, és bízza rá az összetevőivel való interakcióért. A homlokzat egy külső objektum, amely egyetlen belépési pontot biztosít az alrendszer-szolgáltatások számára. A többi alrendszer-összetevő megvalósítása privát, és nem látható a külső összetevők számára. A homlokzati objektum a Protected Variations minta GRASP megvalósítását biztosítja az alrendszer megvalósításának változásai elleni védelem szempontjából.
Az alkalmazás jellemzői
Egy sablon valamilyen házirend beállítására szolgál egy másik objektumcsoportra. Ha a házirendnek világosnak és észrevehetőnek kell lennie, használja a Homlokzati sablon szolgáltatásait. Ha szükséges a titkosság és a pontosság (átláthatóság) biztosítása, a Proxy minta megfelelőbb választás .
Példák
C++
Forrásszöveg
C++ nyelven
#include <iostream>
#include <karakterlánc>
#include <memória>
#include <karakterlánc_nézet>
/** Absztrakt zenész – nem kötelező része a mintának, a kód egyszerűsítése érdekében vezették be */
osztály zenész {
const char * név ;
nyilvános :
Zenész ( std :: string_viewname ) { _
ez -> név = név . adatok ();
}
virtual ~ Zenész () = alapértelmezett ;
védett :
void output ( std :: string_view text ) {
std :: cout << ez -> név << "" << szöveg << "." << std :: endl ;
}
};
/** Meghatározott zenészek */
osztály Énekes : nyilvános zenész {
nyilvános :
Énekes ( std :: string_view név ) : Zenész ( név ) {}
void singCouplet ( int coupletNumber ) {
std :: string text = "énekelt vers #" ;
szöveg += std :: to_karakterlánc ( coupletNumber );
kimenet ( szöveg );
}
void singChorus () {
output ( "énekelte a refrént" );
}
};
osztály Gitáros : közzenész { _
nyilvános :
Gitáros ( std :: string_view név ) : Zenész ( név ) {}
void playCoolOpening () {
output ( "menő intróval kezdődik" );
}
void playCoolRiffs () {
kimenet ( "menő riffeket játszik le" );
}
void playAnotherCoolRiffs () {
kimenet ( "más menő riffeket játszik le" );
}
void playIncrediblyCoolSolo () {
output ( "hihetetlenül menő szólót ad ki" );
}
void playFinalAccord () {
output ( "erőteljes akkorddal fejezi be a dalt" );
}
};
osztály basszusgitáros : publikus zenész {
nyilvános :
Basszusgitáros ( std :: string_view név ) : Zenész ( név ) {}
void followTheDrums () {
output ( "követi a tekercseket" );
}
void changeRhythm ( std :: string_viewtype ) { _
std :: string text = ( "ritmusra kapcsolva" );
szöveg += típus ;
szöveg += "a" ;
kimenet ( szöveg );
}
void stopPlaying () {
kimenet ( "leállítja a lejátszást" );
}
};
osztály Dobos : közzenész { _
nyilvános :
Dobos ( std :: string_view név ) : zenész ( név ) {}
void startPlaying () {
output ( "elkezd játszani" );
}
void stopPlaying () {
kimenet ( "leállítja a lejátszást" );
}
};
/** Homlokzat, jelen esetben egy híres rockzenekar */
class BlackSabbath {
std :: egyedi_ptr < Énekes > énekes ;
std :: egyedi_ptr < Gitáros > gitáros ;
std :: egyedi_ptr < Basszusgitár > basszusgitáros ;
std :: egyedi_ptr < Dobos > dobos ;
nyilvános :
BlackSabbath () {
vokalista = std :: make_unique < Vocalist > ( "Ozzy Osbourne" );
gitáros = std :: make_unique < Gitáros > ( "Tony Iommi" );
basszusgitár = std :: make_unique < Bassist > ( "Geezer Butler" );
dobos = std :: make_unique < Drummer > ( "Bill Ward" );
}
void playCoolSong () {
gitáros -> playCoolOpening ();
dobos -> startPlaying ();
basszusgitáros -> FollowTheDrums ();
gitáros -> playCoolRiffs ();
énekes -> singCouplet ( 1 );
basszusgitáros -> changeRhythm ( "kórus" );
gitáros -> playAnotherCoolRiffs ();
énekes -> singChorus ();
basszusgitáros -> changeRhythm ( "vers" );
gitáros -> playCoolRiffs ();
énekes -> singCouplet ( 2 );
basszusgitáros -> changeRhythm ( "kórus" );
gitáros -> playAnotherCoolRiffs ();
énekes -> singChorus ();
basszusgitáros -> changeRhythm ( "vers" );
gitáros -> playIncrediblyCoolSolo ();
gitáros -> playCoolRiffs ();
énekes -> singCouplet ( 3 );
basszusgitáros -> changeRhythm ( "kórus" );
gitáros -> playAnotherCoolRiffs ();
énekes -> singChorus ();
basszusgitáros -> changeRhythm ( "vers" );
gitáros -> playCoolRiffs ();
basszusgitáros -> lejátszás leállítása ();
dobos -> stopPlaying ();
gitáros -> playFinalAccord ();
}
};
int main () {
std :: cout << "OUTPUT:" << std :: endl ;
BlackSabbath zenekar ;
zenekar . playCoolSong ();
return 0 ;
}
/**
* KIMENET:
* Tony Iommi egy klassz bevezetővel kezdi.
* Bill Ward játszani kezd.
* Geezer Butler követi a dobokat.
* Tony Iommi remek riffeket játszik.
* Ozzy Osbourne az 1. verset énekelte.
* Geezer Butler kórusritmusra váltott.
* Tony Iommi más menő riffeket játszik.
* Ozzy Osbourne énekelte a refrént.
* Geezer Butler a vers ritmusára váltott.
* Tony Iommi remek riffeket játszik.
* Ozzy Osbourne a 2. verset énekelte.
* Geezer Butler kórusritmusra váltott.
* Tony Iommi más menő riffeket játszik.
* Ozzy Osbourne énekelte a refrént.
* Geezer Butler a vers ritmusára váltott.
* Tony Iommi hihetetlenül menő szólót ad elő.
* Tony Iommi remek riffeket játszik.
* Ozzy Osbourne a 3. verset énekelte.
* Geezer Butler kórusritmusra váltott.
* Tony Iommi más menő riffeket játszik.
* Ozzy Osbourne énekelte a refrént.
* Geezer Butler a vers ritmusára váltott.
* Tony Iommi remek riffeket játszik.
* Geezer Butler abbahagyja a játékot.
* Bill Ward abbahagyja a játékot.
* Tony Iommi egy erőteljes akkorddal zárja a dalt.
*/
JavaScript
JavaScript forráskód
/* Összetett részek */
function SubSystem1 () {
this . metódus1 = function () {
konzol . log ( "SubSystem1.method1 hívva" );
};
}
function SubSystem2 () {
this . metódus2 = function () {
konzol . log ( "SubSystem2.method2 hívva" );
};
ezt . MetódusB = function () {
konzol . log ( "SubSystem2.methodB meghívva" );
};
}
/* Homlokzat */
function Homlokzat () {
var s1 = new SubSystem1 (),
s2 = new SubSystem2 ();
ezt . m1 = függvény () {
konzol . log ( "Facade.m1 hívva" );
s1 . 1. módszer ();
s2 . 2. módszer ();
};
ezt . m2 = függvény () {
konzol . log ( "Facade.m2 hívva" );
s2 . B módszer ();
};
}
/* Ügyfél */
funkcióteszt () { var facade = new Homlokzat ( ); homlokzat . m1 (); homlokzat . m2 (); }
teszt ();
/*
Kimenet:
"Facade.m1 called"
"SubSystem1.method1 called"
"SubSystem2.method2 called"
"Facade.m2 called"
"SubSystem2.methodB called"
*/
CoffeeScript
Forrásszöveg
CoffeeScript nyelven
# Képbetöltő
osztály ImageLoader
loadImage = (src) ->
# ...
konstruktor : (hash = {}) ->
@images = {}
@images [ név ] = loadImage ( src ) a névhez , a hash src
# Audio betöltő
osztály SoundLoader
loadSound = (src) ->
# ...
konstruktor : (hash = {}) ->
@hangok = {}
@hangok [ név ] = loadSound ( src ) a névhez , a hash src -jához
# Homlokzati
osztály Loader
konstruktor : ({képek, hangok}) ->
@images = new ImageLoader ( képek ). images
@sounds = új SoundLoader ( hangok ). hangokat
hang : (név) ->
@hangok [ név ]
kép : (név) ->
@images [ név ]
PHP
PHP forráskód
/**
* Egyedi számítógép-alkatrészek megvalósításai.
* Minden osztálymetódusnak van valamilyen megvalósítása, ebben a példában ez kimaradt.
*/
/**
* CPU osztály, a CPU futtatásáért felelős
*/
osztály CPU
{
public function freeze () {}
public function jump ( $pozíció ) {}
public function execute () {}
}
/**
* Osztálymemória, amely a memória működéséért felelős
*/
class Memória
{
const BOOT_ADDRESS = 0x0005 ;
nyilvános függvény betöltése ( $pozíció , $adatok ) {}
}
/**
* Osztályú merevlemez, amely a merevlemez működéséért felelős
*/
class HardDrive
{
const BOOT_SECTOR = 0x001 ;
const SECTOR_SIZE = 64 ;
nyilvános függvény beolvasása ( $lba , $size ) {}
}
/**
* Példa a "Homlokzat" mintára
* A számítógépet egységes objektumként használják.
* Az objektum mögött a belső részeinek munkájának minden részlete el lesz rejtve.
*/
class Computer
{
protected $cpu ;
védett $memória ;
védett $merevlemez ;
/**
* Számítógép-konstruktor.
* A részek inicializálása
*/
public function __construct ()
{
$this -> cpu = new CPU ();
$ez -> memória = új Memória ();
$this -> merevlemez = új merevlemez ();
}
/**
* A "számítógép indítása" viselkedés egyszerűsített kezelése
*/
public function startComputer ()
{
$cpu = $this -> cpu ;
$memória = $ez -> memória ;
$hardDrive = $this -> merevlemez ;
$cpu -> lefagy ();
$memory -> load (
$memory :: BOOT_ADDRESS ,
$hardDrive -> read ( $merevlemez :: BOOT_SECTOR , $hardDrive :: SECTOR_SIZE )
);
$cpu -> jump ( $memory :: BOOT_ADDRESS );
$cpu -> végrehajtás ();
}
}
/**
* A számítógép-felhasználók egy Homlokzatot (számítógépet)
* kapnak, amely elrejti az egyes összetevőkkel való munka bonyolultságát.
*/
$számítógép = új Számítógép ();
$számítógép -> startSzámítógép ();
Python
Forráskód
Pythonban
# A rendszerosztály CPU összetett részei ( objektum ): def __init__ ( self ): # ... pass
def freeze ( self ):
# ...
pass
def jump ( self , address ):
# ...
pass
def execute ( self ):
# ...
pass
osztály Memória ( objektum ):
def __init__ ( self ):
# ...
pass
def load ( self , position , data ):
# ...
pass
osztály Merevlemez ( objektum ):
def __init__ ( self ):
# ...
pass
def read ( self , lba , size ):
# ...
pass
# Homlokzati
osztály Számítógép ( objektum ):
def __init__ ( self ):
self . _cpu = cpu ()
self . _memory = Memória ()
én . _harddrive = merevlemez ()
def startComputer ( self ):
self . _cpu . lefagy ()
én . _memória . betöltés ( BOOT_ADDRESS , saját . _merevlemez . read ( BOOT_SECTOR , SECTOR_SIZE ))
self . _cpu . ugrás ( BOOT_ADDRESS )
önmaga . _cpu . végrehajtani ()
# Kliens oldal
if __name__ == "__main__" :
homlokzat = Számítógép ()
homlokzat . startComputer ()
C#
Forrásszöveg
C# nyelven
a rendszer használatával ;
névtér könyvtár
{
/// <summary>
/// Alrendszer osztály
/// </summary>
/// <remarks>
/// <li>
/// <lu>alrendszer funkcióit valósítja meg;</lu>
/// <lu>elvégzi az objektum által kijelölt munkát <lásd cref="Homlokzat"/>;</lu>
/// <lu>nem "tud" semmit a homlokzat létezéséről, azaz nem tárol hivatkozások rá;</lu>
/ // </li>
/// </remarks>
belső osztály AlrendszerA
{
belső string A1 ()
{
return "A alrendszer, A1 módszer\n" ;
}
belső string A2 ()
{
return "A alrendszer, A2 módszer\n" ;
}
}
belső osztály B alrendszer
{
belső string B1 ()
{
return "B alrendszer, B1 módszer\n" ;
}
}
belső osztály C alrendszer
{
belső string C1 ()
{
return "C alrendszer, C1 módszer\n" ;
}
}
}
/// <summary>
/// Homlokzat - homlokzat
/// </summary>
/// <remarks>
/// <li>
/// <lu>"tudja", hogy mely alrendszerosztályokkal kell kezelni a kérést;< /lu >
/// <lu>klienskérések delegálása az alrendszeren belüli megfelelő objektumokhoz;</lu>
/// </li>
/// </remarks>
public class Homlokzat
{
Library . AlrendszerA a = új könyvtár . AlrendszerA ();
könyvtár . B alrendszer b = új könyvtár . B alrendszer ();
könyvtár . C alrendszer c = új könyvtár . C alrendszer ();
public void Művelet1 ()
{
Konzol . WriteLine ( "Művelet 1\n" +
a . A1 () +
a . A2 () +
b . B1 ());
}
public void Művelet2 ()
{
Konzol . WriteLine ( "2. művelet\n" +
b . B1 () +
c . C1 ());
}
}
class Program
{
static void Main ( string [] args )
{
Homlokzati homlokzat = new Homlokzat ();
homlokzat . Művelet1 ();
homlokzat . Művelet2 ();
// Várja meg a felhasználói
konzolt . olvasni ();
}
}
Ruby
Forrás szöveg
rubin nyelven
modul Könyvtár
# <summary>
# Alrendszer osztály
# </summary>
# <remarks>
# <li>
# <lu>alrendszer működését valósítja meg;</lu>
# <lu>elvégzi a <see cref="Homlokzat"/> által kijelölt feladatot ;</lu>
# <lu>nem "tud" semmit a homlokzat létezéséről, vagyis nem tárol rá hivatkozásokat;</lu>
# </li>
# </remarks>
class SubsystemA
def a1 ; "A alrendszer, a1 módszer \n " ; enddef
a2 ; _ "A alrendszer, a2 módszer \n " ; vége vége
osztály B alrendszer
def b1 ; "B alrendszer, b1 módszer \n " ; vége
vége
osztály SubsystemC
def c1 ; "C alrendszer, c1 módszer \n " ; vége
vég
vége
# <summary>
# Homlokzat
# </summary>
# <remarks>
# <li>
# <lu>"tudja", hogy mely alrendszerosztályokhoz kell címezni a kéréseket;</lu>
# <lu>delegálja a kéréseket a kliensekhez a megfelelő objektumokhoz belül az alrendszer ;</lu>
# </li>
# </remarks>
osztály Homlokzat
def inicializálás
@a = Könyvtár :: AlrendszerA . új ;
@b = Könyvtár :: AlrendszerB . új ;
@c = Könyvtár :: C alrendszer . új ;
vége
A def operation1
az "Operation 1 \n " +
@a parancsot teszi . a1 +
@a . a2 +
@b . b1
vége
A def operation2
az "Operation 2 \n " +
@b parancsot teszi . b1 () +
@c . c1 ()
vége
vége
homlokzat = homlokzat . új
homlokzat . működés1
homlokzat . művelet2
# Várja meg, amíg a felhasználó
megkapja
VB.NET
Forrásszöveg
VB.NET nyelven
Névtér könyvtár
'Alrendszer osztály
' . megvalósítja az alrendszer funkcionalitását
”. elvégzi a Homlokzat objektum által kijelölt munkát
. nem "tud" semmit a homlokzat létezéséről, azaz nem tárol rá hivatkozásokat
Friend Class SubsystemA
Friend Function A1 () As String
Return "A alrendszer, Method A1" & vbCrLf
End Function
A2 barátfüggvény ( ) karakterláncként visszatér : " A alrendszer , A2 módszer " és vbCrLf végfüggvény végosztály
Friend Class B alrendszer
Barát függvény B1 () karakterláncként Visszatér " B alrendszer, B1 módszer " és vbCrLf zárófüggvény vége osztály
Friend Class C alrendszer
baráti függvény C1 () mint karakterlánc
Visszatér : "C alrendszer, C1 módszer " és vbCrLf
vége függvény
végosztály
névtér vége
'Homlokzat
'. "tudja", hogy mely alrendszerosztályokat kell kezelni a kérésnek
. delegálja a kliens kéréseket a megfelelő objektumokhoz a
Public Not Inheritable Class Facade alrendszeren belül
Privát Sub Új ()
Vége Sub
Megosztott egy Újként könyvtárat . _ AlrendszerA ( ) Megosztott b Új könyvtárként . AlrendszerB ( ) Megosztott c Új könyvtárként . C alrendszer ()
Nyilvános megosztott alművelet1 ( )
Konzol . WriteLine ( "Művelet 1" & vbCrLf & a . A1 () & a . A2 () és b . B1 ()) Vége Al
Nyilvános megosztott alművelet2 ( )
Konzol . WriteLine ( "Művelet 2" & vbCrLf & b . B1 () & c . C1 ())
End Sub
End Class
osztály programja
Közös al- fő ()
Homlokzat . Működés1 ()
Homlokzat . 2. művelet ()
'Várakozás felhasználói műveletre
Konzol . Olvassa el ()
End Sub
End Class
Delphi
Forrásszöveg
Delphiben
program FacadePattern ;
{$APPTYPE CONSOLE}
SysUtils-t használ ;
type
TComputer = osztály
nyilvános
eljárás PlugIn ;
eljárás PowerMonitor ;
eljárás Teljesítmény ;
vége ;
eljárás TComputer . Plug In ;
begin
WriteLn ( 'A hálózat része' ) ;
vége ;
eljárás TComputer . PowerMonitor ;
begin
WriteLn ( 'Kapcsolja be a monitort' ) ;
vége ;
eljárás TComputer . teljesítmény ;
begin
WriteLn ( 'Fordítsa el a rendszeregységet' ) ;
vége ;
típus
TNotebook = osztályeljárás
Teljesítmény ; _ vége ;
eljárás TNotebook . teljesítmény ;
begin
WriteLn ( 'Nyomja meg a bekapcsológombot' ) ;
vége ;
típus
TKettle = osztályeljárás
PlugIn ; _ eljárás Teljesítmény ; vége ;
eljárás TKettle . teljesítmény ;
begin
WriteLn ( 'Nyomja meg a bekapcsológombot' ) ;
vége ;
eljárás TKettle . Plug In ;
begin
WriteLn ( 'A hálózat része' ) ;
vége ;
típus
TFacade = osztály
nyilvános
eljárás PowerOn ( aDevice : TObject ) ;
vége ;
eljárás TFacade . Bekapcsolás ( aDevice : TObject ) ; Kezdje el , ha a Device a TComputer , akkor a TComputerrel ( aDevice ) kezdje meg a PlugIn -t ; PowerMonitor ; teljesítmény ; vége ;
ha a Device a TNotebook , akkor
a TNotebook ( aDevice ) segítségével tegye a
Powert ;
ha az aDevice a TKetle , akkor
a TKettle -vel ( aDevice ) kezdje el a
PlugIn -t ; teljesítmény ; vége ;
WriteLn
end ;
Kezdje a TFacade - dal . Létrehozása próbálja ki a
PowerOn ( TComputer . Create ) ; Bekapcsolás ( TNotebook.Create ) ; _ _ Bekapcsolás ( TKettle.Create ) ; _ _ végre Szabad ; vége ; Readln ; vége .
Java
Java forrás
/* Összetett részek */
class CPU {
public void freeze () {
Rendszer . ki . println ( "lefagy" );
}
public void jump ( hosszú pozíció ) {
Rendszer . ki . println ( "ugrási pozíció = " + pozíció );
}
public void execute () {
Rendszer . ki . println ( "végrehajtás" );
}
}
class Memória {
public void load ( long position , byte [ ] data ) {
System . ki . println ( "load position = " + position + ", data = " + data );
}
}
class Merevlemez {
public byte [ ] read ( long lba , int size ) {
System . ki . println ( "read lba = " + lba + ", size = " + size );
return new byte [ méret ] ;
}
}
/* Homlokzat */
class Számítógép {
private final static long BOOT_ADDRESS = 1L ;
privát végső statikus hosszú BOOT_SECTOR = 2L ;
privát végleges static int SECTOR_SIZE = 3 ;
privát CPU cpu ;
privát memória ; _ privát Merevlemez merevlemez ;
public Computer () {
this . cpu = új cpu ();
ezt . memória = új Memória ();
ezt . merevlemez = új merevlemez ();
}
public void startComputer () {
cpu . lefagy ();
memória . betöltés ( BOOT_ADDRESS , merevlemez . read ( BOOT_SECTOR , SECTOR_SIZE ));
cpu . ugrás ( BOOT_CÍM );
cpu . végrehajtani ();
}
}
/* Ügyfél */
class Alkalmazás {
public static void main ( String [] args ) {
Számítógép számítógép = new Computer ();
számítógép . startComputer ();
}
}
haxe
Haxe nyelvű forrásszöveg
/**
* Egyedi számítógép-alkatrészek megvalósításai.
* Minden osztálymetódusnak van valamilyen megvalósítása, ebben a példában ez kimaradt.
*/
/**
* Class CPU, felelős a processzor működéséért
*/
class CPU {
public function new () {
}
nyilvános függvény lefagyása (): Érvénytelen {
//...
}
nyilvános függvény ugrás ( pozíció : Int ): Érvénytelen {
//...
}
nyilvános függvény végrehajtása (): Érvénytelen {
//...
}
}
/**
* Class Memory, felelős a memória működéséért
*/
class Memória {
public static inline var BOOT_ADDRESS
: Int = 0x0005 ;
public function new () {
}
nyilvános függvény betöltése ( pozíció : Int , adatok : haxe . io . Bytes ): Void {
//...
}
}
/**
* Merevlemez-osztály, a merevlemez működéséért felelős
*/
osztály Merevlemez {
public static inline var BOOT_SECTOR
: Int = 0x001 ;
public static inline var SECTOR_SIZE
: Int = 64 ;
public function new () {
}
nyilvános függvény beolvasása ( lba : Int , méret : Int ): haxe . io . Bájtok {
//...
return null ;
}
}
/**
* Példa a "Homlokzat" mintára
* A számítógépet egységes objektumként használják.
* Az objektum mögött a belső részeinek munkájának minden részlete el lesz rejtve.
*/
class Computer {
private var cpu
: CPU ;
privát var memória
: Memória ;
private var merevlemez
: Merevlemez ;
/**
* Számítógép-konstruktor.
* A részek inicializálása
*/
public function new () {
this . cpu = új cpu ();
ezt . memória = új Memória ();
ezt . merevlemez = új merevlemez ();
}
/**
* A "számítógép indítása" viselkedés egyszerűsített kezelése
*/
public function startComputer (): Void {
cpu . lefagy ();
memória . betöltés (
Memória . BOOT_ADDRESS ,
merevlemez . olvasás ( Merevlemez . BOOT_SECTOR , Merevlemez . SECTOR_SIZE )
);
cpu . ugrás ( Memory.BOOT_ADDRESS ) ; _ cpu . végrehajtani (); } }
/**
* A számítógép-felhasználók egy Homlokzatot (számítógépet)
* kapnak, amely elrejti az egyes összetevőkkel való munka bonyolultságát.
*/
class Application {
public static function main (): Void {
var computer
: Computer = new Computer ();
számítógép . startComputer ();
}
}
Swift
Swift forráskód
// Logikai
osztályú CPU {
public func freeze () -> String {
return "A processzor lefagy."
}
public func jump ( pozíció : String ) -> String {
return "Ugrás ide: \( pozíció ) "
}
public func execute () -> String {
return "Végrehajtás."
}
}
osztály memória {
public func load ( pozíció : Karakterlánc , adatok : String ) -> String {
return "Betöltés innen: \( pozíció ) adatok: \( adatok ) "
}
}
osztályú merevlemez {
public func read ( lba : String , size : String ) -> String {
return "Néhány adat a \( lba ) szektorból \ ( méret ) mérettel " }
}
//Homlokzati
osztály ComputerFacade {
private let cpu = CPU ()
private let memory = Memória ()
private let hardDrive = Merevlemez ()
public func start () {
cpu . freeze ()
let ssd = merevlemez . olvasási ( lba : "100" , méret : "1024" )
memória . load ( pozíció : "0x00" , adatok : ssd )
cpu . ugrás ( pozíció : "0x00" )
cpu . végrehajtani ()
}
}
// Kliens
let pc = ComputerFacade ()
pc . kezdés ()
Irodalom
- E. Gamma, R. Helm, R. Johnson, J. Vlissides . Objektumorientált tervezés technikái. Tervezési minták = Design Patterns: Az újrafelhasználható objektum-orientált szoftver elemei. - Szentpétervár. : " Péter ", 2007. - S. 366. - ISBN 978-5-469-01136-1 . ( ISBN 5-272-00355-1 is )
Források és linkek