Cuprins

Curs 1 ................................................................................ 6
Principii de baza in obiectualitate ....................................... 6
Clasa: ........................................................................... 6
Interfaa: ....................................................................... 6
Implementarea: .............................................................. 6
Ascunderea implementarii: ................................................. 7
SPECIFICATORII DE ACCES: ............................................ 7
Private: ......................................................................... 7
Public: .......................................................................... 7
Protected: ...................................................................... 7
REUTILIZAREA IMPLEMENTARII COMPOZIT IE .............. 7
-

Compozitie:............................................................... 7

REUTILIZAREA IMPLEMENTARII MOSTENIRE ................. 8

Mostenire: ..................................................................... 8
OBIECTE INTERSCHIMBABILE PRIN POLIMORFISM .......... 8
IERARHIE CU O SINGURA RADACINA .............................. 9
CONTAINERE .................................................................. 9
CURS 2-3 ......................................................................... 10
ORGANIZAREA CODULUI .............................................. 10
CREAREA OBIECTELOR SI C ICLUL DE VIATA ................. 10
NUME DE OBIECTE REFERINTE ................................... 10
ORGANIZAREA MEMORIE I IN J AVA ............................... 10
TIPURI DE DATE ........................................................... 11
DOMENIILE DE VIZIBILITATE IN JAVA .......................... 11
VIZIBILITATEA NUMELOR ............................................. 12
CUVANTUL CHEIE STATIC ............................................. 12
STIL DE SCRIERE A CODULUI ........................................ 12
OPERATORI .................................................................. 12
CONTROLUL EXECUTIE I ................................................ 13
INIT IALIZAREA OBIECTELOR ........................................ 13
SUPRAINCARCAREA METODELOR ................................. 13
CUVANTUL CHEIE this ................................................ 14
DISTRUGEREA OBIECTELOR .......................................... 14
1

STERGEREA CORECTA A OBIECTELOR ........................... 14

MODUL DE FUNCTIONARE A GARBAGE COLLECTORULUI
.................................................................................... 14
INIT IALIZAREA DATELOR MEMBRE: .............................. 15
PROCESUL CREARII UNUI OBIECT: ................................ 15
BLOCUL STATIC ........................................................... 16
INIT IALIZARE PRIN BLOC NON -STATIC ......................... 16
INIT IALIZAREA SIRUR ILOR ........................................... 16
CONTROLUL ACCESULUI Clase ................................... 16
CONTROLUL ACCESULUI Membrii Claselor ................... 16
CURS 4. ........................................................................... 18
REALIZAREA CLASELOR ............................................... 18
REUTILIZAREA CODULUI: ................................................ 18
INIT IALIZAREA REFERINTELOR LA REALIZAREA
COMPOZIT IE I ................................................................ 18
SINTAXA MOSTENIR II ................................................... 18
IS-A vs Is-Like-A ........................................................... 19
OPERATIA DE DELEGARE .............................................. 19
ASCUNDEREA NUMELOR LA MOSTENIRE ....................... 19
ALEGEREA INTRE COMPOZIT IE S I MOSTENIRE .............. 19
MECANISMUL UPCAST .................................................. 20
DOWNCAST ................................................................... 20
ORDINEA DE APELARE A CONSTRUCTORILOR ............... 21
CURS 5 ............................................................................ 22
Interfete ........................................................................ 22
CLASE ABSTRACTE ....................................................... 22
CONCEPTUL DE INTERFATA .......................................... 22
DESIGN PATTERNUL STRATEGY .................................... 23
DESIGN PATTERNUL ADAPTER ...................................... 23
MOSTENIREA MULT IP LA ............................................... 23
DESIGN PATTERNUL FACTORYMETHOD ........................ 24
CURS 6 ............................................................................ 25
CLASE INTERIOARE ...................................................... 25
INNER CLASSES ............................................................ 25
CLASE INTERIOARE ANONMIE ...................................... 25
2

DE CE CLASE INNER ..................................................... 26

CLOSURES & CALLBACKS ............................................. 26
CONTROL FRAMEWORKS ............................................... 27
MOSTENIRE DIN CLASE INNER ...................................... 27
CURS 7 ............................................................................ 28
COLECTII, EXCEPTII ..................................................... 28
CONTAINERE GENERICE ............................................... 28
TIPURI DE CONTAINERE JAVA ...................................... 28
LUCRUL CU CONTAINERE ............................................. 29
LISTE: 2 TIPURI DE LISTE ............................................. 29
ITERATORI ................................................................... 29
EXCEPTII ...................................................................... 29
GUARDED REGIONS ...................................................... 30
CREAREA PROPRIILOR EXCEPTII ................................... 31
SPECIFICAREA EXCEPTIE I ............................................. 31
INLANTUIREA EXCEPTIILOR ......................................... 31
IERARHIA EXCEPTIILOR IN JAVA .................................. 32
EXCEPTII P IERDUTE...................................................... 32
RESTRICTII LA EXCEPTII .............................................. 32
GUIDE LINES: ................................................................ 32
CURS 8 ............................................................................ 33
I/O J ava ......................................................................... 33
SISTEMUL DE I/O INTR -UN LIMBAJ DE PROGRAMARE .... 33
CLASA FILE .................................................................. 33
INPUT si OUTPUT .......................................................... 33
TIPURI DE InputStream ................................................... 33
TIPURI DE OutputStream ................................................. 34
DESIGN PATTERNUL DECORATOR ................................. 34
TIPURI DE FilterInputStream ........................................... 34
TIPURI DE FilterOutputStream ......................................... 34
READER si WRITER ....................................................... 35
RANDOM AccessFile ....................................................... 35
REALIZAREA FIS IERELOR COMPRIMATE ....................... 35
FIS IERE JAR .................................................................. 35
SERIALIZARE: ............................................................... 36
3

EXTERNALIZARE .......................................................... 36
EVITAREA SERIALIZAR II ANUMIT OR COMPONEN TE ALE
OBIECTELOR................................................................. 37
CURS 9. ........................................................................... 38
RTTI ............................................................................. 38
OBIECTUL CLASS .......................................................... 38
CLASS LITERAL ............................................................ 38
GENERIC CLASS REFERENCE ......................................... 39
COMPARAREA OBIECTELOR DE TIP CLASS .................... 39
REFLECTION ................................................................. 39
DESIGN PATTERNUL PROXY .......................................... 40
CURS 10 .......................................................................... 41
CONCURENTA IN JAVA ................................................. 41
INTRODUCERE IN PROGRAMAREA CONCURENTA: ......... 41
EXECUTIA MAI RAPIDA A PROGRAMELOR ..................... 41
ABORDARI ALE LP ........................................................ 42
CODE DESIGN ............................................................... 42
THREADING IN JAVA .................................................... 42
TERMINOLOGIE ............................................................ 43
CLASA THREAD ............................................................ 43
VARIAT II LA CREAREA TASKURILOR ............................ 43
EXECUTORS .................................................................. 44
CREAREA DE THREADURI PT EXECUTORS ..................... 44
RETURNAREA DE VALORI DIN THREADURI ................... 44
THREADURI DAEMON ................................................... 45
CREAREA UNOR INTERFETE GRAFICE RESPONSIVE ....... 45
PRINDEREA E XCEPTIILOR ............................................. 45
CURS 11 .......................................................................... 47
Partajarea resurselor .......................................................... 47
PARTAJAREA RESURSELOR MUTEX ............................ 47
PARTAJAREA RESURSELOR SYNCHRONIZED ............... 47
MECANISM MUTEX EXPLIC IT: LOCK .............................. 47
AVANTAJELE MECANISMULUI LOCK ............................. 47
ATOMIC ITATE SI VOLAT ILITATE ................................... 48
SECTIUNI CRIT IC E ........................................................ 48
4

STARI ALE UNUI THREAD ............................................. 48

CUM SE PUNE UN THREAD IN STAREA BLOCKED ........... 49
INTRERUPEREA TASKURILOR ........................................ 49
INTRERUPEREA TASKURILOR RULATE CU EXECUTORS . 49
COOPERAREA INTRE TASKURI ...................................... 49
DEADLOCK ................................................................... 50

Teo rie Ja va
Curs 1
Cuprins:
Principiile programarii obiectuale;
Notiunea de obiect;

Principii de baza in obiectualitate

Programarea obiectuala:
Elemente din spatiul problemei precum si reprezentariile
acestora in spatiul solutiei => Obiecte
Caracteristici ale limbajelor obiectuale:
1. Orice element este un obiect;
2. Un program este o colectie de obiecte care isi spun unul
altuia ce sa faca prin trimitere de mesaje
3. Fiecare obiect are un spatiu de memorie, posibil compus
din alte obiecte
4. Fiecare obiect are un tip
5. Toate obiectele de acelasi tip pot primi acelasi mesaj
(PROPRIETATEA UPCAST).
Definitii:
Definitia Bosch pentru un obiect: Un obiect are o stare, un
comportament si o identitate
Clasa: Este un set de obiecte cu caracteristici si
functionalitati identice (termenul de clasa se substituie
termenului tip)
Interfaa: Metode (functionalitate): cererile care pot fi
adresate unui obiect particular dintr -o clasa
Implementarea: Mod concret de realizare a functionalitatii
Un obiect poate fi privit ca si furnizor de servicii
Se imbunatateste coeziunea obiectelor (obiectele trebuie sa
se potriveasca bine unele cu altele)
UML: Limbaj standardizat pentru modelarea obiectuala.

Reprezentarea claselor:
Nume Tip(numele clasei) -> Light
Interfata (Functionalitatiile Clasei )-> On();
Off();
Brighten();
Dim();
Definirea unui obiect din clasa Light:
Light it = new Light();
Apelarea unei functii din clasa light cu ajutorul obiectului
definit in clasa respectiva:
It.on();

Ascunderea implementarii:
Exista doua tipuri de programatori:
-

Creatori de clase creaza clase care expun doar

functionalitatea necesara claselor client, restul ramane
ascuns;
Programatori Client consumatori de clase, rolul lor este
sa fie echipati cu un set de clase pentru dezvoltarea
rapida a aplicatiilor finale

Programatorii creatori de clase trebuie sa poata schimba

implementarea ascunsa fara ca programatorii clienti sa fie
afectati.

SPECIFICATORII DE ACCES:
Private: elementele private pot fi accesate doar de creatorul
clasei in cadrul metodelor acelei clase
Public: elementele publice sunt disponibile oricaror alte
clase
Protected: similar cu private, utilizat in mostenire, clasele
care mostenesc pot accesa elemente private din clasele de baza.

REUTILIZAREA IMPLEMENTARII COMPOZITIE

Managementul complexitatii: desc ompunerea elementelor
problemei in parti componente
2 Metode de realizare a complexitatii:
-

Compozitie: o clasa noua contine clase existente ( relatie

has-a). Se realizeaza prin creare de obiecte membre.
Compozitia realizata dinamic se numeste agregare.
7

REUTILIZAREA IMPLEMENTARII MOSTENIRE

Datele si functionalitatiile se pot impacheta dupa concepte
care reprezinta idei similare din spatiul problemei.
Mostenire: O clasa noua se aseamana (extinde) o clasa
existenta (Relatie is-a sau is-like-a).
Clasa de baza contine caracteristicile si comportamentele
care vor fi partajate cu tipurile derivate.
Clasa Derivata contine:
-

Toti membrii clasei (inclusiv cei privati care sunt

ascunsi).
Toata interfata clasei de baza, care este duplicata

Clasa derivata este in acelasi timp de tipul clasei de baza.

Mostenire cum se diferentiaza clasa derivata de clasa de
baza.
-

Prin adaugarea de noi metode suplimentare;

Schimbarea comportamentului unor metode existente in
clasa de baza (overriding);
Relatia is-a: Clasa derivata doar override metode din
clasa de baza (principiul substitutiei pure)
Relatia is-like-a: Clasa derivata adauga elemente noi
interfetei de baza (metodele noi nu sunt accesibile din
clasa de baza substitutia nu mai este pura).

OBIECTE INTERSCHIMBABILE PR IN POLIMORFISM

-

La ierarhiile de clase dorim sa tratam obiectele unitar

sub tipul de baza, astfel putem scrie cod care nu depinde
de un specific si care manipuleaza obiecte generice
Se doreste ca sa se execute codul in obiectele claselor
derivate fara ca sa stim (la compilare) care vor fi efectiv
aceste obiecte
Compilatoare traditionale (non OOP) early binding
Compilatoare OOP late binding codul apelat este
determinat abia la executie, la compilare se asigura doar
corespondenta tipului argumentelor si a tipului de return.
J a v a c o m p i l a t o r O O P d yn a m i c ( l a t e ) b i n d i n g
Proprietatea de UPCAST: tratarea unui obiect dintr -o
clasa derivata ca si cum ar fi din clasa de baza.

IERARHIE CU O SINGURA RADACINA

In java (si in orice limbaj de programare obiectual cu
excepria c++) toate clasele mostenesc o clasa de baza numita
OBJECT.
Astfel, toate obiectele din limbaj pot fi echipate in mod
garantat cu o anumita functionalitate.
Se usureaza implementarea garbage collectorului.

CONTAINERE
-

Necesare datorita faptului ca nu stim de la design

numarul de obiecte necesare pentru a rezolva o anumita
problema;
Containerele sunt siruri de referinta catre alte obiecte;
Ele se expandeaza automat pentru a salva noi obiecte,
dupa necesitati;
Avem doua tipuri de liste (ArrayList si LinkedList)
Containerele in Java sunt create sa pastreze obiecte de
tipul Object.-> ele pot salva orice.
Pot aparea exceptii la Downcast, la runtime, timp de
executie crescut datorita operatiei de DownCast.
Containere parametrizate (ArrayList<Shape> sh ape = new
ArrayList<Shape> ();)

CU RS 2- 3
-

NOTIUNI INTRODUCTIVE JAVA

INIT IALIZAREA OBIECTELOR

ORGANIZAREA CODULUI
-

Pentru fiecare clasa compilata se produce un fisier

.class;
Un program este compus dintr-o colectie de fisiere .class
Acestea pot fi arhivate: fisier .jar;
Fiecare fisier java incepe cu mentiunea package: se
indica numele packageului din care vor face parte clasele
Clasele utilizate care fac parte din alt package se importa
cu import
Toate clasele dintr-un package vor fi colectate intr -un
singur subdirector;
Conventie pentru denumirea packageurilor: utilizarea
domeniilor de internet in ordine inversa
C a l e a r o o t p e n t r u d i r e c o a r e : v a r i a b i l a s ys t e m
CLASSPATH
CLASSPATH poate include directoare sau fisiere .jar

CREAREA OBIECTELOR SI CICLUL DE VIATA

-

Fiecare obiect necesita resurse (memorie), crearea si

distrugerea obiectelor devin importante;
Java utilizeaza in mod exclusive alocarea dinamica a
memoriei;
Pentru orice obiect, trebuie utilizat new la creare.
Obiectele sunt alocate in zona de heap
Distrugerea obiectelor este realizata automat de catre
garbage collector;
GC identifica momentul in care un obiect nu mai este
utilizat si il dezaloca.

NUME DE OBIECTE REFERINTE

-

Identificatorii prin care se manipuleaza obiectele sunt

referinte catre obiecte
De ex: String s; //se creaza o referinta catre un obiect de
tip string;
String s = new String(exemplu)//referinta create este
initializata
Toate variabilele (referintele) create in program trebuie
initializate!!!

ORGANIZAREA MEMORIEI IN JAVA

-

Zona Registru : registrele procesorului, nu avem acces

direct la ele
Stiva: zona de stiva memoreaza referintele catre obiecte;
10

Heap: In aceasta zona sunt alocate toate obiectele (la

apelul new)
Spatiu de stocare non -RAM: Obiectele care exista in
afara spatiului de memori e a programului (persistenta
obiectelor),

TIPURI DE DATE
Tipurile primitive:
-

Variabile de dimensiune mica, salvate direct pe stiva;

Nu necesita new la alocare;
B o o l e a n , c h a r , b yt e , s h o r t , i n t , l o n g , f l o a t , d o u b l e s i
void;
F i e c a r e d i n a c e s t e a r e u n w r a p p e r t yp e p e n t r u c o n s t r u i r e a
obiectului din tipul correspondent;
Autoboxing: conversie automata de la un tip primitive la
wrapper: Character ch = x;

Numere de inalta precizie

-

BigInteger si BigDecimal
Sunt vazute ca sic lase de tip Wrapper insa nu au un tip
primitive correspondent;

Siruri (Arrays) in JAVA

-

J A V A : l i m b a j d e p r o g r a m a r e o r i e n t a t s a f e t y;
La crearea unui Array se creaza un sir de referinte
fiecare initializata la valoarea null => Fiecare membru al
sirului trebuie initializat;
JAVA nu permite utilizare a unui indice in afara range ului array-ului (se arunca o exceptie)

DOMENIILE DE VIZIBILITATE IN JAVA

-

Intre o acolada deschisa si una inchisa avem un domeniu

de vizibilitate (la fel ca in C/C++);
Java determina cand un obiect nu mai este referit de
catre nici o referinta dintr-un domeniu de vizibilitate
valid => se apeleaza garbage collector pentru
dezalocarea memoriei;

CLASE!!!!
-

Class ATypeName{/*class Body */}

Clasele contin:
Metode;
Campuri;
Modul de accesare a unui camp/metoda:
objectReference.member.

11

Pentru datele din tipuri primitive se garanteaza

initializarea la valori implicite (false si 0);
Metode, argumente si tip de return:
ReturnType methodName(/*argument list*/)
{
/*Method Body*/
}

VIZIBILITATEA NUMELOR
-

Pentru fiecare nume de biblioteci unice, s-a realizat

conventia ca fiecare programator sa isi utilizeze propriul
nume de domeniu de internet ca si nume de biblioteca
(ex: ro.ubbcluj.econ.gsilaghi)
Punctul in numele bibliotecii reprezinta un subdirector
de pe disc;
Utilizarea altor component: INP ORT:
Inport java.util.ArrayList; // se importa o clasa;
Import java.util.*; // se importa tot packageul
java.util.

CUVANTUL CHEIE STATIC

-

Datele membre si metodele pot fi accesate doar sub

calificarea unui obiect existent in memoria programului.
Un camp sau o metoda static nu este legate de vreun
obiect anume dintr-o clasa
Class data sau class method;
Un camp static exista o singura data pentru o clasa, fiind
partajat de toate obiectele clasei respective;
Campurile statice pot fi referite prin numele clasei;
Metodele statice sunt la nivel de clasa, pot fi referite
prin numele clasei (fara a fi necesara existent unui
obiect)
Metoda main;
Metodele statice nu pot accesa campuri/metode ne -statice
din clasa;

STIL DE SCRIERE A CODULUI

-

Code conventions for the java language;

Numele clasei din mai multe cuvinte cu capitalizarea
fiecarui cuvant din nume;
Pentru orice altceva (metode, camputi, referinte de
obiecte) prima litera e mica;

OPERATORI
-

Toti operatorii produc o valoare prin aplicarea lor;

Ei pot produce si side-effects (modificarea valorii
operanzilor);
Operatorul de atribuire =
12

A=4 // atribuirea unei valori dintr -un tip primit unei

variabile
Daca c si d sunt obiecte, c=d; // ambele (c si d) vor
referi acelasi obiect (d);
-

Aliasing: la transmiterea unui obiect ca si argument intro metoda, se transmite o referinta, deci modificarea
valorii in metoda afecteaza valoarea obiectului din afara
metodei;
Operatorii ++ si au forma postfixata (similar cu
C/C++);
Operatorii == si =! Aplicati pe referinte de obiecte,
compara referintele, si nu continutul obiectelor.
Pentru compararea continutului obiectelor, metoda
equals: n1.equals(n2).
Pentru clasa String se pot folosi + si +=;

CONTROLUL EXECUTIEI
-

If-then-else
While, do-while, for
Foreach: pentru a selecta un element d intr-un array si a
efectua o prelucrare pe acel element:
Foreach functioneaza pentru orice sir de obiecte
Iterabile
Intreruperea executiei unei secvente: return, break,
continue;
Switch: intstructiunea de selectie din mai multe
alternative.

INITIALIZAREA OBIECTELOR
-

In fiecare clasa se garanteaza initializarea obiectelor

prin scrierea unui constructor;
La crearea unui obiect, Java apeleaza automat
constructorul clasei respective;
Numele constructorului este identic cu numele clasei
Constructorul default: Nu are argumente;
Constructorul nu are tip de return;
Daca se creaza o clasa fara nici un constructor,
compilatorul creaza in mod automat constructorul
default;

SUPRAINCARCAREA METODELOR
-

Utilizarea aceluias nume de metoda pentru mai multe

metode cu argumente diferite;
Cum diferentiaza Java intre metodele supraincarcate:
aceste metode trebuie sa difere prin lista argumentelor;

13

La supra incarcare, primitivele din lista de argumente

sun promoted catre tipurile mai largi
Metodele nu se pot supraincarca pe tipul de return;

CUVANTUL CHEIE this

-

In fiecare metoda apelata, referinta obiectului sub care

se apeleaza metoda este transmisa in metoda sub forma
referintei this
This poate fi utilizat doar in interiorul metodelor ne statice
In interiorul unei metode dintr -o clasa, la apelul unei
metode din clasa curenta, nu este nevoie sa se utilizeze
this.
This este frecvent utilizat in return, pentru a returna
obiectul curent.

DISTRUGEREA OBIECTELOR
-

Garbage Collectorul dezaloca memoria alocata prin new,

atunci cand obiectele nu mai sunt folosite;
Metoda finalize(): permite operatii de stergere inainte ca
obiectele sa fie supuse garbage collectorului;
Metoda finalize(): Java nu garanteaza apelarea acestei
metode, programatorul nu are control asupra momentului
cand se apeleaz a garbage colectorul;
Daca obiectele noastre agrega alte obiecte, garbage
colectorul se ocupa de dezalocarea obiectelor aggregate;
Finalize se utilizeaza in general pentru a implementa un
termination conditions pentru un obiect(de ex: inchiderea
unui fisier).

STERGEREA CORECTA A OBIECTELOR

-

Java nu garanteaza apelarea metodei finalize la

distrugerea obiectelor;
Ce se intampla atunci cand este necesa ca obiectele sa fie
sterse daca programele se incheie cu exceptie? Se
pune codul de stergere intro metoda di spose
Metoda dispose se apeleaza pe clauza finally a unui try catch global.
La stergerea obiectelor, aceasta trebuie sa se realizeze in
ordine inversa crearii obiectelor => programul trebuie sa
se asigure de acest lucru.

MODUL DE FUNCTIONARE A GARBAGE COL LECTORULUI

-

GC colecteaza memoria ramasa alocata in obiectele care

nu mai sunt utilizate si compacteaza heap -ul, rearanjand
obiectele alocate
14

Reference counting: O modalitate de a implementa un

GC:
De cate ori se asociaza o referinta pentru un obiect,
reference counterul obiectului se incrementeaza;
De cate ori se pierde o referinta pentru un obiect,
reference counterul obiectului se decrementeaza;
GC scaneaza sirul de variabile reference counters sic
and intalneste una nula, dezaloca obiectul respective.
Implementarea JAVA: pentru un obiect live se poate
identifica o referinta fie pe stack fie in static storage;
S t o p - a n d - c o p y: G C - u l o p r e s t e p r o g r a m u l , s c a n e a z a t o a t e
referintele de pe stack si copiaza obiectele identificate in
noul heap. Cee ace ramane e garb age-ul care trbuie
dezalocat, iar noul heap e deja compactat.

INITIALIZAREA DATELOR MEMBRE:

-

Utilizarea unei variabile locale neinitializate => eroare

de compilare;
Orice data membra a unei clase, daca este de tip
primitive, se garanteaza initializare la va loarea
implicita.
Obiectele member neinitializate, vor avea valoarea null
Specificarea valorii de initializare:
La momentul definirii variabilei primitive prin
asignarea cu o valoare;
La momentul definirii variabilei non -primitive, prin
new.
Initializarea datelor member prin constructor
Ordinea de initializare a datelor member: ordinea in care
acestea sunt definite in clasa;
Initializarea datelor statice are loc doar daca acestea
sunt necesar de a fi utilizate;
Obiectele statice sunt initializate inaintea c elor nonstatice, daca ele nu au fost utilizate pana atunci.

PROCESUL CREARII UNUI OBIECT:

-

Presupunem ca avem o clasa Dog;

Prima data cand un obiect de tip Dog este creat, JVM
localizeaza pe disc fisierul Dog.class si il incarca;
La incarcare Doc.class, se initializeaza toti membri static
La new Dog() se aloca memorie pe heap pentru noul
obiect, aceasta zona de memorie se umple cu 0
(primitivele sunt initializate la valoarea implicita)
Se realizeaza toata initializarile explicite la momentul
definiri datelor member
Se executa constructorul;

15

BLOCUL STATIC
-

Static{/*initializari*/}
Blocul static este apelat o singura data, la prima creare a
unui obiect din clasa respective sau la apelearea unei
member statice din acea clasa;
Blocul static poate sa initializeze doar date statice

INITIALIZARE PRIN BLOC NON -STATIC

-

{/*operatii*/}; //fara static inainte;

Intre accolade se specifica operatii de initializare care
trebuie effectuate indifferent de care constructor este
apelat;
Blocul non-static de initializare este nece sar pentru a se
permite definirea claselor interne anonime.

INITIALIZAREA SIRURILOR
-

Sirurile sunt definite prin operatorul de indexare: int[]a;

Pentru a se crea spatiu de memorie pentru sir, sirul
trebuie initializat;
Fiecare sir are un membru intrisec: le ngth(lungimea
sirului);
Elementele sunt indexate de la 0 la length -1;
Integer[]a= new integer[rand.nextInt(20)]; // se creaza
doar un sir de referinte, fiecare din ele trebuie apoi
initializate, de ex: a[i]=rand.nextInt(500);

CONTROLUL ACCESULUI Clase

-

Package: clase grupate impreuna intr -un singur spatiu de

nume logic;
Orice clasa dintr-un package poate face referire directa
la o alta clasa din acelasi package;
Pentru accesarea claselor din alte package -uri se
utilizeaza import
Lipsa definitiei de package : package-ul default;
Nu se recomanda utilizarea acestuia;
Specificatorul de acces public la clase;
Pentru a putea fi referita din afara packageului;
Clasele fara specificator de acces: nu pot fi referite din
afara package-ului.

CONTROLUL ACCESULUI Membrii Claselor

-

Public:
Membrii publici pot fi referiti din afara claselor;
Specifica interfata claselor;
Private:
Pot fi referiti doar din interiorul claselor de definire;
Specifica interfata claselor;
Fara specificator de acces acces package;
16

Pot fi referiti din clasele package-ului curent;

Protected: folosit in contextual mostenirii.

17

CU RS 4.
REALIZAREA CLASELOR
-

COMPOZIT IE;
MOSTENIRE;
ALEGEREA INTRE MOSTERNIRE SI COMPOZIT IE
MECANISMUL DE UPCAST

REU TILIZ AREA CODU LU I:

-

Inseamna mai mult decat copy-paste cod

Operatii principale: Compozitie si Mostenire;
Sintaxa compozitiei: se plaseaza o referinta catre un
obiect nou intr-o clasa noua;
Referintele nou create se initializeaza la valoarea null ->
trebuie initializate explicit;
Metoda toString: mostenita de la cl asa Object: se
perminte convertirea obiectului intr -un obiect String
(necesar pentru tiparire)

INITIALIZAREA REFERINTELOR LA REALIZAREA COMPOZITIEI

-

Initializarea se poate realiza in 4 moduri:

1. La momentul definirii obiectului initializarea se face
inainte de apelarea constructorului;
2. In constructor;
3. Chiar inainte de utilizarea obiectului (lazy
initialization)
4. Instance initialization in bloc non -static de
initializare:

SINTAXA MOSTENIRII:
-

Mostenirea se realizeaza ori de cate ori se creaza o c lasa:

Se mosteneste din OBJECT;
Mostenire: clasa noua se aseamana cu clasa veche:
cuvantul cheie extends;
Clasa noua va prelua automat toate campurile si metodele
din clasa de baza
Regula nescrisa la mostenire: Campurile din clasele de
baza se scriu private iar metodele se lasa public (sau
protected)
Clasa derivate, pentru a se apela o metoda din clasa de
baza se poate utiliza super
Realizarea mostenirii: la crearea obiecului din clasa
derivate, se creaza un subobiect din clasa de baza (ca si
cum ar fi realizata o compozitie catre acesta)
Initializarea subobiectului din clasa de baza: doar prin
constructor;
18

Constructorul clasei de baza este apelat intotdeauna

inaintea constructorului clasei derivate
Pentru apel al constructorului clasei de baza cu
argumente:
Super(argumente)

IS-A vs Is-Like-A
-

Relatia de mostenire de tip is -a: clasa derivate doar

suprascrie interfata clasei de baza;
Relatia de mostenire de tip is -like-a: clasa derivate
contine metode suplimentare fata de clasa de baza
Relatia de substitutie:
La o relatie de tip is -a substitutia este pura: orice
mesaj trimis clasei derivate poate fi omis si trimis
clasei de baza (rezolvarea mesajului se face prin
upcast)
La o relatie de tip is -like-a: partea extinsa din clasa
derivate nu mai este dinsponibila p rin upcast (prin
adresarea clasei de baza)
Downcast: operatia inversa upcast nu este o operatie
garantata, in sensul in care nu stim exact clasa derivate
catre care se face downcast;
Java verifica orice conversie(cast), si daca nu se poate
realiza se arunca o exceptie de tipul ClassCastException

OPERATIA DE DELEGARE
-

Operatie intermediara intre compozitie si agregare

Intr-o clasa se plaseaza un obiect membru din a 2 -a
clasa, iar clasa noua va expune toate metodele furnizate
de obiectul din clasa a 2 -a
Pentru reutilizarea operatiilor de mostenire/compozitie,
este sufficient ca sa se importe clasele reutilizate(codul
lor sursa nu este necesar)

ASCUNDEREA NUMELOR LA MOSTENIRE

-

La suprascrierea unei metode, supraincarcate din clasa de

baza, numele care sunt supr aincarcate din clasa de baza
nu devin ascunse!!!
Supraincarcarea functioneaza indifferent unde este ea
realizata: in clasa de baza sau in cea derivate

ALEGEREA INTRE COMPOZITIE SI MOSTENIRE

-

Compozitia se allege atunci cand interfata clasei de baza

nu se doreste a fi expusa in clasa derivate;
Compozitia se face, de obicei prin agregare private;
Mostenirea se foloseste atunci cand interfata clasei de
baza se doreste preluata si expusa in clasa derivate
19

Protected: functioneaza ca si private in afara ierarhiei;

Upcast: Obiectele din tipul clasei derivate sunt in acelasi
timp si din tipul clasei de baza

FINAL
-

Itemii finali: nu pot fi sctimbati (de exemplu intr -o clasa

derivata)
Datele final:
Constante la compilare care nu se schimba ulterior
Valori initializate la runtime care nu se doreste sa fie
schimbate;
Static final: au o singura locatie de stocare a datei.
Final aplicat la o referinta: face referinta constanta,
valoarea obiectului poate fi modificata
Blank final: campuri declarate final care nu sunt
initializate -> este trebuie initializate inainte de
utilizare;
Argumente final: in metodanu se poate schimba valoarea
catre care arata referinta;
Metode final: nu pot fi schimbate prin mostenire;
Metodele final sunt tratate inline de catre compilator;
Clase final: se inhiba mostenirea din clasa respective;

MECANISMUL UPCAST
-

Asocierea dintre numele metodei si corpul metodei

legare (binding)
Early binding: atunci cand legarea se face la compilare;
Late binding: atunci cand legarea se face la executie,
exact inainte de executia efectiva a metodei.
Late binding: necesita un mecanism pentru identificarea
tipului la executie RTTI pentru a se identifica in mod
correct corpul metodei care trebuie apelat
In J ava se utilizeaza late binding pentru orice apel de
metoda, cu exceptia metodelor static si final (private e
implicit final pt ca o metoda private nu poate fi
mostenita)
De ce e nevoie sa declaram o metoda final? Pentru a
inhiba late binding (creste eficienta la executie)
Campurile si elementele static sunt rezolvate la
compilare
Legarea constructorilor este realizata la compilare

DOWNCAST
-

Downcast: operatia inversa upcast nu este o operatie

garantata in sensul in care nu stim exact clasa derivate
catre care se face downcast
Downcast trebuie realizat explicit de cat re programator
20

Java verifica orice conversie (cast), si daca nu se poate

realiza se arunca o exceptie de tipul ClassCastException

ORDINEA DE APELARE A CONSTRUCTORILOR

-

In cazul obiectelor complex e (cu mostenire), ordinea de

apelare a constructorilor este:
1. Se apeleaza constructorul clasei de baza. Apelul este
recursive, pana la varful ierarhiei (constructorul tipului
din varf este apelat primul)
2. Se initializeaza membrii clasei in ordinea declararii
acestora;
Se apeleaza corpul constructorului clasei der ivate;

Ce se intampla daca in constructor se apeleaza o metoda

p r e s u p u s a a s e l e g a d yn a m i c ?
In constructor se apeleaza exclusive metoda
suprascrisa (cea din clasa cu constructorul legarea
e s t e d e t i p e a r l y)
Covariant return types:
O metoda suprascrisa dintr-l clasa derivate poate
returna un tip derivat dintr -un tip returnat de metoda
din clasa de baza(care este suprascrisa.)

21

CU RS 5
Interfete
Cuprins:
CLASE ABSTRACTE
INTERFETE
DESIGN PATTERNUL STRATEGY SI ADAPTER
DESIGN PATERNUL FACTORY

CLASE ABSTRACTE
-

Rolul clasei Instrument (varful ierarhiei): sa creeze o

interfata comuna claselor derivate(metoda play din
I n s t r u m e n t e s t e d u m m y ) = > o b i e c t e l e d i n c l a s a
instrument nu au sens (din punct de vedere logic) =>
clasa instrument este o clasa abstracta
Pentru a Evita astfel de erori la executie(crearea de
obiecte dintr-un astfel de tip) exista un mechanism prin
care se declara clasele abstracte(si care verifica la
compilare): cuvantul cheie abstract
Clasa abstracta are cel putin o metoda abstracta (metoda
declarata abstracta si care nu are corp)
Se genereaza eroare la compilare daca se incearca
crearea unui obiect dintr -o clasa abstracta
La mostenire dintr -o clasa abstracta, metoda abstracta
trebuie suprascrisa, altfel clasa derivate devine si ea
abstracta.

CONCEPTUL DE INTERFATA
-

In clasa abstracta se furnizeaza o parte din interfata iar

implementarea acesteia este lasata pe seama claselor
derivate
Cuvantul cheie interface: produce o clasa abstracta fara
nici o implementare de metode
Orice code care utilizeaz a o anume interfata va sti ce
metode se pot apela(si doar atat)
Interfetele permit realizarea mostenirii multiple
Interfetele pot contine campuri: acestea sunt implicit
static si final
Implementarea unei interfete: cuvantul cheie implements

22

DESIGN PATTERNUL STRATEGY

-

Crearea unei metode care sa aiba comportament diferit in

functie de tipul argumentului care se prezinta la intrare
Metoda contine o parte fixa care este apelata de
fiecare data si o parte care variaza (strategia)
In cazul In care nu se util izeaza interfete, daca dorim sa
aplicam metoda (strategia) unui obiect dintr -o clasa care
nu face parte din ierarhie, nu se poate. => in exemplul
Apply si Processor, exista o cumplare foarte puternica
intre metoda Apply.proces si clasa Procesor, astfel inc at
aceasta metoda nu poate fi aplicata decat obiectelor din
ierarhia processor, si nicidecum altor obiecte din alte
ierarhii.
Procesor se creaza ca si o interfata, iar clasele care
doresc sa faca parte din strategie vor implementa
interfata scrisa.

DESIGN PATTERNUL ADAPTER

-

Ce se intampla in cazul in care dorim sa utilizam in

strategie o clasa importata dintr -o alta biblioteca?
Desig patternul Adapter: se scrie cod care preia la intrare
interfata existent si care sa produca interfata de care este
nevoie in program
Prin decuplarea interfetei de implementare se permite ca
o interfata sa fie aplicata mai multor implementari, deci
codul devine mai facil de reutilizat.

MOSTENIREA MULTIPLA
-

In java se poate extinde o singura clasa si se pot

implementa oricate clase
Rolul interfetelor: sa se poata face upcast la mai mult
decat o clasa de baza
Daca se poate crea o clasa de baza fara definitii de
metode si variabile member, se recomanda sa se creeze
interfete in locul claselor abstracte
Interfetele se pot combina(se ext end interfetele la fel ca
si clasele)
Coliziunea numelor la implementarea mai multor
interfete (daca interfetele de baza au acelasi nume de
metoda cu semnaturi diferite): este o problema daca
metodele difera doar prin tip de return => eroare la
compilare.
Campurile care sunt inserate intr -o interfata devin in
mod automat static si final => reprezinta un mod
convenabil pentru a define constant (similar cu enum)
Campurile definite in interfete nu pot fi blank finals, ele
trebuie initializate la definire.
23

DESIGN PATTERNUL FACTORYMETHOD

-

Rolul unei interfete: sa permita implementari multiple

pentru diverse clase
D e s i g n p a t t e r n u l F a c t o r y: i n l o c s a s e a p e l e z e u n
constructor in mod direct, pentru crearea unui obiect se
apeleaza o metoda de creare a obiectului dintr -o clasa
F a c t o r y. C l a s a F a c t o r y i m p l e m e n t e a z a o i n t e r f a t a c a r e
specifica metoda de creare.
Astfel, se poate schimba la runtime o implementare a
unei functionalitati cu alta.

24

CU RS 6
CLASE INTERIOARE
INNER CLASSES
-

Se plaseaza clase in interiorul altor clas e

Inner classes reprezinta un concept diferit de compozitie
De obicei, clasa exterioara are o metoda care returneaza
un obiect din clasa ineer.
Tipul obiectului din clasa interioara se specifica precum:
OuterClass.InnerClass
Obiectul clasei interioare are un link(referinta) catre
obiectul clasei exterioare care l -a creat!!!
Obiectul clasei interioare poate accesa membrii
obiectului clasei exterioare fara ca sa fie nevoie de
calificare (dreptul de a accesa este asupra tuturor
obiectelor membre ale clasei ext erioare)
Pentru a se obtine referinta la obiectul clasei exterioare
(din obiectul clasei interioare) se utilizeaza
O u t e r T yp e . t h i s
Pentru a crea un obiect din clasa inner pornind de la un
obiect din clasa outer se poate utiliza obiect.Outer.new
Clasele inner sunt potrivite pentru a implementa
interfete: se realizeaza ascunderea implementarii.
Clasele interioare pot fi create intr -o metoda sau
domeniu de vizibilitate deoarece:
Se implementeaza o interfata, deci se poate crea si
returna o referinta la aceasta (upcast)
Se rezolva o problema complicata si dorim sa creem o
clasa care sa ne ajute la rezolvarea problemei, dar nu
dorim ca aceasta sa fie publica.
Clasa interioara poate fi accesata doar din interiorul
metodei (sau domeniului de vizibilitate) unde a fos t
creata,

CLASE INTERIOARE ANONMIE.

-

Sunt clase interioare fara nume (clase create direct la

momentul utilizarii lor)
Finalizeaza constructia instructiunii care contine
definitia clasei anonime
Campurile din clasele anonime pot fi initializate cu
valori din afara (din domeniul unde se creaza clasa)
Daca intr-o clasa anonima se doreste a fi utilizat un
argument (sau o valoare) definitia in afara acesteia,
atunci referinta acesteia trebuie sa fie final.

25

Clasele anonime nu pot avea constructor, dar

initializariile se pot realiza in blocul non -static de
initializare.
Clasele interioare pot fi create static(nested.clases) daca
nu se doreste utilizarea referintei obiectului exterior in
interiorul clasei inner.
Clasele interioare parte a unei interfete devin automat
static public. Rol: crearea de cod comun care sa fie
utilizat de toate implementariile interfetei.
Oricat de adanca este imbricarea claselor nested, acestea
pot accesa obiecte membre din clasele exterioare,
indiferent de nivelul de imbricare.

DE CE CLASE INNER
-

Fiecare clasa inner poate in mod independent sa

mosteneasca de la o alta implementare. Deci o clasa
inner nu este limitata de faptul ca clasa exterioara
mosteneste sau nu o implementare.
Clasa interioara poate avea interfete multiple, fiecare cu
propria stare, care este independenta de starea obiectului
din clasa exterioara.
O singura clasa exterioara poate avea mai multe clase
interioare fiecare implementand aceasi interfata sau
mostenind din aceasi clasa in mai multe feluri.
La momentul crearii obie ctului din clasa inner, acesta nu
este legat de crearea obiectului din clasa outer.
Inner Class este o clasa total diferita de clasa exterioara,
nu exista confuzie de tipul is -a.

CLOSURES & CALLBACKS

-

Closure: un obiect apelabil care retine informatie despr e

domeniul de vizibilitate in care a fost creat (are acces la
variabilele din domeniul de vizibilitate unde a fost creat)
=> clasa interioara este un closure (deoarece are o
referinta catre obiectul exterior si poate sa acceseze
inclusiv membrii privati ai clasei exterioare).
Callback: Un obiect primeste o informatie care va
permite sa apelam obiectul initial la un moment ulterior
de timp.
Callback se implementeaza cu clase interioare.
Clasa de tip Closure furnizeaza o poarta in interiorul
clasei exterioare (dar intr-un mod seif nu se necesita ca
sa transformam accesul la metodele acestei clase)
De ce callbacks? La executie, se poate schimba metoda
care este apelata in mod dinamic

26

CONTROL FRAMEWORKS
-

Application framework: un set de clase proiectate sa

rezolve un tip anume de problema (design patternul
Template Method)
Pentru aplicarea application framework se mostenesc din
clasele de baza si se schimba implementarea prin
overriding.
Codul suprascris este cel care customizeaza solutia la
cazul particular;
Template Method: contine structura de baza a
algoritmului, iar partile specifice sunt apeluri la metode
care pot fi override.
Astfel se separa partiile neschimbate ale algoritmului de
cele flexibile;
Control framework: un tip particular de application
framework prin care sistemul raspunde la evenimente
generate (sistem event -driven)- de exemplu GUIs
In implementarea Control Framework, inner class sunt
utilizate pentru a exprima diversele actiuni. (metoda
action)

MOSTENIRE DIN CLASE INNER

-

La mostenire dintr -o clasa inner, trebuie furnizat la

constructia obiectului un obiect din clasa inner, pentru a
se permite construirea sub-obiecului
cl.baza(ecnlosingClassReference.super())
Clasele locale unui domeniu de vizibilitate au acces la
toate variabilele domeniului respectiv(inclusiv cel final),
insa aceste clase nu au specificator de acces.

27

CU RS 7
COLECTII, EXCEPTII
S i r u r i l e d e o b i e c t e ( a r r a ys ) : r e p r e z i n t a c e l m a i e f i c i e n t m o d
pentru a pastra obiecte.
Neajuns: Au dimensiunea fixata la compilare
-

Java.util clase containere: List, Set, QUEUE, Map

Pre-Java SE5: containerele java pot memora orice tip de
obiecte, deci pot aparea erori
De exemplu: ArrayList are metode add si get definite
utilizand clasa object.
Erorile la regasirea obiectelor din container pot sa fie
identificate doar la executie ( ClassCasttException)

CONTAINERE GENERICE
-

TipContainer<TipDeBaza>
In container se pot pastra doar obiecte din tipul de baza
Se obtine eroare la compilare daca se incearca stocarea
unui obiect dintr-un alt tip
Nu mai este necesara operatia de cast( conversie) la
regasirea obiectelor
Operatii de efectuat la utilizarea containerelor:
Definirea obiectului de tip container;
Inserarea de obiecte in container ( de ex: Metoda add )
Regasirea obiectelor(de ex Metoda get)
Daca sunt containere generice nu mai este
nevoie de cast;
La containere pre -JavaSE, trebuie
conversie.

TIPURI DE CONTAINERE JAVA

-

Colectii: memoreaza o secventa de elemente individuale,

impreuna cu una sau mai multe reguli aplicate acestora
List: memoreaza obiectele in ordinea in care au fost
inserate;
Set: nu se permit obiecte duplicat;
Queue: se regaseste dupa ordinea furnizata de regula
de insiruire.
Map: reprezinta grupuri de perechi de tip( cheie,valoare)
Intr-un Map se regaseste un obiect( valoarea) furnizata
prin chei
Collection, List, Set, Queue s i Map reprezinta interfete.
List<Apple> apples = new ArrayList< Apple>();
List<Apple> apples = newLinkedList<Apple>();
In colectii se pot adauga grupuri de elemente
C o l l e c t i o n . A r r a y. a s L i s t ( ) C o l l e c t i o n . a d d A l l ( )
28

LUCRUL CU CONTAINERE
-

Tiparirea acestora: metoda toString;

Sortare: metoda Sort

LISTE: 2 TIPURI DE LISTE

-

ArrayList: lista implementata cu un sir. Permite operatii

rapide pentru acces random la elemente. Operatiile de
inserare si stergere de la mijlocul listei sunt costisitoare.
LinkedList: lista implementata cu lista simplu inlatuita.
Permite operatii rapide de insertie si stergere de la
mijlocul listei, insa operatiile de regasire aleatoare sunt
costisitoare.

ITERATORI
-

Este un design pattern

Un obiect de tip iterator este asociat unei colec tii si
permite regasirea ordonata a obiectelor din colectia
respectiva;
Metoda iterator() a unei colectii
Metoda next() a obiectului iterator: produce urmatorul
element din colectie;
Metoda hasNext(): interogheaza daca mai sunt elemente
neiterate
Metoda remove(): sterge ultimul element iterat din
colectie
Iteratorii pot produce elementele colectiei doar intr -o
singura directie
ListIterator: furnizat doar de interfataList, poate
parcurge elementele colectiei in ambele directii.

EXCEPTII
-

Nu toate erorile pot fi prinse la scrierea programului( la

compilare)
Restul problemelor trebuie rezolvate la executie printr un mecanism prin care sa ofere programului client
informatia necesara rezolvarii situatiei => exception
handling: singurul mecanism Java pentru tratarea
erorilor.
Conceptul de exceptie: in domeniul de vizibilitate unde
apare eroarea de obicei nu stim cum sa o tratam, insa
stim ca nu putem sa continuam cu eroarea, astfel ca
transmitem eroarea spre rezolvare unui domeniu de
vizibilitate exterior.
Exception condition: eroa rea aparuta(de exemplu
impartire la 0)
La aparitia unei erori:
Se creaza un obiect de tip exceptie ( pe heap cu new)
29

Firul de executie curent este intrerupt si referinta la

obiectul exceptie este transmisa in afara contextului
curent
Mecanismul de exception handling cauta un context
potrivit pentru reluarea executiei programului
Handlerul de exceptie: locul unde se reia executia
programului, recupereaza programul de la eroarea
aparuta.
Aruncarea unei exceptii
If(t==NULL)
Throw.newNullPointerException();
Obiectele de tip exceptie pot fi construite cu argumente
transmise
La throw se poate arunca orice obiect dintr -un tip care
extind clasa Throwable( clasa radacina a ierarhiei
exceptiilor)
Conceptul de tranzactie: totul sau nimic
Premisa fundamentala a tranzactiilor: existenta
conceptului de exceptie.

GUARDED REGIONS
Try
{
//codul care este susceptibil sa genereze exceptie
} c a t c h ( T yp e 1 t p 1 ) {
//exceptii de tipul 2
} c a t c h ( T yp e 2 ) {
//exceptii de tipul2}
Finall y{
//cod care se executa indiferent de tipul de exceptie aruncat( sau
nu)
}
-

Tr y-catch functioneaz a ca un switch pe tipul de exceptie

2modalitati de tratare a erorilor
Termination: eroarea este aruncata;
Resumption: se insereaza cod try-catch pentru
rezolvarea erorii.

30

CREAREA PROPRIILOR EXCEPTII

-

Mostenire din clasa Exception

L a a f i s a r i l a o e r o a r e s e r e c o m a n d a u t i l i z a r e a S ys t e m . e r r
i n l o c d e S ys t e m . o u t ;
printStackTrace(..): se afiseaza secventa de metode
apelate pentru a ajunge la exceptie
getMessage(..): mostenit de la Throwable, e similar cu
toString pentru erori;
Logging:
Urmarirea executiei programului pentru a putea
rezolva mai usor erorile;
Java.util.logging
Se creaza un obiect de tip Logger;
Se pot loga mesaje de tip fine, info,servere, warning,
etc.

SPECIFICAREA EXCEPTIEI
-

La o metoda, prin throws se indica tipul erorilor care pot

fi aruncate de catre metoda respectiva;
Erorile de tip RuntimeException nu trebuie specificate
prin throws
Compilatorul forteaza programatorul sa specifice
exceptiile
Daca intr-o functioe este posibil sa apara o exceptie si
programatorul nu o specifica prin throws, atunci apare
eroare la compilare
Erorile verificate si enforced la compilare: checked
exceptions
Prinderea oricarei exceptii: catch( Exception e){..}
Stack Trace: printStackTrace, getStackTrace
Rearuncarea unei exceptii: in catch se face throw.

INLANTUIREA EXCEPTIILOR
-

La prinderea unei exceptii si arunca rea unei alte

exceptii, se doreste pastrarea lantului exceptiilor care
apar;
Subclasele Throwable pot sa utilizeze cauza erorii ca si
argument in constructor;
Se poate folosi clauza la constructor doar la clasele de
tip Error, Exception sau RuntimeExceptio n
La celelalte tipuri de erori, se poate utiliza InitCause.

31

IERARHIA EXCEPTIILOR IN JAVA

-

Clasa throwable: orice mostenit din throwable poate fi

aruncat cu throw;
2 tipuri de obiecte throwable: Error and Exception
Exceptiile java most enesc din clasa exception
Numele exceptiei este sugestiv pentru cauza aparitiei
exceptiei
RuntimeException: sunt aruncate in mod automat de catre
java la momentul aparitiei lor unchecked exceptions
De obicei, acestea indica buguri si nu trebuie prinse cu
tr y-catch.

EXCEPTII PIERDUTE
-

Exista o clauza finally fara catch;

Sau in finali se face return
Programatorul nu are nici o indicatie despre exceptia
pierduta

RESTRICTII LA EXCEPTII
-

Cand se suprascrie o metoda, se pot arunca doar

exceptiile de tipu specificat in metoda din clasa de baza
Atentie la exceptii in constructori: constructorii trebuie
sa isi incheie cu succes executia pentru a aaduce
obiectele intr-o stare sigura;
Exception matching: se f ace potrivire pe cea mai
apropiata clauza catch care potriveste cu tipul exceptiei.

GUIDELINES:
-

Tratati exceptiile la domeniul de vizibilitate potrivit( nu

prindeti exceptii decat daca stiti ce sa faceti cu ele )
La rezolvare, de obicei se rezolva problema exceptiei si
se reia executia codului care a generat exceptia sau se
transmite executia la un nivel superior fara reluarea
codului sau se poate calcula un rezultat alternativ celui
produs de codul care a generat exceptia sau se poate
executa tot ce e posibil in domeniul curent si se arunca
in aceeasi exceptie la nivel superior sau Se poate termina
programul
Sa facem programele noastre simple
Sa facem programele noastre safe prin debugging.

32

CU RS 8
I/O Java
SISTEMUL DE I/O INTR-UN LIMBAJ DE PROGRAMARE
-

Sistemul de I/O intr -un limbaj de programare trebuie sa

fie capabil sa trateze
Surse diferite de dispozitive de I/O ( fisiere,
consola,conexiuni de retea etc )
Tipuri diferite de acces la surse( acces secvential,
acces random, acces buffered )
Tipuri diferite de lucru cu sursa ( binar, la nivel de
caracter, la nivel de linie, la nivel de cuvant )

CLASA FILE
-

Reprezinta un nume a unui fisier sau unui set de fisiere

dintr-un director
Metoda list() -> produce un sir de string care reprezinta
fisierele referite de obiectul de tip file
List poate fi invocat utilizand un Directory Filter, pentru
a returna doar acele fisiere pentru care numele respecta
un patern
Interfata Filename Filter: metoda accept primeste la
intrare obiectul de tip File si stringul pentru comparare.
Metoda list din File apeleaza metoda accept pentru
fiecare fisier din File, iar acesta este inserat in lista doar
daca accept furnizeaza true.
Obiectul file poate fi utilizat ca sa
cream/stergem/redenumim un director/fisier sau un
director/fisier cu o intreaga cale;
File poate fi utilizat ca sa citim informatiile referitoare
la un fisier/director

INPUT si OUTPUT
-

Pentru intrare: clasele: InputStr eam si Reader cu metoda

read
Pentru iesire: clasele OutputStream si Writer cu metoda
write
Read si Write lucreaza pe octeti ( sau siruri de octeti )
Toate clasele de I/O sunt derivate din acestea
La real izarea efectiva de I/O programatorii creaza
insiruiri d e obiecte din clasele I/O ( design patternul
Decorator)

TIPURI DE InputStream
-

ByteArrayInputStream: permite ca un buffer de

memorie sa fie utilizat ca si un InputStream( din buffer se
extrag octeti)
33

StringBufferInputStream: converteste un String intr -un

InputStream
FileInputStream: sursa de intrare e fisier. Se furnizeaza
la construirea obiectului fie un String fie un File
PipedInputStream: este asociat cu PipedOutputStream
(care este furnizat la construirea obiectului ).
Implementeaza conceptul de Pipe
SequenceInputStrea: converteste unul sau mai multe
InputStream -uri intr-un singur obiect de tip InputStream
(la construire se furnizeaza fie un InputStream, fie un
Enumerator de obiecte InputStream )
FilterInputStream: clasa abstracta, interfata pentru
decoratorii care furnizeaza tipuri particulare de citire.

TIPURI DE OutputStream
-

ByteArrayOutputStream: creaza un buffer de memorie.

Datele scrise sunt trimise in acest buffer
FileOutputStream: Iesire intr -un fisier. Se constituie
obiectul pe baza unui String sa u a unui File
PipedOutputStream: in conjunctie cu PipedInputStream.
Pentru conceptul de Pipe.
FilterOutputStream: pentru iesire formatata, se
implementeaza functionalitati de scriere.

DESIGN PATTERNUL DECORATOR

-

Decoratorul trebuie sa aiba aceeasi interfa ta cu obiectele

decorate
Decoratorul poate sa extinda maxim interfata acestor
obiecte
Clasele Filter sunt radacina abstracta a claselor de
decorator.

TIPURI DE FilterInputStream
-

DataInputStream: se pot citi tipuri primitive

Buffered InputStream: citire din buffer, se previne
accesul la dispozitivul fizic la fiecare operatie de read
LineNumberInputStream: Tine evidenta numarului de
linie citit
PushBack InputStream: se poate pune inapoi in stream
ultimul octet citit.

TIPURI DE FilterOutputStream
-

DataOutputStream: se pot scrie date primitive

PrintStream: folosit pentru formatarea afisarii
BufferedOutputStream: pentru afisare optimizata prin
buffer

34

READER si WRITER
-

Adauga functionalitatea pentru I/O la nivel de caracter

sau unicode.
Clasele sunt adaugate in ierarhia InputStream si
OutputStream deci nu se inlocuieste aceasta ierarhie
Clase adapter: InputStreamReader si OutputStreamReader
Motivul pentru care au fost create: sa se permita
internationalizarea
Recomandare: sa se utilizeze clase de tip Reader si
Writer ori de cate ori e posibil
La citiri specifice la nivel de octet, sa se utilizeze
InputStream si OutputStream.

RANDOM AccessFile
-

Fisiere cu in registrari cu dimensiune cunoscuta - se poate

utiliza functia seek pentru pozitionare in fisier
Aceasta clasa nu face parte din ierarhiile InputStream
sau OutputStream
Metoda getFilePointer(): returneaza pozitia in fisier
Seek(): pentru a muta pointerul de fisier
Lenght(): lungimea maxima a fisierului
Incepand cu JDK 1.4: apar fisiere memory -mapped.

REALIZAREA FISIERELOR COMPRIMATE

-

Java furnizeaza clase pentru compresie si decompresie,

in ierarhia InputStream si OutputStream
CheckedInputStream: GetCheckSum() produce checksum
CheckedOutputStream: GetCheckSum() produce
checksum
DeflaterOutputStream: Varful ierarhiei de clase pentru
compresie
ZipOutputStream: compresie zip
GZIPOutputStream: compresie GZIP
InflaterInputStream: var ful ierarhiei de clase pentru
decompresie
ZipInputStream decompresie ZIP
GZIPinputStream: decompresie GZIP
Z i p F i l e / Z i p E n t r y: p o a t e m a n i p u l a f i s i e r e d e t i p Z I P .

FISIERE JAR
-

JAR: Java Archive: colecteaza fisiere intr -o singura

arhiva pentru a putea fi transmise in Internet
Fisierul JAR contine fisierele arhivate + Fisier manifest
JDK contine utilitarul JAR pentru crearea de archive JAR
D e o b i c e i u n f i s i e r J A R c o n t i n e B yt e c o d e

35

SERIALIZARE:
-

Pastrarea obiectelor dincolo de executia programelor

Astfel obiectele pot fi recuperate si executia restartata
de la punctul unde a fost oprita anterior
Orice obiect dintr-o clasa care implementeaza
Serializabile poate fi convertit in sie de octeti si apoi
restaurat
Persistenta: durata de viata a unui obiect exista dinco lo
de executia unui program
Pentru realizarea persistentei, obiectele trebuie
serializate/deserializate in mod explicit( lightweight
persistance)
Pentru serializare, se creaza un obiect dintr -un tip
OutputStream, acesta este wrap in interiorul unui
ObjectOutputStream si se utilizeaza metoda writeObject
Pentru deserializare avem ObjectInputStream si
readObject -> se recupereaza un obiect si trebuie facut
downcast
Serializarea salveaza intreg webul de obiecte din spatele
obiectului serializat
Tipul unui obiect deserializat: getClass

EXTERNALIZARE
-

Ce se intampla daca dorim ca parti din obiect sa nu fie

serializate?
Sau dormi sa recreem subobiecte de la 0?
Interfata Externalizable: extinte interfata Serializable
2 metode noi: writeExternal, readExternal
Aceste metode sunt apelate automat la
serializare/deserializare si contin cod suplimentar care se
executa la aceste operatii.
La obiectele deserializate cu Externalizable, obiectele
sunt construite obisnuit( cu default constructor ) si apoi se
apeleaza metoda readExternal
La obiectele Externalizabile, subobiectele componente
trebuie serializate manual(in WriteExternal) iar la
deserializare, ele trebuie recuperate de pe disc
La mostenire dintr -o clasa Externalizable, se apeleaza
writeExternal si readExternal a clasei de baza pentru a se
asigura serializare / deserializare corecta.

36

EVITAREA SERIALIZARII ANUMITOR COMPONENTE A LE

OBIECTELOR
-

Prima metoda: utilizarea Externalizable;

Metoda a 2 a: cuvantul cheie transient: indica faptul ca
acel camp marcat cu transient nu va fi serializat ca si
parte a procesului automat de serializare
Metoda a 3 a: se adauca la clase metodele w riteObject si
readObject in care se furnizeaza codul programatorului
pentru serializare
Aceste metode sunt private si sunt apelate automat de
catre writeObject si readObject a claselor
ObjectOutputStream si ObjectInputStream.

37

CU RS 9.
RTTI
RTTI
-

R u n T i m e T yp e I d e n t i f i c a t i o n
Descoperirea tipului la executie si utilizarea acestuia
2 Tipuri de RTTI:
Traditional la compilare;
Reflection la executie;
Upcast: necesita realizarea automata a RTTI pentru
invocarea automata(polimorfica) a metodei suprascrise
Prin RTTI se poate identifica tipul exact al unui obiect la
executie (limbajul de programare are metode pentru a
realiza acest lucru)

OBIECTUL CLASS
-

Java realizeaza RTTI prin intermediul obiectului Class

Acesta contine informatie referitoare la tip, in formatie
care poate fi interogata.
Pentru fiecare clasa pe care o avem in program, exista un
obiect Class asociat.
La compilarea unei noi clase, acest obiect este creat si
salvat in fisierul .class.
La crearea unui obiect dintr -o clasa, JVM utilizeaza un
subsistem numit class loader.
Toate clasele sunt incarcate in mod dinamic de catre JVM
la prima utilizare a acestora( anume cand se face prima
referinta la un membru static al clasei )
La incarcarea unei clase, se verifica daca obiectul Class
al tipului respectiv este incarcat, daca nu, se identifica
fisierul .class pe disc, si octetii acestuia sunt verificati
inainte sa fie incarcati.
Metoda forName(): returneaza o referinta catre obiectul
Class aferent unui tip.
Solicita incarcarea fisierului .class daca acesta nu e
deja incarcat de class loader.
Metoda Object.getClass(): returneaza obiectul de tip
Class aferent unui tip deja incarcat.
Metode ale obiectului Class: getName, getSimpleName,
getCanonicalName, isInterface, getInterfaces,
getSuperclass.

CLASS LITERAL
-

Referinta la obiectul de tip class poate fi obtinuta si

astfel: NumeTip.class
Este seif: poate fi verificat la compile time;
TYPE: pentru tipurile wrapper primitive
38

Boolean.class == boolean.TYPE
Crearea unei referinte prin .class nu ini tializeaza
obiectul de tip Class corespunzator.
Pregatirea unui obiect pentru utilizare se face in 3
moduri:
Incarcarea clasei, realizata de class loader, se gaseste
b yt e c o d u l p e d i s c s i s e c r e a z a o b i e c t u l d e c l a s a c a t r e
alte clase;
Linking: se aloca sp atiu de stocare pentru membrii
statici si se rezolva toate referintele realizate de clasa
catre alte clase.
Initializare: se executa initializatorii statici si
blocurile statice de initializare. Initializarea este
intarziata pana la prima referinta la o metoda statica
sau un camp non-static.
Initializarea obiectului Class este amanata atata timp cat
este posibil.

GENERIC CLASS REFERENCE

-

Class<tip>: permite salvearea de referinte doar la

obiectul Class a tipului respectiv.
Atentie: Class<integer> nu e subclasa a lui
Class<Number> cu toate ca integer e derivata lui
Number.
Class<?>: se permite orice tip(?-wildcard)
Class<?Extends Tip>: se permite orice subtip a lui Tip.
Conversie de tip: metoda obiectClass.cast(referinta)
Conversie in mod clasic(..)obiect nu apeleaza RTTI =>
nevoia pentru instance of..

COMPARAREA OBIECTELOR DE TIP CLASS

-

Este diferenta intre instanceof/isInstance si compararea

obiectelor de tip class cu == sau equals.
La instan ceOf/Is instance se tine cont de relatiile de
mostenire
La comparare cu == sau equals nu se tine cont de
relatiile de mostenire.

REFLECTION
-

Cum lucram cu obiecte a caror clase nu sunt disponibile

la compilare?
Java.leng.reflect
Clasele Field, Method, Constructor
getFields, getMethods and getConstructors

39

DESIGN PATTERNUL PROXY

-

P r o x y: U n o b i e c t s u b s t i t u t , t a n s m i s i n l o c u l u n u i o b i e c t
real, pentr a furniza prelucrari aditionale inainte de a
transmite operatiile catre obiectul real.
D yn a m i c p r o x y: s e c r e a z a o b i e c t u l p r o x y d i n a m i c s i s e
trateaza apelurile catre metodele proxied in mod dinamic.

40

CU RS 10
CONCURENTA IN JAVA
INTRODUCERE IN PROGRAMAREA CONCURENTA:
-

Programele scrise pana acum: secventiale;

Programare concurenta: mai multe fire de executie care
ruleaza in paralel
Exemple de utilizare a modelului concurent de executie
in Java:
Sistemul WEB clasic
JSP
Swing si SWT au mecanisme pentru suport concurenta
Motive pentru a realiza programe concurente:
Executie mai rapida in conditiile programarii
miltiprocesor
Imbunatatirea code design
Concurenta induce un cost: complexitate sporita a
programelor.

EXECUTIA MAI RAPIDA A PROGRAMELOR

-

Tendinta curenta: numar mai mare de core -uri, in

conditiile plafonarii vitezei chipurilor
Prin distribuirea takurilor pe procesoare se creste
Throughput
Chiar in conditiile single core, prog ramele concurente se
pot executa mai rapid
Daca un task nu poate continua, se spune ca acel task
este blocat.
Event-driven programming: realizarea de interfete
grafice responsive, in conditiile in care prelucrarile
asociate unor evenimente dureaza
Un proces este un program de sine statator cu propriul
spatiu de adrese.
Un sistem de operare multi -tasking poate sa ruleze mai
multe procese la un moment dat. implementarea
concurentei la nivel de SO.
Implementarea concurentei la nivel de mediu de
programare: presupune existenta unor resurse comune si
coordonarea utilizarii acestor resurse de catre threaduri.
Mai mult, procesele pot comunica intre ele.

41

ABORDARI ALE LP
Taskurile concurente sa fie izolate unele de altele ( fiecare
functie concurenta nu produce side efects) modelul distributed
m e m o r y.
-

C/C++ fork: se creaza procese separate gestionate de

catre SO.
Java: in cadrul unui singur proces gestionat de SO, se
creaza mai multe taskuri prin threading
C / C + + / J a v a m o d e l u l s h a r e d m e m o r y.
Java threading este preemtive: mecanismul de scheduling
furnizeaza o felie de timp procesor fiecarui thread, prin
intreruperea periodica a threadului care se executa si
schimbarea contextului de executie catre un alt t hread.
Intr-un sistem multithreading cooperativ fiecare thread
isi lasa controlul catre alt thread la un anume moment =>
p r o g r a m a t o r u l t r e b u i e s a i n s e r e z e u n s o i d e yi e l d .

CODE DESIGN
-

Unele probleme (precum cele de simulare ) sunt

concurente prin definiti a lor
Chiar daca sistemul pe care programul se executa are un
singur CPU, programele concurente au o claritate mai
mare
Java threading este preemtiv -> supor pentru numar
limitat de threaduri.( de ordinul zecilor) -> poate fi
limitativ in anumite situatii
Cooperative multithreading: nu exista o limita a
taskurilor independente care pot rula la un moment dat
Concurenta este benefica daca se lucreaza cu arhitecturi
moderne de tip messaging sisteme distribuite
Prin messaging se realizeaza coordonarea procese lor
intre ele (fara sa fie nevoie de partajarea de resurse )

THREADING IN JAVA
-

Thread: un flux secvential de executie dintr -un proces

Intr-un sistem multi threading, un proces poate contine
mai multe threaduri concurente
Programatorul poate programa fiec are dintre aceste
threaduri ca si cum ar avea intreg procesorul la
dispozitie

42

Pentru a defini un task trebuie implementata interfata

Runnable
In general, metoda run a acestei interfete are o bucla
care se executa atata timp cat este necesar
FcT main are alocat propriul thread. Pt un task nou,
trebuie sa se creeze un obiect dintr -o clasa care
implementeaza Runnable

TERMINOLOGIE
-

In J ava exista distinctie intre taskul care este executat si

threadul care executa acest task
Obiectele care implementeaza Runnab le sunt taskuri, iar
threadurile ajuta la executia acestor taskuri
Crearea unui thread este o operatie costisitoare ( bazata
low-level pa conceptul de trhead din C ) -> are sens ca sa
gestionam threadurile cu grija -> distinctia tasko thread
are sens
Task: un anume job care trebuie realizat
Thread: mecanismul care executa taskul

CLASA THREAD
-

Pentru a crea un thread, trebuie furnizat un obiect de tip

Runnable in constructorul unui obiect de tip Thread
Metoda start a clasei Thread realizeaza toate
initializarile necesare si apoi apeleaza meto da run a
obiectului Runnable agregat. Metoda run este apelata
intr-un fir nou de executie.
Mecanismul pentru lansarea threadurilor in executie este
non-deterministic(nu putem garanta ordinea in care
schedulerul aloca procesorul diverselor taskuri )
T h r e a d . yi e l d ( ) - > s o l i c i t a J V M s a d e a c o n t r o l u l u n u i a l t
thread din programul curent pentru a solicita invocarea
schedulerului.
Garbage Collectorul nu va colecta un thread neferit decat
dupa ce acesta isi tremina executia propriului run

VARIATII LA CREAREA T ASKURILOR

-

Se creaza o clasa care implementeaza Runnable. Un

obiect din aceasta clasa e transmis in constructorul unui
obiect de tip thread
Se mosteneste din clasa T hread, si se suprascrie metoda
run
Se creaza o clasa care implementeaza Runnable. Aceasta
clasa agrega un obiect de tip thread construit prin new
Thread(this)

43

Atentie: la metodele 2 si 3 taskurile sunt pornite din

constructor(cu start). -> e problematic, threadul isi poate
incepe executia inainte ca constructoru l sa se termine
Se prefera varianta 1 si utilizarea executorilor
Clasele care implementeaza Runnable sau exting thread
pot fi scrise si ca si clase inner ( eventual anonime)

EXECUTORS
-

Java furnizeaza un nivel intermediar intr -un client si

taskurile pe ca re acesta le executa. In loc ca clientul sa
apeleze taskurile in mod direct, un obiect intermediar va
apela aceste taskuri indirect.
Executors gestioneaza ciclul de viata a tascurilor
asincrone fara sa fie nevoie sa gestionam explicit ciclul
de viata a unui obiect Thread.
Se creaza un ExecutorsService prin apelarea unei metode
specifice a clasei Executors
Metoda shutdown: previne ca alte taskuri sa fie trimise
catre executorService spre executie
Tipuri de ExecutorService
FixedThreadPool: fixeaza de la inceput numarul de
threaduri utilizate pentru executia taskurilor. Este o
metoda deosebit de eficienta pt ca overheadul cu
crearea taskurilor este realizat la crearea obiectului de
tip ExecutorService
CachedThreadPool: permite un numar variabil de
threaduri. Va opri crearea de threaduri noi pe masura
ce threadurile vechi sunt reciclate
SingheThreadExecutor este un FixedThreadPool cu un
singur thread

CREAREA DE THREADURI PT EXECUTORS

-

T h r e a d F a c t o r y: i n t e r f a t a p e n t r u c r e a r e a d e t h r e a d u r i l a
cerere. Threadurile pot fi personalizate ( de exemplu,
threaduri daemon)- metoda newThread
Obiecte implementand ThreadFactory pot fi furnizate ca
si constructori pentru Executori; executor service -ul
rezultat va utiliza acest threadFactory pentru crearea
noilor threaduri

RETURNAREA DE VALORI DIN THREADURI

-

Interfata Callable: metoda call care trebuie sa returneze

o valoare

44

Obiectele Callable trebuie apelate de metoda submit a

unui ExecutorService
Metoda submit produce un obiect de tip Future
parametrizat cu tipul rezultatului specific returnat din
task
Obiectul Future poate fi interogat cu metoda isDone( )
pentru a vedea daca metoda call a produs reluztatul.
Metoda get() a obiectului Future obtine rezultatul produs
de metoda call. Daca rezultatul nu este disponibil,
metoda get este de tip blocking.

THREADURI DAEMON
-

Un thread daemon furnizeaza un servici u general

programului care ruleaza in background pe durata
executiei programului
Intr-un program, cand toate thread -urile non daemon isi
termina executia, programul este terminat, JVM omorand
threadurile daemon
Daca exista threaduri non-daemon care se executa,
programul nu se termina
Main este executat intr -o instanta non-daemon
Un thread se marcheaza ca si daemon inainte ca sa se
inceapa executia acestuia la start
Daca un thread daemon creaza alte threaduri, acestea
devin un daemon la randul lor.

CREAREA UNOR INTERFETE GRAFICE RESPONSIVE

-

Interfetele grafice trebuie sa raspunda rapid inputului

utilizatorului chiar daca acesta presupune calcule
sofisticate si de lunga durata
Pentru a realiza un program care raspunde inputului
utilizatorului, taskul de lunga durata trebuie rulat in
thread nou (metoda run)

PRINDEREA EXCEPTIILOR
-

Daca apare o exceptie in metoda run, aceasta se va

propaga pana la consola in cazul in care exceptia nu e
rezolvata in run
Problema e rezolvata cu Executors
Exceptiile aruncate de metoda run nu pot fi prinse cu trycatch in jurul comenzii exec a executorului
Prinderea unei exceptii aruncate de metoda run a unui
thread
Se implementeaza interfata
Thread.UncaughtExceptionHandler, creandu -se o clasa
handler de exceptie

45

 Pentru threadul care ruleaza taskul, se asigneaza

handlerul de exceptie cu metoda
setUncaughtExceptionHandler
Aceasta operatie poate fi scrisa in metoda newThread
a u n u i T h r e a d F a c t o r y, s i a p o i s e p o t u t i l i z a e x e c u t o r i i
Se poate asigna handlerul de exceptii implicit a clasei
Thread cu setDefaultUncaughtException

46

CU RS 11
Partajarea resurselor
PARTAJAREA RESURSELOR MUTEX
-

Doua sau mai multe threaduri pot interfera, colizionand

pe aceeasi resursa
Problema apare cand threadurile consumatoare se
interfera cu cele producatoare pe aceeasi resursa
Este nevoie de un mecanism care sa previna doua taskur i
sa utilizeze aceeasi resursa sensibila in acelasi timp
Mecanism mutex (mutual exclusion): se serializeaza
accesul taskurilor la resursa partajata

PARTAJAREA RESURSELOR SYNCHRONIZED

-

C u v a n t u l c h e i e s yn c h r o n i z e d : r e a l i z e a z a m u t u a l
exclusion pentru o resursa
Resursa partajata se incapusleaza intr -un obiect
Toate metodele care utilizeaza resursa sunt marcate ca si
s yn c h r o n i z e d
M e c a n i s m u l s yn c h r o n i z e d : f i e c a r e o b i e c t a r e u n m o n i t o r .
Cand un thread intra in zon a de cod sync. , threadul
achizitioneaza monitorul, si nici un alt thread nu va mai
p u t e a i n t r a i n t r - o z o n a s yn c a a c e l u i a s o b i e c t
Daca primul thread care a achizitionat monitorul intra
intr-o noua zona sync a aceluias obiect, se tine un contor
a numatului de monitoare achizitionate de thread
E x i s t a s i u n m o n i t o r l a n i v e l d e c l a s a p t s yn c l a m e t o d e
statice

MECANISM MUTEX EXPLICIT: LOCK

-

Sectiuni critice: zonele de cod unde poate sa apara

coliziunea intre threaduri
Pentru un obiect de tip Lock: metodele lock() si u nlock()
Imediat dupa lock( )trebuie sa fie inserat un bloc tryfinally cu unlock() in finally
Blocul try trebuie sa ramana comanda de return

AVANTAJELE MECANISMULUI LOCK

-

A v a n t a j u l L o c k a s u p r a s yn c : i n m e t o d e l e s yn c . P o t a p a r e a
exceptii, si atunci nu exista nici o sansa sa se readuca
sistemul in stare valida
C u L o c k , s e u t i l i z e a z a m e c a n i s m u l t r y - f i n a l l y, s i f i n a l l y
se executa in orice situatie ( chiar si la o exceptie)
Sansa pt erori cu sync este mai redusa, se voi utiliza
Lock doar in cazuri speciale
47

Exemplu de situatie speciala: Este nevoie de lock pe o

durata de timp
tryLock(): metoda non -blocking prin care se incearca
achizitionarea lock-ului
tryLock(argumente): metoda care asteapta un anumit timp
pt achizitionarea lockerului.

ATOMICITATE SI VOLATILITATE
-

O operatie este atomica daca ea nu poate fi intrerupta de

thread scheduler.
Ex de operatii atomice: Operatii simple executate pe
tipuri primitive, altele decat long si double
Vizibilitate: Modificari efectuate de un task chiar daca
acestea sunt atomice, pot sa nu fie vizibile altor taskuri
Mecanismul de sincronizare forteaza ca modificariile
unui task sa fie vizibile in toata aplicatia, chiar si pe
multiprocesor
Cuvantul cheie volatile: asigura vizibilitatea : imediat ce
un thread scrie o valoare intr-o variabila volatila, acea
valoare va fi disponibila pentru read
E s t e s e i f s a u t i l i z a m v o l a t i l e i n l o c d e s yn c , d o a r d a c a
clasa are un singur camp care poate fi modificat

SECTIUNI CRITICE
-

Avem nevoie de sectiuni critice daca partea critica este o

bucata de cod dintr-o metoda
Sectiunea critica poate sa fie marcata de cuvantul cheie
s yn c h r o n i z e d ( o b i e c t )
Monitorul se achizitioneaza pentru obiectul specificat
Daca se sincronizeaza doar pe sectiuni critice se poate
castiga timp pretios la executia programului
Pt sectiuni critice se pot folosi si obiecte de tip lock
La sincronizare pe sectiuni critice, trebuie sa se utilizeze
acelasi obiect ca si tina a sincronizarii

STARI ALE UNUI THREAD

-

New: starea unui thread e new imediat dupa ce acesta a

fost creat. Threadul devine eligibil sa fie alocat catre
CPU spre executie
Runnable: threadul poate sa fie rulat. Schedulerul nu este
impiedicat de nimic ca sa puna threadul in executie.
Blocked: taskul poate si fie executat, dar exista ceva ce
previne aceasta
Dead: un thread dead sau teminat nu mai poate fi alocat
de catre scheduler
A realiza return din metoda run pune threadul in starea
dead
48

CUM SE PUNE UN THREAD IN STAREA BLOC KED

-

Metoda Sleep
Metoda wait, threadul devine runnable dupa ce primeste
un notify sau signal
Threadul asteapta o operatie de I/O sa fie finalizata
T h r e a d u l a p e l e a z a o m e t o d a s yn c s i s e a s t e a p t a a c h i z i t i a
monitorului.

INTRERUPEREA TASKURILOR
-

Iesire din metoda run: verificarea unui flag si return

A intrerupe executia unui task in mijlocul metodei run
este similar cu a arunca o exceptie
Apelul metodei interrupt() a clasei Thread: se seteaza
statusul interrupred pentru acel task
Un thread cu statusul interrupted va arunca o exceptie de
tipul InterruptedException daca acest task este deja
blocat sau incearca realizarea unei operatii blocante
Statusul interrupted va fi resetat la momentul aruncarii
exceptiei sau cand taskul apeleaza thread.interrupted.

INTRERUPEREA TASKURILOR RULATE CU EXECUTORS

-

Metoda shutdown() a unui executor apeleaza

Thread.interrupt() la fiecare thread pornit de executor
Apelul cancel pe un obiect Future< ?> genereaza interrupt
T a s k u r i l e b l o c a t e d e I / O s a u s yn c n u s e i n t r e r u p c u
iterrupt
Atentie: Interrupt() apare la inchiderea ( close) unui
socket car nu la close pe un I/O obisnuit
T a s k u r i l e b l o c a t e d a t o r i t a s yn c n u s u n t i n t r e r u p t e c u
interrupt
Sectiunile critice gardate de ReentrantLock pot fi
intrerupte.

COOPERAREA INTRE TASKURI

-

Problema cooperari intre taskuri nu se refera la accesul

la o resursa partajata
Este vorba de modul in care taskurile pot lucra in comun
pentru atingerea aceluias obiectiv: un task trebuie
realizat inaintea altuia
Problema fundamentala la coopeerare: Handshaking
Se rezolva prin extinderea mecanismului excluderii
mutiale
Un task are posibilitatea de a -si suspenda executia pana
in momentul in care apare un eveniment exterior lui.
M e t o d e l e w a i t s i n o t i f yA l l a l e c l a s e i O b j e c t
Wait():

49

Permite sa se astepte realiz area unor conditii care sunt

in afara controlului taskului curent
Suspenda taskul pana cand apare un notify sau un
n o t i f yA l l
E d i f e r i t d e s l e e p s i yi e l d a c e s t e a n u e l i b e r e a z a
lock-ul obiectelor
Suspenda executia threadului si elibereaza lockul
obiectului
Poate avea ca si argument un numar de milisecunde
W a i t ( ) , N o t i f y( ) s i n o t i f yA l l s u n t m e t o d e a l e u n u i O b j e c t ,
e l e p o t f i a p e l a t e d o a r d i n m e t o d e s yn c ( )
W a i t ( ) a p e l a t d i n t r - o m e t o d a n e - s yn c g e n e r e a z a
IllegalMonitorStateEx ception
Wait este inglobat intr-un while
Mai multe taskuri pot sa astepte dupa acelasi lock
pentru acelasi motiv;
Pana ca taskul sa ajunga la wait() e posibil ca alt task
sa schimbe situatia si taskul sa trebuiasca resuspendat
prin wait()
Este posibil ca taskuri diferite sa ceara acelasi lock
pentru motive diferite.

DEADLOCK
-

Apare atunci cand taskurile asteapta utilizarea unei

resurse unul dupa celalalt
Apare atunci cand urmatoar ele conditii sunt simultan
indeplinite:
Excluderea mutuala: cel putin una din resursele
folosite de catre taskuri nu pot fi utilizate in comun;
Cel putin un task detine o astfel de resursa si asteapta
sa achizitioneze o alta resursa detinuta de alt task
O astfel de resursa nu poate fi luata in mod fortat de
la un task
Poate aparea un wait circular
Rezolvarea situatiei de deadlock:
Impiedicarea realizarii uneia dintre cele 4 conditii
mentionate mai sus.

50