NDËRVEPRIMI MIDIS OBJEKTEVE

Deri tani kemi mësuar si mund të krijojmë një projekt në Java, një klasë brenda
këtij projekti, duke krijuar pastaj më tepër objekte nga kjo klasë.

Zakonisht projektet në Java janë më të mëdha dhe përfshijnë më shumë se një

klasë brenda tyre. Kur programet rriten në madhësi (rritet numri i rreshtave të
kodit), është e nevojshme që ky program të ndahet në pjesë më të vogla, me
qëllim të thjeshtëzimit të programit. Ky proces quhet modularizim i programit –
programi ndahet në module të cilat ndërtohen ndarazi, dhe pastaj ndërveprojnë
midis tyre në mënyrë më të thjeshtë. Përfitimet e modularizimit janë:

 Një procedurë e njëjtë mund të ripërdoret pa patur nevojë për rishkrim të

saj. Si rezultat i kësaj kemi numër më të pakët të rreshtave të kodit
 Dizajnimi i aplikacioneve është më i lehtë sepse një grup i caktuar
programuesish merret vetëm me një pjesë të moduleve dhe nuk ka nevojë
për të kuptuar modulet tjera të cilat programohen nga programues tjerë
 Kodi mund të ndahet në më shumë fajle
 Kodi është i shkurtër, i thjeshtë dhe lehtë i kuptueshëm
 Gabimet lokalizohen dhe identifikohen më lehtë
Në programimin e orientuar në objekte modularizimi përdoret për ndarje të
problemit duke implementuar më tepër klasa. Nga këto klasa pastaj krijohen
objekte të ndryshme. Ndërveprimi midis tyre është mirë i definuar nëpërmjet
metodave të tyre.

Për të ilustruar më mirë ndërveprimin midis objekteve do të vazhdojmë me kodin

tonë që ka të bëjë me klasën Student. Supozojmë se duam të shtojmë një fushë të
re që ka të bëjë me adresën e studentit. Normalisht, kjo fushë duhet të përmbajë
minimalisht informacion rreth qytetit, rrugës dhe numrit. Fushat e klasës Student
në këtë rast do të ishin:

1. public class Student {

2. // emri i studentit
3. private String emri;
4. // id e studentit
5. private int id;
6. // kreditet e studentit
7. private int kredite;
8. // Adresa e studentit:
9. private String rruga;

31
10. // Rruga
11. private int numri;
12. // Numri
13. private String qyteti;
14. // Qyteti
15. ...
16. }

Meqë tre fushat qyteti, rruga dhe numri i takojnë një kategorie që është adresa, ne
problemin mund ta modularizojmë duke krijuar një klasë të veçantë të cilën mund
ta quajmë Adresa:

1. public class Adresa {

2. // Adresa:
3. // Rruga
4. private String rruga;
5. // Numri
6. private int numri;
7. // Qyteti
8. private String qyteti;
9. ...
10. }

Në klasën Student tani do të shtojmë një fushë të re adresa, e cila do të jetë e tipit
Adresa:

1. public class Student {

2. // emri i studentit
3. private String emri;
4. // id e studentit
5. private int id;
6. // kreditet e studentit
7. private int kredite;
8. // Adresa e studentit:
9. private Adresa adresa;
10. ...
11. }

32
Fusha e re adresa është objekt i tipit Adresa19. Themi se me klasën e sapokrijuar
Adresa është krijuar një tip i ri i të dhënave, nga i cili mund të krijohen objekte të
reja. Ky quhet tipi i definuar nga përdoruesi20. Deri tani ne kemi përdorur tipe të
dhënash të definuara nga sistemi (gjuha programuese) si int, float, double etj. Këto
lloj tipesh të dhënash quhen tipe primitive. Me një tip primitiv deklarohen
ndryshore (ose variabla). Kur ne shkruajmë:

int numri;

rezervohet një vend në memorie, të cilit i referohemi me emrin numri:

numri

Nëse shkruajmë diku më vonë në kod:

numri = 5;

në lokacionin e vendosur në memorie do të vendoset vlera 5:

numri
5

Me një tip të definuar nga përdoruesi, të definuar nëpërmjet të një klase,

definohet një objekt. Ndryshorja me të cilën definohet objekti nuk përmban
objektin (vlerën e tij), por përmban referencën e këtij objekti (adresën e lokacionin
ku ndodhet ky objekt në memorie):

19
Vini re dallimin midis Adresa dhe adresa – meqë shkronja e parë ka dallim në madhësi,
këto dy gjëra janë të ndryshme. Ju mund të përdorni një emër tjetër për objektin e Adresa
si p.sh. adrese, adr, a, ad etj.
20
Përdoruesi është në fakt programuesi

33
 adresa

Adresa:
rruga
numri
qyteti

Pas kompajlimit të klasave të sapokrijuara, do të shohim se klasat paraqiten të

lidhura me një relacion midis tyre siç vijon:

Figura 18. Relacioni midis klasave

Ky relacion quhet relacioni “ka një” ose “përdor një”21. D.m.th. një klasë ka një
fushë që është e tipit të klasës tjetër. Ekziston edhe një tip tjetër i relacionit midis
klasave dhe ky është relacioni “është një”, por për këtë do të flasim më vonë.

Tani vazhdojmë me ndërtimin e klasës Adresa. Do të shtojmë konstruktorin me

parametra, një metodë që vendos të dhënat për adresën dhe një metodë tjetër që

21
Në gjuhën angleze “has a” ose “uses a”.

34
kthen të dhënat për adresën të formatuar sipas formatit që zakonisht jemi mësuar
ta shohim për adresat.

Të shtojmë së pari konstruktorin me parametra për të gjitha fushat:

1. public class Adresa {

2. // Adresa:
3. // Rruga
4. private String rruga;
5. // Numri
6. private int numri;
7. // Qyteti
8. private String qyteti;
9. public Adresa(String Rruga, int Numri, String Qyteti)
10. {
11. rruga = Rruga;
12. numri = Numri;
13. qyteti = Qyteti;
14. }
15. ...
16. }

Kemi thënë që parametrat kanë emra të ndryshëm nga fushat. Për thjeshtësim deri
tani për emra parametrash kemi vënë emrat e fushave, me atë se ato fillojnë me
shkronjë të madhe, duke mbajtur llogari se fushat fillojnë me shkronjë të vogël.
Gjuha programuese Java ofron një mundësi për të dalluar fushat e saj nga
ndryshore të tjera që mund të kenë të njëjtin emër. Kjo realizohet më ndihmën e
operatorit this, shoqëruar nga operatori pikë (‘.’). Kur shkruajmë:

this.fusha

bëhet fjalë për variabël e cila definon ndonjë nga fushat e klasës. Kodi i mësipërm
me ndihmën e këtij operatori tani mund të shkruhet si:

1. public class Adresa {

2. // Adresa:
3. // Rruga
4. private String rruga;
5. // Numri
6. private int numri;
7. // Qyteti
8. private String qyteti;

35
9. public Adresa(String rruga, int numri, String qyteti)
10. {
11. this.rruga = rruga;
12. this.numri = numri;
13. this.qyteti = qyteti;
14. }
15. ...
16. }

Pasiqë të kemi shtuar kodin për dhënie të vlerave të adresës dhe kthimit të tyrë në
një format teksti të vetëm, do të kemi kodin:

1. public class Adresa {

2. // Adresa:
3. // Rruga
4. private String rruga;
5. // Numri
6. private int numri;
7. // Qyteti
8. private String qyteti;
9. public Adresa(String rruga, int numri, String qyteti)
10. {
11. this.rruga = rruga;
12. this.numri = numri;
13. this.qyteti = qyteti;
14. }
15. public void setAdresa(String rruga, int numri, String
16. qyteti)
17. {
18. this.rruga = rruga;
19. this.numri = numri;
20. this.qyteti = qyteti;
21. }
22. public String jepAdresen() {
23. return "Rruga \"" + rruga + "\" Nr. " + numri +
24. ", " + qyteti;
25. }
26. }

Vërejmë që kodi i konstruktorit dhe metodës setAdresa është i njëjtë, prandaj

mund të bëjmë ndryshim në kod (pa i ndryshuar funksioni), në atë mënyrë që nga
konstruktori të thirret metoda në fjalë:

36
1. public class Adresa {
2. // Adresa:
3. // Rruga
4. private String rruga;
5. // Numri
6. private int numri;
7. // Qyteti
8. private String qyteti;
9. public Adresa(String rruga, int numri, String qyteti)
10. {
11. setAdresa(rruga, numri, qyteti);
12. }
13. public void setAdresa(String rruga, int numri, String
14. qyteti) {
15. this.rruga = rruga;
16. this.numri = numri;
17. this.qyteti = qyteti;
18. }
19. public String jepAdresen() {
20. return "Rruga \"" + rruga + "\" Nr. " + numri +
21. ", " + qyteti;
22. }
23. }

Tani do të fillojmë me ndryshimet në klasën Student. Pasiqë kemi shtuar një fushë
të re adresa, së pari duhet të fillojmë me ndryshimet në konstruktor. Siç kemi
thënë më herët, roli kryesor i konstrukorit është dhënia e vlerave fillestare për
fushat. Deri tani të gjitha fushat kanë qenë të tipit primitiv. Kur kemi fushë e cila
tregon në një objekt, në konstruktur duhet që ky objekt të krijohet. Krijimi bëhet
me fjalën e rezervuar new:

variabla = new emriKlases(parametrat)

Operatorin new e kemi përdorur gjatë krijimit të objekteve në BlueJ (shih Figurën
5). Ky përdorim ka qenë vetëm me përdorim të mausit, ndërsa tani këtë operator
da ta përdorim për krijim të objekteve të reja brenda kodit. Do të bëjmë ndryshim
në dy konstrukorë, njëri pa parametra dhe tjetri me parametra:

1. public class Student {

2. // emri i studentit
3. private String emri;
4. // id e studentit

37
5. private int id;
6. // kreditet e studentit
7. private int kredite;
8. // Adresa e studentit:
9. private Adresa adresa;
10. public Student() {
11. emri = "i panjohur";
12. id = 0;
13. kredite = 0;
14. adresa = new Adresa("", 0, "");
15. }
16. public Student(String emri, int id, String rruga, int
17. numri, String qyteti) {
18. this.emri = emri;
19. this.id = id;
20. this.kredite = 0;
21. adresa = new Adresa(rruga, numri, qyteti);
22. }
23. ...
24. }

Do të shtojmë edhe një metodë e cila kthen vlerën e adresës në formë teksti:

1. public String getAdresa() {

2. return adresa.jepAdresen();
3. }

Shohim se kjo metodë thërret metodën jepAdresen() të klasës Adresa. Një metodë
e një klase tjetër thërritet duke përdorur operatorin pikë (‘.’), të cilin ia
bashkangjesim objektit i cili i përket klasës tjetër:

objekt.metodaKlases(lista e parametrave)

Në fund do të bëjmë ndryshim edhe në metodën print(), meqenëse tani kemi

informacion shtesë rreth studentit dhe duam edhe këto informacione të shfaqen
në output22:

1. public String print() {

2. System.out.print('\u000C');

22
Shprehja System.out.print('\u000C'); na shërben për të fshirë shfaqjen e mëparshme në
output, gjatë ndonjë debagimi të njëpasnjëshëm

38
3. System.out.println("Emri: " + emri + ", ID: " + id + "
4. , Kredite: " + kredite + "\nAdresa: " + getAdresa());
5. }

Metodat tjera të klasës Student, ngelin ashtu siç i kemi definuar më herët. Pas
kompajlimit të klasës, kur të krijojmë një objekt të ri, do të shohim se tani kërkohet
edhe informacion për adresën e studentit:

Figura 19. Krijimi i një objekti Student pas ndryshimeve rreth adresës

Nëse e testojmë metodën print(), do të shohim ndryshimet që janë bërë:

Figura 20. Metoda print() pas ndryshimit në klasën Student

Ne mund të ndryshojmë mënyrën se si shfaqet adresa në klasën Adresa, dhe ky

ndryshim do të reflektohet në metodën print() të klasës Student pa bërë asnjë

39
ndryshim në këtë të fundit. P.sh. nëse në metodën jepAdresen() të klasës Adresa,
pjesën “Nr.” e heqim:

1. public String jepAdresen() {

2. return "Rruga \"" + rruga + "\" " + numri + ", " +
3. qyteti;
4. }

Kur të ekzekutojmë metodën print(), do të kemi:

Figura 21. Metoda print() pas ndryshimit në klasën Adresa

Kjo është një ndër benefitet e programimit të orientuar në objekte – modularizimi i

programeve në klasa të pavaruara nga njëra tjetra, në atë mënyrë që kur bëhen
ndryshime në njërën klasë, klasa tjetër nuk ka nevojë të informohet për këtë gjë,
për sa kohë emri i metodës që thirret, së bashku me listën dhe tipin e
parametrave, ngelet i njëjtë.

40