Sunteți pe pagina 1din 49

SINGLETON - asigura faptul ca o clasa are doar o singura instanta si ofera un punct global de acces la

aceasta.

- utilizam cind trebuie sa existe doar o instanta a unei clase si aceasta trebuie sa fie accesibila clientilor
dintr-un punct de acces bine definit
- utilizam atunci cind instanta unica trebuie sa fie mostenita si clientii trebuie sa poate folosi instanta
mostenita fara a modifica codul
Exemplu de cod (JAVA) :

Volatile - rezultatul operatiei de modificare a valorii unei variabile ce foloseste volatile de un Thread,
permite sa fie vazut de celalte Threaduri ce utilizeaza aceasta variabila pentru citirea valorii din ea.
Synchonized - lucreaza asemeni unui “lock”, adica permite accesul la o resursa doar unui Thread intr-un
moment de timp.
FACTORY METHOD - creaza obiecte fara a specifica tipul acestora, defineste o interfata pentru crearea
unui obiect, dar lasa sublclasele sa decida ce clasa vor instantia.Acest sablon permite unei clase sa transfere
subclaselor sale sarcina instantierii.
- se utilizeaza cind clasa client nu poate anticipa tipul de obiecte pe care trebuie sa il creeze
- o clasa doreste ca subclasa sa specifice tipurile de obiecte pe care le creaza
- clasele delegeaza responsabilitatile sale uneia sau mai multor clase ajutatoare, iar logica trebuie sa se afle
in clasele ajutatoare.

Product - defineste interfata obiectelor pe care le creaza metoda Factory.


ConcreteProduct - implementeaza interfata Product.
Creator - declara metoda factory care returneaza un obiect Product.
ConcreteCreator - supraincarca medota facotory care returneaza un obiect ConcreteProduct
Exemplu de cod (JAVA) :
In acest caz WachCreator este Creator(din diagrama), iar DigitalWatchCreator si RomeWatchCreator este
ConcreteCreator(din diagrama).Watch la rindul sau este Creator(din diagrama), iar DigitalWatch si
RomeWatch sunt ConcreteProduct(din diagrama).
ABSTRACT FACTORY - asigura o interfata pentru crearea familiilor de obiecte inrudite sau dependente
fara a le preciza clasele concrete.
Se utilizeaza cind :
- un sistem ar trebuie sa fie independet de cum a fost creat, compus si reprezentat
- un sistem ar trebuie configurat cu una din familia de produse
- o familie de produse comune sau legate intre ele impun utilizarea acestora cu constringerea familiei
acestuia
- atunci cind se doreste oferirea unei biblioteci de clase de produse si este nevoie de a publica doar

intefetele si nu implementarile.
Abstract Factory - declara o interfata pentru operatiunile, (metodele), de creare a obiectelor produs abstract.

Concrete Factory - implementeaza metodele de creare a obiectelor produs concret.

Abstract Product - declara interfata pentru un tip obiect de produs.

Concrete Product - defineste un obiect produs care va fi creat de un CONCRET FACTORY si


implementeaza interfata Abstract Product.

Client - utilizeaza interfetele declarate de Abstract Product, Abstract Factory.


Exemplu de cod (JAVA) Abstract Factory :
BUILDER - separa constructia unui obiect complex de reprezentarea acestuia, astfel incit acelasi proces de
constructie sa poata crea reprezentari diferite.

- se utilizeaza atunci cind algoritmul pentru crearea obiectelor complexe ar trebui sa fie independent de
modulul in care sunt create si asamblate partile sale.
- cind procesul de construire a produsului trebuie sa permita diferite reprezentari a obiectului creat
- ofera interfata pentru a obtine produsul
Exemplu Builder
PROTOTYPE - creeaza obiecte clonind un obiect existent.

- se utilizeaza cind e complicata crearea obiectului (clonezi un obiect si schimbi valoare unui atribut)
- se utilizeaza atunci cind sistemul ar trebui sa fie independet de modul in care create, compuse si
reprezentate produsele sale
- atunci cind clasele pentru instantiere sunt specificate in runtime (pentru incarcarea dinamica)

- pentru a evita crearea unei ierarhii de fabrici care este paralele cu o ierarhie de produse

Prototype - declara o interfata pentru clonare (metoda Clone)


ConcretePrototype - implementeaza operatia de clonare
Clien - creaza un obiect nou cerind o clona de la prototip
Exemplu de cod (JAVA) Prototip :
ADAPTER - transforma interfata unei clase intr-o alta interfata asteptata de clienti.Acest sablon permite
lucrul in comun al unor clase cu interfete incompatibile sa lucreze impreuna

- cind dorim sa utilizam o clasa insa interfata ei nu are formatul necesar clientului
- dorim sa creem o clasa reutilizabila care va coopera cu alte clase necunoscute ?? si deci numaidecit au

interfete compatibile
Target - defineste interfata utilizata de client
Client - colaboreaza cu obiectele care se conforma cu interfata Target
Adaptee - defineste interfata existenta care trebuie adaptata
Adapter - adapteaza interfata adaptee la interfata Target
Exemplu de cod (JAVA) :
Bridge - separa o abstractie de implementarea ei, astfel incit cele 2 sa poata varia independet.

- se utilizeaza cind dorim sa evitam o legatura permanenta intre abstractie si implementarea ei


- in cazul in care atit abstractia cit si implementarea trebuie sa fie extensibile prin mostenire
- in cazul in care schimbarile de de implementare a abstractiei nu trebuie sa aiba impact asupra claselor
client

- Abstraction - defineste interfata abstractiei si contine o referinta la obiectul Implementor


- RefinedAbstraction - extinde definitia de Abstraction
- Implementor - defineste interfata pentru clasele de implementare
- ConcreteImplementor - implementeaza interfata Implementor
Exemplu de cod (JAVA) :
Composite - compune obiectele in structuri de tip arbore care reprezinta ierarhii de tipul “intreg -
parti componente”.Acest sablon permite clientilor sa trateze uniform obiectele individuale si structurile
compuse din obiecte

- se utilizeaza cind dorim sa reprezentam ierarhii de obiecte de tip parte intreg


- dorim ca clientii sa poata ignora diferenta dintre obiectele compuse si cele individuale, adica clientii vor
trata in acelasi mod toate obiectele unei structuri compuse

Component - declara interfata pentru obiectele din compozitie


- implementeaza comportamentul implicit pentru toate clasele ce implementeaza
aceasta interfata
- declara interfata de acces si management la componentele descendete/child
Leaf/Node - reprezinta obiectele individuale din compozitie, acestea nu au descendenti
- defineste comportamentul obiectelor primitive/de baza din compozitie
Composite - defineste comportamentul pentru componentele care au descendenti
- stocheaza componentele descendent
- implementeaza operatiile legate de descendenti din interfata Component
Client - gestioneaza obiectele din compozitie prin interfata component
Exemplu de cod (JAVA) : Composite.
Mediator – acest șablon definește un obiect care incapsulează modul în care interactionează o mulțime
de obiecte. El definește o cuplare slabă, interzicînd obiectelor să facă referințe explicite unul către celălalt și
să permită modificarea independentă a interacțiunilor. Această cupalare (slaba) se realizază datorită faptului
că colegii comunică între ei nu direct, dar prin intermediul Modiatorului. Se utilizeaza acest
șablon(Mediator) atunci cînd:
 un set de obiecte cominică într-o formă bine definită dar complexa
 interdependențele rezultate sunt nestructurate și dificil de înteles
 reutilizarea unui obiect este dificilă deoarce el se referă și comunică cu o mulțiume de alte obiecte
 un comportament care este distribuit între mai multe clase ar trebui presonalizat fără o mulțime
subclase.

Componentele șablonului sunt:

Mediator – define;te o interfață pentru comunicare cu obiectele Colleague.

ConcreteMediator – cunoaște clasele de tip Colleague și păstrează o referință la obietele de tip Colleague.
Implementează comunicarea si transferul de mesaje între clasele de tip Colleague.

Colleague classes – păstrează o referintă la opbiectul de tip Mediator. Fiecare Colleague comunică mai întîi
cu obiectul sau de tip Mediator ori de cite ori vrea să comunice cu un alt colleague.
Mediator

1. public abstract class Colleague {


2. protected Mediator mediator;
3.
4. public Colleague(Mediator mediator) {
5. this.mediator = mediator;
6. }
7. public void send(String message) {
8. mediator.send(message, this);
9. }
10. public abstract void notify(String message);
11. }
12. public abstract class Mediator {
13.
14. public abstract void send(String message, Colleague colleague);
15. }
16.
17. public class ConcreteColleague1 extends Colleague {
18.
19. public ConcreteColleague1(Mediator mediator) {
20. super(mediator);
21. }
22. @Override
23. public void notify(String message) {
24. System.out.println("Colleague1 gets message: " + message);
25. }
26. }
27.
28. public class ConcreteColleague2 extends Colleague {
29. public ConcreteColleague2(Mediator mediator) {
30. super(mediator);
31. }
32.
33. @Override
34. public void notify(String message) {
35. System.out.println("Colleague2 gets message: " + message);
36. }
37. }
38. public class ConcreteMediator extends Mediator {
39.
40. private ConcreteColleague1 colleague1;
41. private ConcreteColleague2 colleague2;
42.
43. public void setColleague1(ConcreteColleague1 colleague) {
44. this.colleague1 = colleague;
45. }
46. public void setColleague2(ConcreteColleague2 colleague) {
47. this.colleague2 = colleague;
48. }
49.
50. @Override
51. public void send(String message, Colleague colleague) {
52. if (colleague.equals(colleague2)) {
53. colleague1.notify(message);
54. } else {
55. colleague2.notify(message);
56. }
57. }
58. }
59. public class Main {
60. public static void main(String[] args) {
61. ConcreteMediator m = new ConcreteMediator();
62. ConcreteColleague1 c1 = new ConcreteColleague1(m);
63. ConcreteColleague2 c2 = new ConcreteColleague2(m);
64. m.setColleague1(c1);
65. m.setColleague2(c2);
66. c1.send("How are you?");
67. c2.send("Fine, thanks");
68. }
69. }
Observer – acest șablon definește între obiecte o depenedență unu către mai multe, așa încît dacă un
obiect iși schimbă starea, celelate obiecte sunt inștiințate și automat actualizate. De asemena definește un obiect
care este un deținător al modelului de date. Observatorii se înregistrează cu subiectul în care aceștia sunt creați.
Se utilizeaza șablonul atunci cînd:
 o abstracțiune are două aspecte. Încapsularea fiecaruia în obiecte diferite permite modificarea și
folosirea lor independentă
 atunci cînd modificarea unui obiect necesită schimbarea altora, fără se cunoaste cîte obiete au nevoia
de fi schimbate;
 se dorește decupalrea obiectelor notificate de obiectul care se schimba.

Componentele șablonului
Subject – cunoaște observatorul său. Orice număr de obiecte observator pot observa un subiect. Furnizează o
interfață pentru atașarea și dezatașarea obietelor de tip observator.

Observer – Defineste o interfață pentru actualizarea obiectelor care trebuie sa fie notificate(anunțate) despre
modificările din subiect.

ConcreteSubject – transmite o notificare observatorilor săi atunci cînd este o schimbare de stare

ConcreteObserver – menține o referința către obiectul ConcretSubject. Implementarea concretă a


observatorului
1. abstract class Observer {
2. protected Subject subj;
3. public abstract void update();
4. }
5.
6. class HexObserver extends Observer {
7. public HexObserver( Subject s ) {
8. subj = s;
9. subj.attach( this );
10. }
11. public void update() {
12. System.out.print( " " + Integer.toHexString( subj.getState() ) );
13. }
14. } // Observers "pull" information
15. class OctObserver extends Observer {

16. OBSERVER
17. public OctObserver( Subject s ) {
18. subj = s;
19. subj.attach( this );
20. }
21.
22. public void update() {
23. System.out.print( " " + Integer.toOctalString( subj.getState() ) );
24. }
25. } // Observers "pull" information
26. class BinObserver extends Observer {
27. public BinObserver( Subject s ) {
28. subj = s;
29. subj.attach( this ); } // Observers register themselves
30.
31. public void update() {
32. System.out.print( " " + Integer.toBinaryString( subj.getState() ) );
33. }
34. }
35. class Subject {
36. private Observer[] observers = new Observer[9];
37. private int totalObs = 0;
38. private int state;
39. public void attach( Observer o ) {
40. observers[totalObs++] = o;
41. }
42.
43. public int getState() {
44. return state;
45. }
46. public void setState( int in ) {
47. state = in;
48. notify();
49. }
50. private void notify() {
51. for (int i=0; i < totalObs; i++) {
52. observers[i].update();
53. }
54. }
55. }
56. public class ObserverDemo {
57. public static void main( String[] args ) {
58. Subject sub = new Subject();
59. // Client configures the number and type of Observers
60. new HexObserver( sub );
61. new OctObserver( sub );
62. new BinObserver( sub );
63. sub.setState(15);
64. }
65. }
Memento – este șablonul care capturează și exteorizează starea internă a unui obiect, fără a viola principiile
incapsulării, astfel încît obiectul poate fi readus mai tîrziu la aceeași stare. Are următoarele caracteristici:

 aplicația trebuie să permită salvare stării unui obiect


 imaginile stării obiectului pentru diferite momente sunt gestionate separat
 obiectul iși poate restaura starea în baza unei imagini anterioare

Se utilizează acest șablon atunci cînd:

 trebuie de salvat un instantaneu al stării (sau a unei porțiuni de stare), unui obiect astfel încît aceasta
să poată fi readus ulterior la această stare.
 cînd o interfață directă pentru obținerea stării ar expune detaliile implementării si ar viola incapsularea
obietului.

Memento – gestionează starea internă a obietului Originator pentru un anumit moment.

Originator – obiect a carui stare este urmărită. Poate genera un Memento cu starea lui, la momentul respectiv.
Poate sa-și refacă starea pe baza unui Memento.
Carataker – Gestionează obiectele de tip Memento fără a avea acces în conținutul acestora.
1. public class Memento {
2. private final String state;
3. public Memento(String state) {
4. this.state = state;
5. }
6. public String getState() {
7. return state;
8. }
9. }
10. public class Caretaker {
11. private Memento memento;
12. public Memento getMemento() {
13. return memento;
14. }
15. public void setMemento(Memento memento) {
16. this.memento = memento;
17. }
18. }
19. public class Originator {
20.
21. private String state;
22. public void setState(String state) {

23. MEMENTO
24. this.state = state;
25. }
26. public String getState() {
27. return state;
28. }
29. public Memento saveState() {
30. return new Memento(state);
31. }
32. public void restoreState(Memento memento) {
33. this.state = memento.getState();
34. }
35. }
36.
37. public class Application {
38. public static void main(String[] args) {
39. Originator originator = new Originator();
40. Caretaker caretaker = new Caretaker();
41. originator.setState("on");
42. System.out.printf("State is %s\n", originator.getState());
43. caretaker.setMemento(originator.saveState());
44. originator.setState("off");
45. System.out.printf("State is %s\n", originator.getState());
46. originator.restoreState(caretaker.getMemento());
47. System.out.printf("State is %s\n", originator.getState());
48. }
49. }
Visitor – scopul acestui șablon este de a reprezenta o operație ce se efectuează asupra structurii obiectului.
Permite definirea unei noi operații fără a schimba clasele elementelor asupra cărora se lucrează.
Se utilizeaza acest sablon atunci cînd:
 structura unui obiect conține mai multe clase de obiecte cu interfețe diferite, și se dorește efectuara
unor operații cu aceste obiecte care la rîndul lor sunt dependente de clasele lor.
 Trebuie de efectuat operaţii numeroase şi disjuncte pe obiecte, într-o structură obiect şi se doreşte
evitarea „poluării” claselor aferente cu aceste operaţii. Visitor permite păstrarea unitară a operaţiilor
înrudite prin definirea lor într-o clasă. Când structura unui obiect este împărţită de mai multe aplicaţii,
se foloseşte Visitor pentru a pune acele operaţii în aplicaţiile care le necesită
 clasele care definesc structura obiectului se schimbă rar, dar este nevoie de a defini mereu noi operaţii
pe această structură. Modificarea claselor aferente structurii obiectului necesită redefinirea interfeţei
pentru toţi vizitatorii, operaţie care este potenţial costisitoare. Dacă clasa aferentă structurii obiectului
se modifică des, atunci este probabil ca mai bine de definit aceste operaţii direct în acele clase.

Componentele șablonului
Visitor – declară o operație de Vizită pentru fiecare clasă ConcreteElemente în structura obiectului, numele
si semnătura operațiunii identifică clasa care trimite cererea de vizită a vizitatorului. Aceasta permite
Vizitatorului de a determina clasa concretă a elementului ce va fi vizitat. Apoi Vizitatorul poate accesa
elementul direct prin intermediul interfeței sale particulare.
ConcreteVisitor – implementeaza fiecare operație declarată de Visitor. Fiecare operație implementează un
fragment al algoritmului definit pentru clasa corespunzătoare a obiectului în structură. ConcreteVisitor oferă
contextul algoritmului și stochează starea locală.
Element – defineste o operație de acceptare care are un Visitor ca argument.
ConcreteElement – implemenetează operația de acceptare care și ea la rîndul său are un Visitor ca argument.
ObjectStructure – poate enumera elementele sale. Poate oferi o interfața de nivel înalt pentru a permite
vizitatorului să viziteze elemente sale.
Concrete Element Interface
public interface IAcceptVisitor {
public void accept(IVisitor visitor);
}
Visitor interface
public interface IVisitor {
public void view(ActionBook book);
public void view(HistoryBook book);
}

Concrete Visitor
public class BookVisitor implements IVisitor {

@Override
public void view(ActionBook book) {
System.out.println("Action book visitor");
}

@Override
public void view(HistoryBook book) {
System.out.println("History book visitor");
}
}

Conctrete Element

@Override
public void accept(IVisitor visitor) {
visitor.view(this); }

Call visitor

System.out.println("\n******** Visitor pattern: ********");


BookVisitor visitor = new BookVisitor();
ActionBook book = new ActionBook();
book.accept(visitor);
Strategy - Presupune incapsularea separată a fiecarui algoritm dintr-o familie, făcînd astfel ca
algoritmii respectivi să fie interschimbabili. Șablonul se mai numește politică (policy). Acest șablon
are următoarele caracteristic:
 alegerea în run-time a algoritmului/funcției care să fie utilizată pentru procesarea unor date
 algoritmul se poate alege pe baza unor condiții descrise la execuție, in funcție de contextul
datelor de intrare
 clasa existentă nu trebuie să fie modificată
 utilizarea unei abordări tradiționale, prin includerea în clasă a tuturor metodelor posibile, duce
la ierarhii complexe ce sunt greu de gestionat. Derivarea adaugă comportament nou doar la
compilare
Sablonul Strategy se utilizeaza atunci cînd:
 mai multe clase înrudite diferă doar prin comportament
 sunt necesare mai multe variante ale unui algoritm, care diferă între ele, de exemplu
 un algoritm utilizează date pe care clientul algoritmului nu trebuie să le cunoască
 intr-o clasa sunt definite mai multe acțiuni care apar ca structuri condiționale multiple. În loc
de aceasta, se recomanda plasarea ramurilor condiționale înrudite în cîte o clasă separată de
tip strategy.

Strategy - declară o interfață comună pentru toți algoritmii acceptați. Contextul va folosi această
interfață pentru a apela algoritmul definit prin ConcretStrategy.

ConcretStrategy – implementează algoritumul folosind interfața strategiei.

Conctext – este configurat cu un obiect de tip ConcreteStrategy. Menține o referință catre obiectul
de tip Strategy.

Strategy
public interface ISell {
String sell();
}
STRATEGY
Context
public BorrowBook(Book newBook){
book = newBook;
book.selling = new CanSell();
}
Concrete class
public class CanSell implements ISell {

@Override
public String sell() {
return "The book can be sold !";
}
}
Strategy demo

System.out.println("\n******** Strategy pattern: ********");


String temp = bookBorrow.tryToSell();
System.out.println("Try to sell: " + temp + ": " +
bookBorrow.getTitle());

temp = bookContribute.tryToSell();
System.out.println("Try to sell: " + temp + ": " +
bookContribute.getTitle());

bookContribute.setSell(new CanSell());
System.out.println(bookContribute.tryToSell() + ": " +
bookContribute.getTitle());
Chain of Responsibility – acest șablon permite evitare cuplării directe a expeditorului unei cereri cu un anumit
destinatar, folosindu-se in acest sens clase intermediare.

Avantajele lui sunt următoarele:

 expeditorul poate să nu cunoască exact care este destinatarul final al cererii sale, pe el interesandu-l
doar ca respectiva sarcină să fie îndeplinită
 clasele intermediare pot alege destinatarii, gestionînd eventual și gradul de solicitare al acestora și
gradul de solicitare a sistemelor de calcul pe care ruleaza aceștia
 o cerere poate fi procesată de mai mulți destinatari în același timp, secvențial sau respectînd chiar
anumite fluxuri de cereri
 clasele intermediare pot realiza log-uri ale cererilor
 lipsa oricărui potențial destinatar poate fi aflată de către expeditor printr-un mesaj primit de la clasele
intermediare.

Se utilizeaza șablonul atunci cind:

 mai multe obiecte pot trata o cerere, iar obiectul care o va trata nu este cunoscut a priori, el va fi
determinat în mod automat.
 se doreşte ca cererea să fie făcută unui grup de obiecte fără a specifica în mod explicit receptorul
acesteia
 Mulțimea obiectelor care pot trata cererea trebuie specificată în mod dinamic

Handler – definește o interfață pentru manipularea de solicitări. (Optional) implementeaza the succesor link.

ConcreteHandler – gestionează solicitările pentru care este responsabil. Poate accesa succesorul sau. În cazul
cînd ConcreteHandler poate gestiona solicitarea atunci face acest lucru, în caz contrar se transmite cererea
succesorului sau.

Client – inițializează o solicitare către obiectul de tip ConcreteHandler.


1. CHAIM OF RESPRONSABILITY
2. public abstract class AbstractLogger {
3. public static int INFO = 1;
4. public static int DEBUG = 2;
5. public static int ERROR = 3;
6. protected int level;
7.
8. //next element in chain or responsibility
9. protected AbstractLogger nextLogger;
10. public void setNextLogger(AbstractLogger nextLogger){
11. this.nextLogger = nextLogger;
12. }
13. public void logMessage(int level, String message){
14. if(this.level <= level){
15. write(message);
16. }
17. if(nextLogger !=null){
18. nextLogger.logMessage(level, message);
19. }
20. }
21. abstract protected void write(String message);
22. }
23. public class ConsoleLogger extends AbstractLogger {
24.
25. public ConsoleLogger(int level){
26. this.level = level;
27. }
28.
29. @Override
30. protected void write(String message) {
31. System.out.println("Standard Console::Logger: " + message);
32. }
33. }
34. public class ErrorLogger extends AbstractLogger {
35. public ErrorLogger(int level){
36. this.level = level;
37. }
38. @Override
39. protected void write(String message) {
40. System.out.println("Error Console::Logger: " + message);
41. }
42. }
43. public class FileLogger extends AbstractLogger {
44. public FileLogger(int level){
45. this.level = level;
46. }
47.
48. @Override
49. protected void write(String message) {
50. System.out.println("File::Logger: " + message);
51. }
52. }
53. public class ChainPatternDemo {
54. private static AbstractLogger getChainOfLoggers(){
55. AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
56. AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
57. AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);
58. errorLogger.setNextLogger(fileLogger);
59. fileLogger.setNextLogger(consoleLogger);
60. return errorLogger;
61. }
62. public static void main(String[] args) {
63. AbstractLogger loggerChain = getChainOfLoggers();
64. loggerChain.logMessage(AbstractLogger.INFO, "This is an information.");
65. loggerChain.logMessage(AbstractLogger.DEBUG,"This is an debug level information.")

66. loggerChain.logMessage(AbstractLogger.ERROR, "This is an error information."); }}


Template Method - Șablonul definește scheletul algoritmului dintr-o operație, lasînd ca anumiți pași să
fie (re)definiți în subclase.

Se utilizeaza acest șablon în următoarele cazuri:

 pentru a implementa părțile invariante ale unui algoritm o singura data, lăsînd subclaselor sarcina de
a implementa părțile care variază

 cînd părțile comune ale unor subclase trebuie "scoase în factor comun" și localizate într-o singură
clasă, pentru a evita duplicarea de cod; acesta este un exemplu de "reproiectare în vederea
generalizării": mai întîi se identifică diferențele din codul existent și apoi se constituie operații noi cu
diferențele respective, iar în final, codul se înlocuiește cu o metodă șablon care apelează una dintre
operațiile noi;
 pentru a controla extinderea subclaselor, și anume: se poate defini o metodă șablon care apeleaza
așa-numite operatii-hook ("carlige") în puncte specifice, permițînd astfel ca extensiile sa se realizeze
doar în acele puncte.
1. public abstract class Game {
2. abstract void initialize();
3. abstract void startPlay();
4. abstract void endPlay();
5. //template method
6. public final void play(){
7. //initialize the game
8. initialize();
9. //start game
10. startPlay();
11. //end game
12. endPlay();
13. }
14. }
15. public class Cricket extends Game {
16. @Override
17. void endPlay() {
18. System.out.println("Cricket Game Finished!");
19. }
20. @Override
21. void initialize() {

22. TEMPLATE METHOD


23. System.out.println("Cricket Game Initialized! Start playing.");
24. }
25.
26. @Override
27. void startPlay() {
28. System.out.println("Cricket Game Started. Enjoy the game!");
29. }
30. }
31. public class Football extends Game {
32. @Override
33. void endPlay() {
34. System.out.println("Football Game Finished!");
35. }
36.
37. @Override
38. void initialize() {
39. System.out.println("Football Game Initialized! Start playing.");
40. }
41.
42. @Override
43. void startPlay() {
44. System.out.println("Football Game Started. Enjoy the game!");
45. }
46. }
47. public class TemplatePatternDemo {
48. public static void main(String[] args) {
49. Game game = new Cricket();
50. game.play();
51. System.out.println();
52. game = new Football();
53. game.play();
54. }
55. }
Iterator Pattern - este un șablon comportamental, care dă posibilitatea de a trece prin toate elementele unui
obiect compus. Una dintre cele mai importante condiții pentru punerea în aplicare a acestui șablon este că, un
iterator trebuie să asigure integritatea obiectului intern.

Se utilizeaza acest șablon atunci cînd:

 este noviea de a accesa elementele unui obiect secvențial agregat. În Java ara fi colecțiile de date
ArrayList, HashMap etc.

Șablonul dat are urmatoarele beneficii:

 aceelași Iterator poate fi folosit pentu diferite agregări


 permite traversarea obiectului compus în diferite moduri, în dependență de necesități
 incapsulează structura internă în modul în care se produc iterațiile
 nu este nevoie de a face diferite operații suplimentare pentru a efectua traversările posibile

class IteratorPattern

«interface» «interface»
Iterator IterContainer

+ hasNext() : boolean + getIterator() : Iterator


+ Object() : next

NameIterator NameRepository
MainClass
- index: int + name[]: String
+ main(String) : void
+ hasNext() : boolean + getIterator() : NameIterator
+ next() : Object
1. public class NameRepository implements IterContainer {
2. public String names[] = {"Samsung", "Philips", "LG", "Panasonic;"};
3.
4. @Override
5. public Iterator getIterator() {
6. return new NameIterator();
7. }
8.
9. private class NameIterator implements Iterator {
10. int index = 0;
11.
12. @Override
13. public boolean hasNext() {
14. if (index < names.length) {
15. return true;
16. }
17. return false;
18. }
19. @Override
20. public Object next() {
21. if (this.hasNext()) {
22. return names[index++];
23. }
24. return null;
25. }
26. }
27. } ITERATOR
28. public interface IterContainer {
29. Iterator getIterator();
30. }
31. public interface Iterator {
32. boolean hasNext();
33. public Object next();
34. }
35. public class MainClass {
36. public static void main(String[] args) {
37. System.out.println("Iterator Pattern..."); //IteratorPattern
38. NameRepository nameRepository = new NameRepository();
39. System.out.print("TV Marca: ");
40. for (Iterator iterator = nameRepository.getIterator(); iterator.hasNext();) {
41. String name = (String) iterator.next();
42. System.out.print(name + ", "); } }
Command - conform șablonului command un obiect poate incapsula toate informațiile necesare pentru
apelarea unei metode a altui obiect, cum ar fi: numele metodei de apelat, obiectul ce deține metoda și valorile
de transmis parametrilor.

Șablonul are următoarele beneficii:

 aplicația definește acțiuni parametrizabile ce po fi executate mai tîrziu fără a solicita clientului
cunoașterea detaliilor interne necesare execuție

 pentru a nu bloca clientul, se dorește ca aceste acțiuni să fie definite și trimise spre execuție fără a mai
fi gestionate de client

 se decuplează execuția ulteriaoră a unei acțiuni de proprietar. Din punctul acestuia de vedere acțiunea
a fost deja trimisă spre execuție

 concept echivalent cu macrourile. Obiectul de tip command incapsulează toate informațiile necesare
execuție

 clientul este decuplat de cel ce execută acțiunea

Se utilizeaza acest șablon atunci cînd:

 funcționalitați de tip „undo”;


 comportament tranzacțional;
 progress bar sincronizat cu executia unui grup de comenzi;
 functionalitati de tip „wizard”;
 inregistrări de macro-uri;

Commnad – definește interfața necesară execuție acțiunii


ConcreteCommand – extinde interfața comenzii și implemetează metoda prin care este controlat Receiver-
ul. Reprezintă legătura dintre Receiver și acțiune.
Client – crează un obiect ConcreteCommander si setează Receiver-ul acestuia
Invocker – crează comanda și cere îndeplinirea acțiunii
Receiver – Obiectul care este responsabil de execuția acțiunii.
1. COMMAND
public class Switch {/*the Invoker class*/
2. private Command flipUpCommand;
3. private Command flipDownCommand;
4. public Switch(Command flipUpCommand,Command flipDownCommand){
5. this.flipUpCommand=flipUpCommand;
6. this.flipDownCommand=flipDownCommand;
7. }
8. public void flipUp(){
9. flipUpCommand.execute();
10. }
11. public void flipDown(){
12. flipDownCommand.execute();
13. }
14. }
15. public class Light{/*Receiver class*/
16. public Light(){ }
17. public void turnOn(){
18. System.out.println("The light is on");
19. }
20. public void turnOff(){
21. System.out.println("The light is off");
22. }
23. }
24.
25. public interface Command{/*the Command interface*/
26. void execute();
27. }
28. public class TurnOnLightCommand implements Command{Command for turning on the light*/
29. private Light theLight;
30. public TurnOnLightCommand(Light light){
31. this.theLight=light;
32. }
33. public void execute(){
34. theLight.turnOn();
35. }
36. }
37. public class TurnOffLightCommand implements Command{/*the Command for turning off the ligh
t*/
38. private Light theLight;
39. public TurnOffLightCommand(Light light){
40. this.theLight=light;
41. }
42. public void execute(){
43. theLight.turnOff();
44. }
45. }
46. public class TestCommand{/*The test class*/
47. public static void main(String[] args){
48. Light l=new Light();
49. Command switchUp=new TurnOnLightCommand(l);
50. Command switchDown=new TurnOffLightCommand(l);
51. Switch s=new Switch(switchUp,switchDown);
52. s.flipUp();
53. s.flipDown();
54. }
55. }
Decorator Ataseaza dinamic responsabilitati suplimentare la un obiect. Decoratorii ofera
alternatica flexibila la generarea 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 responsabilitati care
pot fi retrase. - cand nu este practica extinderea prin generarea de subclase. Uneori, esteposibil 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


poate 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.
Colaborari Clasa Decorator transmite cererile catre obiectul sau Component. Inainte sau dupa
transmiterea cererii, ea poate efectua optional operatii suplimentare. Consecinte Sablonul Decorator
are cel putin doua avantaje si doua dezavantaje:
1. O mai buna flexibilitate decat mostenirea statica.
2. Evita prezenta la nivelurile inalte ale unei ierarhii a claselor pline de functii.
3. Un decorator si componenta sa nu sunt identice.
4. O multime de obiecte mici.
1.DECORATOR
2. public interface Shape {
3. void draw();
4. }
5.
6. public class Rectangle implements Shape {
7.
8. @Override
9. public void draw() {
10. System.out.println("Shape: Rectangle");
11. }
12. }
13. public class Circle implements Shape {
14.
15. @Override
16. public void draw() {
17. System.out.println("Shape: Circle");
18. }
19. public abstract class ShapeDecorator implements Shape {
20. protected Shape decoratedShape;
21.
22. public ShapeDecorator(Shape decoratedShape){
23. this.decoratedShape = decoratedShape;
24. }
25.
26. public void draw(){
27. decoratedShape.draw();
28. }
29. }
30.
31. public class RedShapeDecorator extends ShapeDecorator {
32.
33. public RedShapeDecorator(Shape decoratedShape) {
34. super(decoratedShape);
35. }
36.
37. @Override
38. public void draw() {
39. decoratedShape.draw();
40. setRedBorder(decoratedShape);
41. }
42.
43. private void setRedBorder(Shape decoratedShape){
44. System.out.println("Border Color: Red");
45. }
46. }
47. public class DecoratorPatternDemo {
48. public static void main(String[] args) {
49.
50. Shape circle = new Circle();
51.
52. Shape redCircle = new RedShapeDecorator(new Circle());
53.
54. Shape redRectangle = new RedShapeDecorator(new Rectangle());
55. System.out.println("Circle with normal border");
56. circle.draw();
57.
58. System.out.println("\nCircle of red border");
59. redCircle.draw();
60.
61. System.out.println("\nRectangle of red border");
62. redRectangle.draw();
63. }
64. }
Façade- Scop – Șablonul Façade asigură o interfață unificată la o mulțime de interfețe dintr-un subsistem. –
Fațada definește o interfață de nivel mai înalt care face subsistemul mai ușor de utilizat.•
Fațada nu numai că simplifică o interfață, ci și decuplează clientul de subsistemul de componente •
Subsistemul poate fi de asemenea accesat direct, fațada nu încapsulează subsistemul. – Atât Fațada cât și
Adaptorul pot împacheta (pot fi wrappere pentru) una sau mai multe clase . Scopul Adaptorului este să
convertească interfața. Scopul Fațadei este să simplifice interfața.
1. public interface Shape {
2. void draw();
3. }
4.
5. public class Rectangle implements Shape {
6.
7. @Override
8. public void draw() {
9. System.out.println("Rectangle::draw()");
10. }
11. }
12.
13. public class Square implements Shape {
14.
15. @Override
16. public void draw() {
17. System.out.println("Square::draw()");
18. }
19. }
20.
21. public class Circle implements Shape {
22.
23. @Override
24. public void draw() {
25. System.out.println("Circle::draw()");
26. }
27. }
28.
29. public class ShapeMaker {
30. private Shape circle;
31. private Shape rectangle;

32. FAÇADE
33. private Shape square;
34.
35. public ShapeMaker() {
36. circle = new Circle();
37. rectangle = new Rectangle();
38. square = new Square();
39. }
40.
41. public void drawCircle(){
42. circle.draw();
43. }
44. public void drawRectangle(){
45. rectangle.draw();
46. }
47. public void drawSquare(){
48. square.draw();
49. }
50. }
51.
52. public class FacadePatternDemo {
53. public static void main(String[] args) {
54. ShapeMaker shapeMaker = new ShapeMaker();
55.
56. shapeMaker.drawCircle();
57. shapeMaker.drawRectangle();
58. shapeMaker.drawSquare();
59. }
60. }
Flyweight design pattern se utilizează pentru a crea o mulțime de obiecte noi, dar în loc să fie create
obiecte noi de fiecare dată, Flyweight pattern permite reutilizarea obiectelor deja existente. Șablonul dat
poate fi folosit pentru a reduce memoria necesară, timpul de instanțiere și costurile relatate la crearea
obiectelor noi.

Flyweight (Character) declară o interfață prin care greutățile pot primi și acționa în stare extrinsecică.

ConcreteFlyweight (CharacterA, CharacterB, ..., CharacterZ) implementează interfața flyweight și


adaugă spațiu de stocare pentru starea intrinsecă, dacă este cazul. Un obiect ConcreteFlyweight trebuie să fie
Sharable. Orice stat pe care îl stochează trebuie să fie intrinsecă, adică trebuie să fie independentă de contextul
obiectului ConcreteFlyweight.

UnsharedConcreteFlyweight ( not used ) Nu toate subclasele flyweight trebuie să fie partajate. Interfața
flyweight permite partajarea, dar nu o pune în aplicare. Este comun pentru obiectele UnsharedConcreteFlyweight
pentru a avea obiecte ConcreteFlyweight ca copii la un anumit nivel în structura obiectului flyweight (ca clasele
de rând și coloană au).

FlyweightFactory (CharacterFactory) creează și gestionează obiecte în greutate. Asigură partajarea corectă


a greutății. Atunci când un client solicită o greutate, FlyweightFactory obiecte activele o instanță existentă sau
creează unul, dacă nu există.

Client (FlyweightApp) menține o referință la flyweight(s) .Calculează sau depozitează starea extrinsecă de
flyweight (e).
1. public interface Shape {
2. void draw();
3. }
4.
5. public class Circle implements Shape {
6. private String color;
7. private int x;
8. private int y;
9. private int radius;
10.
11. public Circle(String color){
12. this.color = color;
13. }
14.
15. public void setX(int x) {
16. this.x = x;
17. }
18.
19. public void setY(int y) {
20. this.y = y;

21. } FLYWEIGHT
22.
23. public void setRadius(int radius) {
24. this.radius = radius;
25. }
26.
27. @Override
28. public void draw() {
29. System.out.println("Circle: Draw() [Color : " + color + ", x : " + x + ", y :" + y +
", radius :" + radius);
30. }
31. }
32.
33. import java.util.HashMap;
34.
35. public class ShapeFactory {
36.
37. // Uncomment the compiler directive line and
38. // javac *.java will compile properly.
39. // @SuppressWarnings("unchecked")
40. private static final HashMap circleMap = new HashMap();
41.
42. public static Shape getCircle(String color) {
43. Circle circle = (Circle)circleMap.get(color);
44.
45. if(circle == null) {
46. circle = new Circle(color);
47. circleMap.put(color, circle);
48. System.out.println("Creating circle of color : " + color);
49. }
50. return circle;
51. }
52. }
53.
54. public class FlyweightPatternDemo {
55. private static final String colors[] = { "Red", "Green", "Blue", "White", "Black" };
56. public static void main(String[] args) {
57.
58. for(int i=0; i < 20; ++i) {
59. Circle circle = (Circle)ShapeFactory.getCircle(getRandomColor());
60. circle.setX(getRandomX());
61. circle.setY(getRandomY());
62. circle.setRadius(100);
63. circle.draw();
64. }
65. }
66. private static String getRandomColor() {
67. return colors[(int)(Math.random()*colors.length)];
68. }
69. private static int getRandomX() {
70. return (int)(Math.random()*100 );
71. }
72. private static int getRandomY() {
73. return (int)(Math.random()*100);
74. }
75. }
76.
77. public class FlyweightPatternDemo {
78. private static final String colors[] = { "Red", "Green", "Blue", "White", "Black" };
79. public static void main(String[] args) {
80.
81. for(int i=0; i < 20; ++i) {
82. Circle circle = (Circle)ShapeFactory.getCircle(getRandomColor());
83. circle.setX(getRandomX());
84. circle.setY(getRandomY());
85. circle.setRadius(100);
86. circle.draw();

87. } FLYWEIGHT
88. }
89. private static String getRandomColor() {
90. return colors[(int)(Math.random()*colors.length)];
91. }
92. private static int getRandomX() {
93. return (int)(Math.random()*100 );
94. }
95. private static int getRandomY() {
96. return (int)(Math.random()*100);
97. }
98. }
PROXY design pattern oferă o clasă surogat sau o clasă înlocuitoare pentru un alt obiect, pentru a controla
accesul la obiectul dat. Proxy pattern este utilizat pentru a creaz reprezentări obiectelor ce controlează
accesul către alte obiecte, ce poate fi folosit de la distanță, costisitor de creat sau este necesar să fie securizat.

Intenția acestui model este de a oferi unui Placeholder pentru un obiect pentru a controla referințele la
acesta.

Subject Interfața implementată de RealSubject și reprezentând serviciile sale. Interfața trebuie implementată
și de proxy, astfel încât proxy-ul să poată fi utilizat în orice locație unde poate fi folosit RealSubject.

PROXY Menține o referință care permite Proxy-ului să acceseze RealSubject.


Implementează aceeași interfață implementată de RealSubject astfel încât Proxy-ul să poată fi înlocuit cu
RealSubject.Controlează accesul la RealSubject și poate fi responsabil pentru crearea și ștergerea acestuia.
Alte responsabilități depind de tipul de proxy.

RealSubject - obiectul real reprezentat de proxy.

Există patru situaţii în care se recomandă să folosim un astfel de şablon:


1)Virtual proxy = o clasă de acces către obiectele unei alte clase ce
presupunhe utilizarea multor resurse; obiectul real este creat la prima cerere de acces la acesta.
2) Remote proxy = asigură o reprezentare locală pentru un obiect dintr -un spaţiu diferit de memorie; în RPC
şi CORBA o astfel de funcţionalitatea o asigură un„stub”.
3) Protective proxy = clasă de control al accesului la obiecte mai sensibiledin punct de vedere al securităţii.
Obiectul proxy verifică dacă expeditorul are dreptul sătransmită mesaje destinatarului.
4) Smart proxy = clasă care nu doar transmite mai departe o operaţie derealizat, ci realizează în plus o serie
de acţiuni, cum ar fi:
a. numără referirile la un anumit obiect;
b.încarcă obiecte persistente la prima utilizare;
c.verifică dacă obiectul adevărat este blocat pentru alte accese (asigură prelucrăritranzacţionale şi diferite
niveluri de izolare
1. interface ICar
2. {
3. void DriveCar();
4. }
5.
6. // Real Object
7. public class Car : ICar
8. {
9. public void DriveCar()
10. {
11. Console.WriteLine("Car has been driven!");
12. }
13. }
14.
15. // Proxy Object
16. public class ProxyCar : ICar
17. {
18. private Driver driver;
19. private ICar realCar;
20.
21. public ProxyCar(Driver driver)
22. {
23. this.driver = driver;
24. this.realCar = new Car();
25. }
26.
27. public void DriveCar()
28. {
29. if (driver.Age < 16)
30. Console.WriteLine("Sorry, the driver is too young to drive.");
31. else

32. PROXY
33. this.realCar.DriveCar();
34. }
35. }
36.
37. public class Driver
38. {
39. public int Age { get; set; }
40.
41. public Driver(int age)
42. {
43. this.Age = age;
44. }
45. }
46.
47. // How to use above Proxy class?
48. private void btnProxy_Click(object sender, EventArgs e)
49. {
50. ICar car = new ProxyCar(new Driver(15));
51. car.DriveCar();
52.
53. car = new ProxyCar(new Driver(25));
54. car.DriveCar();
55. }
strategy ne ajută să alegem un anumit algoritm de utilizat în funcţie de un context. Şablonul conţine un grup
de algoritmi, fiecare din aceştia fiind încapsulat într -un obiect. Clienţii ce folosesc algoritmii nu depind de
aceştia, variind în mod independent.

Strategy declară o interfață care este implementată de toți algoritmii sprijiniți.


Obiectele ConcreteStrategy implementează algoritmul definit de Strategie.
Contextul menține o referință la un obiect Strategy și utilizează această referință pentru a apela algoritmul
definit de o anumită ConcreteStrategy.

Obiectele de tip context conţin câte un obiect strategy, dar alegerea unei strategiiconcrete se realizează în
funcţie de context.
Conform şablonului strategy comportamentul unei clase nu ar trebui să fiemoştenit, ci specific contextului
în care rulează.
avantaje:
1. O familie de algoritmi poate fi definită ca o ierarhie de clasă și poate fi utilizată alternativ pentru a
modifica comportamentul aplicației fără a schimba arhitectura acesteia.
2. Prin încapsularea algoritmului separat, noi algoritmi care respectă aceeași interfață pot fi ușor
introduși.
3. Aplicația poate schimba strategiile la timpul de execuție.
4. Strategia permite clienților să aleagă algoritmul necesar, fără a folosi o declarație "switch" sau o
serie de instrucțiuni "if-else".
Dezavantaje:
1. Aplicația trebuie să fie conștientă de toate strategiile pentru selectarea celei potrivite pentru situația
potrivită.
2. Contextul și clasele Strategiei comunică în mod obișnuit prin interfața specificată de clasa de bază
Abstract Strategy. Strategia bazei de clasă trebuie să expună interfața pentru toate comportamentele
necesare, pe care anumite clase de strategie concrete nu le pot implementa.
3. În cele mai multe cazuri, aplicația configurează contextul cu obiectul Strategie necesar. Prin urmare,
aplicația trebuie să creeze și să mențină două obiecte în locul uneia.
1. abstract class CookStrategy STRATEGY
2. {
3. public abstract void Cook(string food);
4. }
5.
6. class Grilling : CookStrategy
7. {
8. public override void Cook(string food)
9. {
10. Console.WriteLine("\nCooking " + food + " by grilling it.");
11. }
12. }
13.
14. /// <summary>
15. /// A Concrete Strategy class
16. /// </summary>
17. class OvenBaking : CookStrategy
18. {
19. public override void Cook(string food)
20. {
21. Console.WriteLine("\nCooking " + food + " by oven baking it.");
22. }
23. }
24.
25. class DeepFrying : CookStrategy
26. {
27. public override void Cook(string food)
28. {
29. Console.WriteLine("\nCooking " + food + " by deep frying it");
30. }
31. }
32.
33. class CookingMethod
34. {
35. private string Food;
36. private CookStrategy _cookStrategy;
37.
38. public void SetCookStrategy(CookStrategy cookStrategy)
39. {
40. this._cookStrategy = cookStrategy;
41. }
42.
43. public void SetFood(string name)
44. {
45. Food = name;
46. }
47.
48. public void Cook()
49. {
50. _cookStrategy.Cook(Food);
51. Console.WriteLine();
52. }
53. }
54.
55. static void Main(string[] args)
56. {
57. CookingMethod cookMethod = new CookingMethod();
58.
59. Console.WriteLine("What food would you like to cook?");
60. var food = Console.ReadLine();
61. cookMethod.SetFood(food);
62.
63. Console.WriteLine("What cooking strategy would you like to use (1-3)?");
64. int input = int.Parse(Console.ReadKey().KeyChar.ToString());
65.
66. switch(input)
67. {
68. STRATEGY
69. case 1:
70. cookMethod.SetCookStrategy(new Grilling());
71. cookMethod.Cook();
72. break;
73.
74. case 2:
75. cookMethod.SetCookStrategy(new OvenBaking());
76. cookMethod.Cook();
77. break;
78.
79. case 3:
80. cookMethod.SetCookStrategy(new DeepFrying());
81. cookMethod.Cook();
82. break;
83.
84. default:
85. Console.WriteLine("Invalid Selection!");
86. break;
87. }
88. Console.ReadKey();
89. }
Interpreter descrie cum se pot interpreta expresiile într -un anumit limbaj. El îşi găseşte utilitatea în
aplicaţiile economice în care se doreşte salvarea unor formule decalcul într-un format accesibil utilizatorilor
finali şi folosirea ulterioară de către aplicaţie a acestor formule. Conform şablonului interpreter atât peranzii,
cât şi operatorii dintr-o expresie ar trebui să aibă aceeaşi interfaţă.

Diagrama claselor de mai sus (cea din NetBeans de la acest şablon) nu surprindenevoia existenţei unui
evaluator de expresii. Acest evaluator trebuie să împartă expresia deinterpretat în mai multe părţi cu un
parser. Tot evaluatorul trebuie să parcurgă fiecare parte a expresiei:
- când întâlneşte un operand (o variabilă pe care are voie utilizatorul să ofolosească într -o anumită formulă)
îl introduce într -o stivă;
-când întâlneşte un operator extrage din stivă valorile operanzilor afectaţi şiintroduce în loc rezultatul
aplicării operatorului asupra operanzilor.Dacă se pleacă de la o expresie corectă la sfărşitul parcurgerii
acesteia în stiva utilizată va rămâne o singură valoare, ea fiind chiar rezultatul interpretării.

Exemple de aplicaţii în care ar putea fi utilizat şablonul interpreter:


- aplicaţii de salarizare;

- aplicaţii de procesare a datelor la importul sau exportul lor din difer


ite sisteme;
-aplicaţii de interpretare a unui dialect SQL sau de traducere dintr -un dialect SQL în altul.

Un interpretor poate fi văzut şi ca o „cutie neagră” căreia i se dă o expresie şi care returnează un rezultat.