Julkisivu (suunnittelukuvio)
Kokeneet kirjoittajat eivät ole vielä tarkistaneet sivun nykyistä versiota, ja se voi poiketa merkittävästi 4.7.2020 tarkistetusta
versiosta . tarkastukset vaativat
5 muokkausta .
Julkisivukuvio ( eng. Facade ) on rakenteellinen suunnittelukuvio, jonka avulla voit piilottaa järjestelmän monimutkaisuuden vähentämällä kaikki mahdolliset ulkoiset kutsut yhteen objektiin ja delegoimalla ne järjestelmän vastaaville objekteille.
Kuvaus
Ongelma
Kuinka saada aikaan yhtenäinen rajapinta, jossa on joukko erilaisia toteutuksia tai rajapintoja, esimerkiksi osajärjestelmään, jos vahva kytkentä kyseiseen osajärjestelmään ei ole toivottavaa tai osajärjestelmän toteutus saattaa muuttua?
Ratkaisu
Määritä yksi vuorovaikutuskohta alijärjestelmän kanssa - julkisivuobjekti, joka tarjoaa yhteisen rajapinnan osajärjestelmän kanssa, ja anna sille vastuu vuorovaikutuksesta sen komponenttien kanssa. Julkisivu on ulkoinen kohde, joka tarjoaa yhden sisääntulopisteen alijärjestelmäpalveluille. Muiden osajärjestelmän komponenttien toteutus on yksityistä, eikä ulkopuolisten komponenttien näkyvyys. Julkisivuobjekti tarjoaa Protected Variations -mallin GRASP -toteutuksen suojana alijärjestelmän toteutuksen muutoksilta.
Sovelluksen ominaisuudet
Mallia käytetään jonkinlaisen käytännön asettamiseen toiselle objektiryhmälle. Jos politiikan pitäisi olla kirkas ja havaittavissa, sinun tulee käyttää Julkisivumallin palveluita. Jos on tarpeen varmistaa salaisuus ja tarkkuus (läpinäkyvyys), Proxy -malli on sopivampi valinta .
Esimerkkejä
C++
Lähdeteksti
C++ :ssa
#include <iostream>
#sisällytä <merkkijono>
#sisällytä <muisti>
#include <string_view>
/** Abstrakti muusikko - ei pakollinen osa kaavaa, otettu käyttöön koodin yksinkertaistamiseksi */
luokan muusikko {
const char * nimi ;
julkinen :
Muusikko ( std :: merkkijonon_näkymänimi ) { _
tämä -> nimi = nimi . tiedot ();
}
virtuaalinen ~ Muusikko () = oletus ;
suojattu :
void output ( std :: string_view text ) {
std :: cout << tämä -> nimi << "" << teksti << "." << std :: endl ;
}
};
/** Tietyt muusikot */
luokan vokalisti : julkinen muusikko {
julkinen :
Laulaja ( std :: string_view nimi ) : muusikko ( nimi ) {}
void singCouplet ( int coupletNumber ) {
std :: string text = "sang verse #" ;
teksti += std :: merkkijonoon ( parinumero );
tuloste ( teksti );
}
void singChorus () {
tulos ( "lauli kuoron" );
}
};
luokka kitaristi : julkinen muusikko {
julkinen :
Kitaristi ( std :: string_view nimi ) : muusikko ( nimi ) {}
void playCoolOpening () {
output ( "alkaa hienolla introlla" );
}
void playCoolRiffs () {
lähtö ( "soittaa hienoja riffejä" );
}
void playAnotherCoolRiffs () {
output ( "soittaa muita hienoja riffejä" );
}
void playIncrediblyCoolSolo () {
output ( "saa uskomattoman siistiä sooloa" );
}
void playFinalAccord () {
output ( "päättää kappaleen voimakkaalla soinnolla" );
}
};
luokka Basisti : julkinen muusikko {
julkinen :
Basisti ( std :: string_view name ) : muusikko ( nimi ) {}
void followTheDrums () {
output ( "seuraa rullia" );
}
void changeRhythm ( std :: string_viewtype ) { _
std :: string text = ( "vaihtunut rytmiin" );
teksti += tyyppi ;
teksti += "a" ;
tuloste ( teksti );
}
void stopPlaying () {
lähtö ( "lopettaa toiston" );
}
};
luokan rumpali : julkinen muusikko {
julkinen :
Rumpali ( std :: string_view name ) : muusikko ( nimi ) {}
void startPlaying () {
output ( "alkaa toiston" );
}
void stopPlaying () {
lähtö ( "lopettaa toiston" );
}
};
/** Julkisivu, tässä tapauksessa kuuluisa rockbändi */
luokka BlackSabbath {
std :: ainutlaatuinen_ptr < Laulaja > vokalisti ;
std :: ainutlaatuinen_ptr < Kitaristi > kitaristi ;
std :: ainutlaatuinen_ptr < Basisti > basisti ;
std :: ainutlaatuinen_ptr < Drummer > rumpali ;
julkinen :
BlackSabbath () {
vokalisti = std :: make_unique < Laulaja > ( "Ozzy Osbourne" );
kitaristi = std :: make_unique < Guitarist > ( "Tony Iommi" );
basisti = std :: make_unique < Basisti > ( "Geezer Butler" );
rumpali = std :: make_unique < Drummer > ( "Bill Ward" );
}
void playCoolSong () {
kitaristi -> playCoolOpening ();
rumpali -> startPlaying ();
basisti -> followTheDrums ();
kitaristi -> playCoolRiffs ();
vokalisti -> laulaa Couplet ( 1 );
basisti -> changeRhythm ( "koorus" );
kitaristi -> playAnotherCoolRiffs ();
vokalisti -> singChorus ();
basisti -> changeRhythm ( "jae" );
kitaristi -> playCoolRiffs ();
vokalisti -> laulaa Couplet ( 2 );
basisti -> changeRhythm ( "koorus" );
kitaristi -> playAnotherCoolRiffs ();
vokalisti -> singChorus ();
basisti -> changeRhythm ( "jae" );
kitaristi -> playIncrediblyCoolSolo ();
kitaristi -> playCoolRiffs ();
laulaja -> laulaa Couplet ( 3 );
basisti -> changeRhythm ( "koorus" );
kitaristi -> playAnotherCoolRiffs ();
vokalisti -> singChorus ();
basisti -> changeRhythm ( "jae" );
kitaristi -> playCoolRiffs ();
basisti -> lopettaa toiston ();
rumpali -> stopPlaying ();
kitaristi -> playFinalAccord ();
}
};
int main () {
std :: cout << "OUTPUT:" << std :: endl ;
BlackSabbath bändi ;
bändi . playCoolSong ();
paluu 0 ;
}
/**
* TULOS:
* Tony Iommi aloittaa hienolla introlla.
* Bill Ward alkaa pelata.
* Geezer Butler seuraa rumpuja.
* Tony Iommi soittaa upeita riffejä.
* Ozzy Osbourne lauloi säkeen #1.
* Geezer Butler siirtyi kuororytmiin.
* Tony Iommi soittaa muita hienoja riffejä.
* Ozzy Osbourne lauloi kuoron.
* Geezer Butler vaihtoi säkeen rytmiin.
* Tony Iommi soittaa upeita riffejä.
* Ozzy Osbourne lauloi säkeen #2.
* Geezer Butler siirtyi kuororytmiin.
* Tony Iommi soittaa muita hienoja riffejä.
* Ozzy Osbourne lauloi kuoron.
* Geezer Butler vaihtoi säkeen rytmiin.
* Tony Iommi esittää uskomattoman upean soolo.
* Tony Iommi soittaa upeita riffejä.
* Ozzy Osbourne lauloi säkeen #3.
* Geezer Butler siirtyi kuororytmiin.
* Tony Iommi soittaa muita hienoja riffejä.
* Ozzy Osbourne lauloi kuoron.
* Geezer Butler vaihtoi säkeen rytmiin.
* Tony Iommi soittaa upeita riffejä.
* Geezer Butler lopettaa pelaamisen.
* Bill Ward lopettaa pelaamisen.
* Tony Iommi päättää kappaleen voimakkaalla soinnuksella.
*/
JavaScript
JavaScript lähdekoodi
/* Monimutkaiset osat */
toiminto SubSystem1 () {
this . menetelmä1 = funktio () {
konsoli . loki ( "SubSystem1.method1 kutsutaan" );
};
}
function SubSystem2 () {
tämä . metodi2 = funktio () {
konsoli . loki ( "SubSystem2.method2 kutsutaan" );
};
tämä . metodiB = function () {
konsoli . loki ( "SubSystem2.methodB kutsutaan" );
};
}
/* Julkisivu */
toiminto Julkisivu () {
var s1 = new SubSystem1 (),
s2 = uusi osajärjestelmä2 ();
tämä . m1 = funktio () {
konsoli . loki ( "Facade.m1 kutsutaan" );
s1 . menetelmä1 ();
s2 . menetelmä 2 ();
};
tämä . m2 = funktio () {
konsoli . loki ( "Julkisivu.m2 kutsuttu" );
s2 . menetelmä B ();
};
}
/* Asiakas */
toimintotesti () { var facade = new Julkisivu ( ); julkisivu . m1 (); julkisivu . m2 (); }
testi ();
/*
Tulos:
"Facade.m1 kutsutaan"
" SubSystem1.method1 kutsutaan
"
"SubSystem2.method2 kutsutaan" "Julkisivu.m2 kutsutaan" "SubSystem2.methodB kutsutaan
"
*/
CoffeeScript
Lähdeteksti
CoffeeScript -kielellä
#
Kuvanlatausluokka ImageLoader loadImage = (src) -> # ...
rakentaja : (hash = {}) ->
@images = { }
@images [ nimi ] = loadImage ( src ) nimelle , tiivisteen src
#
Äänilatausluokka SoundLoader loadSound = (src) -> # ...
rakentaja : ( hash = {}) ->
@äänet = {}
@ äänet [ nimi ] = loadSound ( src ) nimelle , tiivisteen src
# Julkisivuluokka
Loader konstruktori : ({kuvat, äänet}) -> @images = uusi ImageLoader ( kuvat ). kuvat @sounds = uusi SoundLoader ( sounds ). ääniä
ääni : (nimi) ->
@äänet [ nimi ]
kuva : (nimi) ->
@images [ nimi ]
PHP
PHP lähdekoodi
/**
* Yksittäisten tietokoneen osien toteutukset.
* Jokaisella luokkametodilla on jonkinlainen toteutus, tässä esimerkissä se on jätetty pois.
*/
/**
* Luokan CPU, joka vastaa CPU:n suorittamisesta
*/
luokan CPU
{
public function freeze () {}
public function jump ( $position ) {}
public function execute () {}
}
/**
* Luokkamuisti, joka vastaa muistin toiminnasta
*/
luokka Muisti
{
const BOOT_ADDRESS = 0x0005 ;
julkisen funktion kuormitus ( $sijainti , $data ) {}
}
/**
* Luokan kiintolevy, joka vastaa kiintolevyn toiminnasta
*/
luokan kiintolevy
{
const BOOT_SECTOR = 0x001 ;
const SEKTORIN KOKO = 64 ;
julkinen funktio luettu ( $lba , $size ) {}
}
/**
* Esimerkki "Julkisivu" -kuviosta
* Tietokonetta käytetään yhtenäisenä kohteena.
* Tämän esineen takana piilotetaan kaikki sen sisäisten osien työn yksityiskohdat.
*/
luokka Tietokone
{
suojattu $cpu ;
suojattu $muisti ;
suojattu $kovalevy ;
/**
* Tietokonekonstruktori.
* Alusta osat
*/
julkinen toiminto __construct ()
{
$this -> cpu = uusi CPU ();
$this -> muisti = uusi Muisti ();
$this -> kovalevy = uusi kovalevy ();
}
/**
* Yksinkertaistettu "tietokoneen käynnistyksen" -käyttäytymisen käsittely
*/
public function startComputer ()
{
$cpu = $this -> cpu ;
$muisti = $tämä -> muisti ;
$kovalevy = $this -> kovalevy ;
$cpu -> jäädyttää ();
$muisti -> lataa (
$muisti :: BOOT_ADDRESS ,
$kovalevy -> lue ( $kovalevy :: BOOT_SECTOR , $kovalevy :: SECTOR_SIZE )
);
$cpu -> hyppy ( $muisti :: BOOT_ADDRESS );
$cpu -> suorita ();
}
}
/**
* Tietokoneen käyttäjät saavat julkisivun (tietokoneen)
*, joka piilottaa yksittäisten komponenttien kanssa työskentelyn monimutkaisuuden.
*/
$tietokone = uusi Tietokone ();
$tietokone -> aloitaTietokone ();
Python
Lähdekoodi
Pythonissa
# Järjestelmäluokan CPU ( objekti ) monimutkaiset osat: def __init__ ( self ) : # ... pass
def freeze ( itse ):
# ...
pass
def jump ( itse , osoite ):
# ...
pass
def execute ( itse ):
# ...
pass
luokka Muisti ( objekti ):
def __init__ ( self ):
# ...
pass
def load ( itse , sijainti , data ):
# ...
pass
luokka Kiintolevy ( objekti ):
def __init__ ( self ):
# ...
pass
def read ( self , lba , size ):
# ...
pass
# Julkisivuluokka
Tietokone ( objekti ): def __init__ ( self ) : itse . _cpu = cpu () itse . _memory = Muisti () itse . _harddrive = kovalevy ()
def startComputer ( itse ):
itse . _cpu . jäädyttää ()
itsensä . _muisti . lataa ( BOOT_ADDRESS , itse . _kovalevy . lue ( BOOT_SECTOR , SECTOR_SIZE ))
itse . _cpu . hypätä ( BOOT_ADDRESS )
itse . _cpu . suorittaa ()
# Asiakaspuoli
if __name__ == "__main__" :
julkisivu = Tietokone ()
julkisivu . startComputer ()
C#
Lähdeteksti
C#
käyttäen System ;
nimiavaruuskirjasto { ///
<summary> /// Alijärjestelmäluokka /// </summary> /// <remarks> /// <li> /// <lu>toteuttaa alijärjestelmän toiminnallisuuden;</lu> /// <lu>tekee objektin määräämän työn <katso cref="Julkisivu"/>;</lu> /// <lu>ei "tiedä" mitään julkisivun olemassaolosta, eli se ei tallenna viittaukset siihen;</lu> / // </li> /// </remarks> sisäinen luokka AlijärjestelmäA { sisäinen merkkijono A1 () { return "Alijärjestelmä A, menetelmä A1\n" ; } sisäinen merkkijono A2 () { return "Alijärjestelmä A, menetelmä A2\n" ; } } sisäinen luokka AlijärjestelmäB { sisäinen merkkijono B1 () { return "Alijärjestelmä B, menetelmä B1\n" ; } } sisäinen luokka AlijärjestelmäC { sisäinen merkkijono C1 () { return "Alijärjestelmä C, menetelmä C1\n" ; } } }
/// <summary>
/// Julkisivu - julkisivu
/// </summary>
/// <remarks>
/// <li>
/// <lu>"tietää" millä alijärjestelmäluokilla pyyntö osoitetaan;< /lu >
/// <lu>delegaa asiakaspyynnöt asianmukaisille objekteille alijärjestelmässä;</lu>
/// </li>
/// </remarks>
public class Julkisivu
{
Kirjasto . AlijärjestelmäA a = uusi kirjasto . AlijärjestelmäA ();
kirjasto . AlijärjestelmäB b = uusi kirjasto . AlijärjestelmäB ();
kirjasto . AlijärjestelmäC c = uusi kirjasto . AlijärjestelmäC ();
public void Käyttö1 ()
{
Konsoli . WriteLine ( "Operaatio 1\n" +
a . A1 () +
a . A2 () +
b . B1 ());
}
public void Operation2 ()
{
Konsoli . WriteLine ( "Toiminto 2\n" +
b . B1 () +
c . C1 ());
}
}
class Ohjelma
{
static void Main ( string [] args )
{
Julkisivu julkisivu = uusi Julkisivu ();
julkisivu . Operaatio1 ();
julkisivu . Operaatio2 ();
// Odota käyttäjän
konsolia . lue ();
}
}
Ruby
Lähdeteksti
rubiinin kielellä
moduulin kirjasto
# <summary>
# Alajärjestelmän luokka
# </summary>
# <remarks>
# <li>
# <lu>toteuttaa alijärjestelmän toiminnallisuuden;</lu>
# <lu>tekee <katso cref="Facade"/> määrittämän työn ;</lu>
# <lu>ei "tiedä" mitään julkisivun olemassaolosta, eli ei tallenna viittauksia siihen;</lu>
# </li>
# </remarks>
class SubsystemA
def a1 ; "Alijärjestelmä A, menetelmä a1 \n " ; enddef
a2 ; _ "Alijärjestelmä A, menetelmä a2 \n " ; loppu loppu
luokka AlijärjestelmäB
def b1 ; "Alijärjestelmä B, menetelmä b1 \n " ; loppu
loppu
luokka SubsystemC
def c1 ; "Alijärjestelmä C, menetelmä c1 \n " ; loppu
loppu
loppu
# <summary>
# Julkisivu
# </summary>
# <remarks>
# <li>
# <lu>"tietää" mihin alijärjestelmäluokkiin pyynnöt osoitetaan;</lu>
# <lu>delegoi pyynnöt asiakkaille asianmukaisille objekteille sisällä alijärjestelmä ;</lu>
# </li>
# </remarks>
luokka Julkisivu
def initialize
@a = Kirjasto :: AlijärjestelmäA . uusi ;
@b = Kirjasto :: AlijärjestelmäB . uusi ;
@c = Kirjasto :: AlijärjestelmäC . uusi ;
loppu
def operation1
laittaa "Operation 1 \n " +
@a . a1 +
@a . a2 +
@b . b1
loppu
def operation2
laittaa "Operation 2 \n " +
@b . b1 () +
@c . c1 (
) loppupää
julkisivu = julkisivu . uusi
julkisivu . toiminta1
julkisivu . toiminta 2
# Odota, että käyttäjä
saa
VB.NET
Lähdeteksti
VB.NET -kielellä
Nimitilan kirjasto
'Alijärjestelmäluokka
' . toteuttaa osajärjestelmän toiminnallisuuden
”. suorittaa Julkisivuobjektin määräämän työn
. ei "tiedä" mitään julkisivun olemassaolosta, eli se ei tallenna viittauksia siihen
Friend Class SubsystemA
Friend Function A1 () Kuten merkkijono
Return "Subsystem A, Method A1" & vbCrLf
End Function
Ystäväfunktio A2 () Merkkijonona Palautus " Alijärjestelmä A , menetelmä A2 " & vbCrLf loppufunktion loppuluokka
Ystäväluokka AlijärjestelmäB Ystäväfunktio B1 () merkkijonona Palautus " Alijärjestelmä B , menetelmä B1 " & vbCrLf loppufunktion
loppuluokka
Friend Class SubsystemC
Ystäväfunktio C1 () merkkijonona Palautus " Alijärjestelmä C, menetelmä C1" & vbCrLf End Function End Class
lopeta nimiavaruus
'Julkisivu
'. "tietää", mitkä alajärjestelmäluokat pyyntöön tulee vastata
' . delegoi asiakaspyynnöt asianmukaisille objekteille
Public NotInheritable Class Facade -alijärjestelmässä
Yksityinen ala Uusi ()
End Sub
Jaettu uutena kirjastona . _ _ AlijärjestelmäA ( ) Jaettu b Uutena kirjastona . AlijärjestelmäB ( ) Jaettu c Uutena kirjastona . Alijärjestelmä C ()
Julkinen jaettu alitoiminto1 ( ) Konsoli . WriteLine ( "Operaatio 1" & vbCrLf & a . A1 () & a . A2 () & b . B1 ()) Loppu ala
Julkinen jaettu alitoiminto2 ( ) -konsoli . WriteLine ( "Operation 2" & vbCrLf & b . B1 () & c . C1 ()) End Sub End Class
luokan ohjelma
Jaettu Sub Main ()
Julkisivu . Käyttö1 ()
Julkisivu . Operaatio 2 ()
'Odotetaan käyttäjän toimia
Konsoli . Lue ()
Lopeta Sub
End Class
Delphi
Lähdeteksti
Delphissä
ohjelma FacadePattern ;
{$APPTYPE CONSOLE}
käyttää
SysUtilsia ;
tyyppi
TComputer = luokka
julkinen
menettely PlugIn ;
menettely PowerMonitor ;
menettely ; teho ;
loppu ;
menettely TComputer . Plug In ;
begin
WriteLn ( 'Sisältyy verkkoon' ) ;
loppu ;
menettely TComputer . PowerMonitor ;
begin
WriteLn ( 'Kytke näyttö päälle' ) ;
loppu ;
menettely TComputer . teho ;
begin
WriteLn ( 'Käännä järjestelmäyksikköä' ) ;
loppu ;
tyyppi
TNotebook = luokkamenettely
Power ; _ loppu ;
menettely TNotebook . teho ;
begin
WriteLn ( 'Paina virtapainiketta' ) ;
loppu ;
tyyppi
TKettle = luokkamenettely
PlugIn ; _ menettely ; teho ; loppu ;
menettely TKettle . teho ;
begin
WriteLn ( 'Paina virtapainiketta' ) ;
loppu ;
menettely TKettle . Plug In ;
begin
WriteLn ( 'Sisältyy verkkoon' ) ;
loppu ;
tyyppi
TFacade = luokka
julkinen
menettely PowerOn ( aDevice : TObject ) ;
loppu ;
menettely TFacade . PowerOn ( aDevice : TObject ) ;
aloita
jos aDevice on TComputer , aloita sitten
TComputerilla ( aDevice ) PlugIn ; _ PowerMonitor ; teho ; loppu ;
jos aLaite on TNotebook ,
käytä TNotebookilla ( aDevice ) virtaa ; _
jos aDevice on TKettle ,
aloita PlugIn sovelluksella TKettle ( aDevice ) ; _
teho ; loppu ;
WriteLn
end ;
alkaa
TFacadella . _ Luo kokeile PowerOn ( TComputer . Create ) ; _ PowerOn ( TNotebook.Create ) ; _ _ PowerOn ( TKettle.Create ) ; _ _ vihdoin vapaa ; loppu ; Readln ; loppua .
Java
Java lähde
/* Monimutkaiset osat */
luokan CPU {
public void freeze () {
System . ulos . println ( "jäädyttää" );
}
public void hyppy ( pitkä asento ) {
System . ulos . println ( "hyppysento = " + sijainti );
}
public void execute () {
Järjestelmä . ulos . println ( "suorita" );
}
}
luokka Muisti {
public void load ( pitkä sijainti , tavu [] data ) {
System . ulos . println ( "load position = " + position + ", data = " + data );
}
}
luokka Kiintolevy {
julkinen tavu [ ] lue ( pitkä lba , int koko ) {
Järjestelmä . ulos . println ( "lue lba = " + lba + ", koko = " + koko );
palauttaa uuden tavun [ koko ] ;
}
}
/* Julkisivu */
luokka Tietokone {
yksityinen lopullinen staattinen pitkä BOOT_ADDRESS = 1L ;
yksityinen lopullinen staattinen pitkä BOOT_SECTOR = 2L ;
yksityinen lopullinen staattinen int SECTOR_SIZE = 3 ;
yksityinen CPU CPU ;
yksityinen muisti ; _ yksityinen kiintolevy kovalevy ;
julkinen tietokone () {
tämä . cpu = uusi suoritin ();
tämä . muisti = uusi Muisti ();
tämä . kovalevy = uusi kovalevy ();
}
public void startComputer () {
cpu . jäädyttää ();
muisti . lataa ( BOOT_ADDRESS , kovalevy . lue ( BOOT_SECTOR , SECTOR_SIZE ));
prosessori . hypätä ( BOOT_ADDRESS );
prosessori . suorittaa ();
}
}
/* Asiakas */
class Sovellus {
public static void main ( String [] args ) {
Tietokonetietokone = uusi Tietokone ( ); tietokone . startComputer (); } }
haxe
Lähdeteksti
haxen kielellä
/**
* Yksittäisten tietokoneen osien toteutukset.
* Jokaisella luokkametodilla on jonkinlainen toteutus, tässä esimerkissä se on jätetty pois.
*/
/**
* Luokka CPU, joka vastaa prosessorin toiminnasta
*/
luokka CPU {
julkinen toiminto uusi () {
}
julkinen funktio jäädyttää (): Void {
//...
}
julkisen funktion hyppy ( sijainti : Int ): Void {
//...
}
julkinen toiminto suorita (): Void {
//...
}
}
/**
* Luokkamuisti, joka vastaa muistin toiminnasta
*/
luokka Muisti {
public static inline var BOOT_ADDRESS
: Int = 0x0005 ;
julkinen toiminto uusi () {
}
julkinen funktion lataus ( sijainti : Int , data : haxe . io . Tavut ): Void {
//...
}
}
/**
* Luokan kiintolevy, joka vastaa kiintolevyn toiminnasta
*/
luokka HardDrive {
public static inline var BOOT_SECTOR
: Int = 0x001 ;
julkinen staattinen rivin muuttuja SECTOR_SIZE
: Int = 64 ;
julkinen toiminto uusi () {
}
julkinen funktio luettu ( lba : Int , koko : Int ): haxe . io . Bytes {
//...
return null ;
}
}
/**
* Esimerkki "Julkisivu" -kuviosta
* Tietokonetta käytetään yhtenäisenä kohteena.
* Tämän esineen takana piilotetaan kaikki sen sisäisten osien työn yksityiskohdat.
*/
luokka Tietokone {
yksityinen var cpu
: CPU ;
yksityinen var muisti
: Muisti ;
yksityinen var kovalevy
: Kiintolevy ;
/**
* Tietokonekonstruktori.
* Alusta osat
*/
julkinen toiminto uusi () {
this . cpu = uusi suoritin ();
tämä . muisti = uusi Muisti ();
tämä . kovalevy = uusi kovalevy ();
}
/**
* Yksinkertaistettu "tietokoneen käynnistyksen" käsittely
*/
public function startComputer (): Void {
cpu . jäädyttää ();
muisti . lataus (
Muisti . BOOT_ADDRESS ,
kovalevy . lue ( Kiintolevy . BOOT_SECTOR , Kiintolevy . SECTOR_SIZE )
);
prosessori . hypätä ( Memory.BOOT_ADDRESS ) ; _ prosessori . suorittaa (); } }
/**
* Tietokoneen käyttäjät saavat julkisivun (tietokoneen)
*, joka piilottaa yksittäisten komponenttien kanssa työskentelyn monimutkaisuuden.
*/
luokka Sovellus {
julkinen staattinen toiminto pää (): Void {
var tietokone
: Tietokone = uusi tietokone ();
tietokone . startComputer ();
}
}
Swift
Nopea lähdekoodi
// Logiikkaluokan CPU {
public func freeze () -> String {
return "Jäädytetään prosessori."
}
julkinen toimintohyppy ( sijainti : merkkijono ) -> merkkijono { return "Siirrytään kohteeseen: \ ( position ) " }
public func execute () -> String {
return "Suoritetaan."
}
}
luokka muisti {
public func load ( sijainti : merkkijono , tiedot : merkkijono ) -> merkkijono {
return "Ladataan kohteesta \( sijainti ) data: \( data ) "
}
}
luokan kiintolevy {
public func read ( lba : merkkijono , koko : merkkijono ) -> merkkijono {
return "Joitakin tietoja sektorista \( lba ) , jonka koko on \( koko ) "
}
}
//
Julkisivuluokka ComputerFacade {
yksityinen anna prosessori = CPU ()
yksityinen anna muisti = Muisti ()
yksityinen anna kiintolevy = HardDrive ()
public func start () {
cpu . jäädyttää ()
anna ssd = kovalevy . luku ( lba : "100" , koko : "1024" )
muisti . lataus ( sijainti : "0x00" , tiedot : ssd )
suoritin . hyppy ( sijainti : "0x00" )
prosessori . suorita ()
}
}
// Client
let pc = ComputerFacade ()
pc . aloita ()
Kirjallisuus
- E. Gamma, R. Helm, R. Johnson, J. Vlissides . Olio-suunnittelun tekniikat. Suunnittelumallit = Suunnittelumallit: Uudelleenkäytettävän olio-ohjelmiston elementit. - Pietari. : " Peter ", 2007. - S. 366. - ISBN 978-5-469-01136-1 . (myös ISBN 5-272-00355-1 )
Lähteet ja linkit