Ebook Programare in Java PDF

#InvataProgramare - Introducere in Programare cu Java
_____________________________________________________________________

Introducere in Programare cu Java:

Invata Pas cu Pas cum sa
programezi in Java

Ramon Nastase

_____________________________________________________________________

1

_____________________________________________________________________
Copyright 2018 Ramon Nastase – Toate drepturile rezervate.

Continutul acestei carti nu poate fi reprodus, duplicat sau transmis fara permisiunea
directa scrisa din partea autorului. In niciun caz nu va fi suportata raspunderea juridica
sau vina de catre editor pentru orice reparare, dauna sau pierderi financiare datorate
informatilor din aceasta carte, direct sau indirect.

Aviz juridic

Aceasta carte este protejata prin drepturi de autor. Acest lucru este numai pentru uz
personal. Nu puteți modifica, distribui, vinde, utiliza, cita sau parafraza orice parte sau
continut al acestei carti fara consimtamantul autorului.

Notificare privind renuntarea la raspundere

Retineti ca informatiile continute in acest document sunt numai pentru scopuri
educationale si divertisment. Au fost facute toate incercarile de a furniza informatii
exacte, actualizate si fiabile. Nu sunt exprimate sau implicate garantii de niciun fel.
Cititorii recunosc ca autorul nu se angajeaza in furnizarea de consultanta juridica,
financiara, medicala sau profesionala. Continutul acestei carti a fost derivat din diverse
surse.

Prin citirea acestui document, cititorul este de acord ca in niciun caz autorul nu este
responsabil pentru orice pierderi, directe sau indirecte, care apar ca urmare a utilizarii
informatiilor continute in acest document, inclusiv, dar fara a se limita la omisiuni sau
inexactitati.

_____________________________________________________________________

2

_____________________________________________________________________
Introducere

In primul rand vreau sa te felicit si sa iti multumesc pentru faptul ca ai luat decizia de a
investi in tine si de a deveni mai bun. Vreau sa iti spun ca acest ghid te va lua de la 0 (in
domeniul programarii in Java) si te va duce la un nivel de baza astfel incat sa fii constient
de modul in care functioneaza programarea si mai ales modul in care poti crea aceste
programe.

Odata ce vei parcurge aceasta carte, vei putea sa intelegi elementele de baza si cele
medii care tin de programarea in Java. Practic vei fi capabil sa-ti creezi propriile
programe si vei fi pregatit sa incepi sa aprofundezi conceptele de programare. Dupa
terminarea cartii iti recomand sa te apuci de rezolvarea problemelor, cu scopul de a te
ajuta pe tine sa devii un programator si mai bun astfel incat sa obtii oricand doresti un job
in IT (in tara sau in strainatate). Hai sa-ti arat cateva dintre lucrurile pe care le vei invata
aici:
● Cum arata domeniul IT si care sunt trendurile

● Ce poti sa faci cu JAVA
● Cum sa incepi programarea in Java in doar 30 de minute (instalare si crearea
primului program)
● Elemente de sintaxa si programare in Java
● Folosirea instructiunilor conditionale (if, for, while, switch)
● Concepte de baza despre POO
● Lucrul cu fisiere si cu exceptii in Java
● Structuri de date folosite pentru crearea diferitilor algoritmi
● Si multe altele :)

Aceasta carte este structurata pe 9 capitole care cuprind diferite teme, apartinand
conceptelor de baza din Programare (in Java). Un lucru pe care vreau sa-l stii este faptul
ca daca acum incepi pentru prima oara in IT, aceasta carte este un start destul de bun si
iti va oferi tot ce ai nevoie cand vine vorba de elementele de baza. Tot ce ai tu de facut
este sa urmezi pas cu pas informatiile si sfaturile din aceasta carte si sa depui efortul
necesar pentru a ajunge acolo unde iti doresti. Asa ca iti doresc mult succes si spor la
treaba.

Ramon, cel care te sustine in procesul tau de crestere.

PS: iar daca ai intrebari nu ezita sa ma contactezi pe email, Facebook sau Y ouTube.
_____________________________________________________________________

3

_____________________________________________________________________
Cuprins

Introducere 3
Cuprins 4
Capitolul 0 - Introducere in Programare 7

Ce poti face cu Java si de ce sa inveti programare? 7
1) Java pentru Android 7
2) Java pentru Programare Server Side 8
De ce sa incepi cu programarea in Java? 8
Cat de mare este concurenta cand vine vorba de programarea in Java? 8
Ce oportunitati de angajare ai ca programator (in Romania)? 8
Ce limbaje de programare poti sa inveti pentru a deveni programator? 9
Capitolul 1 - Introducere in Programare in limbajul Java 11

De ce sa inveti Java? La ce te poate ajuta? 11
De ce avem nevoie pentru a programa in Java? 12
Cum instalez si cum pornesc Eclipse? 13
Cum Creez un Proiect in IDE-ul Eclipse? 14
Cum Creez Main Class in Eclipse ? 18
Comentarii in Java 22
Exercitii 23
Capitolul 2 - Variabile in Java 24

Ce este o variabila? 24
Variabile de tip numar (int, float, double) 24
Variabile de tip String (siruri de caractere) 26
Exercitii 29
Capitolul 3 - Instructiuni conditionale (if, for, while) 31

1.1) Instructiunea IF 31
1.2) Instructiunea ELSE 34
2) Instructiunea FOR 37
3) Instructiunea WHILE 40
4) Instructiunea SWITCH 41
Exercitii 43
_____________________________________________________________________

4

_____________________________________________________________________
Capitolul 4 - Metode in Java 45

Ce Este o Functie (Metoda) ? 45
Metode care nu intorc un rezultat 46
Metode care intorc un rezultat 51
Exercitii 56
Capitolul 5 - Concepte de POO in Java 57

1) Concepte teoretice despre POO 57
POO vs. Programare Procedurala 57
Clase si Obiecte 58
Beneficiile POO 59
Scurt rezumat a celor discutate mai sus 59
2) Clase in Java 60
Ce este o clasa? 60
3) Constructori si Destructori 68
Ce este un constructor in POO? 68
Ce este un destructor in POO? 68
Folosirea constructoriilor in Java 68
4) Getters & Setter 73
Exercitii 79
Capitolul 6 - Exceptiile in Programare si Operatiile cu Fisiere in Java 82

I. Exceptii in Java 82
Ce sunt exceptiile? 82
Cum sunt generate exceptiile in Java? 82
Cum tratam exceptiile in Java? 84
Exercitii 90
II. Operatii cu Fisiere in Java 91
Exercitii 96
Capitolul 7 - Structuri de Date in Java 97

Ce sunt structurile de date? 97
Tipuri de structuri de date 97
1) Vectori (Arrays) 98
Cum folosim un Vector in Java? 98
2) Liste inlantuite (Linked Lists) 102
Ce este si cum functioneaza o Lista? 102
Care sunt functiile unei Liste? 103
_____________________________________________________________________

5

_____________________________________________________________________
Cum folosim o Lista (inlantuita) in Java? 103

3) Stiva (Stack) 107
Ce este si cum functioneaza o Stiva? 107
Care sunt functiile unei Stive? 107
Cum folosim o Stiva in Java? 108
4) Coada (Queue) 112
Ce este si cum functioneaza o Coada? 112
Care sunt functiile unei Cozi? 112
Cum folosim o Coada in Java? 112
Cand folosim cozile si ce aplicabilitate practica au? 113
5) Dictionare (Hash Maps) 116
Ce este si cum functioneaza un Dictionar? 116
Care sunt functiile unei HashMap? 117
Cum folosim un HashMap (Dictionar) in Java? 118
Cand folosim Dictionarele si ce aplicabilitate practica au? 119
BONUS: Capitolul 8 - Versiunea codului cu Git si GitHub 121

Ce este Git si GitHub? 121
Cum folosim Git pentru versionarea codului? 122
Cum urcam codul pe GitHub? 123

_____________________________________________________________________

6

_____________________________________________________________________
Capitolul 0 - Introducere in Programare

Ce poti face cu Java si de ce sa inveti programare?

Marea majoritate a companiilor de IT cer ca programatorii sa cunoasca bine limbajul Java
(sau un alt limbaj de programare) pentru ca acesta este un limbaj foarte raspandit si,
bineinteles, extrem de utilizat. Cererea pentru programatori Java este tot mai mare
deoarece acest limbaj este perfect pentru crearea de aplicatii. Comparandu-l cu C si C++,
Java este mai usor de invatat si de scris. Acest limbaj a fost conceput sa fie mai usor de
scris si sa genereze mai putine erori de programare (in comparatie cu C si C++).

Daca nu vrei sa-ti bati prea mult capul cu detaliile in care te poti pierde, te sfatuiesc sa
inveti Java pentru ca programarea este mai rapida in acest limbaj, iar proiectele tale vor
prinde viata mai usor. Este atat de simplu si de usor de folosit incat si un incepator poate
ajunge sa-l stapaneasca intr-un timp destul de scurt. Bineinteles, nu este mai usor de
inteles decat Python, dar ocupa cu siguranta locul 2 dupa acesta atunci cand vine vorba
de principii de programare si de sintaxa.

1) Java pentru Android

Cererea tot mai mare de Java este justificata prin faptul ca Android este construit in Java.
Asta inseamna ca aplicatiile pentru acest sistem sunt facute in Java si ca si tu poti oricand
crea o astfel de aplicatie, doar cunoscand limbajul de programare tocmai mentionat. Nu
ai nevoie decat de Eclipse si de ceva cunostinte solide de Java pentru a dezvolta diverse
aplicatii pentru Android. Apartinand de Google, Android este open-source, asa ca poti
sa-ti aduci oricand contributia la el. Tot ce se gaseste in Google Play este creat in Java,
iar daca iti vei face timp sa intelegi si sa inveti acest limbaj, o sa ti se para usor si o sa
vezi cum multe aplicatii pentru Android functioneaza. Daca te intrebai ce poti face cu
Java, crearea de aplicatii pentru Google Play este o idee buna.

_____________________________________________________________________

7

_____________________________________________________________________
2) Java pentru Programare Server Side

Un alt lucru pe care il poti face cu Java este sa creezi aplicatii de corporate pentru
business-uri foarte mari. Mai exact, sa-l folosesti pe partea de Server Side. IBM si Oracle
folosesc tot timpul Java pentru partea lor de aplicatii. Daca vrei sa fii unul din
programatorii care lucreaza la acesti giganti din industria IT, este absolut obligatoriu sa
cunosti Java, ba chiar sa fii expert in domeniu. Bineinteles ca este nevoie de mult
exercitiu si sa faci chiar nenumarate incercari prin crearea de aplicatii. Doar cu rabdare si
studiu intens poti deveni un programator Java bun, mai ales ca acest limbaj de
programare este usor de inteles si nu te poti trezi cu erori la fiecare pas atunci cand
programezi.

De ce sa incepi cu programarea in Java?

Daca doar ce te-ai apucat de programare, te sfatuiesc sa incepi cu Java pentru ca este
un bun punct de intrare in domeniu. Nu conteaza daca vrei sa te axezi pe algoritmica,
programare GUI sau networking, in Java poti face toate aceste lucruri. In cazul in care nu
te-ai hotarat inca, poti sa accesezi tutorialele de Java pe care le-am pregatit pentru tine si
sa decizi cat de mult rezonezi cu acest limbaj. Pana la urma este OOP (Object Oriented
Programming), deci inca de la inceput vei avea acces la ceea ce asta inseamna si iti vei
da seama de cat de puternic este de fapt acest limbaj de programare.

Cat de mare este concurenta cand vine vorba de programarea in Java?

Daca te intrebai cate lume cunoaste programarea in Java, afla ca domeniul IT duce lipsa
de astfel de programatori si companiile sunt in mare cautare de specialisti in Java (si nu
numai), pentru ca cererea de aplicatii in acest limbaj este tot mai mare. Cu alte cuvinte,
nu vei intampina probleme in gasirea unui loc de munca daca ajungi sa cunosti Java si
poti crea aplicatii cat mai interesante folosindu-te de acest limbaj. Exista desigur si
varianta crearii unei aplicatii de succes si comercializarea ei, ceea ce iti poate aduce o
considerabila sursa de venit si recunoastere ca programator de succes. Acum este sansa
ta, profita de ea!

Ce oportunitati de angajare ai ca programator (in Romania)?

Piata IT-ului din Romania este in continua crestere din 2012. In momentul de fata vorbim
de peste 125.000 de IT-isti care lucreaza in IMM-urile si in multi-nationalele din Romania.
Indiferent ca vorbim de dezvoltare software sau de livrare de servicii, putem fi de acord
_____________________________________________________________________

8

_____________________________________________________________________
ca domeniul IT in momentul de fata reprezinta o reala oportunitate de cariera pentru
oricine isi doreste sa o urmeze. Daca doresti sa te angajezi in IT, iti pot spune ca acesta
este cel mai bun moment si iti recomand sa te grabesti. Iti recomand sa te grabesti
pentru ca marea majoritate a companiilor angajeaza (si nu au doar 1 - 2 posturi deschise,
ci zeci poate chiar sute).

Ca sa-ti faci o idee de cat de mare este aceasta nevoie de personal, te las sa te convingi
singur de aceste cifre: Facultatile de profil (IT/informatica) din Romania livreaza anual
6000 - 7000 de absolventi pe piata muncii, nevoia find cel putin dubla. Aici este
oportunitatea, sansa ta de reusita. Si pot sa-ti spun ca daca faci tot ce iti sta in putinta sa
inveti constant, sa dobandesti abilitati noi si sa exersezi incontinuu conceptele pe care le
vei studia in aceasta carte (si dincolo de ea), eu sunt convins ca tu vei reusi.

Tot ce ai nevoie sa faci este sa te hotaresti pe ce ramura a IT-ului vrei sa mergi (daca
citesti aceasta carte, cel mai probabil, ai ales deja), sa faci research ce se cere in piata,
de catre angajatori (la nivel de abilitati si tehnologii), si sa te apuci de treaba sa
dobandesti acele abilitati astfel incat sa te angajezi in IT. Sper ca ai observat ca am spus
abilitati si nu diplome. E important sa intelegi ca oricine se poate angaja in IT, intrebarea
e cine isi va face o cariera din asta? (aka. va rezista si va evolua), cine va avea un succes
real dpvd profesional si financiar?, cine va fi pasionat si cu adevarat implinit de ceea ce
face zi de zi la locul de munca? Eu sper ca acesta vei fi tu. De aceea iti doresc mult
succes si spor la invatat si mai ales la aplicat de-a lungul acestei carti.

Ce limbaje de programare poti sa inveti pentru a deveni programator?
Primesc foarte des aceasta intrebare si consider ca acum e un moment bun pentru a
raspunde la ea. Pe scurt, raspunsul e … depinde. Depinde ce anume iti doresti, depinde
ce anume te pasioneaza cand vine vorba de IT si pe ce ramura vrei sa dezvolti mai
departe programe si aplicatii. Important de retinut este ca experienta nu consta in
numarul de limbaje cunoscute, ci mai degraba in cunostintele acumulate in cadrul fiecarui
limbaj de programare cunoscut, in parte. O intrebare des intalnita inainte de inceperea
parcurgerii unui limbaj este urmatoarea: “Am nevoie de matematica in programare?”,
raspunsul la aceasta intrebare este unul impartit. O intrebare auxiliara care trebuie
adresata este: “Ce vrei sa faci cu limbajul pe care urmeaza sa il utilizezi?” , daca vrei sa
lucrezi ca Web Developer si vei folosi limbaje din aceasta speta, cel mai probabil nu, dar
daca vei lucra pe post de Machine Learning Expert, atunci probabil te vei lovi ceva mai
mult de matematica. In orice caz, important este sa nu te lasi descurajat de matematica,
un limbaj de programare poate fi invatat si fara aceasta, iar rolul ei nu este esential la
_____________________________________________________________________

9

_____________________________________________________________________
inceput. Pe langa toate acestea, nu exista un limbaj “nefolositor”, fiecare are rolul sau si
este adaptat pentru un anumit set de nevoi si cerinte.
Acum hai sa vedem ce limbaj de programare poti sa inveti (in functie de ce iti doresti sa
faci pe termen lung):
● C / C++ – Limbaje perfecte pentru proiecte low-level, des intalnite in
reprogramarea sistemului de operare si utilizate de placutele Arduino, pentru
diferite proiecte de automatizare / robotica.
● HTML + CSS + JavaScript – Un combo excelent pentru realizare de pagini web
statice. Cel mai popular framework care include aceste limbaje de marcare este
Bootstrap, un framework dezvoltat de catre creatorii aplicatiei Twitter.
● PHP – Realizarea Backend-ului pentru o pagina web interactiva, limbaj intalnit si in
inlocuirea Shell Script-ului pe Linux. Doua dintre framework-urile populare pentru
acest limbaj sunt Laravel si Symfony, de asemenea PHP-ul este adesea folosit
impreauna cu SQL-ul, folosit in programarea bazelor de date.
● Java / C# / Swift – Limbaje destinate aplicatiilor mobile pentru Android, Microsoft
sau Apple.
● Python, Perl, Ruby – Aceste trei limbaje, sunt catalogate ca limbaje de scripting,
deoarece sunt cel mai des intalnite in automatizari. Ultimul dintre acestea, Ruby,
poate fi folosit ca inlocuitor al PHP-ului, prin framework-ul Ruby on Rails, destinat
Web Developing-ului.

Cele de mai sus sunt cele mai populare din sutele de limbaje de programare existente.
Unele din aceste limbaje sunt compilate (C/C++/C#), la acestea este nevoie de un
compilator, iar altele sunt interpretate (Python, PHP, Perl), unde sistemul va citi linie cu
linie pentru a pune in aplicare instructiunile. Cel mai important este sa iti alegi un limbaj
care se potriveste nevoilor tale si sa incepi sa il practici si sa cunosti cat mai bine.

In cele ce urmeaza vom studia in detaliu limbajul Java si iti voi explica pas cu pas cum
sa-l setezi la tine pe laptop si cum sa te apuci in doar cateva minute de programat. Hai sa
mergem la urmatorul capitol ;)

_____________________________________________________________________

10

_____________________________________________________________________
Capitolul 1 - Introducere in Programare in limbajul

Java

In acest prim capitol introductiv in Java vom discuta despre acest limbaj, astfel incat sa
stii de ce anume inveti Java. De asemenea vei afla cum sa-ti setezi mediul de dezvoltare
(aka. IDE) astfel incat sa incepi sa programezi… si bineinteles vei afla cum sa-ti creezi
primul program in limbajul Java. La sfarsitul acestui capitol (precum si a celorlalte) vei
avea un set de exercitii practice pe care te invit sa le rezolvi, asta te va ajuta sa-ti
imbunatatesti cunostintele practice de programare (in general si in Java). Focusul acestei
carti va fi si pe partea teoretica, dar mai ales pe partea practica prin exemplele pe care ti
le voi arata pe parcursul capitolelor si prin exercitiile de final de capitol (pe care te invit sa
le rezolvi). Si acum, hai sa trecem la treaba :)

De ce sa inveti Java? La ce te poate ajuta?

Java este un limbaj de programare care a fost creat de James Gosling in anii ‘90. Dupa
cum am mai spus, seamana foarte mult cu C++. Asta pentru ca C++ este si el limbaj
orientat pe obiecte, insa Java e limbaj pur orientat pe obiecte. Pe langa asta, Java
foloseste compilator si interpretor, intre timp ce C si C++ folosesc doar compilatorul.
Avantajul folosirii limbajului Java fata de celelalte doua este ca, acesta este independent
de platforma, deci poti rula codul executat pe un alt sistem de operare. Astfel, daca ai un
program scris in Java si e gata compilat, il poti rula pe orice platforma care are JVM (Java
Virtual Machine - Masina Virtuala Java - mediu in care programul Java e executat). Un alt
super-avantaj (spune eu ca e super :D) consta in faptul ca in Java permite conectivitatea
la bazele de date, fapt care ne ajuta sa cream si sa programam aplicatii mult mai eficient.
In figura 1.1 de mai jos poti vedea tot procesul de editare, compilare si executie a codului
in Java. IDE-ul Eclipse (despre care vom vorbi imediat), vine la pachet cu toate acestea,
deci nu-ti fa griji. Programul tau va functia in urma apasarii unui singur buton :)

Figura 1.1
_____________________________________________________________________

11

_____________________________________________________________________
Java este un limbaj foarte cunoscut si de viitor, extrem de folosit de catre foarte multe
tehnologii. Poate ai auzit de Android, sistem de operare pentru dispozitive mobile
(smartphones, tablete, smartwatches, smart TVs etc.), care este construit in Java. Foarte
utilizat de oameni in intreaga lume, Android foloseste Java pentru a functiona.

Figura 1.2
Cunoscand limbajul de programare Java vei putea construi aplicatii in Android si pentru

servere, mai ales pe partea de Enterprise, unde este foarte folosit. Hai sa incepem si sa
vedem elementele de care ai nevoie pentru a incepe programarea in Java. In
urmatoarele tutoriale o sa te invat sa scrii cod si sa iti exersezi modul in care programezi,
pentru a te ajuta sa devii mai eficient.

De ce avem nevoie pentru a programa in Java?

Pentru a avea acces la Java, vei avea nevoie de Eclipse. Eclipse este un IDE, un mediu
de dezvoltare in care tu poti sa scrii cod Java. Acest IDE va compila codul tau si ti-l va
rula. Java functioneaza pe orice sistem de operare. Astfel ca, daca vei lua codul pe care
l-ai scris intr-un fisier si vei incerca sa il rulezi pe MacOS, Windows sau Linux, acel cod va
rula.

Cu o simpla cautare a cuvantului “eclipse” in Google, vei primi rezultate ce te vor trimite
la pagina de download a programului. Descarca Eclipse Oxygen de AICI. Ai si alte
alternative, dar eu iti recomand Oxygen.

Urmatorul pas este descarcarea altor programe care iti compileaza si iti fac programul in
Java sa functioneze. Eclipse este doar un mediu grafic de dezvoltare. Ai nevoie Java
Runtime Environment (JRE), care este practic locul in care va lucra programul tau, si Java
Development Kit (JDK). Acestea doua iti recomand sa le descarci de pe site-ul Oracle,
versiunea 1.8, folosind Java 1.8. Pe acest site vei avea tot ceea ce ai nevoie.

_____________________________________________________________________

12

_____________________________________________________________________
Este important sa treci prin acest proces de instalare pentru ca altfel nu vei putea rula
programele. Odata ce esti pe site-ul de la Oracle, cauta, de exemplu, JDK. Vei primi
rezultatele la tot ceea ce ai nevoie pentru a programa in Java. In cele mai multe cazuri,
este vorba de varianta 64 de biti ce va trebui descarcata. Cauta JRE si fa acelasi lucru.

Sau, daca nu vrei sa cauti, poti descarca cele 2 programe dand un click pe link-urile mai
jos:
● JRE (Java Runtime Environment): https://goo.gl/CfGbzE
● JDK (Java Development Kit): https://goo.gl/ycgamA

Cum instalez si cum pornesc Eclipse?

Dupa ce ai descarcat Eclipse-ul, te poti apuca de descarcare. Dupa ce l-ai descarcat, da
dublu click si treci prin procesul de instalare care este destul de simplu. La un moment
dat, o sa observi ca ai mai multe resurse din care poti alege.

Ai, de exemplu, Eclipse IDE for Java Developers, Eclipse IDE for Java EE Developers si
asa mai departe. In Eclipse poti sa folosesti mai multe limbaje de programare si in mai
multe scopuri. Poti sa folosesti Eclipse pentru C++, pentru JavaScript sau Web
Development si pentru PHP. Eu iti recomand sa folosesti prima varianta, Eclipse IDE for
Java Developers. Da click pe ea si aceasta se va instala, creandu-ti o iconita pe desktop
sub numele de Java Eclipse Oxygen.

Da dublu-click pe Java Eclipse Oxygen si vei vedea ca iti va cere sa iti creezi un
workspace, adica un loc in care toate uneltele si toate proiectele pe care le creezi vor fi
puse. Aici se va si salva tot ceea ce tu ai scris in cod, ca de fiecare data cand deschizi
acest program sa poti ajunge la ceea ce ai scris. Apasa Launch si totul va fi default (dupa
cum poti sa vezi si in figura 1.3). De fiecare data cand vei porni acest program vei primi
aceasta intrebare despre worskpace. Vei putea selecta fiecare workspace pe care l-ai
creat.

_____________________________________________________________________

13

_____________________________________________________________________

Figura 1.3

Cum Creez un Proiect in IDE-ul Eclipse?

Mai departe, primul lucru pe care poti sa il faci este sa creezi un proiect. Te vei duce la
File, New, unde poti vedea ca ai mai multe optiuni. Ceea ce tu vei face este sa creezi un
proiect in care vei pune codul tau. Dar nu vei pune acolo cod pur si simplu. Java
functioneaza in felul urmator, ai nevoie de un proiect (gandeste-te la acest proiect ca la
un folder), dupa care ai pachete (in acest proiect). Acestea contin la randul lor clase. In
Java, fiecare fisier va determina o clasa.

Aceasta este OOP (Object Oriented Programming), adica Programare Orientat pe
Obiecte. Daca inca nu iti este clar ce sunt clasele, vei putea urmari sau citi un alt tutorial
in care voi explica totul despre elementele esentiale in Programarea Orientata pe
Obiecte. Nu voi intra acum in detalii. O sa iti explic mai tarziu ce sunt clasele, ce sunt
obiectele si toti acesti termeni cu care va trebui sa te obisnuiesti. Dar sa trecem mai
departe.

_____________________________________________________________________

14

_____________________________________________________________________

Figura 1.4

Creeaza proiectul si alege-i un nume. Lasa totul pe default. Vei fi intrebat ce
environment vei dori sa folosesti pentru a rula. Lasa elementele asa cum sunt. Daca nu ai
instalat corect JDE-ul si JDK-ul, toate aceste lucruri despre care vorbesc nu vor aparea
pe ecranul tau, iar programul nu va functiona.

_____________________________________________________________________

15

_____________________________________________________________________
1
Figura 1.5

Daca totul este in regula, proiectul pe care tocmai l-ai inceput ti se va deschide. Apasand
sageata din dreptul numelui proiectului, in stanga, vei vedea ca ai JRE System Library si
SRC. Acestea sunt cateva librarii care exista by default si care contin cateva functii. Un
limbaj de programare este slab fara functii si librarii scrise de alte persoane. Scopul sau
este sa iti puna totul la dispozitie, iar tu sa te folosesti de functiile lui pentru a scrie cod
mut mai rapid si mai eficient.

_____________________________________________________________________

16

_____________________________________________________________________

Figura 1.6

Figura 1.7

_____________________________________________________________________

17

_____________________________________________________________________
Cum Creez Main Class in Eclipse ?

Dute la SRC si da click-dreapta. Vei vedea ca trebuie sa creezi o noua clasa si sa ii dai
nume. Alege, de exemplu numele MainClass si apasa Finish. Ti se va crea o clasa in care
vei putea scrie cod. Aceasta clasa o vei folosi pe post de Main. Java functioneaza la fel
ca C++ cand vine vorba de clase. Numai scrierea este un pic diferita.

Figura 1.8

Daca in C++ avem int main(), in Java avem public static void main() (figura 1.6), adica
locurile in care noi vom crea si vom executa anumite functii, metode si clase pe care
le-am creat. Aici se uneste toata ierarhia cu toate clasele. Aici vei pune tot, si aici (in
main() ) vei rula toate functiile. Exista un fisier principal, de obicei numit Main Class, iar in
rest vei avea diferite clase care vor da o anumita functionalitate programului. Toate
aceste clase trebuie undeva executate si rulate rand pe rand, iar Main este tocmai pentru
acest scop.

Mai departe tot ce trebuie sa facem este sa incepem sa scriem cod. In primul rand (daca
nu ai mai interactionat cu Java sau cu un alt limbaj de tip OOP), iti recomand sa scrii acest
program care va afisa pe ecran un text:
System.out.println("Hello World");

_____________________________________________________________________

18

_____________________________________________________________________

Figura 1.9

Codul tau va arata similar cu cel din figura 1.9 de mai sus, dupa care vei apasa pe butonul
verde de “Run”, care va compila si va rula programul pe care l-ai creat (dupa cum poti sa
vezi in figura 1.10 de mai jos).

Figura 1.10
Dupa aceea te va intreba daca vrei sa salvezi programul si iti recomand sa apesi pe “OK”
pentru a-l putea executa, iar rezultatul final va fi afisat in consola din Eclipse (sau oricarea
ar fi IDE-ul tau).
_____________________________________________________________________

19

_____________________________________________________________________

Figura 1.11

Aceasta linie de cod ne va afisa in consola textul "Hello World" cu un spatiu dupa
aceasta. Daca vrem sa afisam un simplu text fara a adauga un spatiu la final atunci vom
recurge la functia:
System.out.print("Hello World");
Dupa cum poti sa vezi in figura 1.12 de mai jos, aceasta functie print ( de mai sus) este una
similara cu println, doar ca se comporta putin diferit cand vine vorba de afisarea textului
pe ecran sau in consola. Functia aceasta nu va afisa textul cu o linie noua dupa el dupa
cum poti sa vezi in figura 1.11 de pe urmatoarea pagina.

Totodata, in timp ce ai scris tot acest cod si diferitele functii, banuiesc ca ai descoperit si
feature-ul de autocomplete a IDE-ului Eclipse (mai ales in momentul in care ai apasat
butonul pentru "."). Este un feature pe care eu il consider extrem de util si care iti va salva
mult timp (si nervi :D) pe masura ce vei incepe sa-ti creezi propriile programe si proiecte,
precum si la job. Vei vedea pe parcurs ce inveti sa programezi mai bine si faci mai mult
cat de util iti va fi. Astfel poti programa mult mai usor fara a avea nevoie de cunostinte
legate de sintaxa exacta a liniei de cod. Java si Eclipse ne permit sa facem astfel de
lucruri.
_____________________________________________________________________

20

_____________________________________________________________________

Figura 1.13

Figura 1.14
_____________________________________________________________________

21

_____________________________________________________________________
Comentarii in Java
In Java, precum si in marea majoritate a limbajelor de programare, avem la dispozitie sa
comentam diverse aspecte ale codului pe care noi il scriem. Aceste comentarii pot fi
extrem de benefice din mai multe puncte de vedere: unul dintre ele ar fi faptul ca poti
lasa comentarii despre ce face o secventa de cod - o functie, o clasa etc- (aka.
documentezi codul astfel incat tu sau alte persoane sa inteleaga ceea ce face acesta).
Un alt motiv ar fi sa invalidezi o secventa de cod deja existenta (adica vei face ca acea
secventa sa nu fie compilata si executata). Acum propun sa iti arat 2 exemple astfel incat
tu sa intelegi mult mai bine la ce ma refer:

public class Main {
public static void main(String args[]) {
/acesta este un comentariu in care pot sa scriu orice

/
System.out.println("Se va afisa acest text");
/* Testul de mai jos nu se va afisa */

//System.out.println("Acest text nu se va afisa");
}
}
Rezultatul afisat pe ecran va fi:

Figura 1.15

Dupa cum poti vedea in cele 2 exemple de mai sus, avem 2 moduri prin care putem lasa
un comentariu: primul fiind cel cu //, iar cel al 2-lea fiind cel cu /* */. Ambele variante sunt
folosite, doar ca varianta a doua ne permite sa comentam secvente mult mai lungi (care
se intind pe mai multe randuri) de text.

_____________________________________________________________________

22

_____________________________________________________________________
Exercitii

Incepand cu acest capitol, la fiecare final de capitol iti voi pune la dispozitie un set de
exercitii pe care tu sa le practici, ele te vor ajuta sa-ti intaresti in minte conceptele deja
studiate si sa aprofundezi si mai mult studiul programarii.

Setul de Exercitii #1

1) Scrie un program care sa afiseze prenumele tau pe primul rand, iar pe urmatorul
rand numele.
2) Acum, modifica codul de la punctul anterior, astfel incat la afisare prima linie (adica
primul rand) sa fie goala, a doua linie sa contina prenumele, a treia linie sa fie
goala, iar pe a patra linie sa apara numele.


1) Daca ar trebui sa scrii un program care afiseaza cate o litera din numele si
prenume tau, cum l-ai scrie folosind doar cunostintele din acest capitol (fara a te
complica cu alte functii sau metode):
S
t
a
n

A
n
a


1) Afiseaza prenumele astfel incat literele sa apara pe diagonala, in felul urmator:
S
t
a
n

A
n
a
_____________________________________________________________________

23

_____________________________________________________________________
Capitolul 2 - Variabile in Java

In acest capitol trecem mai departe cu conceptele de programare si vorbim despre
variabile. Vei vedea cum sa le folosesti pentru a face diferite lucruri in Java. Fie ca este
vorba de calcule matematice, retinerea de valori sau manipulari cu sirurilor de caractere,
o sa vezi cum poti folosi variabilele.

Ce este o variabila?
In programare variabila este o locatie de memorie care poate pastra o valoare de un
anumit tip. Practic, este un mod prin care programul nostru poate retine (in memorie)
anumite informatii de mai multe tipuri. Aceste tipuri difera de la caz la caz, dar in general
acestea pot fi numere (naturale, intregi sau reale), caractere (sau siruri de caractere -
aka. string-uri), expresii booleane (True sau False - 1 sau 0). Un aspect important pe care
doresc sa-l mentionez este faptul ca variabilele isi pot schimba valoarea pe care o
stocheaza in memorie (de obicei prin mai multe moduri: prin schimbare manuala sau prin
atribuiri, respectiv operatii matematice). In cele ce urmeaza le vom lua pe rand pe fiecare
in parte si vom vedea cum le putem defini si folosi in programare.

Variabile de tip numar (int, float, double)
Pentru inceput, propun sa luam variabilele de tip numar si sa vorbim mai multe despre
ele. Acestea pot fi de mai multe feluri, dupa cum am spus si mai devreme si anume:
● Numere naturale - unsigned int

● Numere intregi - int
● Numere reale - f loat s au double
In exemplul de mai jos poti sa vezi cum se declara aceste variabile si cum le putem
atribuii o valoarea.
unsigned int x = 5;
int y = -10;
Acestea sunt exemple de variabile pe care tu le poti folosi in Java sau in alte limbje de
programare. Int i nseamna integer, adica numere intregi. Pot fi atat valori pozitive, cat si
negative, atata timp cat nu au virgula. Daca vrem numere cu virgula, adica numere
rationale, putem folosi float:
float a = 5.1f;
float b = 6.2f;
_____________________________________________________________________

24

_____________________________________________________________________

Am pus f la final ca sa specificam clar ca acestea sunt float. Putem avea fie float, fie
double. Sunt diferite moduri prin care putem defini aceste numere rationale.

Figura 2.1

Acum, hai sa facem o operatie (matematica) cu aceste variabile (si anume sa calculam
suma dintre x si y):
int sum = x + y;
Printam ceea ce am scris mai devreme pe ecran:
System.out.println(sum);
Dupa ce vom da Run, va aparea in partea de jos a ecranului suma, care este 15.
Acum hai sa scriem putin mai frumos. Tot ceea ce scriem cu ghilimele in Java este un sir
de caractere. Astfel, vom printa in consola:
System.out.println("The total sum is:" + sum);
Va trebui sa punem semnul plus “+” , deoarece “The total sum is:” reprezinta un string, iar
sum e ste pur si simplu un numar. Noi va trebui sa facem o operatie ca “+”, in care suma
se va atasa pur si simplu string-ului, devenind per total un string. Vom da Run din nou, si
vom vedea cum pe ecran va aparea:
The total sum is: 15

_____________________________________________________________________

25

_____________________________________________________________________

Figura 2.2
Si iata si rezultatul operatiei de mai devreme, il poti vedea afisat in consola din figura 2.3
de mai jos:

Figura 2.3

Variabile de tip String (siruri de caractere)
Mergand mai departe vom avea de-a face cu variabile de tip caracter si cele de tip String
(aka. Siruri de caracter). Pentru a crea un caracter, vom folosi urmatoarea sercventa de
cod:
char a = 'a';
System.out.println(a);
Hai sa cream si un String:
String abc = "Abc";

System.out.println(abc);
Daca rulam tot ceea ce am scris pana acum in program, va aparea pe ecran:
a
Abc
_____________________________________________________________________

26

_____________________________________________________________________
Daca ar fi sa scriem:
abc = abc + "a";
cand vom da:
vom vedea pe ecran ca lui Abc i se va mai adauga inca o litera, inca un string care va fi a.
Astfel, ceea ce va aparea printat pe ecran va fi:
Abc
Abca
Te poti juca in foarte multe moduri cu string-urile. Poti face foarte multe. Toate variabilele

(int, float) sunt scrise cu litere mici. Acestea sunt variabilele clasice embedded in Java, ce
pot fi gasite in orice limbaj de programare, indiferent ca e vorba de C++, Python sau alte
limbaje. Aici, string-ul este o clasa, o variabila mai speciala, pentru ca isi poate insusi
anumite functii, anumite metode. De exemplu, daca inlocuim:
cu:
System.out.println(abc.);
vom primi foarte multe functii, sub-functii ale lui abc. (scris cu punct dupa cele 3 litere).
Acestea ne ofera diferite valori sau informatii cu care putem sa folosim acest string si sa-l
manipulam. Putem selecta:
System.out.println(abc.length());
si vom primi numarul de caractere din acest sir abc. Vei observa ca nu putem sa facem
acelasi lucru in:
System.out.println("The total sum is:" + sum);

adaugand:
System.out.println("The total sum is:" + sum.length);
Variabila int suma nu a fost conceputa in acest mod. Aceasta este frumusetea in Java.
Putem folosi string-uri speciale care sunt de fapt clase in spate, care ne ofera anumite
abilitati in plus cand vine vorba de functii. Si aceste functii sunt foarte benefice. Vei
vedea, in timp, ca le vei folosi foarte, foarte des. Acesta este un avantaj al programarii in
Java: poti crea astfel de clase si poti avea foarte multe functii in spate, ale diferitelor
obiecte.
_____________________________________________________________________

27

_____________________________________________________________________

Figura 2.4

Figura 2.5

Stiu ca am vorbit un pic mai detaliat despre programarea orientata pe obiecte, dar nu te
ingrijora, vor urma alte tutoriale mai in detaliu. Pana atunci, poti incerca sa faci alte lucruri:
adaugare de elemente, scaderi, diferite siruri, etc. Cauta pe Google alte diferite tutoriale
despre cum sa faci lucruri in Java si aplica-le.

_____________________________________________________________________

28

_____________________________________________________________________
Exercitii

Felicitari pentru faptul ca ai ajuns la sectiunea de exercitii din acest capitol. Iata
programele pe care te rog sa le creezi:

1) Creeaza cate o variabila de tipul: string, int si float, dupa cum urmeaza:
Variabila de tip unsigned int va retine valoarea 20

Variabila de tip int va retine valoarea - 5
Variabila de tip float va retine valoarea 8
.73
Variabila de tip String retine valoarea “Java”
Variabila de tip String retine valoarea “I mi place programarea in ”
Variabila de tip String retine valoarea “ pentru ca suma acestor 2 numere este: ”
Variabila de tip char retine valoarea “! ”
Avand aceste variabile, afiseaza pe ecran un mesaj (care sa aiba cat de cat sens :D ) cu
acestea.

2) Scrie un program care calculeaza valoarea pentru urmatoarele variabile de tip float:

x = -7 + 4/3*5
y = -7 + 4/(3*5)
z = (-7 + 4/3)*5

Afiseaza aceste valori in felul urmator pe ecran:
x = …valoare care se va calcula pentru x…

y = …valoare care se va calcula pentru y…
z = …valoare care se va calcula pentru z...

Observa care sunt diferentele dintre cele trei valori afisate. Acum incearca sa schimbi
tipurile acestor variabile in int si ruleaza programul. Ce se intampla?

_____________________________________________________________________

29

_____________________________________________________________________

_____________________________________________________________________

30

_____________________________________________________________________
Capitolul 3 - Instructiuni conditionale (if, for, while)

In acest capitol vom discuta despre elementele de baza din programare
(instructiunile) care fac logica programarii posibila. Aceste instructiuni ne contureaza
programele si le ofera o logica (o structura) pe care sa o urmeze cu scopul de a ne ajuta
sa rezolvam probleme mult mai complicate. Cand vorbim despre instructiunile
conditionale ale limbajelor de programare, avem la dispozitie urmatoarele:
● Instructiunea if - daca se respecta conditia X, atunci se intampla Y

● Instructiunea w hile - cat timp se respecta conditia X, se intampla Y
● Instructiunea f or - pentru o anumita conditie X, (cat timp aceasta este respectata)
se intampla Y
● Instructiunea switch - daca se respecta conditia X, atunci se intampla A, daca nu,
se intampla B, daca nu, se intampla C, daca nu, se intampla
D...

1.1) Instructiunea IF

Daca ai mai avut de-a face cu programarea, atunci cel mai probabil te-ai intalnit cu
aceasta instructiune IF. Ea este una dintre cele mai folosite si cunoscute instructiuni si
este intalnita in marea majoritate a limbajelor de programare (C/C++, Java, Python, PHP,
Ruby, Bash etc.). Functia ei este clara si simpla: sa verifice valoarea de adevar a unei
expresii (ex: “5 > 3?” , aceasta expresie este adevarata). In cazul in care expresia este
adevarata se va merge mai departe cu executarea instructiunilor din blocul IF. Asadar,
sintaxa de cod pentru instructiunea IF arata in felul urmator:
if ( conditie ) {
instructiune 1;
instructiune 2; ...
}
if ( conditie ) {
instructiune 1;
instructiune 2; ...
}
_____________________________________________________________________

31

_____________________________________________________________________
La nivel fundamental, cam asa arata instructiunea IF. Va exista o conditie care va rezulta
o valoare de adevar (fie ea Adevarata sau Falsa). In cazul in care aceasta valoare este
Adevarata (ex: 5 > 3), se vor executa instructiunea 1, instructiunea 2, instructiunea 3.
Altfel, in cazul in care nu este adevarata conditia (de exemplu pentru 5 > 8), programul va
trece de blocul de date if si nu se vor executa cele 3 instructiuni.
Poate te intrebi ce reprezinta aceste conditii. Ei bine, conditiile din instructiunea IF pot fi
operatii (comparatii) matematice, precum cele de mai jos:
● A > B - se verifica daca A este mai mare ca B

● A < B - se verifica daca A este mai mic ca B
● A >= B - se verifica daca A este mai mare SAU egal ca B
● A <= B - se verifica daca A este mai mic SAU egal ca B
● A == B - se verifica daca A este egal cu B
● A != B - se verifica daca A este diferit de B
Toate acestea sunt operatii matematice care vor rezulta o valoarea de adevar: fie ea
falsa sau adevarata. Daca instructiunea if are o conditie ADEVARATA, atunci va continua
cu executarea instructiunilor din acoladele { }, in caz contrar (daca acea conditie este
FALSA), se va trece peste acele instructiuni ( din { } ).
Da-mi voie sa-ti dau un exemplu pentru a intelege mult mai bine :
int a = 5;
int res = 0;
if ( a > 3 ) {
res = a + 1;
}
System.out.println(res);

Care crezi ca va fi rezultatul afisat al secventei de cod de mai sus? Dupa cum probabil ai
raspuns, rezultatul este 6. Iar acum haide sa vedem de ce. Initial am declarat doua
variabile (a si res), dupa care am creat un bloc de instructiuni, folosind IF, in care am
testat (verificat) daca valoarea lui a este mai mare decat numarul 3.

Expresia aceasta este adevarata pentru propozitia “5 este mai mare decat 3”, ceea ce
inseamna ca programul nostru merge mai departe si intra in blocul de date IF, unde are
loc acea operatie matematica si se atribuie lui res r ezultatul adunarii lui 1 cu 5, adica 6.
_____________________________________________________________________

32

_____________________________________________________________________
Astfel, in momentul afisarii, rezultatul res va fi 6 (dupa cum poti sa vezi si in figura 3.1 de
mai jos). Daca expresia din IF ar fi aratat in felul urmator:
int a = 5;
int res = 0;
if ( a > 8 ) {
res = a + 1;
}

Atunci rezultatul ar fi fost total diferit: valoarea afisata a lui res, in acest caz, este 0. De
ce? Pentru ca in cazul acesta a ( care are valoarea 5) este mai mic fata de 8, iar expresia
(a > 8) devine falsa, deci programul nu va mai executa codul dintre acolade { }, ci va
merge mai departe la afisarea valorii lui res. Toate acestea poti sa le vezi in figura de mai
jos:

Figura 3.1

In sectiunea de exercitii de la sfarsitul acestui capitol vei avea ocazia sa te joci mai mult
cu aceasta instructiune IF pentru ca vei avea mai multe programe pe care sa le creezi cu
scopul de a stapanii cat mai bine programarea :)

_____________________________________________________________________

33

_____________________________________________________________________
1.2) Instructiunea ELSE

Instructiunea IF este extrem de benefica, deoarece ne permite sa comparam sau sa luam
anumite decizii logice pe baza rezultatului conditiei (adevarat sau fals). De multe ori in
programare vor exista situatii in care trebuie sa comparam mai multe conditii si sa luam
decizii specifice pe baza lor. Unele conditii sunt adevarate intr-o anumita situatie, iar
altele nu. Forma generala a acestor conditii alternative poate arata in felul urmator:
if ( conditie 1 ) {
instructiune 1;
....
}
else {
instructiune 2;
...
}

Dupa cum poti sa vezi, avem IF-ul cu prima conditie (care daca este adevarata va fi
executata instructiunea 1) , iar in cazul in care aceasta conditie nu este adevarata se
ajunge la executarea instructiunii 2 din else. Hai sa luam un exemplu prin care sa
intelegi mult mai bine ce vreau sa spun:
int a = 2;
int res = 0;
if ( a > 3 ) {
res = a - 1;
}
else {
res = a + 1;
}
In acest exemplu, poti sa vezi ca in cazul in care a este mai mare decat 3, atunci res v a
avea valoarea a - 1. Daca aceasta conditie este falsa (a nu este mai mic decat 3, ceea ce
in acest exemplu asa este), programul va trece de instructiunile din blocul if si va merge
mai departe in blocul else, unde va executa instructiunea de adunare (res = a + 1), iar apoi
va afisa rezultatul 3. Orice valoarea a lui a care nu respecta a > 3, va ajunge sa execute
instructiunea din blocul else.
_____________________________________________________________________

34

_____________________________________________________________________
Daca ar fi sa mergem mai departe si sa fim si mai specifici in alegerea rezultatului dorit,
putem structura IF-urile in formatul urmator:

if ( conditie 1 ) {
instructiune 1;
....
}
else if ( conditie 2 ) {
instructiune 2;
...
}
else if ( conditie 3 ) {
instructiune 3;
...
}

Iar mai jos poti sa vezi exemplul:
int a = 2;
int res = 0;
if ( a > 3 ) {
res = a - 1;
}
else if ( a == 3 ){
res = a;
}
else if ( a < 3 ) {
res = a + 1;
}
else {
System.out.println("Nu exista un rezultat pentru res");
}

In exemplul de mai sus poti sa vezi un exemplu mai detaliat despre cum poti sa folosesti
instructiunea IF, combinand si instructiunea ELSE. Indiferent ca este vorba de ELSE IF sau
pur si simplu ELSE, putem executa instructiuni diferite daca conditia initiala (din primul IF)
nu a fost indeplinita. Acesta este o metoda foarte buna pe care o putem folosi cand vrem
sa rezolvam anumite probleme (cu programul nostru) pentru ca ne va fi mult mai usor sa
_____________________________________________________________________

35

_____________________________________________________________________
filtram si sa executam instructiunile (codul) corecte. Iata, in figura 3.2 de mai jos poti sa
vezi aceste exemple “puse in actiune” in Eclipse.

Figura 3.2

_____________________________________________________________________

36

_____________________________________________________________________
2) Instructiunea FOR

Mergand mai departe cu subiectul legat de instructiunile conditionale din programare,
am ajuns la instructiunea FOR. O instructiune care ne permite sa-i spunem programului
nostru sa execute un cod in mod repetat (atat timp cat se respecta o conditie).

Gandeste-te in felul urmator: cum ar fi daca am avea 10 operatiuni de verificat, iar in urma
fiecareia sa efectuam un anumit calcul sau sa afisam un rezultat. Cu cele invatate pana
acum, am vazut ca se poate face asta, doar ca mica problema ar consta in faptul ca ar
trebui sa facem totul manual. Practic, pentru fiecare operatiune de verificare (folosind IF),
ar trebui sa scriem manual fiecare secventa de cod. Problema cu metoda asta e ca
necesita mult timp, nu e scalabila, iar in timp va consuma multa memorie.

Hai sa-ti dau un exemplu concret. Iata mai jos o secventa de cod scrisa cu instructiunea
IF, fara a folosi IF ELSE ori ELSE:

int i = 0;
int suma = 0;
int a = 5;
if ( i == 0 ) {
suma = suma + a;
i++;
}
if ( i == 1) {
suma = suma + a + i;
i++;
}
if ( i == 2) {
suma += a + i;
i++;
}
if ( i == 3 ) {
suma += a + i;
i++;
}
System.out.println("Suma este: " + suma);

_____________________________________________________________________

37

_____________________________________________________________________

In aceasta secventa de cod poti sa vezi ca am calculat o anumita suma in functie de
variabila a si i. Rezultatul acestei sume este: 26. In aceasta situatie, a este pur si simplu o
variabila int careia i-am asignat o valoare, iar i este un iterator (o variabila care
contorizeaza numarul de procesari). Dupa fiecare calculare a sumei, acest iterator i va fi
incrementat (prin i++) , iar valoarea acestuia va creste cu 1. In programarea in Java, C++,
expresia i++ este echivalenta cu i = i + 1;.

Acum hai sa-ti arat aceeasi secventa de cod, dar de data asta scrisa cu FOR:

int suma = 0;
int a = 5;
for (int i = 0; i <= 3; i++) {
suma += a + i;
}

Dupa cum poti sa vezi in aceasta secventa de cod, lucrurile au fost mult simplificate prin
instructiunea FOR:
1. In care am declarat o variabila iterator i - int i = 0.
2. Urmata de o conditie - i <= 3 - care spune: “ruleaza aceasta bucla atat timp cat i
are valoarea mai mica sau egala cu 3”.
3. Iar valoarea lui i este incrementata (i++ - creste cu 1) dupa fiecare iteratie, atat timp
cat conditia este adevarata.

Dupa cum poti sa vezi, in aceasta situatie, FOR face diferenta dpvd. al codului, al
executiei acestuia si al memorie consumate. Toate sunt in favoarea celei de a doua
secvente de cod. Ideea aici consta in task-uri repetitive, practic, bucle. Prin FOR putem
crea bucle (loops) care sa verifice/opereze diferite secvente de cod, in mod repetat.

Vei vedea putin mai tarziu in aceasta carte, cum putem folosi FOR atunci cand vine vorba
de structuri de date (parcurgerea, modificarea, verificarea lor), de clase si obiecte, iar
astfel vei avea o idee mult mai buna despre utilizarea acestei instructiuni.

Dupa cum am spus si la inceputul acestui capitol instructiunile conditionale (IF, FOR,
WHILE) stau la baza majoritatii limbajelor de programare si este modul prin care noi
putem programa calculatorul, astfel incat sa ne folosim intr-un mod cat mai benefic (noua)
si eficient de resursele acestuia.
_____________________________________________________________________

38

_____________________________________________________________________
In figura 3.3 de mai jos poti sa vezi cum arata secventele de cod exemplificate mai
devreme:

Figura 3.3

_____________________________________________________________________

39

_____________________________________________________________________
3) Instructiunea WHILE

Instructiunea WHILE are o functionalitate similara cu cea a FOR-ului, doar ca se foloseste
putin diferit. Cand folosim WHILE putem gandi problema in felul urmator: cat timp se
intampla X, executa Y. Pe de alta parte, cand folosim FOR, gandim problema in
urmatorul mod: pentru o anumita conditie X, se intampla Y. Cele 2 abordari seamana,
dar sunt usor diferite (sunt folosite in contexte diferite).
Buclele FOR sunt folosite mai des in momentul in care se cunoaste numarul fix de iteratii
care trebuie sa aiba loc pe parcursul rularii programului, iar WHILE folosim cand nu
cunoastem acest numar. O bucla WHILE se poate folosi cand dorim sa rulam un program
la infinit (prin while (1) { } ). Deci formatul standard pentru aceasta bucla este:

int contor = 0;
while ( contor < 100 ) {
instructiune 1;
...
contor++;
}

Sa reluam secventa de cod de mai devreme:
int suma = 0;
int a = 5;
for (int i = 0; i <= 3; i++) {
suma += a + i;
}

Iar acum iata aceeasi varianta, dar cu instructiunea while:
int suma = 0;
int a = 5;
int i = 0;
while ( i <= 3 ) {
suma += a + i;
i++;
}
_____________________________________________________________________

40

_____________________________________________________________________
Iata cum arata in Eclipse expresia de mai sus:

Figura 3.4

4) Instructiunea SWITCH
Instructiunea initiala despre care am vorbit a fost IF (daca X este adevarat, atunci
executa Y) , dar ce se intampla in momentul in care avem mai multe blocuri de verificare a
unor expresii. Un raspuns care ne poate veni in minte ar putea fi: daca expresia A nu este
adevarata, atunci ar putea fi adevarata expresia B, iar daca nici ea nu este, atunci
expresia C. Lucrurile ar arata in felul acesta:

if ( A ) {
....
}
else if (B) {
....
}
else if (C) {
....
}
...
_____________________________________________________________________

41

_____________________________________________________________________
else {
....
}

Aceasta este o varianta de solutionare a problemei noastre, dar nu este cea mai buna. O
varianta si mai buna ar fi folosirea instructiunii SWITCH, instructiune care ne ajuta sa
formam astfel de blocuri conditionale care arata in felul urmator:

int nota = 5;
switch(nota) {
case 10:
System.out.println("Excelent!");
break;
case 8:
System.out.println("Bravo");
case 7:
System.out.println("Te-ai descurcat bine");
break;
case 5:
System.out.println("Ai trecut");
case 2:
System.out.println("Ai picat. Mai incearca");
break;
default:
System.out.println("Nota nu a fost introdusa corect");
}

In acest scenariu poti sa vezi ca, codul este mult mai bine structurat, iar SWITCH va trece
prin fiecare case ( caz) pana cand va gasi matching-ul potrivit intre variabila nota si
rezultatul asteptat. In cazul in care nu se gaseste nici o potrivire intre variabila si
rezultatele specificate, atunci se va ajunge la default, c are ne va da rezultatul standard
(in cazul acesta un mesaj de eroare) in caz de nepotrivire cu unul dintre cazurile
specificate mai devreme prin case.
De asemenea, in structura switch-ului (mai exact in cea a case-ului), poti sa vezi ca apare
instructiunea break, care va opri parcurgerea intregului SWITCH si va iesi din functie,
continuand cu rularea restului de program. Odata gasit, rezultatul asteptat (in aceasta
situatie find vorba de al patrulea), programul va executa acea instructiune si va iesi din
blocul switch(), continuandu-si executia instructiunilor pana la finalizarea sa.
_____________________________________________________________________

42

_____________________________________________________________________
Exercitii

Felicitari! Acum ai ajuns la sectiunea in care e timpul sa creezi tu (cu cele invatate)
propriile programe folosind Java. Te rog sa incerci pe cat posibil sa faci singur aceste
exercitii, sa faci research pe Google doar daca lipseste ceva esential sau nu mai stii ce ai
gresit.
1) Creeaza un program care determina daca un numar (introdus de la tastatura) este par
sau impar. Se va afisa (print) in terminal un mesaj similar cu: "Numarul introdus X este
par", in cazul in care numarul este par, iar "Numarul nu este par" i n rest.
PS: un numar este par daca se poate imparti la 2. Exemplu (2, 4, 8, 24150, etc.)
2) Creeaza un chestionar de intrebari simple pe care o persoana din departamentul de
resurse umane le poate adresa la interviul de angajare. Vor exista 5 intrebari (similare cu
cele de mai jos) pe care le vei adresa persoanei care va rula programul si care va putea
sa le raspunda prin input, de la tastatura. In timpul executiei programului, acesta
stocheaza datele, iar la sfarsitul acestor intrebari se vor afisa sub forma urmatoare:
"Canditatul X a raspuns astfel la intrebarile de mai sus: ..."

Intrebarile: "Cum te numesti ?", "Ce job iti doresti ?", "In cat timp crezi ca poti obtine acest
job ?", "Care sunt pasii pe care trebuie sa-i urmezi pentru a te putea angaja ?", "De cand
doresti sa incepi ?"
3) Creeaza un program care determina daca un cuvant (string) introdus de catre utilizator

(de la tastatura) este Palindrom sau nu. Un palindrom este un sir de caractere care citit de
la stanga la dreapta sau de la dreapta la stanga ramane neschimbat.
Exemplu: lupul, capac, apa, cojoc - toate se citeste la fel din ambele parti.
WHILE / FOR

In aceasta parte a sectiunii practice ne vom juca putin si vom face putina matematica (de
fapt, calculatorul, nu noi... :D ):
4.1) Calculeaza suma tuturor numerelor de la 1 la 100. Creeaza o varianta a programului
folosind bucle FOR, iar alta varianta folosind bucle WHILE. Afiseaza rezultatul pe ecran
intr-un format precum: "Suma numerelor de A la Z este... ".
4.2) Dinamizeaza programul prin adaugarea optiunii de introducere a celor 2 numere (nr.

de inceput si cel de sfarsit) de la tastatura, de la punctul anterior.

_____________________________________________________________________

43

_____________________________________________________________________
5) Creeaza un joc Piatră-hârtie-foarfecă la care participa 2 persoane. (Nota: folositi-va de

clasa "Scanner" pentru a cere date de la jucatori; in momentul in care cineva castiga,
printati un mesaj de felicitare si intrebati utilizatorii daca vor sa inceapa un joc nou).

Amintiti-va regulile:
Piatra bate foarfeca
Foarfeca bate hartia
Hartia bate piatra

PS: folositi-va de conditiile discutate in lectiile anterioare (IF, FOR sau WHILE)

_____________________________________________________________________

44

_____________________________________________________________________
Capitolul 4 - Metode in Java

Continuam drumul nostru spre a invata programare cu un capitol in care vom vorbi
despre functii. Vom vedea ce sunt functiile, de ce avem nevoie de ele si cum le putem
a sfarsitul acestui capitol vei avea o sectiune cu exercitii pe care te rog sa le
folosi? L
rezolvi dupa ce termini de citit si de aplicat conceptele care vor fi explicate in
urmatoarele randuri. Nu uita faptul ca, pentru a deveni programator ai nevoie de foarte
multa practica. Nu ajunge doar sa stii si sa intelegi conceptele, ci ai nevoie sa le si faci.
Deci sa trecem la treaba...

Ce Este o Functie (Metoda) ?

O functie este o modalitate prin care putem grupa codul nostru astfel incat sa poata fi
folosit de mai multe ori (fara a necesita rescrierea acestuia). Practic, este o forma de a
grupa, de a structura codul nostru, astfel incat noi sa scriem cod mai eficient, mai rapid si
cu mult mai multa usurinta. Acest lucru este bine atat pentru noi cat si pentru program
pentru ca astfel va consuma mai putine resurse si va fi mai usor de inteles datorita
structurii sale.

In POO (Programare Orientata pe Obiecte) despre care vom vorbi in detaliu in capitolul 5,
functiile poarta denumirea de metode (“method” in engleza). Se practica acest lucru
pentru a se face distinctia dintre POO si programarea procedurala (aka. cea clasica -
limbajul C).

Exista mai multe tipuri de functii:
● functii (grupari de cod) care nu intorc nici un rezultat, adica functii void (ex:
efectueaza o operatie “in spate”)
● functii (grupari de cod) care intorc un anumit rezultat (ex: numele unei persoane)

Mai intai vom vorbi despre primul tip de functii, cele void. Dar in primul rand, hai sa
vedem...

_____________________________________________________________________

45

_____________________________________________________________________
Metode care nu intorc un rezultat

Acum vom lua un exemplu de program in care iti voi arata cum functioneaza aceste
metode/functii. Pentru inceput, programul nostru in Java contine urmatoarea linie de
cod:
System.out.println("Hello!");
care va afisa in consola mesajul Hello!

Ce vom face este sa cream o functie. Noi, in momentul de fata, ne aflam in MainClass
(vezi figura 4.1), care in acelasi timp contine si functia main. Daca esti familiar cu C sau
C++, acolo avem int main sau void main, o functie principala unde grupam elementele
astfel incat programul nostru sa aiba o structura si un sens (urmand ca el sa poate fi
executat). Noi aici vom crea o noua metoda numita helloFunction astfel:
public static v
oid helloFunction() {}

Acesta este o functie publica, ceea ce inseamna ca poate fi accesata (mai multe despre
asta vom vorbi in capitolul 5), apelata din mai multe clase sau programe. O sa vorbim
despre asta mai incolo. Metoda este statica, adica isi pastreaza valoarea si este void,
adica aceasta metoda dupa executarea ei nu va intoarce niciun rezultat.

Un exemplu practic ar fi punerea unui fruct intr-o cana. Se pot intampla doua lucruri:
fructul ramane in acea cana (adica nu intoarce un rezultat) sau fructul scoate ceva din
acea cana (vine cu un rezultat, un output – acel fruct sau suc pe care l-am creat va
curge). Acum vom merge mai departe si vom scrie putin cod in aceasta functie astfel
incat ea sa faca ceva:

public static void helloFunction() {
System.out.println("Hello from function!");
}

Dupa care venim in main s i o apelam, scriind “helloFunction();”. In consola va fi afisat
mesajul “Hello from function!”, dupa cel de “Hello!” . Toate aceste concepte despre care
am discutat mai devreme sunt exemplificate in figurile 4.1 si 4.2 de mai jos:

_____________________________________________________________________

46

_____________________________________________________________________

Figura 4.1
Rezultatul secventei de cod din figura 4.1 este urmatorul:

Figura 4.2

Hai sa facem lucrurile putin mai complexe si sa personalizam acest mesaj. Vom adauga
intre parantezele de dupa Hello ceea ce se numeste un parametru. Vom pune String
nume pentru ca vrem sa fie un nume, un text. Astfel ca functia noastra va arata:

public static void helloFunction(String name) {
System.out.println("Hello " + name + " from function!");
}
Vom apela in main, scriind numele in parantezele, sub forma de parametru:

hellofunction("John");

ello John from function!”
Iar rezultatul afisat va fi: “H

_____________________________________________________________________

47

_____________________________________________________________________
Hello era mesajul intial, nume e ste un parametru adaugat, am introdus si semnul
exclamarii. Practic, cu + facem concatenarea, adica legam de un string un alt string, apoi
un al string, si venim cu un string total, un rezultat.

Asta este, in mare, modul in care functioneaza si opereaza o astfel de functie. Un lucru
pe care il mai putem face este sa apelam din nou functia Hello. Dupa
helloFunction(“John”); vom scrie:

String name = new String ("John");
helloFunction(name);

Am scris name ca sa nu confundam numele de sus cu cel de jos. String este un obiect
specific Java, si new String e ste modul in care am creat un nou obiect String si il voi
initializa cu “John”. Practic, valoarea “John” i a locul lui name. Vom da Run, si pe ecran va
aparea:

Hello John!

Figura 4.3

_____________________________________________________________________

48

_____________________________________________________________________
Rezultatul secventei de cod din figura 4.3 este cel de mai jos:

Figura 4.4
Mai putem sa adaugam si int a, respectiv int b ca parametru al functiei (metodei):

public static void Hello(String nume, int a, int b) {
nt sum = a + b;
i
System.out.println("Salutare" + nume + "!"+"\n " +
String.valueOf(sum) );
}

Daca facem aceasta modificare, suntem nevoiti sa schimbam si in clasa Main, modul in
care va fi apelata functia Hello, din: Hello(“Ramon”); in Hello(name, 2, 3);. Dupa ce vom
apasa pe Run, pe ecran va aparea 5.

De fapt, ce am facut noi in aceasta functie Hello?
● Am adaugat alti doi parametri de tipul int (a si b):
public static void Hello(String nume, int a, int b)
● am convertit int sum = a + b; intr-un String pentru a putea afisa in consola suma
totala a celor 2 variabile:
String.valueOf(sum);

_____________________________________________________________________

49

_____________________________________________________________________

Figura 4.5

Rezultatul acestui cod este cel pe care il poti vedea in figura 4.6

Figura 4.6

Am printat acest String pe ecran. Cam atat cu metodele care nu intorc un rezultat (void) .
In urmatoarea sectiune vom discuta despre metodele care pot intoarce un rezultat pe
care noi sa-l putem folosi.

_____________________________________________________________________

50

_____________________________________________________________________
Metode care intorc un rezultat

O functie (dupa cum am spus si mai devreme) reprezinta o grupare structurata a unei
secvente de cod cu scopul de a face codul reutilizabil si usor de inteles (fapt care duce la
edificentizarea volumului de munca depusa). Ca exemplu practic ne putem gandi la un
blender care contine multe fructe. Ele toate vor ramane acolo. Nu vor putea fi turnate
intr-un pahar. Acum vrem sa le si turnam intr-un pahar, astfel incat sa ne si putem folosi
de rezultatul pe care aceasta metoda sau functie il genereaza. Vom lasa in Eclipse ceea
ce am lucrat data trecuta. De data aceasta vom intoarce sum, mai precis:
int sum = a + b;
Ni se va spune ca aceasta variabila sum nu este folosita, dar noi vom intoarce, ii vom da
return, scriind int in:
public static void helloFunction(String name, int a, int b) { }
ce acum va aparea:
public static int helloFunction(String name, int a, int b) { }
Eclipse ne spune ca avea, o problema, prin faptul ca aceasta functie trebuie sa intoarca
un rezultat de tipul int. Si ce trebuie sa facem este sa scriem:
return sum;
In momentul in care rulam programul nu va aparea nicio modificare in consola. Vor
ramane pe ecran:
Hello!
Hello John!
In schimb, functia:
helloFunction(name, 2, 3);
Nu va face nimic. Ea intoarce un rezultat care il putem folosi mai departe (dar nu este
absolut necesar). Totusi noi il vom folosi in modul urmator:
int ret =
in fata, si astfel functia va arata:

int ret = helloFunction(name, 2, 3);
Salvam rezultatul intors de functia helloFunction in variabila ret, dupa care il afisam:
_____________________________________________________________________

51

_____________________________________________________________________
System.out.println(ret);
Rulam acest program si vedem ca se intoarce aceasta valoare, care este 5. De acum
putem sa mergem mai departe si sa facem absolut orice dorim cu aceasta valoare 5. O
functie poate fi o functie matematica sau un algoritm care face ceva anume.

Tot ceea ce noi trebuie sa facem este sa introducem anumite date, acea functie sau
metoda ne va procesa datele in modul in care i-am spus, dupa care ne va da alte date. Iar
acele date, output-ul sau datele finale, sunt ceea ce de fapt pe noi ne intereseaza si cu
care vom putea merge mai departe sa generam alte date sau sa facem ceea ce dorim. Si
cam asta am facut pana acum in acest tutorial. Cum in:
public static int helloFunction(String name, int a, int b) {
avem acest int, asta inseamna ca putem face orice altceva. Putem sa cream o alta
functie:
public static String userName(String name) {
Si sa spunem ca avem aceasta functie care intoarce un String, va intoarce un sir de
caractere – nume, user.

ATENTIE: Vom scrie nume cu n mic pentru ca acesta este stilul de cod pe care cei care
scriu Java il recomanda. Functia sau metoda trebuie sa inceapa cu litera mica, dupa care,
pentru a diferentia, poti sa scrii cu litera mare. Dar sa revenim. Sub ceea ce am scris, vom
scrie:
String ret = "Your name is " + nume;
return ret;
Aceasta functie va afisa in consola urmatorul text:
Your name is
Dar nu este gata. Sus, in main, trebuie sa adaugam:

System.out.println(userName("John"));
Salvam, apasam pe Run si pe ecran va aparea:
Your name is John

_____________________________________________________________________

52

_____________________________________________________________________

Figura 4.1

In figura 4.1 poti sa vezi intregul cod pe care l-am scris pentru a crea programul, iar mai
jos in figura 4.2 poti sa vezi rezultatul afisat.

Figura 4.2
De ce? Pentru ca ni se va intoarce un String. Acest String poate fi foarte usor de printat
pe ecran, dupa cum am si vazut. Ne putem folosi de el sau il putem printa, pur si simplu.
De exemplu, daca ar fi sa stergem:
System.out.println(userName("John"));
si sa scriem:
String temp = userName("John");
_____________________________________________________________________

53

_____________________________________________________________________
temp va lua valoarea pe care am trecut-o mai devreme. Si de aici putem sa facem ce
dorim, cum ar fi sa adaugam in main:
System.out.println(temp.length() + "- Total number of characters");
Rulam, si pe ecran va aparea:
17 – Total number of characters
Si aceasta este o functie pe care o putem folosi in acest fel. De asemenea, putem sa
adaugam si:
System.out.println(temp + " and it has " temp.length() + "
characters");
In figura 4.3 poti sa vezi intregul cod pe care l-am scris pentru a crea programul, iar mai
jos in figura 4.4 poti sa vezi rezultatul afisat.

Figura 4.3

_____________________________________________________________________

54

_____________________________________________________________________

Figura 4.4

Daca ai mai folosit Java pana acum, probabil aceste lucruri ti se par simple. Daca nu, iti
recomand sa folosesti aceste functii. Metodele, atat cele void cat si non void, sunt foarte
importante. Cam atat cu elementele de baza de programare in Java. Bineinteles, sunt
mult mai multe. Dar incepand cu urmatoarele tutoriale vom vorbi mai mult despre
programarea orientata pe obiecte. Vom intra in clase, vom vedea ce inseamna un camp,
ce inseamna metodele dintr-o clasa, un constructor, un destructor, un getter, un setter,
toate elementele de baza, cand vine vorba de acest gen de programare.

_____________________________________________________________________

55

_____________________________________________________________________
Exercitii
Dupa cum te-ai obisnuit pana acum, la fiecare final de capitol iti pun la dispozitie un set
de exercitii pe care tu sa le practici.

1) Scrie o functie care primeste 3 parametri de tip real. Functia va returna 1 daca suma
celor trei parametri formeaza un numar natural (aka, valoare fixa, fara virgula) si 0 in rest.
Testeaza aceasta functie cu urmatoarele valori de intrare:
4.67, 8.93, 10.00

51.24, 33.10, 1.66
9.00, 8.01, 21.21

2) Scrie o functie care returneaza ultima cifra a unui numar natural. De exemplu, daca
numarul este 234, functia va returna 4.

3) Aceste exercitii vor include cateva probleme de logica matematica:
a) Folosind functia recursiva, scrie un program care sa ridice un numar x la o
putere data y, pozitiva.
b) Scrie o functie recursiva care sa returneze numarul de cifre al unui numar
intreg.
c) Folosindu-te de functiile scrise anterior scrie o funcție recursiva ce
inverseaza ordinea cifrelor unui numar intreg pozitiv.

4) Scrieti o functie in Java prin care sa determinati numarul de cuvinte din urmatorul text.

“Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus est odio, auctor eget massa quis,
rhoncus porttitor est. Nunc eleifend malesuada mattis. Praesent sed lacinia urna. Integer non
tincidunt justo. Duis nunc sapien, mattis sagittis felis vulputate, pharetra porta ante. Aliquam tortor
ligula, pulvinar vitae ligula eu, efficitur tincidunt eros. Curabitur vitae lectus quis est elementum
egestas. Vestibulum pulvinar nulla arcu, eu dignissim ante ornare vitae. Donec porta purus enim, a
venenatis nisl luctus non. Curabitur porta fermentum elit sed rutrum. Ut vitae gravida velit, sed
dictum eros. Pellentesque vel varius nisl. Fusce eget convallis urna.”

Textul va fi primit ca parametru al functiei, iar rezultatul intors de aceasta va fi numarul de
cuvinte al textului.

_____________________________________________________________________

56

_____________________________________________________________________
Capitolul 5 - Concepte de POO in Java

1) Concepte teoretice despre POO

POO - Programare Orientata pe Obiecte - (sau OOP - Object Oriented Programming)
este o paradigma de programare care foloseste concepte abstracte (sub forma de clase
si obiecte) pentru a crea modele bazate pe elemente din lumea reala. O aplicatie
construita pe POO foloseste mai multe obiecte care comunica prin mesaje specifice
pentru a rezolva diverse servicii (ale aplicatiei) solicitate. Aceste obiecte sunt capabile sa
trimita mesaje (date), sa primeasca mesaje (date) si sa proceseze date. Scopul
programarii orientate pe obiecte este de a incerca sa creasca flexibilitatea si
mentenabilitatea programelor. Deoarece programele create folosind un limbaj orientat
pe obiecte (cum este Java) sunt modulare, ele pot fi mai usor de dezvoltat si mai usor de
inteles dupa dezvoltare.
POO vs. Programare Procedurala
Programele sunt alcatuite din module. Aceste module pot fi programe de sine statatoare

(independente) care pot fi dezvoltate (codate) si testate separat fata de programul initial
(ulterior acestea - mai multe module - putand fi asamblate pentru a forma un program
complet). In limbajele de programare procedurale (cum ar fi C si Pascal) aceste module
sunt de fapt proceduri, adica o secventa de instructiuni.

In limbajul C, procedurile sunt functii care au un set clar de instructiuni (de tipul IF, FOR,
WHILE etc.) cu scopul de a intoarce (sau nu) un rezultat (al acelei functii).
In programarea procedurala se ia problema (care se doreste a fi rezolvata) si se sparge in
mai multe bucati (sub proceduri). Astfel sub-procedurile rezolva bucati mai mici din
problema initiala. Lucrurile continua asa pana cand problemele secundare (bucatile mai
mici) sunt suficient de simple pentru a fi rezolvate de sub-procedura corespunzatoare ei.

Dificultatea cu acest tip de programare consta in faptul ca intretinerea software-ului
poate fi dificila si consumatoare de timp. Atunci cand se efectueaza modificari ale
procedurii principale, aceste modificari pot intra in cascada, iar schimbarea poate avea
un impact major asupra tuturor procedurilor din programul initial.
_____________________________________________________________________

57

_____________________________________________________________________
O alternativa la programarea procedurala este programarea orientata pe obiecte. Scopul

POO este cel de a rezolva dificultatile legate de programarea procedurala. In POO
principalele module dintr-un program sunt clase, mai degraba decat proceduri. POO ne
permite sa ne cream clase si obiecte care modeleaza elementele din lumea reala.
Clase si Obiecte
O clasa este o colectie de obiecte care au proprietati, operatii si comportamente
comune. O clasa este o combinatie de stari (date) si comportament (metode).

In POO o clasa este un tip de date, iar obiectele sunt instante ale acestui tip de date.

De exemplu, putem crea o clasa Om(), care este o colectie a tuturor oamenilor din lume.
Oamenii au un statut, cum ar fi inaltimea, greutatea, sexul, culoarea parului etc.. Ei au, de
asemenea, un anumit comportament, o anumita limba pe care o vorbesc, o mancare
preferata. Toate aceste caracteristici despre oameni sunt incapsulate (continute) in clasa
Om().

Un obiect este o instanta a unei clase. Obiectele sunt unitati de abstractizare. Un obiect
poate comunica cu alte obiecte folosind mesaje. Un obiect transmite un mesaj unui alt
obiect, ceea ce duce la invocarea unei metode. Obiectele efectueaza apoi actiunile
necesare pentru a obtine un raspuns de la sistem.

Obiectele din lumea reala au 2 caracteristici in comun: toate au o stare si un
comportament. O metoda de a gandi intr-un mod orientat pe obiecte este de a identifica
starea si comportamentul obiectelor din lumea reala. Complexitatea acestor obiecte
poate sa difere, unele obiecte au mai multe stari si comportamente considerabil mai
complexe decat alte obiecte. Compara starea si comportamentul unui TV cu starile si
comportamentele unei masini, sunt total diferite.

Obiectele unei clase, dpvd conceptual, sunt similare cu obiectele din lumea reala. Un
obiect isi stocheaza starea in campuri (aka. Variabile ale clasei) si isi expune
comportamentele prin metodele sale (aka. Functiile clasei). Vom vedea in cele ce
urmeaza mai multe detalii (si exemple) despre acestea.

Un principiu fundamental al POO este incapsularea. Se ascund anumite stari interne a
obiectelor, devenind necesar ca toate interactiunile sa fie efectuate utilizand metodele
obiectelor. Cu alte cuvinte, campurile unei clase nu vor putea fi accesate (si modificate) in
_____________________________________________________________________

58

_____________________________________________________________________
mod direct, ele nefiind vizibile (pentru ca sunt private), dar modificarile vor putea fi facute

prin intermediul metodelor.

Beneficiile POO
Iata un sumar al beneficiilor cu care vine Programare Orientata pe Obiecte:
1. Modularitatea: Codul sursa pentru o clasa poate fi scris si mentinut independent de
codul sursa pentru alte clase. Odata creat, un obiect poate fi usor transferat in interiorul
sistemului.
2. Securitatea ridicata la nivel de cod: Interactionand doar cu metodele obiectului,
detaliile implementarii interne raman ascunse de lumea exterioara.
3. Reutilizarea codului: Daca o clasa exista deja, puteti utiliza in programul dvs. obiecte
din acea clasa. Acest lucru permite programatorilor sa implementeze / testeze / sa faca
depanare pe obiecte complexe, specifice pentru sarcini, pe care apoi le puteti folosi in
propriul cod.
4. Debugging mai usor: Daca un anumit obiect se dovedeste a fi o problema, il puteti
elimina din program si puteti adauga/conecta, ca inlocuitor, un obiect diferit. Acest lucru
este similar cu rezolvarea problemelor mecanice in lumea reala. Daca un surub se rupe, il
inlocuiti pe el, nu intreaga masina.
Scurt rezumat a celor discutate mai sus

1. In POO totul este un obiect.
2. Calculul se realizeaza prin obiecte care comunica intre ele, solicitand ca alte obiecte
sa efectueze actiuni. Obiectele comunica prin trimiterea si primirea de mesaje. Un mesaj
este o cerere de actiune, insotita de oricate argumente care ar putea fi necesare pentru
a finaliza sarcinile.
3. Fiecare obiect are propria sa memorie alocata de catre OS.
4. Fiecare obiect este o instanta a unei clase. O clasa reprezinta pur si simplu o grupare
de obiecte similare, cum ar fi Integer, String sau liste.
5. Clasa este depozitul pentru comportamentul asociat unui obiect. Asta inseamna ca
toate obiectele care sunt instante din aceeasi clasa pot efectua aceleasi actiuni.

_____________________________________________________________________

59

_____________________________________________________________________
2) Clase in Java

Odata ce ai inteles mai multe lucruri despre POO si care este rolul acestui mod de
structurare a datelor este timpul sa intram in partea concreta, practica, a lucrurilor. Pentru
inceput vom relua definitia unei clase in Java, dupa care iti voi arata un exemplu de
folosire a acestora.
Ce este o clasa?
O clasa este o colectie de obiecte care au proprietati, operatii si comportamente
comune. O clasa este o combinatie de stari (date) si de comportamente (metode). In POO
o clasa este un tip de date, iar obiectele sunt instante ale acestui tip de date. Iata mai
jos o secventa de cod care ne demonstreaza modul de folosire al acestora:
public class ClasaPrincipala {

}
Exemplul de mai sus creeaza o clasa denumita ClasaPrincipala. Mai jos vom crea
functia principala (main), functie in care se pune cap la cap intreaga logica si structura a
programului cu scopul de a fi executata.
public class ClasaPrincipala {

public static void main(String)[] args) {
}
}
Vom ramane aici pentru cateva momente, pentru ca vreau sa iti spun mai multe lucruri.
Repet ceea ce am spus mai devreme, dar cu alte cuvinte: Scopul unei clase este de a ne
ajuta sa grupam si sa eficientizam munca noastra. Cu ajutorul unei clase vom face
lucrurile mult mai bine si intr-un mod mult mai structurat.

Avem un set de clase predefinite pe care le putem folosi deja in Java, precum si in alte
limbaje de programare (cum ar fi C++, Python, Ruby si altele). In toate aceste limbaje
exista deja anumite functii, anumite grupari, anumite clase care au scopul de a ne ajuta
pe noi sa ne eficientizam munca. Ce rost ar avea un limbaj de programare fara functiile
definite de catre o comunitate, de catre persoanele care au dezvoltat acel limbaj?

Fiecare limbaj are specificul lui si ne ajuta sa ne facem munca mult mai eficient in
anumite arii. De exemplu, cand facem programare in Java, e mai usor sa facem aplicatii
pentru telefoane sau pentru servere. Cand facem programare in PHP, va fi mult mai usor
_____________________________________________________________________

60

_____________________________________________________________________
sa ne ocupam de partea de web pentru ca acest limbaj a fost optimizat si gandit pentru
asa ceva.

Programarea in C ne ajuta sa facem lucruri care tin de sistemul de operare sau de
programarea placutelor pentru ca acest limbaj este foarte rapid si asa a fost conceput.
Vei vedea ca fiecare limbaj de programare are specificul lui. Dupa cum poate iti mai
aduci aminte de la matematica (nu ca ar trebui sa fii expert in matematica, dar bazele din
scoala generala ar ajuta mult), am facut numere reale, numere integer (adica intregi), float
(adica numere reale) si asa mai departe. In engleza, “numerele intregi” se numesc
“integer”. Sunt doua moduri in care putem defini un numar intreg:
Integer x;
int y;
int y este o variabila clasica pe care ai vazut-o si in alte exemple din capitolele
precedente. Dar declararea variabilei cu Integer este putin diferita. Integer este un tip de
date (aka. O clasa) definita in Java care ne ofera mai multe functii/proprietati fata de o
varianta clasica. Documentatia din Eclipse ne ofera mai multe detalii despre clasa
Integer:
“The Integer class wraps a value of the primitive type int in an object.”
Practic, ne ofera un obiect (care trebuie initializat) care are mult mai multe proprietati si
functii fata de un simplu int. Aceste variabile trebuiesc intializate si modul in care o vom
face este in felul urmator (pentru int):
Integer x;
int y = 0;
Modul in care initializam o variabila de tip Integer - sau o variabila care este de fapt un
obiect pentru ca x in acest caz este de fapt un obiect al acestui Integer, adica x va prelua
proprietatile, metodele, functiile care exista in aceasta clasa Integer s i le va putea folosi –
va fi:
Integer x = new Integer(5);
I-am dat valoarea 5. Haideti sa printam acest lucru pe ecran:
System.out.println(x);
System.out.println(y);
Cand vom rula cele doua, pe ecran va aparea:
5
0
_____________________________________________________________________

61

_____________________________________________________________________

Figura 5.1
Acum poate te gandesti “Ok, si ce sens au aceste x si y? De ce e unul Integer s i celalalt
int?”. Ei bine, punand un punct “.” si scriind (figura 5.2):
System.out.println(x.);
putem sa apelam metodele care se afla in clasa Integer. Asta este frumusetea acestor
obiecte, acestor clase si a programarii orientate pe obiecte. Faptul ca noi definim un
obiect al unei clase si acel obiect poate sa preia proprietatile clasei respective. De
exemplu, putem transforma acest Integer intr-un String. Deci 5 sa nu mai fie o cifra, ci o
litera. Stiu ca nu suna foarte logic la prima vedere, dar sunt diferite moduri in care poti sa
procesezi aceste date.

Figura 5.2
_____________________________________________________________________

62

_____________________________________________________________________
De exemplu, in momentul in care introduci informatiile bancare si vrei sa cumperi ceva
online, ai o grupare de litere si cifre. Ei bine, toate acele date vor fi tratate ca fiind
String-uri s i apoi vor fi analizate. Deci vor fi String-uri, nu vor fi luate ca fiind numere
intregi. Abia dupa ce vor fi luate ca String-uri si procesate, tranzactia va avea succes.

Putem transforma x- ul in String, putem transforma acelasi x d in Integer s a fie un int
(public int intValue () - asta este clasa care transforma acest Integer i ntr-un int), si tot asa.
Exista foarte multe lucruri pe care le poti face aici. Pe langa acestea mai poti efectua
anumite operatii foarte usor, cum ar fi:
●Definirea valoarea maxima (sau minima) prin comparatie a 2 variabile Integer

●Definirea valorii hash a unei variabile
●Aflarea celui mai mare bit
●Convertirea din int i ntr-un alt tip de variabila (char, String, float e
tc.)

Toate aceste operatii au loc cu ajutorul functiilor predefinite din clasa Integer. Vom alege
functia toString si vom adauga un cuvant la intamplare care va fi, sa zicem, “cool”:
System.out.println(x.toString() + " cool");
Vom rula si pe ecran va aparea:
5 cool

Figura 5.3

Iata in cele 2 figuri 5.3, respectiv 5.4, codul si rezultatul in urma rularii secventei de cod:
_____________________________________________________________________

63

_____________________________________________________________________

Figura 5.4

Variabila x, definita ca Integer, a fost afisata ca un String. Acelasi lucru poti sa il faci si cu
String-uri. Poti sa iti definesti un obiect String, sa spunem:
String a = new String("abc");
Asta inseamna ca acestui a ii putem face diferite lucruri cu functiile predefinite, scriind:
a.
si selectand fie length() pentru a afla lungimea totala a acestui sir sau specificand ca vrem
sa luam un substring din acest String, de la 0 la 1:
String b = a.substring(0, 1);

System.out.println(a + "vs" + b);
Dupa ce vom rula, pe ecran va aparea:
abc vs. a
b are valoarea a.

Figura 5.5
Revenind in:
System.out.println(x.toString() + "tare");
_____________________________________________________________________

64

_____________________________________________________________________
System.out.println(y);
observam ca y nu are aceste proprietati. Nu ii putem atribui ceva. Nu are anumite functii
in spate de care sa se foloseasca. Si atunci y, dupa cum poti sa vezi, este o variabila
clasica. Este un tip de variabila clasica, din acelea int, float, double si asa mai departe.
Deci nu il vom putea folosi pentru a face operatii mai complexe.

Figura 5.6
Si acum sa vedem cum putem crea o clasa proprie si cum putem sa definim astfel de
metode in aceste clase. Vom crea o noua clasa, ClasaMea, accesand New Class si
numind-o:
public class ClasaMea {

}

Este foarte important ca numele fisierului sa fie identic cu numele care va fi scris in linia
de cod, mai ales daca este public. O sa vorbim in tutorialele urmatoare ce inseamna
public, ce inseamna private.

Pe scurt, cand o clasa este public i nseamna ca va putea fi apelata din alte clase. Adica
aceasta clasa fiind public, o vom putea apela din ClasaPrincipala s au chiar dintr-un alt
pachet. Vom discuta despre acest lucru mai tarziu. Daca ClasaMea ar fi private, in
momentul care vom dori sa facem diferite lucruri cu ea, nu vom putea. Hai sa definim in
ClasaMea:
public class ClasaMea {

int x;
String a;
public String numeleMeu(String nume) {
return nume;
}
}

_____________________________________________________________________

65

_____________________________________________________________________

Figura 5.7
Am creat doua variabile (int x si String a) , dupa care am creat o metoda care este public
String, adica imi va intoarce un String c e se numeste numeleMeu si cere ca parametru un
nume, si apoi am intors acest nume. Revenind in ClasaPrincipala, vom defini un obiect ce
se va numi ClasaMea:
ClasaMea ob1 = new ClasaMea();
Astfel am creat un obiect si l-am intializat. Daca vom scrie sub:
ob1.
vom vedea ca avem variabile declarate mai inainte: String a si int x. Vom lua o
b1.x si
ob1.a si le vom da valori:
ob1.x = 10;
John";
ob1.a = "
Apoi vom printa in felul urmator:
System.out.println(ob1.numeleMeu(ob1.a));
Dupa ce vom rula, pe ecran va aparea
John
Ce am facut aici este ca am apelat functia din ob1, functia din ClasaMea, si i-am dat
careia noi i-am atribuit o anumita
variabila ca si parametru, mai exact variabila String a
valoare. In clasa principala, putem merge mai departe si adauga in:
System.out.println(ob1.numeleMeu(ob1.a));
astfel:
System.out.println(ob1.numeleMeu(ob1.a) + " numarul este: " + ob1.x);

_____________________________________________________________________

66

_____________________________________________________________________

Figura 5.8

Figura 5.9

In consolo va aparea:
John numarul este: 10
Ce am facut in acest tutorial este:

● am creat o clasa
● i-am creat acestei clase anumte variabile
● am adaugat anumite valori acestor variabile
● ne-am folosit de valori pentru a intoarce un anumit rezultat dintr-o functie din clasa
pe care am definit-o separat
● am printat totul pe ecran

_____________________________________________________________________

67

_____________________________________________________________________
3) Constructori si Destructori

Acum ca ai inteles si ai vazut cum se folosesc clasele in Java, a venit momentul sa
mergem mai departe si sa vorbim despre Constructori (si Destructori) in POO (aceste
concepte se aplica in orice limbaj orientat pe obiecte si nu doar in Java).

Ce este un constructor in POO?

Constructorul unei clase este o functie interna, speciala a acelei clase care este apelata
in momentul in care se creeaza o instanta a acelei clase. De exemplu:
Proiect x = new Proiect();
In momentul in care rulam programul, in background va fi apelat constructorul clasei
Proiect care poate sa faca urmatoarele operatiuni:
● Initializarea campurilor (variabilelor) clasei sau a celor date ca parametru

● Alocarea memorie pentru acestea sau alte campuri ale clasei
In exemplele care urmeaza vei vedea cum declaram constructorii unei clase si cum ii
putem folosi pentru o alocare cat mai eficienta a resurselor.

Ce este un destructor in POO?

Daca un constructor este folosit pentru initializarea variabilelor si alocarea de memorie
pentru diferiti membri ai clasei, atunci destructorul este o componenta apelata in
momentul in care se termina executia codului pentru dealocarea obiectului din memorie.
Astfel gestiunea memorie va fi corect facuta (memoria alocata initial, fiind eliberata
pentru folosirea acesteia de catre alte programe). In Java nu este necesara crearea unui
destructor pentru ca acest proces are loc automat in momentul in care se termina
executia programului.

Folosirea constructoriilor in Java

Vom crea un proiect nou pe care il vom putea denumi ProiectClase. Vom vedea clasa
principala cu functia Main, unde adaugam toate elementele pentru a rula programul, si
vom crea clasa Person prin care vom defini o persoana. Clasa Person va contine
urmatoarele campuri principale care definesc o persoana: varsta, sex, nume si prenume,
CNP.

_____________________________________________________________________

68

_____________________________________________________________________
Aceasta clasa, impreuna cu campurile care o compun, ne va ajuta sa colectam mai multe

date despre persoanele care folosesc aplicatia (gandeste-te la o aplicatie de gestiune a
clientilor, de exemplu).
Permite-mi sa-ti dau un exemplu: In momentul in care vizitam un site web si introducem
datele personale, in spate sunt anumite structuri sau clase ce iti cer acele date si le
structureaza intr-un singur loc. Prin urmare, clasa Person ne va ajuta sa luam un cumul
mare de date si sa le aranjam intr-un mod mai ordonat is mai clar, ca apoi sa putem
interpreta si folosi informatia in diferite scopuri. Astfel, la inceput clasa noastra va arata in
felul urmator:
class Person {
int age;
String fname;
String lname;
String sex;
}
Te poti gandi la mai multe elemente care apartin unei persoane. Poti merge mult mai in
detaliu, prin adaugarea altor caracteristici precum CNP, inaltime, studii etc. Iar acum, sa
definim constructorul nostru:
Person() {
}
In acest constructor vom trece o valoare default a campurilor definite mai sus, iar in
momentul in care o instanta noua va fi creata (vezi urmatoarea secventa de cod), i se vor
atribui chiar aceste valori:
Person() {
age = 20;
fname = "Unknown";
lname = "Anonymous";
sex = null;
}
In main vom defini un obiect al clasei Person pe care il vom initializa (acesta devenind o
instanta a clasei):
Person A = new Person();
Acest constructor poate avea mai multi parametri daca il vom scrie:
Person (int age, String fname) {
_____________________________________________________________________

69

_____________________________________________________________________
}

In momentul in care cream o instanta, trebuie sa adaugam o valoare pentru acea
instanta. Astfel ca, constructorul initial pe care l-am definit astfel: “Person (int age, String
fname)” va deveni:
this.age = age;
this.fname = fname;
}
In acest caz keywordul this se refera la valoare, in contextul variabilelor din cadrul clasei.
Aici, “this.age = age;” va fi aceasta variabila. Ii va atribui lui int age valoarea pe care o
vom da. Vom folosi this. pentru a distinge intre cele doua variabile age pe care le avem.
Ii vom putea atribui valoarea in Main, unde vom putea inlocui:
Person A = new Person(20, "Adi");
cu:
Person A = new Person(24, "Ramon");
sau alte valori pe care doresti sa le introduci. Scriind aceste valori, o sa vezi ca variabilei
age i se va atribui valoarea 24 s i variabilei fname, valoarea Ramon. Si putem merge mai
departe sa cream alt constructor, in functie de nevoile noastre:
Person(int age, String fname, String lname) {
this.age = age;
this.fname = fname;
this.lname = lname;
}
Inainte de a trece mai departe, vreau sa ma opresc si sa-ti arat codul intregii functii care
arata in felul urmator:
class Person {
int age;
String fname;
String lname;
String sex;
Person() {
this.age = 20;
this.fname = "Unknown";
_____________________________________________________________________

70

_____________________________________________________________________
this.lname = "Anonymous";
this.sex = null;
}

this.age = age;
this.fname = fname;
this.sex = null;
}
Person(int age, String fname, String lname, String sex) {

this.age = age;
this.fname = fname;
this.lname = lname;
this.sex = sex;
}
}
Instanta A este goala in momentul de fata (in sensul in care nu are atribuite valori catre
campurile definite in clasa). Acum putem testa cei 2 constructori definiti mai devreme
astfel:
Person A = new Person();
Exemplul de sus e pentru primul constructor, iar urmatorul pentru al doilea:
Person B = new Person(20, "Adi");
Vom rula urmatoarea secventa de cod:
which has " +
System.out.println("This person is " + A.fname + "
A.age + "years old");
System.out.println("This person is " + B.fname + " which has " +
B.age + "years old");
Iar rezultatul care va aparea pe ecran este:
This person is Unknown which has 20 years old.
This person is Ramon which has 24 years old.
Pentru a afisa pe ecran acest rezultat am fost nevoiti sa luam fiecare camp in parte si sa-l

printam pe ecran. Avem o metoda si mai eficienta de a face acest lucru prin definirea
_____________________________________________________________________

71

_____________________________________________________________________
unei functii toString, care practic ne permite sa customizam modul in care vrem sa
printam obiectul din clasa noastra. Daca vrem sa printam datele persoanei A, vom creea
in clasa Person urmatoarea functie:
public String toString() {

return "This person's name is: " + this.fname + " " +
this.lname + " and he/she is " + this.age + + years old";
}
Prin return, am intors valoarea clasei Person c a fiind un String. Vom printa din Main:
System.out.println(A);
si pe ecran vor aparea datele clasei:
This person's name is: Unknown Anonymous and she/she is 20 years old.
Vom face acelasi lucru pentru B, tot din Main:

System.out.println(B);
Pe ecran va aparea urmatorul text:
This person's name is: Ramon null and he/she is 24 years old.
In primul exemplu va aparea Unknown si Anonymous p

entru ca asa a fost definit in
primul constructor.

_____________________________________________________________________

72

_____________________________________________________________________
4) Getters & Setter

In aceasta sectiune vom discuta despre functiile de tip Getters & Setters si despre
tipurile de acces ale claselor/functiilor/variabilelor: public, private si protected. Acestea
din urma sunt moduri de “securizare” a accesului la diferite functii, clase, etc. Toate sunt
parte a POO si vom discuta despre fiecare in parte, pe rand.
Propun sa revenim la exemplul de mai devreme (cel cu clasa Person) si sa operam in
aceasta clasa astfel incat sa intelegem ce sunt getters, setters si tipurile de acces la
variabile, functii, clase etc. Vom incepe prin a lua urmatoarea secventa de cod, drept
exemplu:
public class Person {
public void sayHello() {

System.out.println(“Hello World, from Person!”);
}
}
In secventa de cod de mai sus poti vedea ca am setat tipul de acces (aka. nivelul de
securitate al codului) ca find public (atat pentru clasa cat si pentru functia acesteia). Asta
inseamna ca in orice proiect in Java in care dorim sa apelam functia sayHello, a clasei
Person, vom putea face asta pentru ca functia este publica. Daca ar fi fost private,
aceasta functie NU ar fi putut fi apelata deloc dintr-un alt fisier, pachet, clasa (si nici din
main). Haide sa facem asta prin adaugarea urmatoarei secvente de cod in clasa Person:
nt age;
private i
private String fname;
private String lname;
Tipul private este pentru a nu putea apela variabilele (campurile) din alta parte. In Main
vom primi o eroare ca variabilele age, fname s i lname nu mai sunt vizibile. Pentru a le
putea din nou apela, trebuie sa cream mai multi getteri. Un getter este o metoda care
arata in felul urmator:
public int g etAge() {

return t his.age;
}
Vom crea acest getter de mai sus in Person. Este public pentru ca vrem sa il apelam de
oriunde. Revenim in Main s i inlocuim astfel:

_____________________________________________________________________

73

_____________________________________________________________________
System.out.println("This person " + A.fname + " has " + A.age + "

years old");
cu:
System.out.println("This person " + A.fname + " has " + A.getAge() +
" years old");
Facem acelasi lucru cu fname s i lname, in Person:
public String get fName() {

return this.fname;
}
si:
public String get lName() {
return this.lname;
}
In Main v om schimba astfel:
System.out.println("This person " + A.getFname() + " has " +
A.getAge() + " years old");

Dupa ce vom rula, pe ecran va aparea:
This person John has 24 years old.

Acesta este un mod mai securizat si curat de a apela variabilele create. Pur si simplu
apelam metodele care intorc variabila respectiva. Pentru a modifica aceste variabile
trebuie sa revenim in Person s i sa cream seteri:
public void setAge(int age) {
this.age = age;
}
age din aceasta linie de cod este parametrul pe care l-am introdus mai devreme.
this.age este campul private int age. Continuam sa facem acelasi lucru si pentru restul
functiilor:
public void setFname(String fname) {
this.fname = fname;
}

_____________________________________________________________________

74

_____________________________________________________________________

si:
public void setLname(String fname) {
this.lname = lname;
}
Astfel, codul complet din clasa Person v a fi urmatorul:

public class Person {
nt age;
private i
private String fname;
private String lname;
Person() {
this.age = 0;
this.fname = “None”;
this.lname = “no one”;
}
public int getAge() {

return this.age;
}
public String getlName() {
return this.lname;
}
public String getfName() {
return this.fname;
}
public void setAge(int age) {
this.age = age;
}
public void setlName(String lname) {
this.lname = lname;
}
public void setfName(String fname) {
this.fname = fname;
}
_____________________________________________________________________

75

_____________________________________________________________________
public void sayHello() {

System.out.println(“Hello World, from Person!”);
}
public String toString() {
return "This person's name is: " + this.fname + " " +
this.lname + " and he/she is " + this.age + " years old";
}
}
In Main, vom scrie pentru a modifica si a printa:

A.setfName("Adi");
A.setAge(23);
System.out.println(A);
Pe ecran, va aparea modificat:
This person's name is: Adi null and he/she is 23 years old
Null apare pentru ca nu am definit lname. Putem sa il setam in Main:

A.setlName("Nastase");
Dupa ce vom da Run, pe ecran va aparea:
This person's name is: Adi Nastase and he/she is 23 years old

Iata mai jos, in figurile 5.10 - 11, codul complet asa cum arata el in Eclipse:

_____________________________________________________________________

76

_____________________________________________________________________
Clasa Person
Figura 5.10
_____________________________________________________________________

77

_____________________________________________________________________
Clasa Main & Rezultatul final

Figura 5.11

Ca un scurt rezumat la ce am vorbit pana acum: tipul public este pentru ca oricine sa ne
poata folosi clasa, functia sau ce mai avem creat. Tipul private este pentru a folosi
campurile doar in aceeasi clasa sau functie, iar tipul protected care inseamna ca putem
accesa si folosi elementul creat (clasa, variabila etc.) doar in acelasi pachet (package,
care se refera la “folderul” in care se afla proiectul in Java - initial denumirea acestuia find
default).

Acest pachet despre care vorbesc este de obicei creat la inceput (si se numeste default,
dupa cum spuneam). Fiecare pachet are caracteristicile si functiile lui, iar daca functiile
sunt protected, nu pot fi folosite in afara pachetului. Daca sunt private, nu pot fi folosite
in afara fisierului. Numai public permite folosirea lor de oriunde.

_____________________________________________________________________

78

_____________________________________________________________________
Exercitii
de cateva exercitii care te ajuta pe tine sa si practici.

1) Definiti o clasa Fractie care modeleaza lucrul cu fractiile. Membrii acestei clase sunt:
● doua atribuite de tip double pentru numaratorul fractiei, respectiv numitorul ei;
● constructorul cu doi parametri de tip double, pentru setarea celor doua parti ale
fractiei (numarator si numitor);
● un constructor fara parametri care apeleaza constructorul anterior;
● o metoda, cu un singur parametru, de calcul a sumei a doua fractii;
● o metoda toString utilizata pentru afisarea pe ecran a valorii fractiei;
● o metoda equals, cu un parametru de tip Object, care va returna true d
aca fractiile
sunt egale, respectiv false in sens contrar;
● o metoda main pentru testarea functionalitatii clasei.

2) Definiti o clasa Numar care are ca membru un numar intreg si contine metodele
descrise mai jos. Implementati metodele astfel incat fiecare metoda sa efectueze o
singura adunare. Instantiati un obiect de tip Numar in metoda main s i apelati metodele
implementate. Ce principiu POO este evidentiat in acest exercitiu?

//returneaza suma dintre nr (membrul clasei) si a
public int suma(int a);
//returneaza suma dintre nr, a si b

public int suma(int a, int b);
//returneaza suma dintre nr, a, b si c

public int suma(int a, int b, int c);
//returneaza suma dintre nr, a, b, c si d

public int suma(int a, int b, int c, int d);

_____________________________________________________________________

79

_____________________________________________________________________
3) Un produs este caracterizat prin nume (String), pret (double) si cantitate (int). Un
magazin are un nume (String) si contine 3 produse. Creati clasele Produs si Magazin
corespunzatoare specificatiilor de mai sus. In fiecare clasa, implementati constructorul
potrivit, astfel incat caracteristicile instantelor sa fie setate la crearea acestora.

Clasa Produs contine o metoda toString, care va returna un String sub forma “Produs
<nume_produs> <pret_produs> <cantitate>“ si o metoda getTotalProdus care va
returna un double, produsul dintre c antitate si p
ret. Clasa Magazin contine o metoda
toString care va returna String-ul corespondent tuturor componentelor magazinului si o
metoda getTotalMagazin care va calcula suma totalurilor produselor si o va returna.
Creati, intr-o metoda main, un obiect de tip Magazin, folosind obiecte anonime in cadrul
instantierii.

4) Implementati clasa Punct care defineste un punct din spatiul 2D.

Datele clasei (private):
● doua nr. intregi reprezentand cele doua coordonate ale punctului.

Conctructorul clasei:
● un constructor fara parametri care instantiaza punctul O(0, 0).

Metodele clasei:
● int getX() = intoarce abscisa punctului;
● void setX(int x) = seteaza abscisa punctului;
● int getY() = intoarce ordonata punctului;
● void setY(int y) = seteaza ordonata punctului;
● String toString() = returneaza un String de forma \textit{(x, y)};
● double distance(int, int) = calculeaza distanta dintre 2 puncte;
● double distance(Punct p1) = calculeaza distanta dintre 2 puncte.

Creati o clasa Test in acelasi pachet cu clasa Punct, care contine o metoda main care
calculeaza distanta dintre punctele A(1, 2) si B(-1, 3). Puteti accesa datele clasei Punct in
metoda main d in clasa Test?

_____________________________________________________________________

80

_____________________________________________________________________
5) Sa se implementeze o clasa PasswordMaker care genereaza, folosind

RandomStringGenerator, o parola pornind de la datele unei persoane. Aceasta clasa o sa
contina urmatoarele:
● o constanta MAGIC_NUMBER avand orice valoare doriti
● un String constant MAGIC_STRING, lung de minim 20 de caractere, generat
random
● un constructor care primeste: un String numit firstName, un String numit lastName
si un int numit age
● o metoda getPassword() c are va returna parola
Parola se construieste concatenand urmatoarele siruri:
● sirul format din ultimele (age % 3) litere din firstName
● un sir random de lungime MAGIC_NUMBER, generat cu RandomStringGenerator
si cu un alfabet obtinut din 10 caractere obtinute random din MAGIC_STRING
● si sirul format prin conversia la String a numarului (age + lungimea lui lastName).
Pentru subsiruri si alte metode utile consultati documentatia clasei String

_____________________________________________________________________

81

_____________________________________________________________________
Capitolul 6 - Exceptiile in Programare si Operatiile

cu Fisiere in Java

I. Exceptii in Java

Ce sunt exceptiile?

O exceptie reprezinta un eveniment (neasteptat) care are loc in timpul executiei unui
program. Aceasta exceptie (daca nu este tratata) poate duce la intreruperea programului
si oprirea permanenta a acestuia. Exceptiile pot aparea in mai multe situatii cum ar fi:
● Imposibilitatea citirii unui fisier de pe disk (ex: File Not Found)

● Imposibilitatea crearii unui fisier pe disk (Insufficient Permissions)
● Imposibilitatea utilizarii (sau inexistenta) unei clase (Class Not Found)
● Depasirea lungimii maxime definite pentru un Vector/Array (Array Index Out of
Bound)
● Imposibilitatea conectarii la un server
Toate aceste exceptii precum si multe altele pot aparea (sub forma de eroare) atunci
cand scriem programele noastre si facem greseli la nivel de comportament al codului
nostru si nu la nivel de compilare (greseli de sintaxa in programare).

Cum sunt generate exceptiile in Java?

O exceptie este generata prin “aruncarea” sa in momentul in care o anumita conditie nu
este respectata. Sa luam codul de mai jos sub forma de exemplu pentru a intelege mai
bine:
String s = null;
if (s == null) {
throw new Exception("Sirul este gol");
}
In acest exemplu am creat un String p e care l-am initializat cu null (o valoare care indica
faptul ca sirul e complet gol; nu are atribuit nimic), dupa care am testat daca acesta este
gol. In cazul in care if-ul este valid, atunci va fi aruncata o exceptie (prin crearea unui
instante de tipul Exception) care va anunta faptul ca sirul este gol, iar programul nu poate
merge mai departe datorita acestui fapt.
_____________________________________________________________________

82

_____________________________________________________________________
Exceptiile pot fi de 2 feluri: exceptii built-in (figura 6.1) si exceptii definite de catre user.
Clasa Exception este clasa parinte a majoritatii exceptiilor din Java. O parte dintre
exceptiile built-in le-am mentionat si la inceputul acestui capitol:
● FileNotFoundException
● NullPointerException
● ArithmeticException
● ClassNotFoundException
● IOException
● IndexOutOfBoundsException
● Si multe altele

Figura 6.1
In aceasta sectiune ne vom concentra asupra exceptiilor built-in, iar in cele ce urmeaza iti

voi arata cateva exemple de programe care genereaza exceptii si cum le putem trata.
Iata mai jos un exemplu de cod care genereaza o exceptie:

public class MyClass {
int[] vec = new int[15];

System.out.print("Vectorul este: ");
for(int i = 0; i < 16; i++) {

vec[i] = i;
System.out.print(vec[i] + " " );
}
}
}
_____________________________________________________________________

83

_____________________________________________________________________
In exemplul de mai sus, secventa de cod adauga in vector cate o valoarea numerica
pentru fiecare pozitie a vectorului. Problema consta in faptul ca este depasita lungimea
maxima a vectorului (pozitia a 16-a, desi au fost alocate doar 15), iar astfel, o eroare va fi
generata. Iata in figura de mai jos exceptia aruncata in urma compilarii programului:

Figura 6.2

Cum tratam exceptiile in Java?

Pentru a rezolva aceasta problema (si pentru a permite codului nostru sa fie executat in
continuare, fara intreruperi) trebuie sa prindem exceptiile care sunt aruncate, dupa care
sa le tratam. Putem face asta in formatul urmator:

nt[] vec = new int[15];

i
try {
for(int i = 0; i < 16; i++) {
vec[i] = i;
System.out.print(vec[i] + " " );
}
} catch (ArrayIndexOutOfBoundsException e) {
System.err.println(e.getMessage());
}
}
}
Iar codul in Eclipse si rezultatul afisat in consola, in urma compilarii, este:
_____________________________________________________________________

84

_____________________________________________________________________

Figura 6.3

Practic prin folosirea blocului de instructiuni try - catch putem sa ne protejam codul (si
programul) nostru de o eventuala intrerupere care poate avea loc. In blocul try - catch
am introdus codul principal care va fi executat instructiune cu instructiune. In momentul
va prinde si o va trata (in functie de codul
in care se arunca o exceptie, blocul catch o
scris acolo).

Iata alte exemple de cod care genereaza o parte din exceptiile mentionate la inceputul
acestui capitol:

_____________________________________________________________________

85

_____________________________________________________________________
Exemplul #1 - Divide by 0
In acest exemplu poti sa vezi cum are loc o operatie de impartire a unui numar la 0 si
rezultatul generat de catre compilator:

int a = 30, b = 0;
int c = a/b; // nu se poate imparti la 0
System.out.println("Rezultatul= " + c);
System.out.println("Programul a fost finalizat cu succes");

}
}
Iata rezultatul, in figura de mai jos:

Figura 6.4

Pentru a rezolva aceasta problema, vom folosi blocul try - catch, care ne ve permite sa
prindem o eventuala exceptie care ar putea fi aruncata de catre program. In secventa
catch vom incerca sa prindem exceptia ArithmeticException.

try {
int a = 30, b = 0;
int c = a/b; // nu se poate imparti la 0
System.out.println ("Rezultatul= " + c);
} catch(ArithmeticException e) {
System.out.println("Can't divide a number by 0");
}
}
}
_____________________________________________________________________

86

_____________________________________________________________________
Si rezultatul in urma rularii codului:

Figura 6.5
Exemplul #2 - File Not Found

In acest al doilea exemplu poti sa vezi cum are loc o operatie de citire a datelor dintr-un
fisier si rezultatul generat de catre compilator:
import java.io.*;

public static void main(String args[]) throws
FileNotFoundException {
// acest fisier nu exista
File file = new File("E://file.txt");
FileReader fr = new FileReader(file);

}
}

_____________________________________________________________________

87

_____________________________________________________________________
Iata rezultatul in figura 6.6 de mai jos:

Figura 6.6
catch vom incerca sa prindem exceptia FileNotFoundException, doar ca de data
aceasta am sa te las pe tine sa scrii codul pentru prinderea exceptiilor (vezi sectiunea de
exercitii de la sfarsitul acestei prime parti ale capitolului).

Exemplul #3 - Null Pointer Exception

In acest al treilea exemplu poti sa vezi cum are loc o operatie de folosire a unei variabile
care a fost initializata cu valoarea null si rezultatul generat de catre compilator:

// acesta variabila contine nimic, null

String a = null;
// incercam sa determinam lungimea variabilei a
System.out.println(a.length());

}
}

Figura 6.7
_____________________________________________________________________

88

_____________________________________________________________________

catch vom incerca sa prindem exceptia NullPointerException, doar ca de data
aceasta am sa te las pe tine sa scrii codul pentru prinderea exceptiilor (vezi sectiunea de
exercitii de la sfarsitul acestei prime parti ale capitolului).

Exemplul #4 - String Index Out of Bounds

In acest al patrulea exemplu poti sa vezi cum are loc o operatie de parcurgere a
caracterelor dintr-un sir (ba chiar depasirea numarului total de caractere) si rezultatul
generat de catre compilator:

// acesta variabila contine un text random

String text = “Random text for this example”;
int lungime = text.length();
for(int i = 0; i < lungime + 1; i++) {

System.out.print(text.charAt(i));
}

}
}

Figura 6.8

_____________________________________________________________________

89

_____________________________________________________________________
catch vom incerca sa prindem exceptia StringIndexOutOfBoundsException, doar ca

de data aceasta am sa te las pe tine sa scrii codul pentru prinderea exceptiilor (vezi
sectiunea de exercitii de la sfarsitul acestei prime parti ale capitolului).
ATENTIE: acestea au fost cateva exemple de erori pe care le poti avea atunci cand iti
scrii programele in Java. Cand vine vorba de exceptii precum
StringIndexOutOfBoundsException sau ArrayIndexOutOfBoundsException te
incurajez sa rezolvi cauza acestei exceptii si NU sa pui codul intr-un bloc try - catch
pentru ca aceasta solutie nu este una eficienta.

Exercitii

1) Pentru fiecare exemplu (2 - 4) de mai sus care nu contine o solutie de tratare a
exceptiilor, te invit sa rescrii codul astfel incat programul sa nu fie intrerupt si sa-si poata
continua executia.

_____________________________________________________________________

90

_____________________________________________________________________
II. Operatii cu Fisiere in Java

Cand vine vorba de programare, o buna parte din timp vei lucra cu operarea sau
manipularea de date (care sunt folosite de programul sau aplicatia la care lucrezi). In
marea majoritate a cazurilor, aceste date se vor afla stocate pe disc (cel mai probabil in
fisiere) sau intr-o baza de date. In aceasta sectiune vom invata cum sa gestionam citirea
si scrierea dintr-un, respectiv intr-un fisier prin Java.

Cand vine vorba de lucrul cu fisiere, in mare parte, poti face 2 lucruri: citirea, respectiv
scrierea in acele fisiere. Nu este nimic special in legatura cu acest subiect, dar este
important sa il ai in vedere pentru ca te vei intalni destul de des cu astfel de operatii. Alte
moduri prin care programul tau poate obtine date (pe care sa le proceseze) sunt:
● De la alte programe prin fisierele locale (aflate pe acelasi PC/laptop, hard disk)
● De la alte programe prin retea (aflate pe anumite PC-uri/laptop-uri sau servere)
● Din program, datele fiind introduse de la tastatura.

Citirea datelor de la tastatura in Java

Inainte de a incepe sa citim datele dintr-un fisier, vreau sa-ti arat cum o poti face de la
tastatura. Probabil ca ai mai interactionat cu citirea datelor de la tastatura in capitolul 2, in
sectiunea de exercitii, iar daca nu ai reusit sa faci acel exercitiu, nici o problema pentru
ca iti voi explica in cele ce urmeaza ce inseamna si cum o poti face.
Citirea datelor de la tastatura (aka. Citirea datelor prin consola - din Eclipse, in acest caz)
inseamna sa rulezi un program, iar aceasta sa-ti ceara introducerea datelor direct de la
tastatura. Este o metoda foarte buna de antrenament si de verificare a faptului ca
programul tau functioneaza corect. In aplicatii reale nu vei interactiona foarte mult cu
acest mod, decat atunci cand ii ceri utilizatorului sa o faca (in rest vei opera cu fisere sau
date transferate prin retea).
Iata mai jos un exemplu de citire a datelor de la tastatura pe care te incurajez sa-l
exersezi si sa-l adopti in programele tale pentru ca poate fi o metoda foarte buna de
testare a programelor lor.
System.out.println("Introdu adresa de email: ");

Scanner scanner = new Scanner(System.in);
String email = scanner.nextLine();
System.out.println("Adresa ta de mail este " + email);
_____________________________________________________________________

91

_____________________________________________________________________
System.out.println("Introdu numele tau: ");

String nume = scanner.nextLine();
System.out.println("Numele tau este " + nume);
System.out.println("Introdu varsta ta: ");

String varsta = scanner.nextLine();
System.out.println("Varsta ta este " + varsta);
//modifica tipul variabilei din String in int

int age = Integer.parseInt(varsta);

In urma folosirii codului scanner.nextLine(), programul va stoca in variabila email prima
linie de text care va fi introdusa in consola. Un aspect important consta in faptul ca liniile
citite sunt de tipul String, iar asta iti ofera multa flexibilitate pentru ca astfel le poti
interpreta si modifica asa cum doresti tu.

Citirea si scrierea fisierelor in Java

Cand vine vorba de citirea dintr-un fisier, este extrem de important ca acel fisier sa existe
si sa-i fie precizata locatia exacta de pe disk, astfel incat sa fie citite datele din el. Daca
locatia oferita programului nu este exacta si programul esuaza sa citeasca datele din
fisier, atunci acesta (daca nu este scris corect) se poate opri din executie. In marea
majoritate a cazurilor o exceptie este aruncata cand fisierul nu exista (de tipul
FileNotFoundException) .

Daca ajungem in aceasta situatie, e important sa tratam aceasta exceptie astfel incat
programul nostru sa continue si sa nu-si inceteze executia. Asadar, indiferent daca esti
pe Windows, Linux sau macOS iti recomand sa folosesti calea absoluta (adica locul exact
unde se afla pe disc) pentru a arata unde se afla fisierul din care doresti sa faci operatia
de citire. Iata mai jos un exemplu:

public class FileReadTest {
String fileLocationWindows =
"C:\Users\Public\Desktop\fisierIntrare.txt";
String fileLocationLinux = "/home/ramon/Desktop/fisierIntrare.txt";
_____________________________________________________________________

92

_____________________________________________________________________
String fileLocationMac = "/Users/ramon/Desktop/fisierIntrare.txt";
FileReader in = null;
try {
//Daca esti pe Windows foloseste variabila fileLocationWindows

//Asigura-te ca acest fisier exista si are orice fel de text in el
in = new FileReader(fileLocationWindows);
String dateFisier = new String();
int c;
char tmp;
while ((c = in.read()) != -1) {

tmp = (char) c;
//Intregul fisier va fi stocat in variabila dateFisier
dateFisier += String.valueOf(tmp);
}
System.out.println(dateFisier);
} catch (FileNotFoundException e) {
} finally {
//Spunem Sistemului de Operare sa inchida fisierul deschis
if (in != null) {
in.close();
}
}
}
Operatia de scriere intr-un fisier este mai usor de facut pentru ca nu trebuie sa existe
fisierul in care vrem sa scriem. Daca fisierul destinatie (cel cu denumirea in care vrem sa
scriem) nu exista, atunci programul il va crea automat, deci nu trebuie sa-ti faci griji.
Important si aici este sa te asiguri ca oferi corect locatia de destinatie a fisierului. Iata mai
jos un exemplu:
String text = "Hello World, new world";

String fileDestination = "C:\Users\Public\Desktop\outFile.txt";
try {
out = new FileWriter(fileDestination);
_____________________________________________________________________

93

_____________________________________________________________________
//folosim aceasta secventa de cod pentru a scrie un flux de date

//de tipul String intr-un fisier aflat pe Desktop
out.write(text);
} catch (IOException e) {
} finally {
if (out != null) {
out.close();
}
}

In sectiunea de cod de mai jos poti vedea un exemplu complet de citire, respectiv scriere
a unui text intr-un fisier. Programul citeste datele din fisierul input.txt si le scrie in fisierul
output.txt. Daca nu introducem o locatie anume de unde dorim sa citim/scriem in fisier,
programul va folosi locatia default (cea in care se afla proiectul tau Java).
Pentru a afla aceasta locatie, avem la dispozitie functia

System.getProperty("user.dir"). Aceasta functie o folosim pentru a afisa in
consola locatia curenta, unde programul nostru in Java cauta (by default) fisierul input.txt,
respectiv unde va crea fisierul output.txt.
public class FileTest {

public static void main(String[] args) throws IOException {
String currentDir = System.getProperty("user.dir")

System.out.println("Working Directory = " + currentDir);
FileReader in = null;
FileWriter out = null;
try {
in = new FileReader("input.txt");
out = new FileWriter("output.txt");
String dateFisier = new String();

int c;
char tmp;
_____________________________________________________________________

94

_____________________________________________________________________
while ((c = in.read()) != -1) {

tmp = (char) c;
//Intregul fisier va fi stocat in variabila dateFisier
dateFisier += String.valueOf(tmp);
}
dateFisier += “ NOI DATE LA SFARSIT”;
out.write(dateFisier);
} catch (FileNotFoundException e) {
} finally {
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}

Acest program citeste datele dintr-un fisier, le stocheaza intr-o variabila de tipul String
(dateFisier), dupa care le scrie intr-un alt fisier. Lucrul cu fisiere in Java este mult mai
complicat fata de exemplul pe care ti l-am dat eu mai sus. Recomandarea mea este sa iei
aceasta sectiune de cod si sa o folosesti (cat timp esti la inceput) pentru a citi tot textul
dintr-un fisier (input) pe care ulterior sa-l manipulezi (sa elimini spatiile / sa identifici
elementele care te intereseaza din fisier etc) folosind functiile clasei String.

_____________________________________________________________________

95

_____________________________________________________________________
Exercitii
de cateva exercitii pe care tu sa le practici. De aceasta data

1) Creeaza un program care citeste numerele din cele 3 fisiere atasate AICI. Dupa citire,
aceste numere vor fi sortate in ordine crescatoare si vor fi scrise intr-un fisier nou
denumit "rezultat.txt". Pe prima linie se va scrie cel mai mare numar dintre cele citite,
urmat numarul total de elemente citite din cele 3 fisiere.

Exemplu fisiere "rezultat.txt":

8181 45
3
4
5
19
...

Unde 8181 reprezinta cel mai mare numar dintre cele citite, iar 45 reprezinta numarul total
de numere citite din cele 3 fisiere. Raspuns corect:

991 44
3
4

_____________________________________________________________________

96

_____________________________________________________________________
Capitolul 7 - Structuri de Date in Java

In acest capitol si in urmatorul vom discuta despre 2 elemente fundamentale din
programare care ne fac viata mai usoara: Structuri de Date si Colectii. La sfarsitul acestui
capitol iti va fi mult mai clar ce sunt acestea, unde si cand le poti folosi si mai ales de ce
sa le folosesti. Haide sa incepem cu prima dintre cele doua.

Ce sunt structurile de date?

Structurile de date sunt fix ceea ce sugereaza titlul: structuri de date. Sunt anumite tipuri
de date speciale care ne ajuta pe noi sa le structuram si sa le manipulam in functie de
obiectivul nostru. Mai exact, structurile de date reprezinta o grupare de date care sunt
organizate, stocate si manage-uite cu scopul de face accesul si modificarea (datelor) cat
mai eficienta si mai usoara. Fiecare structura de date (ex: stive, cozi, vectori etc.) are un
comportament, un mod de acces la date si functii specifice. Utilizarea acestora depinde
foarte mult de context si, bineinteles, de problema care se doreste a fi rezolvata. In cele
ce urmeaza vom discuta mai multe despre acestea, dar mai intai hai sa vedem de cate
tipuri pot fi aceste structuri de date.

Tipuri de structuri de date

Cand vine vorba de structuri de date, avem mai multe tipuri din care putem alege in
functie de nevoie. Iti voi enumera cateva dintre cele mai des folosite, dupa care vom
incepe sa discutam (si sa le folosim) pe fiecare in parte:
● Vectori
● Liste (LinkedList, ArrayList)
● Stive (Stack)
● Cozi (Queue)
● Dictionare (HashMap, TreeMap)
Acestea sunt doar o parte dintre structurile de date disponibile (si precreate deja in Java).
Pe langa acestea mai exista multe altele care fie au fost implementate deja, fie necesita
implementare (cum ar fi grafurile).

Un aspect important pe care trebuie sa-l avem in considerare este faptul ca fiecare
structura de date are rolul sau si utilitatea potrivita in anumite contexte.
_____________________________________________________________________

97

_____________________________________________________________________
De exemplu, daca dorim sa stocam mai multe elemente si sa le accesam recurent (prin
cautare), ar fi mai util sa utilizam un anumite structuri (dictionare sau multimi), in schimbul
altora. De ce? Pentru ca timpii de accesare/cautare sunt mult redusi fata de alte structuri
(liste, vectori, cozi etc.). Acum haide sa le luam pe rand si sa vorbim despre fiecare in
parte:

1) Vectori (Arrays)

Vectorii reprezinta structuri de date care pot stoca informatii in variabile structurate care
au un scop bine definit. Acestea pot stoca numere (int, float etc.), caractere, sau chiar
siruri de caractere. Declararea acestor siruri este foarte simpla, fiind asemanatoare cu
declararea unei simple variabile. Deosebirea dintre o variabila si un sir, este ca variabila
poate sa aiba alocata o singura valoare pe cand unui sir ii pot fi alocate mai multe valori.
Iata in figura 7.1 un exemplu de Array/Vector (arr) cu 10 elemente (care nu au fost alocate
deocamdata):

Figura 7.1

In programare numaratoarea incepe de la 0, astfel prima pozitie a variabilei noastre
"arr", declarata cu 10 pozitii este 0, iar ultima este 9. Atribuirea valorilor a unei anumite
pozitii se face prin index (ex: [3], [5] ), care este valoarea aflata in parantezele drepte si
determina pozitia careia ii va fi atribuita valoarea dorita.

Cum folosim un Vector in Java?

Mai jos este evidentiata diferenta dintre declararea unei variabile si declararea unui
vector. Initializarea numarului de pozitii se face astfel.
int var;
int[] exempluVector;
Acum, pentru a folosi acest vector, trebuie sa-l initializam (sa-i alocam o dimensiune fixa -
de memorie - astfel incat sa-l putem folosi), iar apoi sa alocam valori (de tipul int) pe
diferite pozitii din acest vector.
_____________________________________________________________________

98

_____________________________________________________________________
//declararea si alocarea de memorie

int[] exempluVector = new int[15];
//atribuirea unui element la un anumit index

exempluVector[12] = 5;
exempluVector[7] = 12;

Pana in acest moment, am creat o variabila de tip vector, i-am alocat o dimensiune si am
alocat valori pe cateva pozitii din vector. Dar dupa cum poti observa, acest procedeu nu
este prea scalabil (imagineaza-ti sa ai 1000 de pozitii intr-un vector si sa le aloci manual
pe fiecare in parte…). Pentru a automatiza acest proces, vectorii sunt cel mai des intalniti
impreuna cu buclele (for loops & while l oops). Aceste bucle sunt folosite in operatii
repetitive care se folosesc de vectori. O secventa de cod prin care putem face asta este:
for (int i = 0; i < 15; i++) {
exempluVector[i] = 0;
}
Astfel toate valorile din vectorul de mai sus au fost initializate cu valoarea 0. Un subiect
important care trebuie dezbatut este initializarea mai multor valori decat pozitii. In cazul
in care valoarea lui "i" de mai sus ar fi depasit numarul de pozitii al variabilei "numar", in
program s-ar fi regasit o eroare de tip "Array Index Out of Bounds" , o referire la iesirea
din numarul de pozitii alocate variabilei. In acest caz, ca o recomandare, putem modifica
valoarea 15 (care a fost pusa manual), cu functia exempluVector.length care va
intoarce valoarea maxima alocata pentru vector (in momentul initializarii). In cazul in care
vrem sa facem o operatiune cu acest vector (exemplu: sa adaugam elemente in el si sa
printam valoarea acestora) putem face in felul urmator:
int[] exempluVector = new int[15];

for(int i = 0; i < exempluVector.length; i++) {

exempluVector[i] = i + 2;
System.out.print(exempluVector[i] + " " );
}

Rezultatul afisat in urma rularii codului de mai sus va fi:
Vectorul este: 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

_____________________________________________________________________

99

_____________________________________________________________________
Iata in figura de mai jos o ilustratie cu codul si rezultatul in urma compilarii acestuia in
Eclipse.

Figura 7.2

_____________________________________________________________________

100

_____________________________________________________________________
Exercitii

Dezvolta o aplicatie pentru reprezentarea vectorilor de numere intregi, si anume:
● se va determina un tip de date pentru astfel de reprezentari

● se va citi un vector de numere intregi
● se va afisa un vector de numere intregi
● se vor aduna componentele vectorului (vom prezenta doua metode: una cu
transfer rezultat prin tipul rezultat si alta cu transfer prin linia de parametri)
● se va realiza operatia de inmultire a componentelor vectorului
● media elementelor din vector
● numarul de componente negative si numarul de componente pozitive din vector
● minimul si maximul dintre elementele vectorului
● sortarea ascendenta a vectorului
● cautarea unui anumit element (adica un numar, o valoare) in sir cu returnarea
pozitiei pe care se gaseste; in cazul in care elementul (o valoare) se afla de mai
multe ori pe pozitii diferite, vom avea ca rezultat prima pozitie pe care acesta se
gaseste.

Vectorul va contine 50 de elemente, numere intregi, generate aleator (vezi functia
Random), de la -250 la 250.

_____________________________________________________________________

101

_____________________________________________________________________
2) Liste inlantuite (Linked Lists)

Ce este si cum functioneaza o Lista?

Listele inlantuite sunt un tip de structuri de date, similare cu vectorii, care stocheaza mai
multe elemente in serie. Fiecare element din lista se numeste nod si contine 2 lucruri
importante: valoarea stocata in nod (partea din stanga) si informatia de memorie (pointer)
cu privire la urmatorul nod (partea din dreapta). Ca mod de functionare listele seamana
foarte multe cu vectorii, dar exista cateva diferente fundamentale:
● Vectorii au o dimensiune fixa (ex: 100 de elemente), iar Listele au o dimensiune
dinamica
● Listele au nevoie de mai multa memorie alocata datorita celor 2 componente ale
nodului, fata de o singura componenta a vectorului
● Pentru liste este mult mai usor (si mai eficient dpvd resurse) sa adaugi si sa stergi
elemente in comparatie cu vectorii

Figura 7.3
Un lucru pe care vreau sa-l retii este faptul ca exista 2 tipuri de Liste (LinkedList si
ArrayList) cu urmatoarele caracteristici:
● LinkedList
○ Dimensiunea listei este dinamica
○ Adaugarea si eliminarea elementelor se face cu usurinta, de la cele 2
capete ale listelor
○ Accesul la un element se face mai greu (dureaza mai mult, pana cand lista
este parcursa si elementul este gasit)
● ArrayList
○ Dimensiunea listei este dinamica
○ Adaugarea si eliminarea elementelor necesita mai mult timp si mai multe
resurse
○ Accesul la orice element din lista se face mai rapid si cu usurinta
_____________________________________________________________________

102

_____________________________________________________________________
Nu este una mai buna fata de cealalta, dar cu ce vreau sa ramai din acest exemplu, este
faptul ca aceste 2 tipuri de liste au atat puncte tari cat si puncte slabe, iar totul depinde
de tine sa le cunosti si sa le utilizezi in cele mai bune momente posibile, astfel incat
programul sa functioneze cat mai eficient posibil, cu un consum minim de resurse.

Care sunt functiile unei Liste?

Hai sa vedem care sunt (o parte din) functiile unui liste (LinkedList sau ArrayList):
● AddFirst – adauga un element in fruntea listei

● AddLast – adauga un element la sfarsitul listei
● RemoveFirst – sterge primul element din fruntea listei si il returneaza
● RemoveLast – sterge ultimul element din listei si il returneaza
● isEmpty – intoarce 1 daca lista este goala; returneaza 0 daca lista contine cel
putin un element
Acestea sunt functiile de baza pe care le vei folosi in marea majoritate a cazurilor, dar pe
langa aceastea mai exista si multe altele. Vei avea ocazia sa le testezi pe masura ce vei
progresa cu studiile tale ;)

Cum folosim o Lista (inlantuita) in Java?

Haide sa luam un exemplu concret de utilizare a listelor (LinkedList si ArrayList), astfel
incat, tu, sa poti vedea functiile acestora si modul lor de lucru. Dupa cum poti sa vezi si in
exemplul de mai jos, am creat o lista inlantuita (LinkedList) si folosim instanta creata
pentru a exemplifica functiile pe care le avem la dispozitie:

import java.util.*; //NU UITA SA INCLUZI functiile din Java Util
public class ListTest {
public static void main(String[] args) {
// Crearea obiectului din lista

LinkedList<String> list = new LinkedList<String>();
// Adaugarea elementelor in lista

list.add("A");
_____________________________________________________________________

103

_____________________________________________________________________
list.add("B");
list.addLast("C");
list.addFirst("D");
list.add(2, "E");
list.add("F");
list.add("G");
System.out.println("Lista inlantuita: " + list);
// Stergerea elementelor din lista

list.remove("B");
list.remove(3);
list.removeFirst();
list.removeLast();
System.out.println("Lista inlantuita dupa elementele eliminate: " +
list);
// Cautarea elementelor din lista
if( list.contains("E") ) {
System.out.println("Lista contine elementul 'E' ");
}
else {
System.out.println("Lista nu contine elementul 'E'");
}
// Numarul elementelor din lista

System.out.println("Lungimea listei = " + list.size());
// Functiile get si set ale listei inlantuite

String element = list.get(2);
System.out.println("Element din lista, ales este : " + element);
list.set(2, "Y");
System.out.println("Lista inlantuita dupa modificare : " + list);
}
}

Dupa cum ai putut sa vezi mai sus (si in exemplele de mai jos) listele inlantuite au multe
functii si aplicabilitati practice. Un exemplu real de folosire a listelor poate fi un browser
web, mai exact istoricul de navigare al acestuia. In “spatele unui browser” se afla o lista
inlantuita care va retine fiecare site pe care ai navigat in sesiunea curenta de browsing.
_____________________________________________________________________

104

_____________________________________________________________________
In momentul in care apesi pe butonul “Back” sau “Forward” vei parcurge paginile stocate

de catre aceasta lista. Destul de cool, nu? :)
Un alt exemplu poate fi managementul memoriei unui calculator. In “spate” exista o lista
inlantuita care mentine blocurile de memorie libere si cele utilizate (alocate). Iata in figura
de mai jos o rezultatul in urma compilarii programului in Eclipse.

Figura 7.4

_____________________________________________________________________

105

_____________________________________________________________________
Exercitii
1) Creaza o lista care contine elementele: 1, 4, 9, 16, 25, 36, 49, 64, 81, 100. Scrie in Java
un program care ia aceasta lista si face o lista noua care contine doar elementele pare
ale acestei liste.

2) Creaza o lista cu numele a 10 prieteni (numele nu trebuie sa fie distincte). Respectand
ordinea, rezolva urmatoarele cerinte:
● Sorteaza lista de nume.
● Utilizand o lista auxiliara, determina numarul de aparitii al fiecarui nume.
● Determina numele care apare de cele mai multe ori in lista initiala.
● Determina numele care apar cel mai putin ori in lista initiala.
● Revenind la lista initiala de nume, inverseaza ordinea elementelor.

_____________________________________________________________________

106

_____________________________________________________________________
3) Stiva (Stack)

Ce este si cum functioneaza o Stiva?

In programare stivele reprezinta un tip de date abstracte, extrem de benefice in mai
multe contexte. Ele stau la baza alocarii de memorie, deci si la baza functionarii
calculatoarelor (si a OS-urilor). Ca mod de functionare, stivele sunt de tipul LIFO (Last In
First Out) si merg pe principiul: ultimul element adaugat in stiva este si primul element
care iese din ea. Iata mai jos o ilustratie care exemplifica modul de functionare:

Figura 7.5

Care sunt functiile unei Stive?

Dupa cum am spus si mai devreme, stiva, ca structura de date, are anumite functii
specifice. Aceste functii arata in felul urmator:
● Push – adauga un element (o entitate) in stiva. Adaugarea se poate face doar la
varful stivei.
● Pop – sterge un element din stiva si il returneaza. Stergerea se poate face doar la
varful stivei.
● Peek – intoarce elementul din varful stivei fara a efectua nicio modificare asupra
acesteia.
● isEmpty – intoarce 1 daca stiva este goala; 0 daca are cel putin un element.
_____________________________________________________________________

107

_____________________________________________________________________
Iata in figura de mai jos exemplificate cele 2 functii principale ale stivei, cu scopul de a te

face sa intelegi mai bine conceptul:

Figura 7.6

Cum folosim o Stiva in Java?

Haide acum sa cream o stiva si sa o folosim intr-un exemplu practic. In primul rand vom
folosi clasa Stack, cu ajutorul careia ne vom crea o instanta prin care vom reprezenta
stiva. Prin intermediul acestei instante vom putea folosi functiile deja create in aceasta
clasa (push, pop, isEmpty s i peek).

//In fisierul Stiva vom scrie
public class Stiva {
static final int MAX = 1000; //dimensiunea maxima a stivei
int top;
int a[] = new int[MAX];
Stiva() {
top = -1;
}
boolean isEmpty() {
return (top < 0);
}
_____________________________________________________________________

108

_____________________________________________________________________
boolean push(int x) {
if (top >= (MAX-1)) {
System.out.println("Stiva este plina");
return false;
}
else {
a[++top] = x;
System.out.println(x + " a fost adaugat in stiva");
return true;
}
}
int pop() {
if (top < 0) {
System.out.println("Stiva este goala");
return 0;
}
else {
int x = a[top--];
return x;
}
}
int peek() {
if (isEmpty() == false) {
return a[top];
}
return -9999;
}
}
//intr-un alt fisier numit Main, vom scrie

public class Main {
Stiva s = new Stiva();
s.push(10);
s.push(20);
s.push(30);
System.out.println(s.pop() + " este primul element din stiva");
}
}

_____________________________________________________________________

109

_____________________________________________________________________
Stiva, ca structura de date, este folosita de sistemul de operare in momentul in care aloca
memorie programelor care au nevoie pentru a fi executate. De asemenea, stivele le poti
folosi pentru a sorta, respectiv a procesa anumite tipuri (si formate) de date in diferite
moduri. Foloseste-te de aceasta structura de date de tip LIFO oricand ai nevoie sa rezolvi
o problema de programare, pentru ca este o resursa foarte buna pe care de acum incolo
o vei putea accesa.
Iata in figura de mai jos o ilustratie cu codul din Main si rezultatul in urma compilarii
acestuia in Eclipse.

Figura 7.7

_____________________________________________________________________

110

_____________________________________________________________________
Exercitii
1) Scrie un program prin care sa testati functionalitatea unei stive. Stiva va contine 10
numere, generate aleator (vezi functia Random), de la 1 la 100. Afiseaza elementele din
stiva in ordinea in care au fost procesate (LIFO).

2) Scrie un program cu ajutorul caruia sa sortezi elementele dintr-o stiva. Stiva va contine
elementele: 9 -4 20 1 -1 44 -9 2. Nu ai acces decat la operatiile push(), pop(), top() si
isEmpty().

_____________________________________________________________________

111

_____________________________________________________________________
4) Coada (Queue)

Ce este si cum functioneaza o Coada?

Cozile reprezinta un anumit tip de structuri de date, care au rolul de a retine/mentine
datele, cu scopul de a fi procesate pe rand. Ca mod de functionare, cozile sunt de tipul
FIFO (First In First Out) si merg pe principiul: primul element adaugat in coada este si
primul element care iese din ea. Iata mai jos o ilustratie care exemplifica modul de
functionare:

Figura 7.4

Care sunt functiile unei Cozi?

Dupa cum am spus si mai devreme, coada, ca structura de date, are anumite functii
specifice. Aceste functii arata in felul urmator:
● Add (ENQUEUE) – adauga un element in coada. Adaugarea se poate face doar la

finalul (back) cozii.
● Remove (DEQUEUE) – sterge primul element din coada si il returneaza. Stergerea
se poate face doar la varful cozii (front).
● Peek – intoarce elementul din varful cozii fara a efectua nicio modificare asupra
acesteia.
● isEmpty – intoarce 1 daca coada este goala; 0 daca are cel putin un element.

Cum folosim o Coada in Java?

Haide acum sa cream o coada si sa o folosim intr-un exemplu practic. In primul rand vom
folosi interfata Queue, cu ajutorul careia ne vom crea o instanta prin care vom reprezenta
coada. In Java, Queue find doar o interfata, trebuie sa o initializam cu o clasa, iar in acest
caz am ales LinkedList ( listele inlantuite despre care vorbeam si mai devreme). Iata mai
departe exemplul de utilizare a unei cozi in Java:
_____________________________________________________________________

112

_____________________________________________________________________
import java.util.LinkedList;
import java.util.Queue;
public class QueueTest {
public static void main(String[] args) {
// Definirea instantei unei cozi cu proprietati de lista

Queue<Integer> q = new LinkedList<Integer>();
// Adauga nr. {0, 1, 2, 3, 4} in coada

for (int i = 0; i < 5; i++) {
q.add(i);
}
// Afiseaza elementele din coada

System.out.println("Elementele cozii: " + q);
int elementSters = q.remove();

System.out.println("Elementul eliminat: " + elementSters);
System.out.println(q);
int head = q.peek();

System.out.println("Primul element din coda: " + head);
int size = q.size();

System.out.println("Dimensiunea cozii: " + size);
}
}

Cand folosim cozile si ce aplicabilitate practica au?

In momentul in care dorim ca datele noastre sa fie procesate in ordine, folosirea unei cozi
este recomandata. De asemenea, si in cazul in care aceste date trebuie sa fie procesate
pe rang. In aceasta situatie iti sugerez sa te gandesti la un Router (echipament de retea
care ne conecteaza la Internet). Acest Router primeste mai multe pachete din retea si le
trimite in Internet. Ei bine, ia gandeste-te ce se intampla daca Router-ul primeste prea
multe pachete si nu le poate procesa pe toate (pachetele care nu vor putea fi procesate,
vor fi aruncate).
_____________________________________________________________________

113

_____________________________________________________________________
Ca un astfel de fenomen sa nu se intample, inginerii au adaugat pentru fiecare
port/interfata a unui Router cozi, care sa retina fiecare pachet (care nu poate fi procesat)
in parte. Aceste cozi se umple doar in momentul in care utilizarea interfetei este la 100%.
Pe langa utilitatea in cazul echipamentelor de transmisie a pachetelor in retea, cozile se
mai folosesc si in urmatoarele situatii:
● Memorie Cache - structurata sub forma unei cozi cu scopul de a procesa pe rand
fiecare instructiune
● Functii de cautare - in timpul rularii algoritmilor de cautare, cozile pot fi folosite
pentru retinerea de informatii (ex: algoritmul lui Dijkstra - foloseste o coada de
prioritati - priority queue)
● Retinere a informatiilor care urmeaza a fi procesate


Figura 7.8
_____________________________________________________________________

114

_____________________________________________________________________
Exercitii

1) Scrieti un program prin care sa testati functionalitatea unei cozi. Coada va contine 15
numere, generate aleator (vezi functia Random), de la 1 la -100. Afisati elementele din
coada in ordinea in care acestea sunt procesate (FIFO).

2) Sa se defineasca o clasa MyQueue care sa descrie o structura de date de tip coada.
Datele clasei (private) vor fi urmatoarele:
● un obiect de tip MyArray (clasa inclusa in arhiva laboratorului);

● o constanta (Infinit) avand valoarea 9500;
● indicele primului element din coada;
● indicele ultimului element din coada;
● numarul de elemente din coada.
Constructorul clasei va fi un:
● constructor fara parametri care se ocupa de initializarile membrilor.
Metodele clasei:
● int getSize() = are ca rezultat numarul de elemente din coada;

● void enqueue(int value) = adauga o valoare in coada;
● int dequeue() = intoarce primul element din coada si il elimina, incrementand
indicele corespunzator, fara a elimina efectiv elementul din obiectul de tip
MyArray ( Infinit - coada vida);
● boolean isEmpty() = verifica daca este vida coada;
● String toString() = String cu elementele din structura de date.

_____________________________________________________________________

115

_____________________________________________________________________
5) Dictionare (Hash Maps)

Ce este si cum functioneaza un Dictionar?

In programare dictionarele reprezinta un sir de noduri (figura 7.9) care stocheaza o
pereche de “(cheie, valoare)”. Astfel pentru fiecare cheie (unica) in parte va fi alocata o
anumita valoare (care nu trebuie sa fie unica). Cheile trebuie sa fie unice pentru ca
dictionarul foloseste o tehnica numita hashing.

Hashing-ul este o metoda (un algoritm) prin care se genereaza o valoarea numerica (aka.
hash), care identifica in mod unic acea cheie. Aceasta tehnica permite ca accesarea
elementelor dintr-un dictionar sa fie facuta extrem de rapid in comparatie cu alte structuri
de date. Motivul se datoreaza acestui hash, care permite dictionarului sa acceseze direct
(aproape instant) indexul unde se afla perechea de (cheie, valoare) care doreste a fi
accesata.

Figura 7.9

In figura 7.9 de mai sus poti sa vezi structura dictionarului (care contine mai multe casute
- noduri) si structura fiecarui nod in parte (care este alcatuit dintr-un hash, o cheie, o
valoarea si adresa - locul unde se afla in memorie - urmatorului nod).

Gasesti in figura de mai jos o ilustratie prin care vei putea intelege mai bine cum are loc
maparea perechii cheie - valoarea intr-un dictionar.
_____________________________________________________________________

116

_____________________________________________________________________

Figura 7.10

Care sunt functiile unei HashMap?

Dictionarele (HashMap) au cateva functii de baza care permit introducerea perechilor de
cheie - valoare, cautarea acestora, stergerea lor etc. Hai sa aruncam o privire peste o
parte din acestea:
● Put (cheie, valoare) – adauga o pereche de cheie - valoare in dictionar.

● Remove (cheie)– sterge elementul din dictionar care se afla la si il returneaza.
● Get (cheie) – intoarce elementul din dictionar care se afla la nodul <cheie> a
efectua nicio modificare asupra acesteia.
● ContainsKey (cheie) - intoarce 1 daca dictionarul contine cheia cautata; 0 daca nu
contine acea cheie.
● isEmpty – intoarce 1 daca dictionarul este goal; 0 daca are cel putin un element.
Pe langa aceste functii, exista multa altele, dar am considerat ca acestea sunt cele de
baza cu ajutorul carora vei putea profita de utilitatea acestei structuri de date.

_____________________________________________________________________

117

_____________________________________________________________________
Cum folosim un HashMap (Dictionar) in Java?

Haide acum sa cream un dictionar si sa-l folosim intr-un exemplu practic. In primul rand
vom folosi clasa HashMap, cu ajutorul careia ne vom crea o instanta prin care vom
reprezenta un dictionar. Prin intermediul acestei instante vom putea folosi functiile deja
create in aceasta clasa (put, get, remove, etc.).

import java.util.*;
public class HashDemo {

// Crearea unui dictionar de tipul HashMap

HashMap<String, Double> dictionar = new HashMap();
/ Adaugarea elementelor in dictionar

/
//- Persoana si contul bancar in EUR
dictionar.put("Ana", 3434.34);
dictionar.put("Alex", 123.22);
dictionar.put("Dan", 1378.00);
dictionar.put("Ion", 99.22);
dictionar.put("Claudiu", -19.08);
/ Parcurgerea dictionarului prin folosirea unui for

/
or( Map.Entry<String, Double> entry : dictionar.entrySet()) {
f
System.out.print(entry.getKey() + ": ");

System.out.println(entry.getValue());
}
// Depozitarea a 1000 EUR in contul lui Ion

double valoareCont = dictionar.get("Ion").doubleValue();
dictionar.put("Ion", valoareCont + 1000);
System.out.println("Noul cont al lui Ion: "
+ dictionar.get("Ion"));
}
}
_____________________________________________________________________

118

_____________________________________________________________________
Cand folosim Dictionarele si ce aplicabilitate practica au?

Dictionarele sunt folosite in tabelele de rutare pentru ca routerele trebuie sa decida unde
sa trimita traficul: catre retea sau catre portul spre care poate trimite. Dictionarele sunt
folosite:
● In retelistica, pe Routere, in crearea tabelelor de rutare.

● In stocarea parolelor in baza de date. Deoarece parolele sunt criptate, ele au un
hash stocat in baza de date. In momentul in care tu trimiti parola, serverele
lucreaza sa o puna intr-o functie si intr-un hash. Cheia este parola, hash-ul este
valoarea acelei chei, deci acesta este un alt exemplu de dictionar.


Figura 7.11
_____________________________________________________________________

119

_____________________________________________________________________
Exercitii

1) Scrieti un program prin care sa asociati o valoare unei chei anume. Pentru asta folositi
un HashMap c are va face asocierea intre numele unei persoane (cheia) si varsta ei
(valoarea). Introduceti 5 persoane din cercul apropiat de prieteni dupa care afisati datele
introduse in urmatorul format:
“El este <nume>. Saluta-l pe <nume>. Are <varsta> ani si este tot mai fericit pe zi ce
trece.”

_____________________________________________________________________

120

_____________________________________________________________________
BONUS: Capitolul 8 - Versiunea codului cu Git si

GitHub
Ce este Git si GitHub?
Hai sa vedem cum iti poti salva si cum iti poti apoi accesa codul in orice moment. Git si
GitHub este din ce in ce mai utilizat si cerut de catre toti angajatorii. Reprezinta un
software ce te ajuta la versionarea codului tau si chiar in management-ul codului sursa
(SCM).

Git-ul te ajuta sa iti salvezi codul scris, online. Iar cel mai mare avantaj este ca tu si ceilalti
programatori dintr-un proiect puteti vedea schimbarile pe care le faceti in cod. Pe langa
asta, poti si gasi anumite solutii pe problemele pe care le intampini in cod.

Creatorul Linux, pe numele lui Linus Torvalds, este cel care s-a gandit la o metoda de
versionare a codului, in momentul in care a considerat ca este nevoie ca mai multi
programatori sa lucreze la versiunea sa de Linux.

Hai sa vedem in ce context ai putea folosi Git-ul. De exemplu, daca vrei sa construiesti pe
baza a ceea ce ai lucrat deja sau sa aduci si alte persoane care sa contribuie la munca ta,
nu poti tine codul pe calculatorul tau pentru ca va deveni dificil ca si altii sa acceseze si
sa lucreze cu ceea ce tu ai facut pana la momentul respectiv.

Un alt exemplu ar fi ca, dupa ce ai scris cod si ai adaugat ceva acum 3 zile, te anunta
testerul de software ca 90% din codul scris in ultimele 3 zile trebuie rescris, conform
modificarilor in cerinta initiala (presupunand ca sunteti echipa mica). Prin GitHub te poti
intoarce la versiunea de acum 3 zile si poti incepe sa lucrezi la asta fara ca tu manual sa
stergi fiecare linie de cod adaugat in cele 3 zile.

Bun bun, dar este folositor Git-ul pentru proiecte mari cu o echipa mai complexa?
Raspunsul este da. Tocmai aici se vede cat de util poate fi. O echipa complexa inseamna
o echipa care are membrii cu diferite roluri si chiar diferite drepturi pe proiect. Cei cu rol
de tester pot colabora cu developerii, intre timp project managerul poate monitoriza cine,
unde si ce a adaugat.

_____________________________________________________________________

121

_____________________________________________________________________
Simplu spus, prin folosirea Git, altii vor putea adauga si isi pot pune amprenta pe codul
deja creat de tine. INTRA AICI pentru a afla mai multe despre Git si GitHub.

Multi programatori folosesc GitHub pentru a-si stoca ceea ce au codat si pentru a-si crea
un portofoliu pe care angajatorii il pot oricand vizualiza. Este extrem de important sa ai
cont pe GitHub daca iti doresti o cariera in IT. Sa nu mai vorbesc ca poti colabora cu alti
programatori ce vor aduce imbunatatiri codului tau. Pe langa GitHub, te mai poti folosi de
GitLab si Atlantis, care fac exact aceleasi lucruri, dar au doar cateva mici diferente de
design.
Cum folosim Git pentru versionarea codului?
De ce este important sa iti faci back-up la cod in Git? Versionarea codului este necesara,

deoarece un program se scrie pe o perioada indelungata de timp, iar salvarile anumitor
etape sunt absolut necesare pentru a te intoarce la versiunea codului pe care o doresti
sau la versiunea care este corecta. Exemplele anterioare sunt doar cateva dintre cele
simple, un intreg flow de dezvoltare al unui produs final fiind mult mai complicat in
realitate, pentru echipele mari.

Am amintit deja ca Git este foarte util atunci cand mai multi programatori lucreaza la
acelasi cod si aduc propriile lor versiuni de cod, ce pot fi mai mult sau mai putin bune.
Acum ca tot mai multi programatori aplica “laptop lifestyle”, adica isi iau laptopul si
lucreaza cand, cat si mai ales de unde doresc ei atata timp cat au acces la Internet, este
evident ca multi programatori care colaboreaza nu se afla in aceeasi tara, deci au diferite
zone de timp (fusuri orare).

Git-ul are avantajul de a mentine integritatea codului sursa . Asta datorita posibilitatii
lucrului pe diferite “branch”-uri, adica pe diferite ramuri (pe care se lucreaza) care nu intra
in conflict in momentul in care, sa zicem ca, mai multi programatori lucreaza pentru
aceeasi aplicatie.

Am putea sa ne uitam la un “repository” ca la un depozit in care practic chiar depozitam
un intreg proiect, cu toate fisierele si folderele din care acesta este compus, dar care pe
langa asta contine si un istoric al modificarilor/revizuirilor care au avut loc in fiecare fisier
in parte. In Git, oricine care are o copie locala (pe propriul PC) al repository-ului are acces
la intreaga baza de date a schimbarilor care au avut loc asupra codului, cu istoricul lor cu
tot.

_____________________________________________________________________

122

_____________________________________________________________________
Acum, daca tot avem o baza de date a intregului istoric al codului, cu toate fisierele si
folderele din el, ce putem face cu acesta si cum anume? Pentru a interactiona cu codul,
putem folosi linia de comanda sau un program cu interfata grafica. Mai concret:
● Putem clona istoricul sau putem interactiona cu el
● Putem crea branch-uri
● Putem da commit la ce am scris noi (acest commit se face local)
● Putem face merge
● Putem schimba si testa diferite versiuni ale codului, etc.

Hai sa vedem comenzile pe care sa le dam pentru a configura contul de GitHub si cum
se seteaza mai multi useri ce pot lucra la codul tau. Dupa asta vom adauga in Repository
si vom modifica codul astfel incat munca ta sa evolueze in directia cea buna. Bineinteles,
te poti oricand intoarce la anumite salvari ale codului tau, deci nu fi speriat daca ai gresit
ceva. Este posibil ca oricand sa reincepi de la un nivel in care erai multumit. INTRA AICI
pentru a vedea cum sa folosesti Git.
Cum urcam codul pe GitHub?
Stocand munca ta intr-o baza de date (repository) din GitHub, vei avea posibilitatea sa
revii oricand la stadii din proiectele tale si sa inviti alte persoane sa contribuie la codul
tau.

Poti avea repository-uri publice si private, acestea din urma trebuind sa fie platite. Sunt
multe alte platforme asemenatoare cu GitHub, dar aceasta este totusi cea mai cunoscuta
pentru cod open source. Sa nu mai vorbesc ca marea majoritate a angajatorilor se ajuta
foarte mult de ea si cer aplicantilor la job-urile lor sa-si prezinte portofoliul aici .

Acum vei afla cum sa accesezi codul tau in GitHub, cum sa-l downloadezi si cum sa-l
copiezi sau modifici. Bineinteles ca poti lua bucati de cod din anumite repository-uri si sa
lucrezi la ele, dupa care sa le urci inapoi in repository-ul de care apartin si sa astepti sa
vezi daca ai avut o contributie de succes, care multumeste pe toata lumea.

Vei invata cum sa-ti creezi repository- urile tale si cum sa urci munca ta pe platforma. Poti
vedea cine a adaugat ceva codul tau, urmarind commit- urile ce s-au facut. Urmareste
acest video BONUS pentru a vedea cum poti face asta: INTRA AICI.

_____________________________________________________________________

123

Ebook Programare in Java PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Ebook Programare in Java PDF

Încărcat de

Drepturi de autor:

Formate disponibile

Introducere in Programare cu Java:

Copyright 2018 Ramon Nastase – Toate drepturile rezervate.

● Cum arata domeniul IT si care sunt trendurile

Capitolul 0 - Introducere in Programare 7

Capitolul 1 - Introducere in Programare in limbajul Java 11

Capitolul 2 - Variabile in Java 24

Capitolul 3 - Instructiuni conditionale (if, for, while) 31

Capitolul 4 - Metode in Java 45

Capitolul 5 - Concepte de POO in Java 57

Capitolul 6 - Exceptiile in Programare si Operatiile cu Fisiere in Java 82

Capitolul 7 - Structuri de Date in Java 97

Cum folosim o Lista (inlantuita) in Java? 103

BONUS: Capitolul 8 - Versiunea codului cu Git si GitHub 121

Capitolul 0 - Introducere in Programare

2) Java pentru Programare Server Side

Capitolul 1 - Introducere in Programare in limbajul

Cunoscand ​limbajul de programare Java vei putea construi aplicatii in Android si pentru

Cum Creez Main Class in Eclipse ?

​ /acesta este un comentariu in care pot sa scriu orice

​/* Testul de mai jos nu se va afisa */

Capitolul 2 - Variabile in Java

● Numere naturale - ​unsigned int

The total sum is: 15

Hai sa cream si un String:

String abc = ​"Abc"​;

Te poti juca in foarte multe moduri cu ​string​-urile. Poti face foarte multe. Toate variabilele

System.out.println(​"The total sum is:"​ + sum);

Variabila de tip ​unsigned​​ ​int​​ va retine valoarea ​20

x = ​…valoare care se va calcula pentru x…

Capitolul 3 - Instructiuni conditionale (if, for, while)

● Instructiunea ​if ​- daca se respecta conditia X, atunci se intampla Y

● A ​>​ B - se verifica daca A este ​mai mare​​ ca B

1.2) Instructiunea ​ELSE

Iata cum arata in Eclipse expresia de mai sus:

"Canditatul X a raspuns astfel la intrebarile de mai sus: ..."

3) ​Creeaza un program care determina daca un cuvant (​string​) introdus de catre utilizator

4.2) ​Dinamizeaza programul prin adaugarea optiunii de introducere a celor 2 numere (nr.

5) ​Creeaza un joc Piatră-hârtie-foarfecă la care participa 2 persoane. (Nota: folositi-va de

Capitolul 4 - Metode in Java

Metode care nu intorc un rezultat

Rezultatul secventei de cod din figura 4.1 este urmatorul:

Metode care intorc un rezultat

public​ ​static​ ​void​​ ​helloFunction​(String name, ​int​ a, ​int​ b) { }

public​ ​static​ ​int​​ ​helloFunction​(String name, ​int​ a, ​int​ b) { }

in fata, si astfel functia va arata:

Your name is

Dar nu este gata. Sus, in ​main,​ trebuie sa adaugam:

Your name is John

17 – Total number of characters

4.67, 8.93, 10.00

Capitolul 5 - Concepte de POO in Java

POO vs. Programare Procedurala

Programele sunt alcatuite din ​module​​. Aceste module pot fi programe de sine statatoare

O alternativa la programarea procedurala este programarea orientata pe obiecte. Scopul

mod direct, ele nefiind vizibile (pentru ca sunt private), dar modificarile vor putea fi facute

Scurt rezumat a celor discutate mai sus

public​ ​class​ ​ClasaPrincipala​ {

public​ ​class​ ​ClasaPrincipala​ {

●Definirea valoarea maxima (sau minima) prin comparatie a 2 variabile ​Integer

String b = a.substring(0, 1);

public​ ​class​ ​ClasaMea​ {

public​ ​class​ ​ClasaMea​ {

John numarul este: 10

Cunoscand limbajul de programare Java vei putea construi aplicatii in Android si pentru

/acesta este un comentariu in care pot sa scriu orice

/* Testul de mai jos nu se va afisa */

● Numere naturale - unsigned int

String abc = "Abc";

Te poti juca in foarte multe moduri cu string-urile. Poti face foarte multe. Toate variabilele

System.out.println("The total sum is:" + sum);

Variabila de tip unsigned int va retine valoarea 20

x = …valoare care se va calcula pentru x…

● Instructiunea if - daca se respecta conditia X, atunci se intampla Y

● A > B - se verifica daca A este mai mare ca B

1.2) Instructiunea ELSE

3) Creeaza un program care determina daca un cuvant (string) introdus de catre utilizator

4.2) Dinamizeaza programul prin adaugarea optiunii de introducere a celor 2 numere (nr.

5) Creeaza un joc Piatră-hârtie-foarfecă la care participa 2 persoane. (Nota: folositi-va de

public static void helloFunction(String name, int a, int b) { }

public static int helloFunction(String name, int a, int b) { }

Dar nu este gata. Sus, in main, trebuie sa adaugam:

Programele sunt alcatuite din module. Aceste module pot fi programe de sine statatoare

public class ClasaPrincipala {

public class ClasaPrincipala {

●Definirea valoarea maxima (sau minima) prin comparatie a 2 variabile Integer

public class ClasaMea {

public class ClasaMea {

Person (int age, String fname) {

Person(int age, String fname, String lname, String sex) {

public String toString() {

Vom face acelasi lucru pentru B, tot din Main:

In primul exemplu va aparea Unknown si Anonymous p

public void sayHello() {

public int g etAge() {

System.out.println("This person " + A.fname + " has " + A.age + "

public String get fName() {

Astfel, codul complet din clasa Person v a fi urmatorul:

public int getAge() {

public void sayHello() {

In Main, vom scrie pentru a modifica si a printa:

Null apare pentru ca nu am definit lname. Putem sa il setam in Main:

5) Sa se implementeze o clasa PasswordMaker care genereaza, folosind

● Imposibilitatea citirii unui fisier de pe disk (ex: File Not Found)

int[] vec = new int[15];

for(int i = 0; i < 16; i++) {

nt[] vec = new int[15];

System.out.println("Programul a fost finalizat cu succes");

public class MyClass {

System.out.println("Programul a fost finalizat cu succes");

// acesta variabila contine nimic, null

System.out.println("Programul a fost finalizat cu succes");

// acesta variabila contine un text random

for(int i = 0; i < lungime + 1; i++) {

System.out.println("Programul a fost finalizat cu succes");

catch vom incerca sa prindem exceptia StringIndexOutOfBoundsException, doar ca

System.out.println("Introdu adresa de email: ");

System.out.println("Introdu numele tau: ");

System.out.println("Introdu varsta ta: ");

String fileLocationMac = "/Users/ramon/Desktop/fisierIntrare.txt";

while ((c = in.read()) != -1) {

String text = "Hello World, new world";

public class FileTest {

String currentDir = System.getProperty("user.dir")

while ((c = in.read()) != -1) {

int[] exempluVector = new int[15];

for(int i = 0; i < exempluVector.length; i++) {

● AddFirst – adauga un element in fruntea listei