Cuprins

.class ............................................................................................................................................................. 2
CLASSPATH................................................................................................................................................ 2
Diferenta dintre compilarea in C si compilarea in Java. ............................................................................... 3
Obiect – in Java ............................................................................................................................................. 3
Clasa (Ce este o clasa in Java) ...................................................................................................................... 3
Organizarea memoriei in Java ....................................................................................................................... 3
Primitivele ..................................................................................................................................................... 4
Specificatori de access .................................................................................................................................. 4
Variabile........................................................................................................................................................ 4
Static (static keyword – cuvantul cheie static) .............................................................................................. 4
Constructor.................................................................................................................................................... 5
Overloading (Supraincarcarea) ..................................................................................................................... 5
This (cuvantul cheie this) .............................................................................................................................. 6
Distrugerea obiectelor (GARBAGE COLLECTOR) .................................................................................... 6
Finalize() ....................................................................................................................................................... 6
Bloc static...................................................................................................................................................... 6
Compozitie. ................................................................................................................................................... 7
Mostenirea..................................................................................................................................................... 7
SUPER (cuvantul cheie super)...................................................................................................................... 8
DELEGAREA............................................................................................................................................... 8
FINAL ........................................................................................................................................................... 9
Blank final..................................................................................................................................................... 9
Upcast ........................................................................................................................................................... 9
BINDING ................................................................................................................................................... 10
Covariant return types ................................................................................................................................. 10
Clasele abstracte.......................................................................................................................................... 10
Interfata ..................................................................................................................................................... 11
Polimorfism ................................................................................................ 11
Dispose() .........................................................................................................................11
Design pattern Strategy (D.P Strategy) ....................................................................................................... 11
Design pattern Adapter ......................................................................................................12
Mostenirea multipla ...........................................................................................................12
Design pattern Factory Method ...........................................................................................12
Clase inner .......................................................................................................................12
De ce inner class? ..............................................................................................................13
Clase interioare anonime ....................................................................................................13
Closure ............................................................................................................................13
Callback ...........................................................................................................................14
Mostenire in clase inner ......................................................................................................14
EXCEPTII ................................................................................................................................... 14
ITERATORUL ....................................................................................................................15
CONTAINERE....................................................................................................................16
LISTE ...............................................................................................................................16

.class
Extensia .class se refera la un fisier .class care rezulta in urma compilarii de catre Masina
Virtuala Java a fisierelor .java. Cand compilam un fisier .java primim la output cat un fisier
pentru fiecare clasa compilate din fisierul .java. Fiecare output va fi de forma ClassName.class
adica numele clasei si extensia .class. Fisierele .class contin bytecode adica cod binary executat
la rulare de Java Virtual Machine.
Un program Java contine mai multe fisiere .class care pot fi puse intr-un package sau
comprimate intr-un jar. In programul nostru clasele se incarca atunci cand cream un obiect de
tipul acelei clase; dupa crearea obiectului este identificat fisierul .class creat si sunt adusi in
memorie octetii pentru aceasta clasa.
Un fisier .class poate fi compliat prin linie de comanda introducand javac.

CLASSPATH
Variabilele classpath spun aplicatiilor, JDKurilor unde sa caute clasele deoarece acestea contin
calea root pentru directoare. Valoare default este punctul (.) ceea ce inseamna ca sunt cautate
clasele doar in directorul current, dar prin folosirea classpath-ului supreascriem valoarea default.
Pentru ca Masina Virtuala sa nu caute clasele compilate prin toate folderele, trebuie sa ii
specificam in ce foldere sa se uite, iar acest lucru il facem cu CLASSPATH. Maisna Virtuala
trebuie sa gaseasca orice clasa (cu extensia .class) compilata cu javac.
Classpath-ul il setam pe nu system windows de la setarile de environment.
Diferenta dintre compilarea in C si compilarea in Java.
C ia codul sursa introdus ca input si produce cod masina care poate fi executat. Codul masina
poate rula doar pe hardware compatibile si care au un sistem de operare compatibil.
Java ia codul sursa introdus ca input si nu produce cod masina, ci BYTE CODE. Byte codul nu
poate fi executat direct pe o masina si are nevoie de o Masina Virtuala (JVM). Byte codul poate
rula pe orice platforma care are fie un compilator de byte code fie o masina virtuala. Din acest
motiv Java, spre deosebire de C ofera portabilitate.

Obiect – in Java
Un program Java este compus dintr-o colectie de obiecte care isi spun unul altuia ce sa faca. In
Java orice element este un obiect si fiecare obiect are un spatiu de memorie si un tip.
In Java se realizeaza un schimb de informatii. Prin obiecte se trimit mesaje. Toate obiectele de
acelasi tip pot primi acleasi mesaj.
Obiectul poate fi privit ca si furnizor de servicii. Un obiect este format din stari (adica attribute)
si comportamente (adica metode) si o identitate (adica un tip). Obiectul este instant unei clase.
De fiecare data cand vrem sa intantiem o anumita clasa, cream un obiect din clasa respective cu
comanda new. La instant new, se aloca memorie in spatiu heap.
Fiecare obiect necesita resurse iar Java utilizeaza in mod explicit alocarea dinamica a resurselor.
Obiectele se manipuleaza prin referintele catre obiecte.
Distrugerea obiectelor este realizata automat de GarbageCollector care identifica momentul in
care un obiect nu mai este utilizat si ii dezaloca memoria. Doar GarbageCollector poate disturge
obiectele in Java. Compilatorul nu stie cand intervine GarbageCollector-ul.

Clasa (Ce este o clasa in Java)

Clasa este un sablon care descrie comportamentul/ starea pe care o are obiectul de tipul clasei
respective. O clasa poate avea mai multe metode.

Organizarea memoriei in Java

In Java exista mai multe zone de memorie.
1. Zona Registru. Este cea mai rapida zona de memorie. Se afla inauntrul procesorului si are
un numar limitat de registrii. Utilizatorii nu au control direct la aceasta zona.
2. Zona de Stiva. Aceasta zona se afla in memoria RAM. Este a doua cea mai eficienta si
rapida zona de memorie. Sistemul Java trebuie sa stie exact in timp ce ruleaza prorgamul,
timpul exact al itemilor din stiva. Stiva memoreaza referintele catre obiecte
3. Zona de Heap. La fel ca Stiva se afla in memoria RAM si contine toate obiectele create
cu new in momentul executarii. Spre deosebire de stiva, nu are nevoie sa stie cat timp sta
memoria in heap. Dezavantajul este ca poate dura mai mult pana alocam sau dezalocam
memoria din heap decat din stiva.
4. Non-RAM contine obiectele care exista in afara spatiului de memorie a programului.
Primitivele
Toate variabilele din Java trebuie sa fie prima data declarate inainte de a fi utilizate.
Tipurile de primitive sunt variabile de dimensiune mica. Salvarea lor se face direct pe stiva si nu
e nevoie sa le cream cu new.
Tipuri de primitive: byte 1 octet, char si short 2 octeti, int si float  4 octeti, double si long
8 octeti(64 biti)

Specificatori de access
1. Public . Daca intr-un package definim clase cu acest specificator de acces de tipul:
public class MyClass{} toti membrii, variabilele si metodele vor avea access la calsa
respectiva.
2. Private Daca intr-un package definim clase cu acest specificator de access de tipul:
private class MyClass{} , vor avea access la clasa doar membrii, variabilele si metodele
din interiorul acelei clase. Optiunea private ne permite sa schimbam membrii din interior
fara sa ne gandim ca o alta clasa poata fi afectata de asta. Daca avem un contructor privat,
nu putem sa cream un obiect din clasa A in clasa B. Trebuie sa cream o metoda care
creaza obiectul clasei A si sa o apelam in clasa B.
3. Package. Daca intr-un package definim clase cu acest specificator de tipul: package class
ClasaA{} vor avea acces la clasa doar mebrii, metodele si variabilele din package-ul
respecitv cu mentiunea ca si clasele care mostenesc ClasaA vor avea access la clasa A
4. Defaul. Daca intr-un package definim clase cu acest specificator de tipul: class
ClasaA{}, vor avea acces la clasa doar mebrii, metodele si variabilele din package-ul
respecitv.

Variabile
Variabile locale- sunt definite in interiorul metodelor, costructorilor sau blocurilor
Variabile de instanta- sunt variabile in cadrul unor clase dar inafara ,metodelor. Sunt initializate
cand e instantiata clasa.
Variabile de clasa- sunt variabile declarate intr-o clasa cu cuvantul cheie static

Static (static keyword – cuvantul cheie static).

In mod normal datele member si metodele pot fi accesate doar daca avem creat un obiect de tipul
clasei respective. Daca vrem sa apelam metoda speak() din clasa Vorbitor, trebuie sa cream
prima data un obiect din clasa Vorbitor si apoi putem apela metoda. Cu static, nu mai avem
nevoie sa cream un obiect din clasa respectiva de aceea putem spune ca un camp sau o metoda
static nu este legata de un obiect anume dintr-o clasa. Un camp static exista o singura data pentru
o clasa pentru ca e partajat de toate metodele clasei.
Cuvantul cheie static ne ajuta sa cream obiecte dintr-o clasa fara sa apelam numele clasei.
Campurile statice pot fi referite prin numele clasei, la fel si metodele statice. Metodele statice nu
pot accesa campuri nestatice dintr-o clasa. Daca cream o metoda static aceasta nu poate avea
cuvantul cheie this.
Nu putem apela metode nestatice din interiorul metodelor statice (desi inversul este posibil).
Cu o metoda statica noi nu trimitem un mesaj unui obiect pentru ca nu exista unul.

Initializarea obiectelor in Java

Intilializarea obiectelor se face prin scrierea unui constructor

Constructor
O clasa contine constructori care ajuta la crearea obiectelor din acea clasa. Constructorul este
apelat cu oepratorul new. Prototipul pentru un constructor din clasa A este: public A(){}
Putem avea mai multi constructori intr-o clasa daca au numar diferit de argumente. La fel ca la
metode, Java diferentiaza constructorii in functie de tipul si numarul de argumente pe care il au.
Daca nu declaram niciun constructor intr-o clasa, compilatorul declara automat un constructor
default. Constructorul default este un constructor care nu are argumente si corpul construtorului
este gol.
Numele constructorului trebuie sa fie identic cu numele clasei. In plus constructorul nu are tip de
return.

Overloading (Supraincarcarea)
In Java ne referim la un obiect, clasa, atribut sau metoda prin numele acestora. Daca avem
metode cu acelasi nume, Java trebuie sa stie ce metoda sa acceseze in momentul apelarii. Din
acest motiv argumentele metodei trebuie sa fie diferite. Aceasta este supraincarcarea.
Supraincarcarea metodelor mareste lizibilitatea programului. Putem supraincarca metode prin
schimbarea numarului de argumente sau prin modificarea tipului de date. Putem supraincarca si
emtoda main, dar programuol o va accesa mereu pe cea cu parametrii: (String[] args) .
În Java un alt factor forțează supraicarcarea metodelor este constructorul.

Nu putem supraincarca metode pe tipu de return pentru ca este ambiguu.

This (cuvantul cheie this)
Utilizand this, luam referinta obiectului curent. This poate fi folosit doar inauntrul metodelor
care nu sunt statice. Daca apelam o metoda din ClasaA intr-o alta clasa metoda din ClasaA nu e
nevoie sa utilizam this.
Daca folosim variabile si numele variabilelor locale este diferit de instant variabilelor, nu avem
nevoie de this. This e folosit foarte des in tipurile de return cand vrem sa returnam referinta
obiectului curent. This invoca constructorul. Putem folosi this in constructor.

Distrugerea obiectelor (GARBAGE COLLECTOR)

GC dezaloca memoria alocata cu new atunci cand isi da seama ca un anumit obiect nu mai este
folosit. Exista obiecte care aloca memorie speciala, fara folosirea operatorului new. GC stie doar
cum sa elibereze memoria alocata cu new, deci nu va sti sa elibereze o memorie speciala care nu
este alocata cu new. Pentru asta putem utiliza Finalize(). Cand GC este gata sa elibereze
memoria pentru un anumit obiect, apeleaza finalize() si doar la urmatorul pas de ‘’colectare’’ va
recupera memoria obiectului.
GC nu distruge obiectele, el recupereaza doar memoria care a fost alocata obiectelor. Java nu are
nicio metoda de distrugere a obiectelor, deci trebuie sa cream noi una. Daca e necesar ca un
obiect sa fie sters, se pune codul de stergere intr-o metoda dispose() care se apeleaza pe clauza
finally a unui try-catch. GC colecteaza memoria ramasa si compacteaza heap-ul rearanjand
obiectele alocate.

Finalize()
Aceasta metoda permite operatii de stergere inainte ca obiectele sa fie supuse garbage
collectorului
GC stie doar cum sa elibereze memoria alocata cu new, deci nu va sti sa elibereze o memorie
speciala care nu este alocata cu new. Pentru asta putem utiliza Finalize(). Cand GC este gata sa
elibereze memoria pentru un anumit obiect, apeleaza finalize() si doar la urmatorul pas de
‘’colectare’’ va recupera memoria obiectului. Java nu garanteaza apelarea emtodei finalize().

Bloc static
Este folosit pentru initializarea statica intr-o clasa.
 Codul din blocul static este executat o singură dată: prima dată când facem un obiect din
acea clasă sau prima dată când accesam un membru static din acea clasă (chiar dacă nu
facem niciodată un obiect din acea clasă).
 Blocurile statice sunt executate înainte de constructori
Bloc non-static (nestatic)
Prin blocul non-static se permite definirea claselor interne anonime.

Reutilizarea claselor

Compozitie.
Prin compozitie plasam referinta unui obiect din clasa A intr-o clasa B.
Compozitia este o forma restransa de agregare in care doua entitati sunt dependente.
Este de tipul “part of”.
In compozitie ambele entitati depinde una de celalalta, deci obiectul compus nu poate
exista fara cealalta entitate. De exemplu: nu poate exista o carte fara file (compozitie),
dar poate exista o biblioteca fara carti (agregare).

Initializarea referintelor la realizarea compozitiei se face in 4 moduri: La

momentul definirii obiectului, In constructor, inainte de utilizarea obiectului,
Instance initialization

Diferenta Compozitie-Agregare
Prin compozitie plasam referinta unui obiect din clasa A intr-o clasa B, iar prin
agregare plasam doar o variabila de tipul clasei A in clasa B
In compozitie ambele entitati depinde una de celalalta, iar la agregare entitatile nu
depind una de cealalta.

Mostenirea
Atunci cand o clasa (superclasa) dobandeste proprietatile unei alt clase (subclasa)
avem mostenire.
O subclasa mosteneste membrii (campuri, metode, clase imbricate) din superclasa.
Constructorii nu sunt membrii deci nu sunt mosteniti de subclase dar pot fi invocati (cu
super). Constructorul clasei de bază este apelat intotdeauna inaintea constructorului clasei
derivate

La crearea obiectului din clasa derivată, se crează un subobiect din clasa de bază (ca
si cum ar fi realizată o compozitie către acesta)
 Mostenirea se realizează ori de câte ori se crează o clasă pentru că dacă nu moșteniți în
mod explicit din altă clasă, mosteniti implicit din Object.

Mostenirea de tip is-a

Relatie de mostenire de tip is-a: clasa derivată doar suprascrie interfața clasei de bază.
Aceasta ar însemna că clasa derivată este exact același tip ca și clasa de bază, deoarece
are aceeași interfață.

Mostenirea de tip is-like-a

clasa derivată contine metode suplimentare față de clasa de bază. Există momente când
trebuie să adăugați noi elemente de interfață la un tip derivat, extindând astfel interfața.
Tipul nou poate fi în continuare înlocuit de tipul de bază, dar înlocuirea nu este perfectă
deoarece noile metode nu sunt accesibile de la tipul de bază.

Relația de substituție:
La o relatie de tip is-a substitutia este pură: orice mesaj trimis clasei derivate
poate fi trimis si clasei de bază (rezolvarea mesajului se face prin upcast)
La o relație de tip is-like-a: partea extinsă din clasa derivată nu mai este
disponibilă prin upcast (prin adresarea clasei de bază)

SUPER (cuvantul cheie super)

In Java folosim cuvantul cheie super pentru a diferentia membrii superclasei de

membrii subclasei si pentru a invoca constructorul superclasei din subclasa. Cu alte
cuvinte apelam membrii clasei de baza din interiorul clasei derivate.

DELEGAREA
Prin delegare plasam un obiect mebru in clasa pe care o construim(compozitie)
dar in acelasi timp xpunem toate metodele din obiectul membru in noua clasa.
FINAL

Cuvântul cheie final este folosit pentru a face o variabilă constantă. Atunci când o
variabilă este declarată cu cuvântul cheie final , valoarea sa nu poate fi
modificată. Acest lucru este util pentru constantele care au valori universale.
La primitive final face ca valoarea primitive sa fie constanta.
La referintele de obiect final face referinta constanta. O data ce o referinta este
initializata spre un obiect, aceasta nu va putea fi niciodata modificata pentru a indica
un alt obiect, dar obiectul insusi poate fi modificat.
Final este aplicabil doar unei variabile, unei metode sau unei clase.
Daca declaram o metoda final, metoda nu mai poate fi suprascrisa. Orice metoda
private (private) este implicit final. Metodele final sunt tratate inline de către compilator

Cand folosim final?

Singura diferență dintre o variabilă normală și o variabilă finală este aceea că putemre-
atribui valoarea unei variabile normale, dar nu putem schimba valoarea unei
variabile finale după atribuire. Prin urmare, variabilele finale trebuie folosite doar
pentru valorile pe care dorim să le rămânem constante pe parcursul executării
programului.
abstract și final (abstract vs final abstract si final)
Pentru clase, Final este folosit pentru a preveni moștenirea, în timp ce clasele
abstracte depind de clasele lor copii pentru o implementare complete. Putem folosi
clase abstracte pentru mostenire. O clasa abstracta poate avea atat metode abstracte
cat si metode cu corp. Daca declaram o clasa fina, nu mai putem mosteni din ea.

Blank final
Un bank final in java este un camp final care nu este inițializat în timpul declarației.
Poate fi inițializat numai în cadrul unui constructor. Acesta generează eroare de
compilare dacă nu este inițializat, deoarece ar trebui să i se dea o valoare undeva în
program și asta numai de la un constructor.

Upcast
Folosim upcast pentru a converti de la un tip mai specific la un tip mai general.
 Facem upcast cand luam o referinta a unui obiect si o tratam ca referinta a tipului de
baza.

BINDING
In Java exista doua tipuri de legare (binding). Early binding si late binding. Early
binding este atunci cand legarea se face la compilare si Late binding este atunci cand
legarea se face la executie (numita si legare dinamica sau run-time binding). Atunci
cand un limbaj implementeaza late binding trebuie sa existe un mecanism pentru a
determina tipul obiectului la momentul executarii pentru a apela metoda
corespunzatoare.
In Java se foloseste metoda late binding cu exceptia metodelor declarate static sau
final.

Daca declaram o metoda final se inhiba late bindingul si creste eficienta la executie
pentru ca legarea se face la compilare.

Covariant return types:

 O metodă suprascrisă dintr-o clasă derivată poate returna un tip derivat dintr-un
tip returnat de metoda din clasa de baza (care este suprascrisă)

Clasele abstracte
Cream clase abstracte cand vrem sa manipulam un set de clase prin interfata lor comuna.
Clasele abstracte sunt un punct de mofloc intre clasele normale si interfetele si sunt necesare
pentru construirea de clase care au metode neimplementate.
O clasa abstracta are cel putin o metoda abstracta. Metodele abstracte sunt incomplete deoarece
au doar declaratia de metoda, fara corp. Din acest motiv nu se poate crea un obiect dintr-o clasa
abstracta (pentru ca nu are corp) Se generează eroare la compilare dacă se incearcă crearea unui
obiect dintr-o clasă abstractă.
Daca mostenim dintr-o clasa abstracta, metoda abstractă trebuie suprascrisă, altfel clasa derivată
devine si ea abstractă
Diferenta dintre interfata si clasa abstracta (interfata clasa abstracta)
Interfata nu poate oferi implementari de metode si putem implementa din mai multe interfete dar
nu putem mosteni din mai multe clase abstracte.
Metodele abstracte pot fi si package acces, nu neaparat public cum sunt interfetele.

Interfata
Interfata o implementam cu cuvantul cheie implements.
Interfetele ofera doar o forma, nu si o implementare. Interfetele produc clase complet abstracte,
fara implementare de metode.
Interfata permite mostenirea multipla: Putem implementa din mai multe interfete dar nu putem
mosteni dikn mai multe clase.
O interfata poate contine campuri dar sunt implicit static si final.

Polimorfism
Este a 3-a caracteristica importanta in Programarea orientate obiect, dupa abstractizare si mostenire si
se caracterizeaza prin separarea interfetei de punerea ei in aplicare. Metoda polimorfica permite unui
tip (adica unei clase) sa arate elementele ei diferite fata de un alt tip (clasa) similar atata timp cat
ambele tipuri sunt derivate din acelasi tip de baza.

Polimorfismul arata prin ce se deosebeste o Clasa A de o clasa B tinand cont ca ambele mostenesc din
Clasa C, adica prin diferentele de comportament ale metodelor.

Dispose()
Metoda este folosita pentru clean-up

Design pattern Strategy (D.P Strategy)

In DP Stretegy o clasa sau un algoritm isi poate modifica comportamentul la rulare. Este un
design pattern de comportament in care cream un obiect care are mai multe strategii de
solutionare a unei probeleme si un context al obiectului al carui comportament difera in functie
de strategia pe care o apelam. De exemplu ca sa ajungem la un rezultat intr-o operatie putem ori
sa adunam 2 numere, ori sa le scadem, ori sa le inmultim. Adunarea, Scadere si Inmultirea sunt
strategiile.
Putem folosi acest design pattern cand vrem sa selectam ce algoritm sa folosim la rulare. De
exemplu: salvarea unor fisiere, comprimarea unor fisiere, modificarea scrisului dintr-un text
(uppercase, lowercase etc);
Design pattern Adapter
Functioneaza ca o legatura intre doua interfete incompatibile, ca un adaptor. Preia la intrare interfata

Acest tip de model de design intră sub model structural deoarece acest model combină capacitatea a
două interfețe independente.

Mostenirea multipla
Interfetele pot face upcast la mai mult decat o singura clasa de baza. La interfete putem adauga noi
declaratii de metode utilizand mostenirea

Daca se poate crea o clasa de baza fara definitii de metode si variabile membre, se recomanda sa se
creeze interfete in locul claselor abstracte

Print interfete putem face upcast la mai mult decat o clasa de baza

Campurile care sunt inserate intr-o interfata devin in mod automat static si final. Nu putem declara
campuri blank final in interfata.

Interfetele pot fi imbricate in cadrul claselor sau in cadrul altor interfete.

Design pattern Factory Method

La Design pattern Factory Method in loc sa apelam un constructor in mod direct, putem apela o metoda
de creare a unui obiect din Factory, care produce o implementare a interfetei.
Factory Method oferă una dintre cele mai bune modalități de a crea un obiect.

Clase inner
Clasele interioare sunt clase definite in interiorul altor clase. De obicei clasele exterioare au o
metoda care returneaza o referinta la clasele interioare.
Obiectul clasei interioare are o referinta catre obiectul clasei exterioare
Tipul obiectului din clasa interioara se specifica prin NumeleClaseiExterioare.NumeleClaseiIterioare

Daca vrem sa obtinem referinta la obiectul clasei exterioare (din obiectul clasei inner) folosim:
OuterType.this
Daca vrem sa cream un obiect din clasa inner pornind de la un obiect din clasaouter folosim:
obiectOuter.new

Clasa interioara poate fi accesata doar din interiorul metodei(sau a doemniului de vizibilitate) in care a
fost definita.

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)

De ce inner class?
Fără capacitatea oferită de clasele interioare de a moșteni - din mai
multe clase concrete sau abstracte , unele probleme de proiectare și programare ar fi
imposibil de rezolvat.

Putem privi clasa interioară este ca si o solutie pentru moștenirea multipla. Clasele
interioare permit "moștenirea mai multor implementări".Clasele interioare permit în
mod efectiv să moștenim din mai multe interfețe .

Daca avem clase abstracte sau concrete în loc de interfețe, suntem limitati sa folosim
clase inner.

1. Clasa interioară poate avea mai multe instanțe, iar acestea sunt independente de
clasa exterioara.
2. Într-o singură clasă exterioară putem avea mai multe clase interioare, fiecare
implementând aceeași interfață sau moștenind din aceeași clasă într-un mod
diferit.
3. Nu exista relatie de tip is-a

Clase interioare anonime

Clasele anonime ne permit să ne facem codul mai concis. Putem declara si instantia o clasă în același
timp. Sutn ca și clasele locale, cu excepția faptului că nu au un nume.

Clasele locale sunt declarații de clasă, dar clasele anonime sunt expresii, ceea ce înseamnă că definim clasa
într-o altă expresie. Sintaxa unei expresii de clasă anonimă este ca invocarea unui constructor, cu excepția
faptului că există o definiție de clasă conținută într-un bloc de cod.

Clasele anonime nu pot avea constructor, dar initializarile se pot realiza in blocul non-static de initializare

Closure
Este un obiect apelabil care pastreaza informatii despre domeniul de vizibilitate in care s-a creat.

Clasele inner sunt closure pentru ca au o referinta catre obiectul din clasa exterioara si poate accesa
chiar si membrii private ai clasei.
Callback
Un obiect primeste o informatie care va permite sa apelam obiectul initial la un moment ulterior de timp

De ce callbacks? La executie, se poate schimba metoda care este apelată, in mod dinamic
Callback se implementeaza cu clase interioare

Mostenire in clase inner

La mostenire dintr-o clasa inner, trebuie furnizat la constructia obiectului un obiect din clasa inner,
pentru a se permite construirea sub-obiectului clasei de baza

EXCEPTII
Erorile ar trebui prinse la compilare, inainte de a incerca sa rulam programul.

Avantajul execptiilor este ca nu mai avem nevoie sa verificam eroarea particulara in mai multe locuri din
program; nu mai e nevoie sa verificam atunci cand apelam metoda din moment ce exceptiile garanteaza
ca cineva le va prinde. Astfel trebuie sa rezolvam eroarea doar intr-un singur loc. Asta inseamna ca si
codul devine mult mai usor de scris si de citit.

Problemele care nu pot fi rpinse la compilare trebuie rezolvate la executie printr-un mecanism prin care
clientul sa fie constient de rezolvarea situatiei.

Cand gasim o eroare pe care nu stim sa o tratam, insa stim ca nu putem continua cu ea, o transmitem la
un mediu de vizibilitate exterior.

Exceptiile se creaza pe heap, cu new.

Cand apare o eroare, cream un obiect de tip exceptie, firul de executie se intrerupe si referinta e trimisa
la mediu de vizibilitate extern, se incearca reluarea executiei programului, iar handlerul de exceptie
recupereaza programul de la eroarea aparuta.
Aruncam o exceptie prin throw (exemplu: throw new NullPointerException();)

Daca extindem clasa Throwable, putem arunca orice tip de obiect din throwable cu throw.

Sunt 2 tipuri de obiecte Throwable: Error and Exception

Dacă o metodă aruncă o excepție, trebuie să presupunem că această excepție va fi

"prinsă" și tratată.(adica try and catch)
Sunt 2 modalitati de tratare a erorilor:

1. Termination: eroarea este aruncata.

2. Resumption: se insereaza cod try – catch pt rezolvarea erorii
La Termination eroarea este atât de critică încât nu există nicio modalitate de a reveni la locul în care a avut loc
excepția

Putem crea propriile noastre exceptii pentru a define o problema

Logging

Cu logging se urmareste executia programului pentru a depista mai usor eroarea.

Erorile de tip RuntimeException nu trebuiesc specificate prin throws.

Restrictii la exceptii:

Cand se suprascrie o metoda, se pot arunca doar exceptiile de tipul specificat in metoda din
clasa de baza

Constructorii trebuie sa isi incheie cu success executia pentru a aduce obiectele intr-o stare
sigura

Exception matching: se face potrivire pe cea mai apropiata clauza catch care potriveste cu tipul
exceptiei

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

ITERATORUL
La colectii, iteratorul permite regasirea ordonata a obiectelor din colectia respectiva

Cu metoda next() produce urmatorul element din colectie

Cu metoda hasNext() interogheaza daca mai sunt elemente neiterate. Metoda e de tip Boolean

CU metoda remove() remove(): sterge ultimul element iterat din colectie

Spre deosebire de ListIterator, Iteratorii pot produce elementele colectiei doar intr-o singura directie.
ListIteratorul poate parcurge elementele colectiei in ambele directii.
CONTAINERE

LISTE
ArrayList: lista implementata cu un sir. Permite operatii rapide pentru access random la
elemente. Operatiile de inserare si stergere de la mijlocul listei sunt costisitoare

LinkedList: lista implementata cu lista simplu inlantuita. Permite operatii rapide de insertie si
stergere de la mijlocul listei, insa operatiile de regasirea aleatoare sunt costisitoare

Colectiile memoreaza o secventa de elemente individuale.

List: memoreaza obiectele in ordinea in care au fost inserate

Set: nu se permit obiecte duplicat

 Queue: regaseste elementele după ordinea furnizata de regula de insiruire

 Map: reprezinta grupuri de perechi de tip (cheie, valoare).