Table of Contents

ȘABLOANE CREAȚIONALE ...................................................................................................................................................................... 2

Șablonul Factory Method................................................................................................................................................................... 2
Șablonul Abstract Factory .................................................................................................................................................................. 2
Sablonul Prototype ............................................................................................................................................................................ 4
Sablonul Singleton ............................................................................................................................................................................. 4
Sablonul Builder ................................................................................................................................................................................. 1
ȘABLOANE STRUCTURALE ...................................................................................................................................................................... 2
Sablonul Adapter ............................................................................................................................................................................... 2
Sablonul Bridge .................................................................................................................................................................................. 3
Sablonul Composite ........................................................................................................................................................................... 4
Sablonul Decorator ............................................................................................................................................................................ 5
Sablonul Flyweight ............................................................................................................................................................................. 6
Sablonul Proxy ................................................................................................................................................................................... 7
SABLOANE COMPORTAMENTALE .......................................................................................................................................................... 8
Sablonul Mediator ............................................................................................................................................................................. 8
Șablonul Observer .............................................................................................................................................................................. 9
Sablonul Memento .......................................................................................................................................................................... 10
Șablonul Visitor ................................................................................................................................................................................ 10
Sablonul Strategy ............................................................................................................................................................................. 12
Sablonul Chain of Responsibility ...................................................................................................................................................... 13
 ȘABLOANE CREAȚIONALE
Șablonul Factory Method
Factory Method creeaza obiecte fara a specifica clasa exacta a obiectului creat.
Aplicabilitate
Sablonul Factory Method se utilizeaza cind:
 O clasa nu poate anticipa clasa obiectelor pe care trebuie sa le creeze ;
 O clasa doreste ca subclasele sale sa precizeze obiectele pe care le creaza;
 Clasele deleaga responsabiliteatea catre una dintre mai multe subclase ajutatoare si doriti sa localizati
cunoasterea subclasei ajutatoare delegat.
Structura

Participanti:
 Product(Document)
 Defineste interfata pentru obiectele create de metoda atelier
 CreatorProduct(My Document)
 Implementeaza interfata Product.
 Creator(Application)
 Declara metoda de atelier, care returneaza un obiect de tipul Product. De asemenea, clasa Creator
poate defini o implementare prestabilita a metodei de atelier, care sa returneze un obiect Concrete
Product implicit.
 Poate apela metoda de atelier pentru a crea un obiect Product.
 ConcreteCreator(MyApplication)
 Redefineste metoda de atelier astfel incit sa returneze o instanta a unui obiect ConcretProduct.

Șablonul Abstract Factory

Abstract Factory asigura o interfata pentru crearea familiilor de obiecte inrudite sau dependente fara a le
preciza clasele concrete.
Sablonul Abstract Factory se utilizeaza cand:
 un sistem trebuie sa fie independent de modul in care produsele sale sunt create, compuse si
reprezentate;
 un sistem trebuie sa fie configurat la un moment dat cu una din mai multe familii de produse;
 trebuie fortata restrictia ca produsele dintr-o anumita familie sa fie utilizate impreuna si nu amestecate
cu produsele altei familii; '
 se doreste crearea unei biblioteci de produse pentru care sunt relevante doar interfetele, nu si
implementarile (de exemplu, in cazul generatorului de interfete analizat mai inainte, nu ne intereseaza
cum sunt desenate pe ecran diversele elemente de control, ci doar care sunt efectele actionarii lor de
catre utilizator si aceste efecte sunt asemenatoare, indiferent de standardul de prezentare).
Sablonul Abstract Factory are urmatoarele beneficii si indatoriri:
 1. Izoleaza clasele concrete. Sablonul Abstract Factory ajuta la controlul claselor de obiecte pe care o
aplicatie le creaza. Pentru ca o factory incapsuleaza responsabilitatea si procesul de creare a obiectelor-
produs, aceasta izoleaza clientii de clasele de implementare. Clientii manipuleaza instante prin
interfetele lor abstracte. Numele claselor de produse sunt izolate in implementarea “concrete factory”-
ului, ele nu apar in codul clientului.
2. Face usor schimbul de familii de produse. Clasa unei “concrete factory” apare o singura data intr-o
aplicatie – si anume, acolo unde este instantiata. Astfel este mai usor ca “concrete factory”-ul pe care il
utilizeaza o aplicatie sa fie schimbat. Se pot utiliza configuratii diferite de produse prin simpla
schimbare a “concrete factory”-ului. Pentru ca o “abstract factory” creeaza o familie completa de
produse, intreaga familie de produse se schimba o data.
3. Promoveaza consistenta intre produse.Atunci cand obiectele-produs intr-o familie sunt proiectate sa
functioneze impreuna, este important ca o aplicatie sa foloseasca obiecte dintr-o singura familie la un
moment dat. AbstractFactory face acest lucru usor de a pune in aplicare.
4. Suportul pentru noi tipuri de produse este dificil.Extinderea “abstract factory”-urilor, pentru a produce
noi tipuri de produse nu este usoara. Asta pentru ca interfata AbstractFactory fixeaza setul de produse
care pot fi create. Suportul pentru noi tipuri de produse impune extinderea interfetei “factory”, care
implica schimbarea clasei AbstractFactory si toate subclaselor sale.

Participanti:
 AbstractFactory
o Declară o interfață pentru operații care creează obiecte produs abstracte.
 Concrete Factory
o Implementează operațiile pentru crearea obiectelor produs concrete.
 ProdusAbstract
o Declară o interfață pentru un tip de obiect produs.
 Produs Concret
o Definește un obiect produs care va fi creat de atelierul concret corespondent.
o Implementează interfața ProdusAbstract.
 Client
o Utilizează doar interfețele declarate de clasele AbstractFactory și ProdusAbstract.
 Sablonul Prototype
Sablonul prototype creaza obiecte clonind obiecte existente
Aplicabilitate:
Sablonul Prototype se utilizeaza cind un sistem nu trebuie sa depinda de modul in care sunt create, compuse si
repreentate produsele sale si:
 In cazul in care clasele de instanta sunt precizate la executie, de exemplu, prin incarcare dinamica ;
 Pentru a evita costruirea unei ierarhii de clasa de ateliere paralela cu ierarhia de clasa de produse;
 Cind instantele unei clase nu pot avea una dintre citeva combinatii diferite de stari. Ar putea fi mai
convenabil sa se instaleze un numar corespunzator de prototipuri care sa fie clonate, decit sa se
instantieze manual clasa, de fiecare data cu starea corecta.

Participanti:
 Prototype(Graphic)  Implementeaza o operatie pentru clonarea sa
 Declara o interfata pentru clonarea sa.  Client(GraphicTool)
 ConcretePrototype(Staff, WholeNote,  Creaza un obiect nou cerind unui prototip sa
HalfNote) se cloneze

Sablonul Singleton
Singleton restrcitioneaza crearea obiectelor doar la o instanta a unei singure clasa.
Sablonul Singleton se utilizeazi cind:
 Trebuie sa existe doar o singura instanta a unei clase si aceasta trebuie si fie accesibila cliendior printr-un
punct binecunoscur de acces;
 Unica instanta trebuie sa poata fi extinsa prin generare de subclase, iar clientii trebuie sa fie capabili si
utilizeze o instanta extinsa fara a-si schimba codul.

Participanti:
 Singleton
 Defineste o operatie instance care permite clientilor sa acceseze unica ei instanta. Instance este o
operatie de clasa(adica, o metoda de clasa Smalltalk si o functie membru statica in C++).
 Ea poate fi responsabila pentru crearea instantei sale unice.
 Sablonul Builder
Sablonul Builder Separa constructia unui obiect complex de reprezentarea acestuia, astfel incit acelasi proces
de constructie sa poata crea reprezentari diferite.
Aplicabilitate:
Sablonul Builder se utilizeazi cind:
 algoritmul pentru crearea unui obiect complex trebuie sa fie independent de partile care compun obiectul
si de modul in care acestea sunt asamblate;
 procesul de constructie trebuie sa permita reprezentari diferite pentru obiectul care este construit.
Structura:

Participanti
 Builder (TextConverter)
 Precizeaza o interfata abstracta pentru crearea partilor unui obiect produs.
 ConcreteBuilder (ASCII Converter, TeXConverter, TextWidgetConverter)
 Construieste si asambleaza parti ale produsului implementind interfata Builder(Cnstructor)
 Defineste si tine evidenta reprezentarii pe carea o creeaza.
 Furnizeaza o interfata pentru preluarea produslui(de exemplu, GetASCIIText,GetTextWidget).
 Director (RTFReader)
 Construieste un obiect utilizind interfata Builder.
 Produs (ASCIIText, TeXText, TextWidget)
 Reprezinta obiectul complex in constructie . Clasa ConcreteBuilder construieste reprezentarea
interna a produslui si defineste procesusul prin care acesta este asamblat.
 Contine clase care definesc partile constitutive, inclusiv interfete pentru asamblarea acestora in
rezultatul final.
 ȘABLOANE STRUCTURALE
Sablonul Adapter
Transforma interfata unei clase int-o alta interfata care este asteptata de client. Sablonul Adapter permite lucrul
impreuna pentru clase care altfel nu ar purea face acest lucru din cauza interfetelor incompatibile.
Sablonul Adapter se utilizeaza cind:
 Dorita sa utilizati o clasa existenta, dar interfata acesteia nu corespunde celei de care aveti nevoie;
 Dorita sa creati o clasa reutilizabila care coopereaza cu clase neinrudite sau nesteptate, adica clasele care
nu au in mod necesar interfete compatibile;
 (doar pentru obiecte adapter) trebuie sa utilizati mai multe subclase existente, dar nu este practic sa le
adaptati interfata generind subclase pentru fiecare. Un obiect adaptor poate adapta interfata interfata
clasei sale parinte;
Structura:
o clasa adaptor utilizeaza mostenirea multipla pentru a adapra o interfata la alta:

Un obiect adaptor se bazeaza pe compunerea obiectelor:

Participantii:
 Tinta(Shape)
 Defineste interfata specifica domeniului, utilizata de catre client.
 Client(DrawingEditor)
 Colaboreaza cu obiectele in conformitate cu interfata tinta
 Adaptat(textView)
 Defineste o interfata existenta care trebuie adaptata.
 Adaptor(TextShape)
 Adapteaza interfata Adaptat la interfata Tinta.
 Sablonul Bridge
Decupleaza o abstractizare de implementaea ei, astfel incit cele doua sa poata varia independent.
Aplicabilitate
Sablonul Bridge se utilizeaza cind:
 Dorita sa evitati o legatura permanenta intre o abstractizare si implementarea acesteia. Astfel de cazuri
ar putea fi, de exemplu, cind implementarea trebuie selectata sau schimbat la executie
 Atit abstractizarile, cit si implementarile acestora trebuie sa fie extensibile prin generarea subclaselor. In
acest caz, sablonul Bridge va permite sa combinati abstractizarii si implementarii diferite si sa le
extindeti independent.
 Modificarile in implementarea unei abstractizari nu trebuie sa afecteze clientii, cu alte cuvinte, codul
client nu trebuie sa fie recompilat.
 (C++) dorita sa ascundeti complet fata de clientiimplementarea unei abstractizari. In C++, reprezentarea
unei clase este vizibila in interfata clasei.
 Va confruntati cu o proliferare a claselor, asa cum s-a demonstrat anterior in prima diagrama
Motivation. O astfel de ierarhie de clasa indica necesitatea de impartire a unui obiect in doua parti. Cind
se refera la astfel de ierarhii de clasa, Rumbaugh foloseste termenul „generalizarii imbricate” [RBP+91].
 Doriti sa partajati o implementare intre mai multe obiecte(probabil prin folosirea numararii referintei),
iar acest fapt trebuie ascuns fata de client. Un exemplu simplu este clasa String a lui Coplient[Cop92], in
care mai multe obiecte pot partaja acceasi reprezentare sir(StringRep)
Structura

Participanti
 Abstraction(Window)
 Defineste interfata abstractizarii
 Pastreaza o referinta catre un obiect de tipul Implementor
 RefinedAbstraction(IconWindow)
 Extinde interfata definita de clasa abstraction.
 Implementor(WindowImp)
 Defineste interfata pentru clasele de implementare. Aceasta interfata nu trebuie sa corespunda
exact interfetei Abstraction; de fapt, cele doua interfete pot fi diferite. In mod obisnuit, interfata
Implementor furnizeaza doar operatii primitive, iar interfata Abstraction defineste operatii de
nivel mai inalt, bazate pe aceste primitive.
 ConcreteImplementor(XwindowImp, PMWindowImp)
 Implementeaza intefata Implementor si ii defineste implementarea concreta.
 Sablonul Composite
Compune obiecte in structuri de arbore pentru a reprezenta ierarhii de tip parte-intreg. Sablonul Composite
permite clientilor sa trateze uniform obiecte individuale si compunerii de obiecte.
Aplicabilitate:
Sablonul Composite se utilizeaza cind:
 Doriti sa reprezentati ierarhii de obiecte, de tip parte-intreg
 Doriti ca clientii sa poata ignora diferentele dintre compunerile de obiecte si obiectele individuale.
Clientii vor trata uniform toate obiectele din structura compusa.
Structura

Participanti:
 Component(Graphic)
 Declara interfata pentru obiectele din compunere;
 Implementeaza, in mod corespunzator, coportarea prestabilita pentru interfata comun a tuturor
claselor;
 Declara o interfata pentru accesarea si gestionarea componentelor sale copil
 (optional) Defineste o interfata pentru accesarea parintelui unei componente din structura
recursiva si i implementeaza daca este necesar;
 Leaf(Rectangle, Line, Text etc.)
 Reprezinta obiectele frunza din compunere. O frunza nu are copii.
 Defineste comportarea pentru obiectele primitive din compunere.
 Composite(Picture)
 Defineste comportarea pentru componentele care au copii;
 Stocheaza componentele copil;
 Implementeaza in interfata Component, operatiile referitoare la copii.
 Client
 Manevreaza obiectele din compunere prin intermediul interfetei Component.
 Sablonul Decorator
Decorator ataseaza dinamic responsabilitati suplimentare la un obiect. Decoratorii ofera o alternativa flexibila
la generara subclaselor in scopul extinderii functionalitatii.
Aplicabilitate
Utilizati sablonul Decorator:
 Pentru a adauga dinamic si transparent responsabilitati la obiecte individuale, adica fara a afecta alte
obiecte.
 Pentru responasabilitati care pot fi retrase.
 Cind nu este practica extinderea prin generarea de subclase. Uneori, este posibil un numar mare de
extinderi independente care vor produce o explozie de subclase ce suporta fiecare combinatie. Sau
definitia unei clase ar putea fi ascunsa sau indisponibila pentru generarea de subclase.

Structura

Participanti
 Component(VisualComponent)
 Defineste interfata pentru obiectele la care se pot adauga dinamic responsabilitati
 ConcreteComponent(TextView)
 Defineste un obiect la care pot fi atasate responsabilitati suplimentare.
 Decorator
 Pastreaza o referinta catre un obiect Component si defineste o interfata care se conformeaza
interfetei obiectului Component.
 ConcreteDecorator(BorderDecorator, ScrollDecorator)
 Adauga responsabilitati la componenta.
 Sablonul Flyweight
Utilizeaza partajarea pentru a suporta eficient numere mari de obiecte cu granularitate fina.
Aplicabilitate
Eficienta sablonului flyweight depinde foarte mult de modul si de locul in care este utilizat. Aplicati sablonul
flyweight in situatiile in care toate afirmatiile urmatoare sunt adevarate:
 O aplicatie utilizeaza un numar mare de obiecte. Costurile de stocare sunt ridicate, datorita cantitatimari
de obiecte.
 Majoritatea starilor de obiect pot fi facute extrinsenci. Multe grupuri de obiecte pot fi inlocuite cu un
numar relativ mic de obiecte partajate, dupa ce este eliminata starea extrinseca
 Aplicatia nu depinde de identitatea obiectului. Deoarece obiectele flyweight pot fi partajate, testele de
identitate vor returna valoarea True pentru obiecte distincte din punct de vedere conceptual.
Structura

Participanti
 Flyweight(Glyph)
 Declara o interfata prin care obiectele flyweight pot primi si pot actiona asupra starii extrinsece
 ConcreteFlyweight(Character)
 Implementeaza interfata Flyweight si adauga stocarea starii intriseci, daca exista. Un obiect
ConcreteFlyweight trebuie sa poata fi partajat. Orice stare stocata de acest obiect trebuie sa fie
intriseca, adica ea trebuie sa nu depinda de contextul obiectului ConcreteFlyweight
 UnsharedConcreteFlyweight(Row, Column)
 Nu toate subclasele Flyweight trebuie sa fie partajate. Interfata Flyweight permite partajarea, ea
nu o impune. La anumite niveluri din structura obiectlui flyweight, este o situatie obisnuita ca
obiectele UnsharedConcreteFlyweight sa aiba drept copii obiecte ConcreteFlyweight(asa cum au
clasele Row si Column)
 FlyweightFactori
 Creeaza si gestioneazaobiectele flyweight
 Asigura faptul ca obiectele flyweight sunt partajate corect. Cind un client solicita un obiect
flyweight, obiectul FlyweightFactory furnizeaza o instanta existenta sau creeaza una, daca nu
exista nici una
 Client
 Pastreaza o referinta catre obiectul(obiectele) flyweight.
 Sablonul Proxy
Sablonul Proxy asigura, pentru un alt obiect, un surogat sau un locuitor in scopul controlarii accesului la
acesta.
Aplicabilitate
Sablonul Proxy poate fi aplicat oriunde este nevoie de o referinta la un obiect, mai versatila sau mai sofisticata
decit un pointer simplu. Va prezentam in continuare citeva situatii obisnuite in care se poate aplica sablonul
Proxy:
 Un proxy la distanta ofera un reprezentant local pentru un obiect dintr-un spatiu de adresa. Sistemul
NEXTSTEP utilizeaza in acest scop clasa NXTProxy
 Un proxy virtual creeaza la cerere obiecte costisitoare. Clasa ImageProxy descrisa in sectiunea
Motivatie este un exemplu de astfel de obiect proxy.
 Un proxy de protectie controleaza accesul la obiectul original. Obiectele proxy de protectie sunt utile
atunci cind obiectele reprezentate trebuie sa aiba drepturi diferite de acces.De exemplu, obiectele
KernelProxines din sistemul de operare Choices asigura acces protejat la obiectele sistemului de
operare.
 O referinta inteligenta este un inlocuitor pentru un pointer gol, care efectueaza actiuni suplimentare in
momentul accesarii unui obiect. Utilizarile tipice includ:
 Stabilirea numarului de referinte catre obiectul real, astfel incit acesta sa poata fi automat eliberat
atunci cind nu mai exista referinte(numite, de asemenea, si pointeri inteligenti)
 Incarcarea unui obiect persistent in memorie atunci cind acesta este referit pentru prima data.
 Verificarea blocarii obiectului real inainte de a fi accesat, ca sa asigure faptul ca nici un alt obiect
nu-l poate modifica.

Structura

Participanti
 Proxy(ImageProxy)
 Pastreaza o referinta care permite obiectului proxy sa acceseze subiectul real. Obiectul proxy
poate referi u obiect. Subject daca interfetele RealSubject si Subiect sunt la fel.
 Asigura o interfata identica celei a clasei Subject, astfel incit un obiect proxy, sa poata fi
inlocuit de obiectul real
 Controleaza accesul la subiectul real si poate raspunde de crearea si stergerea acestora.
 Subject(Graphic)
 Defineste interfata comuna pentru obiectele RealSubject si Proxy, astfel incit un obiect Proxy sa
poata fi utilizat in orice loc in care este asteptat un obiect RealSubject.
 RealSubject(Image)
 Defineste obiectul real reprezentat de obiectul proxy.
 SABLOANE COMPORTAMENTALE
Sablonul Mediator
Defineste un obiect care incapsuleaza modul in care interactioneaza un set de obiecte. Acest sablon
promoveaza cuplarea slaba, interzicind obiectelor sa faca referinte explicite unul la celalalt si permite sa le
modificati interactiunea independent.
Aplicabilitate
Sablonul Mediator se utilizeaza cand:
- Un set de obiecte comunica pe cai bine definite, dar complexe. Interdepenentele rezultate nu sunt
structurate si sunt dificil de inteles.
- Este dificila reutilizarea unui obiect deoaree el se refera la si comunica cu mai multe alte obiecte.
- O comportare distribuita intre mai multe clase trebuie sa poata fi particularizata fara a genera o multime
de subclase.
Structura

Participanți:
 Mediator (DialogDirector)
- Definește o interfata pentru comunicarea cu obiectele Colleague.

 ConcreteMediator (FontDialogDirector)
- Implementeaza comportarea cooperanta prin coordonarea obiectelor Colleague.
- Isi cunoaste si pastreaza colegii sai.
  Clasele Colleague (ListBox, EntryField)
- Fiecare clasa Colleague isi cunoaste obiectul Mediator.
- Fiecare coleg comunica cu mediatorul sau in orice situatie in care, altfel, ar fi comunicat cu un alt
coleg.
Șablonul Observer
Defineste o dependenta ”unu la mai multi” intre obiecte, astfel incit in cazul in care un obiect isi schimba
starea, vor fi instiintate si actualizate automat toate obiectele sale dependente.
Aplicabilitate
 Cind o abstractizare are doua aspecte, unul depinzind de celalalt. Incapsularea acestor aspecte in obiecte
separate va permite sa le variati si sa le reutilizati independent.
 Cind modificarea unui obiect necesita modificarea altor obiecte si nu stiti cit de multe obiecte trebuie
schimbate.
 Cind un obiect trebuie sa poata instiinta alte obiecte fara a fi obligat sa faca presupuneri despre
identitatea acestora. Cu alte cuvinte, cind nu doriti ca respectivele obiecte sa fie strins cuplate.
Structura

Participanti
 Subject
- Isi cunoaste observatorii. Un subiect poate fi observat de oricat de multe obiecte Observer.
- Furnizeaza o interfata penru atasarea si detasarea obiectelor Observer.

 Observer
- Defineste o interfata de actualizare pentru obiectele care trebuie instiintate de modificarile dintr-un
subiect.

 ConcreteSubject
- Stocheaza starile ce prezinta interes pentru obiectele ConcreteObserver.
- Cind i se modifica starea, trimite instiintari catre observatorii sai.

 ConcreteObserver
- Pastreaza o referinta catre un obiect ConcreteSubject.
- Stocheaza stare, care trebuie sa fie consecventa cu cea a subiectului.
- Implementeaza interfata de actualizare Observer pentru a-si pastra starea in concordanta cu cea a
subiectului.
 Sablonul Memento
Fara a viola incapsularea, sablonul captureaza si exteriorizeaza starea interna a unui obiect astfel incit acesta a
poata fi readus ulterior la respectiva stare.
Aplicabilitate
Sablonul Memento se utilizeaza cand:
 Trebuie salvat un instantaneu al (unei portiuni a) starii unui obiect, astfel incit acesta sa poata fi readus
ulterior la acea stare și
 O interfata directa pentru obtinerea starii ar expune detaliile implementarii si ar sparge incapsularea
obiectului.
Structura

Participanti:
 Memento
- Stocheaza starea interna a obiectului Originator. Un memento poate stoca oricat de mult sau de putin
din stare interna a creatorului este necesar; creatorul stabileste cat de mult din stare trebuie stocata.
- Protejeaza impotriva accesului altor obiecte, diferite de creator. Mementro-urile pot avea efectiv doua
interfete. Obiectul Caretaker vede o interfata redusa catre obiectul Memento – acest obiect nu poate
decat sa treaca memento-ul catre alte obiecte. Obiectul Originator, insa, vede o interfata largita, una
care-i permite accesulla toate datele necesare pentru a reveni la starea sa anterioara. Ideal, doar
creatorului care a produs memento-ul i se va permite accesul la starea interna a obiectului memento.

 Originator
- Creeaza un memento care contine un instantaneu al starii sale interne curente.
- utilizeaza obiectul Memento pentru a-si reface starea sa interna.

 Cartetaker
- Raspunde de pastrarea in siguranta a memento-ului.
- Nu opereaza si nici nu examineaza niciodata continutul unui memento.

Șablonul Visitor
Reprezinta o operatie care va fi efectuata pe elementele unei structuri de obiect. Acest sablon va permite sa
definiti o operatie noua fara a schimba clasele elementelor pe care opereaza.
Aplicabilitate
Sablonul Visitor se utilizeaza cand:
 O structura de obiect contine multe clase de obiecte cu interfete diferite si, pe aceste obiecte, doriti sa
efectuati operatii care depind de clasele lor concrete.
 Pe obiectele dintr-o structura de obiecte trebuie efectuate mai multe operatii distincte si neinrudite si
doriti sa evitati ”poluarea” claselor lor cu aceste operații. Prin definirea lor intr-o singura clasa, sablonul
 Visitor va permite sa pastrati laolata operatiile inrudite. Cand structura de obiecte este partajata de mai
multe aplicații, folositi sablonul Visitor pentru a pune operatiile doar in acele aplicatii care le necesita.
 Clasele care definesc structura de obiect se modifica rareori, dar doriti deseori sa definiti operatii noi pe
structura. Modificarea claselor structurii de obiect necesita redefinirea interfetei pentru toti vizitatorii,
lucru ce poate fi costisior. In cazul in care clasele structurii de obiect se modifica frecvent, atunci este
probabil mai bine sa feiniti operatiile in aceste clase.
Structura

Participanti
 Visitor
- Declara o operatie Visit pentru fiecare clasa ConcreteElement din structura de obiecte. Numele si
semnatura operatiei precizeaza clasa care trimite cererea Visit catre vizitator. Acest lucru permite
vizitatorului sa determine clasa concreta a elementului vizitat. Apoi, vizitatorul poate accesa direct
elementul, prin intermediul interefetei lui particulare.

 ConcreteVisitor
- Implementeaza fiecare operatie declarata de clasa Visitor. Fiecare operatie implementeaza un fragment
din algoritmul definit pentru clasa corespondenta ociectului din structura. Clasa ConcreteVisitor asigura
contextul algoritmului si stocheaza starea lui locala. Deseori, aceasta stare acumuleaza rezultate in
timpul traversarii structurii.
 Element
- Defineste o operatie Accept care ia ca argument un vizitator.
 ConcreteElement
- Implementeaza o operatie Accept care ia ca argument un vizitator.
 ObjectStructure
- Isi poate numara elementele.
 Sablonul Strategy
Defineste o familie de algoritmi, incapsuleaza fiecare algoritm si ii face interschimbabili. Acest sablon permite
algoritmului sa varieze independent de clientii care il utilizeaza.
Aplicabilitate
Utilizati sablonul Strategy cand:
 Mai multe clase inrudite difera doar prin modul lor de comportare. Strategiile ofera o metoda de
configurare a clasei cu una din comportari.
 Aveti nevoie de variante diferite ale unui algoritm. De exemplu, puteti defini algoritmi care reflecta
diferite compromisuri spatiu/timp. Pot fi utilizate strategii cind se omplementeaza aceste variante ca o
ierarhie de clasa cu algoritmi.
 Un algoritm utilizeaza date ce nu trebuie cunoscute de catre clienti. Folositi sablonul Strategy pentru a
vita expunerea structurilor de date complexe, specifice algoritmului.
 O clasa defineste mai multe comportari, iar acestea apar in operatiile ei sub forma de instructiuni
conditionale multiple. In locul mai multor instructiuni conditionale, puteti muta ramurile conditionale
inrudite in propriile lor clase Strategy.
Structura

Participanti:
 Strategy
- Declara o interfata comuna pentru toti algoritmii suportati. Obiectele Context utilizeaza aceasta
interfata pentru a apela algoritmul definit de o clasa ConcreteStrategy.
 ConcreteStrategy
- Implementeaza algoritmul utilizat de interfata Strategy
 Context
- Este configurat cu un obiect ConcreteStrategy
- Pastreaza o referitna catre un obiect Strategy
- Poate defini o interfata care permite obiectului Strategy sa-i acceseze datele.
 Sablonul Chain of Responsibility
Evita cuplarea intre expeditorul si destinatarul unei cereri, acordind mai multor obiecte o sansa de a rezolva
cererea. Sablonul inlantuie obiectele destinatar si trece cererea de-a lungul lantului pina cind un obiect rezolva.
Structura

Participanti:
 Handler
- Defineste o interfata pentru rezolvarea cererilor.
- Implementeaza legatura catre succesor

 ConcreteHandler
- Rezolva cererile de care raspunde
- Isi poate accesa succesorul
- Daca obiectul ConcreteHandler poate rezolva cererea, el face acest lucru; in caz contrar, el transmite
cererea catre succesorul sau.

 Client
- Initiaza cererea catre un obiect ConcreteHandler din lant.
 State

Participanti

- Context - defineste interfata de interese pentru clienti. Mentine instanta subclasei StartState, StopState care defineste starea
curenta
- State - defineste interfata pentru incapsulare a comportamentului asociat cu starea particulara a contextului
- StartState, StopState - fiecare subclasa implementeaza comportamentul asociat cu context