42
Univerzitet u Novom Sadu Tehnički fakultet »Mihajlo Pupin« Zrenjanin SEMINARSKI RAD Objekti i klase Ime i prezime studenata: Dušan Panić, Angela Cini Broj dosijea: MBI 20/16, MBI 23/13 1

Objekti i klase

Embed Size (px)

DESCRIPTION

Java, Objekti i klase

Citation preview

Page 1: Objekti i klase

Univerzitet u Novom Sadu

Tehnički fakultet »Mihajlo Pupin« Zrenjanin

SEMINARSKI RAD

Objekti i klase

Ime i prezime studenata: Dušan Panić, Angela CiniBroj dosijea: MBI 20/16, MBI 23/13Smer: Informacione tehnologije u e-upravi i poslovnim sistemima

Predmet: E upravaPredmetni nastavnik: prof. dr Miodrag IvkovićPredmetni asistent: mr Dejan Lacmanović

Zrenjanin, 2014

1

Page 2: Objekti i klase

Sadržaj

1. Uvod...................................................................................................................................................3

2. Objekti................................................................................................................................................5

2.1. Deklarisanje objekata......................................................................................................................6

2.2. Brisanje objekata.............................................................................................................................8

2.3. Reference na objekat.....................................................................................................................10

3. Klase.................................................................................................................................................17

3.1. Definisanje klasa...........................................................................................................................17

3.2. Pristupanje članovima klasa..........................................................................................................18

3.3. Polja klasa.....................................................................................................................................19

3.4. Metode klasa.................................................................................................................................20

3.4.1. Sastav metode............................................................................................................................21

3.4.2. Parametrizirane metode..............................................................................................................21

3.4.3. Konstruktori...............................................................................................................................21

3.4.4. Rezervisana reč this...................................................................................................................23

3.4.5. Sakrivanja atributa klasa preko parametara metoda...................................................................24

3.4.6. Sakupljanje smeća......................................................................................................................25

3.4.7. Metoda finalize..........................................................................................................................25

3.4.8. Preklapanje metoda....................................................................................................................26

3.4.9. Preklapanje konstruktora............................................................................................................27

3.4.10. Prenos argumenata metoda......................................................................................................27

3.4.11. Ključna reč static......................................................................................................................29

4. Zaključak..........................................................................................................................................32

5. Literatura...........................................................................................................................................33

2

Page 3: Objekti i klase

1. Uvod

Java je objektno orijentisani programski jezik, čiji je tvorac James Gosling iz Sun Microsistems-a. Objektno orijentisano programiranje (OOP) je pristup realizaciji softvera kao modela realnog sveta. U OOP-u se u problemu identifikuju objekti koji nešto rade i apstrakcije koje predstavljaju skupove objekata istih svojstava. Objekat ima svoje unutrašnje stanje čija je realizacija nedostupna drugim objektima i operacije (akcije) koje se nad njim mogu vršiti spolja. Objekti međusobno sarađuju izvršavanjem operacija.

Java je zamišljena kao jednostavan, platformski nezavistan jezik namenjen pokretanju elektroskih uređaja kao što su interaktivna TV, inteligentne rerne, telefoni i slične naprave. Eksplozijom web-a 1994. godine inžinjeri Sun-a ugrađuju Javu u web browser WebRunner, a početkom 1995. objavljuju izvorni kod i dokumentaciju na internetu. Java postaje sve popularniji programski jezik zbog sledećih svojstava:

Objektna orijentacija - Java je objektno orijentisani jezik koji podržava sve koncepte OO programiranja. Njena sintaksa nalikuje sintaksi C++ jezika, ali su iz nje izbačeni složeni koncepti C++ za koje se smatralo da zbunjuju programere ili prave probleme.

Prenosivost - Java izvorni programi se prevode u takozvani bajt kod koji nije mašinski jezik nijednog konkretnog računara, već se izvršava na Java Virtuelnoj Mašini (VM). Java Virtuelna Mašina je virtelni računar koji može biti simuliran na bilo kojem računaru. Time je postignuto da Java programi mogu da se izvršavaju na raznim platformama bez potrebe za prepravljanjem. Java stranice se mogu prenositi sa jedne platforme na drugu, ili promeniti Web server, ponašanje aplikacije će biti potpuno isto.

Prirodna prilagođenost internetu - Java programi mogu da se izvršavaju u Web browserima, poseduje sigurnosne mehanizme, njeni delovi koda mogu u realnom vremenu da se distribuiraju i izvršavaju na različitim mašinama, podržava konkurentno programiranje i njene predefinisane klase za korisnički interfejs (API) omogućuju jedinstven izgled i korišćenje aplikacija.

Odvojen statički od dinamičkog sadržaja: Kada se klijentski sadržaj generiše u okviru servleta, logika stvaranja dinamičkog sadržaja je sastavni deo koda servleta. Takođe statički deo klijentske strane je “sakrivena” u okviru servleta. Pored otežanog praćenja samog koda, nakon svake, pa i najmanje promene, servlet se mora ponovo kompajlirati. Sve ovo prouzrokuje stvaranje aplikacije čija se logika veom ateško razume, a svaka promena zahteva određeno vreme.

Dinamički sadržaj se može predstaviti u različitim formatima: Ne postoji pravilo u kom formatu staitički (template) deo java stranice mora da bude. Tako, da java stranica može koristiti standardni HTML/DHTML kod koji se može izvržavati pomoću browser-a, ili WML kod koji se izvršava na hanheld bežičnim uređajima, dok novije aplikacije koriste XML kod.

Dobijanje Web pristupnog nivoa kod aplikacija n-slojnr arhitekture: Standardna Sunova dokumentacija J2EE TM Blueprints, koja predstavlja glavni vodič za implementaciju složenih Java aplikacija pomoću enterprise Java klasa i JavaBeans, kategorično preporučuje korišćenje JSP stranica u odnosu na servlete za generisanje klijentske strane aplikacije.

Potpuna usklađenost sa servlet tehnologijom: Za svakog servlet programera, potrebno je veoma malo truda i vremena za razumevanje JSP tehnolgije. U stvari, servlet programeri su u velikoj

3

Page 4: Objekti i klase

prednosti, jer je su JSP stranice u stvari servelti pisani na velikom nivou apstrakcije. Sve što se može uraditi sa servletima, može i pomoću JSP stranica, ali mnogo jednostavnije!

Java kod prevodi se u u tzv. „bytecode“ kojeg pokreće operativni sistem, drugi program ili uređaji pomoću Java prevodioca. Bytecode nije izvršni kod, već visokooptimizirani skup instrukcija dizajniran za izvršavanje unutar Java izvršnog sistema koji se naziva Java Virtual Machine – JVM koji je prevodilac za bytecode.

4

Page 5: Objekti i klase

2. Objekti

U objektno-orijentisanom programiranju osnovnu ulogu imaju objekti koji sadrže i podatke i funkcije (metode). Program se konstruiše kao skup objekata koji međusobno komuniciraju. Podaci koje objekat sadrži predstavljaju njegovo stanje, dok pomoću metoda on to stanje može da menja i komunicira sa drugim objektima.

Klasa je osnovna jedinica programiranja u Javi. Klase obezbeđuju strukturu objekata, kao i mehanizme za proizvodnju objekata, na osnovu datih definicija u klasi. Klase definišu metode, skupove izvršivog koda, koje izračunavaju podatke i njima upravljaju unutar objekta. One obezbeđuju ponašanje objekata klase.

Grady Booch, jedan od pionira objektno orijentisanog programiranja koristi sledeću definiciju objekta: Objekat ima stanje, ponašanje i identitet. Struktura i ponašanje sličnih objekata su definisani njihovom zajedničkom klasom.

Stanje nekog objekta obuhvata sve statičke (nepromenljive) osobine objekta, zajedno sa trenutnim vrednostima dinamičkih osobina. Činjenica da svaki objekat ima stanje implicira da svaki objekat zauzima neki prostor, bilo da je reč o stvamom svetu, ili o memoriji računara. Nijedan objekat ne postoji samostalno. Objekti komuniciraju sa drugim objektima. U skladu sa tim možemo reći, da ponašanje pokazuje kako se objekti ponašaju i reaguju, u smislu promene njihovog stanja i razmene poruka. Drugim rečima ponašanje objekta predstavlja njegove vidljive aktivnosti. Operacija predstavlja neku akciju koju jedan objekat obavlja da bi od drugog izmamio reakciju. Klijent na primer, može pozvati operaciju length, koja vraća vrednost koja označava dužinu nekog objekta. Identitet je osobina objekta koja ga razlikuje od svih drugih objekata.

U programiranju posebnu pažnju treba obratiti na razliku između imena objekta i samog objekta. Mogu postojati (često i postoje) više imena za isti objekat, ali to ne znači da su u pitanju različiti objekti.

Objekat:

ima podatke ima metode ima jedinstvenu adresu u memoriji predstavlja instancu neke konkretne klase

Objekti predstavljaju osnovni koncept objektno-orijentisane paradigme u modelovanju sistema. Svaki objekat realnog sistema koga posmatramo predstavljamo odgovarajućim objektom koji je sastavni deo modela sistema. Objekte koji imaju zajedničke osobine možemo da opišemo klasom. U tom smislu, objekat je jedna konkretna instanca (primerak) svoje klase. Dakle, klasa predstavlja model objekta koji obuhvata atribute i metode. Klasa definiše nov tip podataka. Kada se jednom definiše, ovaj novi tip može da se koristi za pravljenje objekata tog tipa. Prema tome, klasa može da se definiše kao skup objekata koji imaju iste osobine. Odnos klase i objekta je prikazan u sledećem primeru:

5

Page 6: Objekti i klase

Automobil predstavlja klasu jer je to opšti nacrt nekih karakteristika i ponašanja koje svaki automobil ima. Međutim, “Aston Martin DB9” sa godinom proizvodnje 2008 i registracijom “BG123-456” predstavlja jedan konkretan primerak automobila tj. objekat klase automobil.

1. Slika: Odnos klase i objekata

2.1. Deklarisanje objekata

Novi objekti se deklarišu korišćenjem ključne reči new. U Javi, objekti se deklarišu na sličan način kao i atributi klase. Prvo se navede naziv klase pa onda naziv konkretnog objekta. Na ovaj način se stvara promenljiva koja će da referencira konkretan objekat:

NazivKlase nazivobjekta;

Međutim, da bi objekat mogao da se koristi (da se pozivaju njegove metode, menjaju vrednosti atributa itd.), potrebno ga je inicijalizovati. Ako se objektu pokuša pristupiti bez inicijalizacije, Java javlja grešku. Inicijalizacija se vrši korišćenjem naredbe “new” na sledeći način:

nazivobjekta = new NazivKlase();

Šta se zapravo dešava kada se incijalizuje objekat? Naime, kada se deklariše objekat (promenljiva), samo se stvori pokazivač koji će da referencira objekat. Ali, kada se izvrši incijalizacija, tek se onda alocira deo memorije računara (deo RAM memorije) u kome će da bude objekat i poveže se

6

Page 7: Objekti i klase

sa pokazivačem - pokazivač tada sadrži adresu objekta u memoriji (Slika 2). Tek sada objekat može da se koristi.

3. Slika: Inicijalizacija objekta

Da bi se pozvao mehanizam deklarisanja objekata, potrebno je zadovoljiti neke uslove koji se tiču deklaracije promenljivih koje će referncirati nove objekte. Postavlja se pitanje koji su to uslovi i koji je mehanizam zadužen za pravljenje objekata. Da bismo odgovorili na ova pitanja, analiziraćemo sledeći kod, koji odgovara pravljenju novih objekata tipa “Student”:

Student student1 = newStudent();

student1.index= 251;

student1.ime= "Ivan";

Student.brojStudenata++;

Student student2 = newStudent();

student2.index= 66;

student2.ime= "Bojana";

Student.brojStudenata++;

student1.mentor= student2;

student2.mentor= null;

7

Page 8: Objekti i klase

U ovom kodu napravljena su dva nova objekta tj, analogno realnoj situaciji, na manifestaciju su prijavljena dva nova studenta. Zatim su im inicijalizovani podaci. Broj studenata se povećava analogono prijavljivanju novih studenata na manifestaciju.

Primetićemo da ovo povećanje sada programer unosi ručno, a logično bi bilo da postoji automatizovani mehanizam koji bi ovu proceduru izvršavao svaki put kada se napravi novi objekat. Uskoro će i ovaj problem biti rešen, ali, za sada, hajde da objasnimo detaljnije navedeni kod. Prvo je deklarisana promenjliva student1, koja može da referencira objekte tipa “Student”. Podsetimo se, ova deklaracija NE pravi objekat, već samo definiše promenljivu i njen tip. Svi objekti koje bi ona referencirala moraju se eksplicitno napraviti. Objekat koji predstavlja prvog studenta koji se upisuje za učešće na manifestaciji moramo napraviti korišćenjem ključne reči new. Ovo je najčešći način pravljenja objekata.

Nakon dodeljivanja odgovarajućih vrednosti poljima studenata objekti su spremni za korišćenje u daljem programu. Primetimo da je kao mentor prvom studentu (Ivanu) dodeljen drugi student (Bojana), a da je polje mentorpodešeno kao null. To je zato što Bojana ne učestvuje kao takmičar, nego samo kao mentor, te ona nema svog mentora. U ovom primeru, prvo smo napravili novi objekat, pa smo njegovim poljima dodavali vrendnosti. Zatim smo ručno podešavali statičko polje klase, koje označava broj studenata koji učestvuju na manifestaciji. Uslov da objekat bude napravljen i referenciran jeste da je jasno i tačno deklarisan tip reference koja će ga primiti.

2.2. Brisanje objekata

Potpuno je normalna situacija da se u toku izvršavanja nekog ozbiljnijeg programa za kratko vreme stvori (inicijalizuje) na stotine ili hiljade objekata. Svaki od tih objekata zauzima neki deo memorije računara, a često se dešava da mnogi od njih uopšte više nisu potrebni, pa bi ih trebalo obrisati tj. izbaciti iz memorije. Ako se ovo ne uradi, može doći do preopterećenja memorije. Java ima mehanizam koji se zove “garbage collection” (sakupljanje smeća) koji vrši automatsko brisanje nepotrebnih objekata. Objekat je nepotreban ako na njega ne pokazuje ni jedna promenljiva niti pokazivač. Drugim rečima, dovoljno je promenljivoj (pokazivaču) dodeliti null vrednost ili inicijalizovati novi objekat preko iste promenljive pa da stari objekat bude automatski izbrisan posle nekog vremena (Slika 3).

8

Page 9: Objekti i klase

Slika 3: Brisanje objekata u Javi ("garbage collection")

Da bi neki Java program mogao da se pokrene, potrebno je da ima tzv. “main” metodu. Deklaracija ove metode je uvek ista i piše se u okviru tela klase na sledeći način:

public static void main (String[] args){

//naredbe...

}

1. Primer

class Kutija {

double sirina;

double visina;

double dubina;

}

9

Page 10: Objekti i klase

// Ova klasa deklarise objekat tipa Kutija

class KutijaDemo {

public static void main(String args[]) {

Kutija mojaKutija = new Kutija();

double zapremina;

// dodeljivanje vrednosti promenljivama instanci objekta mojaKutija

mojaKutija.sirina = 10;

mojaKutija.visina = 20;

mojaKutija.dubina = 15;

// izracunava zapreminu kutije

zapremina = mojaKutija.sirina * mojaKutija.visina * mojaKutija.dubina;

System.out.println(“Zapremina je ” + zapremina);

}

}

Datoteku koja sadrži ovaj program treba da nazovete KutijaDemo.java, jer se metoda main() ne nalazi u klasi Kutija, već u klasi KutijaDemo. Prevođenjem ovog programa napravićete dve datoteke .class, jednu za klasu Kutija i drugu za klasu KutijaDemo. Javin prevodilac svaku klasu automatski smešta u datoteku .class. Nije ni neophodno da ove dve klase budu u istoj izvornoj datoteci, možete ih snimiti u posebne datoteke kao Kutija.java i KutijaDemo.java. Da biste program izvršili, morate da pokrenete datoteku KutijaDemo.class, nakon čega će se ispisati sledeći rezultat:

Zapremina je 3000.0

2.3. Reference na objekat

Kada se pravi klasa, tada se u stvari pravi novi tip podataka. Novi tip se može upotrebiti za deklarisanje nekog objekta tog tipa. Međutim, pravljenje objekata određene klase izvodi se u dve faze:

1. Prvi korak je deklarisanje promenljive čiji tip odgovara klasi. (ova promenljiva ne definiše objekat, već samo može da ukazuje na njega);

2. Drugi korak je da se toj promenljivoj doda stvarna, fizička kopija objekta. To se izvodi operatorom new koji dinamički (tj. u trenutku izvršavanja) dodeljuje memoriju za objekat i programu vraća referencu na njega. Ta referenca u stvari predstavlja adresu objekta stvorenog operatorom new u memoriji. Referenca se smešta u promenljivu.

10

Page 11: Objekti i klase

Posmatrajući prethodni primer, objekat tipa Kutija je deklarisan ovakvim iskazom:

Kutija mojaKutija = new Kutija();

U ovom iskazu su spojene obe faze pravljenja objekta, inače bi se pisale na duži način, kao što se prikazuje:

Kutija mojaKutija; //deklarisanje reference na objekat

MojaKutija=new Kutija(); //dodeljivanje memorije objektu Kutija

U prvom redu se deklariše promenljiva mojaKutija kao referenca na objekat tipa Kutija.

Nakon što se ovaj red izvrši, promenljiva mojaKutija sadrži vrednost null, što znači da ona još uvek ne ukazuje na stvarni objekat.

U sledećem redu se dodeljuje memorija stvarnom objektu, a promenljivoj mojaKutija se dodeljuje referenca na njega. Pošto se izvrši drugi red, promenljivu mojaKutija možete da koristite kao da predstavlja objekat Kutija. Znači, promenljiva mojaKutija sadrži samo memorijsku adresu objekta Kutija.

Kao što se do sada moglo uočiti, opšti oblik upotrebe operatora new koji dinamički dodeljuje memoriju objektu glasi:

promenljiva=new imeklase();

Ovde se promenljiva odnosi na tip klase koja se pravi. Ime klase označava klasu čiji se primerak (instanca) pravi. Imenom klase iza koga slede zagrade određuje se konstruktor klase. Konstruktor definiše šta se događa kada se pravi jedan od objekata klase. Konstruktori su važan deo svih klasa i imaju mnoge značajne atribute.

Sledeći primer prikazuje kreiranje dva objekta klase Automobil i inicijalizaciju referenci, tako da ukazuju na odgovarajuce objekte. Reference se nalaze na steku programa.

Automobil a = new Automobil();

Automobil b = new Automobil();

Dve refence koje ukazuju na dva objekta

Ako se sada izvrši naredba:

b = a;

Postavlja se pitanje šta se u ovoj situaciji dešava sa objektom na koga je ukazivala referenca b: taj objekat više nije dostupan ni na jedan način, jer je jedina mogućnost da se nekoj referenci dodeli vrednost ili postojeće reference (tipa b = a) ili reference na novokreiran objekat (tipa a = new …). Kako objekat više nije dostupan, valjalo bi ga ukloniti iz memorije kako bi se izbeglo „curenje memorije”. Java ne poseduje posebnu jezičku konstrukciju kojom se memorija dealocira. Za dealokaciju memorije zadužen je poseban pozadinski proces programa koji se naziva garbage collector („skupljač đubreta”).

11

Page 12: Objekti i klase

2. Primer

Napraviti klasu Motocikl koja ima:

atribut markaIModel. Atribut kubikaza (ceo broj). Napraviti klasu Test koja sadrži main metodu i, u okviru nje,

pravi dva objekta klase Motocikl.

class Motocikl { String markaIModel;

int kubikaza; } class

Test {

public static void main(String[] args) {

Motocikl m1;Motocikl m2; m1 = new Motocikl();

m2 = new Motocikl(); }

}

Prava slika o objektima se stiče tek kada se vidi kako se menjaju vrednosti atributa. Pristup atributima se vrši tako što se napiše naziv objekta, pa tačka, pa naziv atributa:

nazivobjekta.nazivAtributa

3. Primer

Iskoristiti klasu Motocikl iz prethodnog primera i prepraviti klasu Test koja sadrži main metodu tako da pravi dva objekta klase Motocikl. Prvi bi trebalo da bude “Suzuki GS” od 500 kubika (dodeliti atributima prvog objekta ove vrednosti) a drugi “Yamaha R6” od 600 kubika (dodeliti atributima drugog objekta ove vrednosti).

//Kod za klasu Motocikl ostaje isti

class Test { public static void main(String[] args) {

Motocikl m1;Motocikl m2; m1 = new Motocikl();

m2 = new Motocikl();

m1.markaIModel = "Suzuki GS";m1.kubikaza = 500; m2.markaIModel = "Yamaha R6";

m2.kubikaza = 600;

} }

12

Page 13: Objekti i klase

U Javi se komande izvršavaju u redosledu u kojem su napisane (“odozgo na dole”). Ako se, na primer, u okviru main metode prvo napišu komande za pristup atributima, a tek posle sledi komanda za inicijalizaciju objekta, Java će da prijavi grešku.

Prethodna dva primera sadrže main metodu pa mogu da se izvrše. Međutim, rezultat njihovog izvršavanja neće da bude ništa vidljivo -objekti će da se inicijalizuju, dodeliće se vrednosti atributima, ali ništa neće da se ispiše na ekranu. Komanda za ispisivanje na ekranu (u Javi se to zove “standardni izlaz”) je sledeća:

System.out.println( ...neki tekst i/ili vrednost... );

Rezultat izvršavanja ove komande je ispis (na ekranu) sadržaja koji se nalazi između zagrada i prelazak u novi red. Taj sadržaj može da bude neki tekst, vrednost nekog atributa (ili promenljive) ili kombinacija ova dva. U sledećem primeru je prikazano šta ova komanda tačno radi i kako se koristi.

4. Primer

Sledi nekoliko primera upotrebe komande “println” za ispis na ekranu i rezultata koji će biti prikazani:

System.out.println("Lep dan danas");//Ispisace se na ekranu://Lep dan danas

int broj;broj = 12;System.out.println(broj);//Ispisace se na ekranu://12

System.out.println("Ova recenica ide u prvi red");System.out.println("Ova recenica ide u drugi red");//Ispisace se na ekranu://Ova recenica ide u prvi red//Ova recenica ide u drugi red

int temperatura;temperatura = 21;System.out.println("Temperatura je: "+temperatura);//Uloga znaka plus (+) je da omoguci nadovezivanje vrednosti//temperature na poruku//Ispisace se na ekranu://Temperatura je: 21

5. Primer

Iskoristiti klasu Motocikl iz prethodnih primera i klasu Test koja sadrži main metodu i pravi dva objekta klase Motocikl -“Suzuki GS” od 500 kubika i “Yamaha R6” od 600 kubika. Prepraviti main metodu klase Test tako da ispisuje vrednosti atributa oba objekta na ekranu.

//Kod za klasu Motocikl ostaje isti

class Test {

public static void main(String[] args) {

Motocikl m1;Motocikl m2;

13

Page 14: Objekti i klase

m1 = new Motocikl();m2 = new Motocikl();

m1.markaIModel = "Suzuki GS";m1.kubikaza = 500;

m2.markaIModel = "Yamaha R6";m2.kubikaza = 600;

System.out.println(m1.markaIModel);System.out.println(m1.kubikaza);

System.out.println(m2.markaIModel);System.out.println(m2.kubikaza);

//Ispisace se na ekranu://Suzuki GS//500//Yamaha R6//600

} }

Jedna od varijanti naredbe za ispis na ekranu je i “print” naredba. Jedina razlika u odnosu na “println” (“print-line”) naredbu je ta što se posle ispisa teksta ne prelazi u sledeći red već se i dalje ispisuje u postojećem redu.

System.out.print( ...neki tekst i/ili vrednost... );

6. Primer

Zadatak:Napraviti klasu Grad. Ova klasa bi trebalo da ima: • Atribut naziv. Početna vrednost ovog atributa je “nepoznat” • Atribut brojStanovnika. Početna vrednost ovog atributa je 0.

Napraviti klasu TestGrad koja ima main metodu i u okviru nje kreira tri objekta klase Grad: Beograd (1.800.000 stanovnika), Njujork (20.000.000 stanovnika) i Vankuver (nepoznat broj stanovnika -ne dodeljivati nikakvu vrednost). Potrebno je ispisati vrednosti atributa svih objekata na ekranu.

Rešenje:

class Grad {

String naziv = "nepoznat";int brojStanovnika = 0;

}

class TestGrad {

public static void main(String[] args) {

Grad g1 = new Grad();Grad g2 = new Grad();Grad g3 = new Grad();

g1.naziv = "Beograd";g1.brojStanovnika = 1600000;

g2.naziv = "Njujork";g2.brojStanovnika = 20000000;

g3.naziv = "Vankuver";

14

Page 15: Objekti i klase

System.out.println(g1.naziv);System.out.println(g1.brojStanovnika);

System.out.println(g2.naziv);System.out.println(g2.brojStanovnika);

System.out.println(g3.naziv);System.out.println(g3.brojStanovnika);

//Ispisace se na ekranu://Beograd//1600000 //Njujork//20000000//Vankuver//0

} }

7. Primer

Zadatak:Napraviti klasu Osoba. Ova klasa bi trebalo da ima: • Atribut imePrezime. Početna vrednost ovog atributa je “nepoznato” • Atribut tezina. Tezina može imati vrednosti 56.5 kg, 123.1 kg itd.

Napraviti klasu TestOsoba koja ima main metodu i u okviru nje kreira dva objekta klase Osoba: Pera Perić (81.6kg) i Mika Mikic (100.0kg). Prvo, potrebno je ispisati vrednosti atributa ovih objekata na ekranu. Posle, potrebno ih je ispisati ponovo ali tako da se uz ispis vrednosti atributa daje i neki propratni tekst, npr. “Ime osobe je: ” i “Tezina ove osobe je:”. Podatke svakog atributa bi trebalo ispisati u posebnom redu. Konačno, potrebno je ispisati vrednosti atributa oba objekta ali tako da se vrednosti svih atributa jednog objekta ispisuju u istom redu u formatu “Ime: #### Tezina: ####”.

Rešenje:

class Osoba {

String imePrezime = "nepoznato";double tezina;

}

class TestOsoba {

public static void main(String[] args) {

Osoba o1 = new Osoba();Osoba o2 = new Osoba();

o1.imePrezime = "Pera Peric";o1.tezina = 81.6;

o2.imePrezime = "Mika Mikic";o2.tezina = 100.0;

System.out.println(o1.imePrezime);System.out.println(o1.tezina);

System.out.println(o2.imePrezime);System.out.println(o2.tezina);//Ispisace se na ekranu://Pera Peric//81.6//Mika Mikic//100.0

System.out.println("Ime osobe je: "+o1.imePrezime);System.out.println("Tezina ove osobe je: "+o1.tezina);

System.out.println("Ime osobe je:

15

Page 16: Objekti i klase

"+o2.imePrezime);System.out.println("Tezina ove osobe je: "+o2.tezina);

16

Page 17: Objekti i klase

//Ispisace se na ekranu: //Ime osobe je: Pera Peric//Tezina ove osobe je: 81.6//Ime osobe je: Mika Mikic//Tezina ove osobe je: 100.0

System.out.println("Ime: "+o1.imePrezime+" Tezina: "+o1.tezina);

System.out.println("Ime: "+o2.imePrezime+" Tezina: "+o2.tezina);//Ispisace se na ekranu://Ime: Pera Peric Tezina: 81.6//Ime: Mika Mikic Tezina: 100.0

} }

3. Klase

Klase (classes) u jeziku Java složeni su tipovi podataka koji se sastoje od elemenata koji mogu da budu međusobno različitih tipova. Ti elementi nazivaju se članovi klasa (class members).

Podaci klasnih tipova predstavljaju primerke date klase (class instances) i nazivaju se objekti (objects). Termin klasa često se koristi, skraćeno, za označavanje pojma primera klase. Iz konteksta treba tada zaključiti, da li reč klasa označava tip ili objekat.

Klase kao složeni tipovi podataka u jeziku Java su pokazani tipovi (§2.3, 16). To znači da je promenljiva klasnog tipa samo pokazivač na objekat. Sam objekat nalazi se negde drugde u memoriji.

Članovi klasa mogu da budu polja ili metode. Polja (fields) klase, odnosno objekta su podaci koji čine stanje (state) objekta. Metode (methods) klase su funkcije koje mogu da izvode razne operacije nad poljima čime menjaju stanje (vrednost) objekta na koji se primenjuju.

Članovi klasa mogu da budu privatni ili javni. Privatnim (private) članovima može da se pristupa samo iz unutrašnjosti posmatrane klase. To znači da privatna polja mogu da koriste ili menjaju samo metode date klase, a privatne metode mogu da pozivaju samo druge metode iste klase. Javnim (public) članovima može da se pristupa bez ograničenja kako iz unutrašnjosti klase, tako i iz delova programa izvan posmatrane klase. Kaže se da ove osobine označavaju prava pristupanja (access rights) ili dostupnost članova.

U većini slučajeva polja su privatna, dok su od metoda neke privatne a neke javne. Javne metode su tada jedina mogućnost da se dođe do podataka sadržanih u klasnim objektima. Klase su pravi tipovi jer:

određuju moguće vrednosti objekata određuju moguće operacije nad objektima mogu da spreče izvršavanje bilo koje druge operacije nad objektima obezbeđuju inicijalizaciju (dodelu početnih vrednosti) stvaranih objekata

3.1. Definisanje klasa

17

Page 18: Objekti i klase

-Definicija klase predstavlja navođenje svih članova klase. Na osnovu te definicije mora da se zna veličina potrebnog memorijskog prostora za smeštanje pojedinih objekata tipa te klase. Klasa se definiše opisom class čiji je opšti oblik:

class ImeKlase { modifikatori član modifikatori član … }

Modifikatori određuju neke specifične osobine člana klase. U slučaju više modifikatora redosled nije bitan.

Modifikator private ili public označava da je član privatan, odnosno javan. Privatni članovi mogu da se koriste samo unutar date klase, a javni iz bilo kog dela programa.

ImeKlase je po formi identifikator i ima status identifikatora tipa. Može da se koristi u naredbama za definisanje podataka za podatke (objekte) tipa te klase. Uobičajeno je da se imena klasa pišu velikim početnim slovom. Član u definiciji klase može da bude:

• definicija polja (§6.3, 101)• definicija metode (§6.4, 102)• definicija druge klase (§9, 209)

Pored toga u definiciji klase mogu biti: • inicijalizacioni blokovi (§6.8, 118)• definicije konstruktora (§6.5, 111)

Oni se ne ubrajaju u članove klase zbog specifične namene i načina korišćenja. Doseg svih identifikatora unutar klase je od mesta definisanja do kraja klase. Kaže se da članovi

klase imaju klasni doseg (class scope).

3.2. Pristupanje članovima klasa

-Članu klase pristupa se izrazom oblika:

objekat . član

Tačka (.) je binaran operator za pristup članu klase prioriteta 15 koji se grupiše sleva nadesno. Objekat je najčešće identifikator objekta čijem članu se pristupa, ali može biti i rezul- tat složenijeg

izraza čiji je rezultat (pokazivač na) objekat. Član može da predstavlja polje ili metodu. Za polje treba navesti ime polja. Pristupanje metodi

predstavlja pozivanje te metode i treba navesti izraz za pozivanje .Unutar klase objekat kojem se pristupa može da se predstavlja ključnom reči this. Time se označava

da se pristupa članu objekta koji se upravo obrađuje (tekućeg objekta):

this . član

18

Page 19: Objekti i klase

Za pristup članu spostvene klase dovoljno je i navođenje samo člana:

član

tj. this. se podrazumeva. Ponekad je, ipak, zgodno da se napiše to neobavezno this., naročito ako se u metodi, pored tekućeg, koristi još i veći broj objekata.

3.3. Polja klasa

-Polja klasa su podatkovni članovi čija definicija ima isti oblik kao i naredba za definisanje samostalnih podataka u §2.8 (20):

imeTipa imePolja = početnaVredost , imePolja , … ;

Odjednom mogu da se definišu više polja zajedničkog tipa. ImeTipa može biti bilo koji prost ili složen tip, uključujući i klasu koja se upravo definiše.

Uz imenaPolja mogu da se navedu i početneVrednosti (inicijalizatori). Za razliku od samostalnih promenljivih, polja imaju nulte početne vrednosti u odsustvu inicijalizatora.

U izrazima za početneVrednosti kao operandi mogu da se koriste i polja koja su već definisana po redosledu navođenja, a ne i polja koja će biti definisana tek kasnije u tekstu klase.

Polja mogu biti konačna, ako se na početku definicije navodi modifikator final. Vrednosti konačnih polja mogu da se postave samo u toku stvaranja objekata, ne obavezno navođenjem početneVrednosti, već i u inicijalizacionom bloku ili u konstruktoru.

Polja su skoro bez izuzetka privatna da bi se postiglo učaurivanje podataka, tj. zaštita podataka od neprimerenog korišćenja.

Primer 6.1 – Definisanje polja klasa

class Alfa { private int a = 1, b; // b == 0 public double c = a + b; public double d = c * j; // GREŠKA: k još ne postoji. private short[] e = {1, 2, 3, 4}; private byte[] f = new byte[55]; private char[][] g; // g == null private String h = "Dobar dan."; private Alfa i; // i == null public final int j = 55; public final double k; … } class AlfaTest {

19

Page 20: Objekti i klase

public static void main(String[] varg) { Alfa a = new Alfa(); // Stvaranje objekta . a.c = 35; a.b = 56; // GREŠKA: b nije dostupno. int x = a.j; a.k = 13; // GREŠKA: k je konačno polje. } }

Na početku klase Alfa definisana su privatna celobrojna polja a i b. Polje a se inicijalizatorom postavlja na vrednost 1, dok b poprima podrazumevanu vrednost 0.

Javna realna polja c i d se inicijalizuju vrednostima izraza u kojima se kao operandi koriste druga polja klase Alfa. Izraz a+b je prihvatljiv, pošto su oba operanda već definisana polja. Izraz c*j je neispravan jer je polje j definisano je tek kasnije.

Javna polja se retko koriste u praksi, pa su sva preostala polja klase Alfa privatna. Polja e, f i g su nizovnog tipa. Vektor e se inicijalizuje na osnovu navedenih vrednosti.

Vektor f se inicijalizuje, izrazom za dodelu memorije, nizom od 55 elemenata čije vrednosti su podrazumevano nule . Matrica g nema inicijalizator, pa to polje poprima podrazumevanu vrednost null.

Polja h i i su klasnog tipa. Niska h se inicijalizuje konstantnim tekstom. Polje i je tipa sopstvene klase Alfa i poprima podrazumevanu vrednost null (klase su pokazani tipovi i promenljive i polja klasnog tipa su, u stvari, pokazivači).

Na kraju, polja j i k su konačna. Polje j ima inicijalizator i time je postavljena njegova konačna vrednost. Polje k nema inicijalizator i zasad ima podrazumevanu vrednost 0. Ovo se, međutim, ne smatra postavljanjem vrednosti, tako da je dozvoljena jedna kasnija dodela vrednosti. Pošto konačna polja ne mogu da se promene izvan klase, ne smeta što su polja j i k javna. Izvan klase moći će samo da se dohvate, a ne i da se promene, pa nije narušen princip učaurivanja podataka.

U metodi main klase AlfaTest prikazane su mogućnosti korišćenja članova klase Alfa izvan te klase (unutar neke druge klase). Prvom naredbom se stvara objekat a tipa Alfa, što je detaljno objašnjeno u Javnom članu c dozvoljen je pristup sa a.c, ali a.b nije dozvoljeno, pošto je b privatan član klase Alfa.

U poslednje dve naredbe pristupa se javnim konačnim članovima j i k. Za njih je dozvo- ljeno samo dohvatanje vrednosti kao operand (x=a.j), a ne i promena vrednosti (a.k=13).

3.4. Metode klasa

-Metode klasa su funkcionalni članovi koji ostvaruju operacije nad poljima klasa menjajući time vrednosti (stanja) objekata.

Metode se obično definišu kao programski moduli koji na osnovu izvesnog broja ar- gumenata daju jedan rezultat koji se naziva povratna vrednost (return value), ili skraćeno samo vrednost metode. Tip povratne vrednosti naziva se tip metode. Vrednost metode mo- že da se koristi ugrađivanjem poziva metode u izraze. Poziv metode se, u stvari, smatra operatorom kao i svi ostali operatori.

Jezik Java dozvoljava da metode, pored vrednosti metode, daju i druge rezultate koji se nazivaju bočni efekti metoda. Štaviše, vrlo često vrednost metode uopšte se ne koristi, već samo njeni bočni efekti. Ukoliko nema potrebe da se koristi vrednost metode, poziv metode predstavlja jedini operand izraza u okviru kojeg se poziva metoda.

20

Page 21: Objekti i klase

Jezik Java dozvoljava i da metoda uopšte ne stvara vrednost već samo bočne efekte. Nema smisla da se pozivi metoda, koje stvaraju samo bočne efekte, ugrađuju kao operandi u složenije izraze. Metode su najčešće javne, a ređe privatne . Pomoću javnih metoda moguće je obrađivati objekte klase iz drugih klasa, dok se privatne metode koriste kao pomoćne metode unutar sopstvene klase.

3.4.1. Sastav metode

-Svaka metoda sadrži: a) tip koji vraća ( ili void ukoliko ne vraća nikakav tip), b) naziv, c) listu parametara i d) telo metode. Ukoliko metoda vraća neku vrednost tada se koristi return vrednost.

double Podizanje(double Stanje1) { Stanje = Stanje - Stanje1; return Stanje;}

3.4.2. Parametrizirane metode

-Ukoliko metoda sadrži parametre, za nju se kaže da je ona parametrizirana metoda.

double Podizanje(double Stanje1) { Stanje = Stanje - Stanje1; return Stanje;}

3.4.3. Konstruktori

-Konstruktori predstavljaju specijalne metode pomoću kojih se vrši inicijalizacija objekta (dodeljivanje početnih vrednosti atributima objekta), prilikom njihovog kreiranja.

• Konstruktor ima isti naziv kao i ime klase. • Konstruktor se pokreće kod deklaracije objekta. • Konstruktori ne vraćaju nikakav tip podataka (čak ni void).

I. Default konstruktori Default konstruktori postavljaju atribute svakog objekta na istu početnu vrednost. class AutomatNovca { String ImeKlijenta; double Stanje; // Default konstruktor AutomatNovca(){ ImeKlijenta = null; Stanje = 0;} public static void main(String args[]) { // Kod deklaracije objekta poziva se default konstruktor . AutomatNovca au = new AutomatNovca(); AutomatNovca au1 = new AutomatNovca(); …

21

Page 22: Objekti i klase

au 30

Ime klijenta

null

stanje

0

70  

Ime klijenta

null

stanje

0au1

70

30

30

50

100 100

“Pera Perić”

au

ImeK1

Ime klijenta stanje Stanje 1

} … }

Izgled operativne memorije:

II.Parametarski konstruktori Parametarski konstruktori postavljaju atribute objekta na vrednosti koje su definisane parametrima kod deklaracije objekta.

class AutomatNovca { String ImeKlijenta; double Stanje; // Parametarski ili copy konstruktor AutomatNovca(String ImeK1, double Stanje 1){ ImeKlijenta = ImeK1; Stanje = Stanje1;} public static void main(String args[]) { // Kod deklaracije objekta poziva se copy konstruktor. AutomatNovca au = new AutomatNovca(“Pera Peric”,100); // Linija A AutomatNovca au1 = new AutomatNovca(“Milan Savic”,150); // Linija B … }

… }

Izgled operativne memorije Linija A, uključujući i poziv konstruktora:

22

Page 23: Objekti i klase

70  

  90    

 150 150

“Milan Savić”

au1

ImeK1

Ime klijenta stanje Stanje 1

  90

90

30 30 10 10

Ulaganje:: this

au

30

stanje Stanje 1

Izgled operativne memorije Linija B, uključujući i poziv konstruktora:

3.4.4. Rezervisana reč this

Rezervisana reč this predstavlja referencu na objekat koji je pozvao sopstvenu metodu klase.

class AutomatNovca { double Stanje; AutomatNovca(){ Stanje = 0;} void Ulaganje(double Stanje1) {Stanje = Stanje + Stanje1;} // Moglo je da se napise this.Stanje = this.Stanje + Stanje1; // sto pokazuje da this ukazuje na tekuci objekat koji je // pozvao metodu Ulaganje. … public static void main(String args[]) { AutomatNovca au = new AutomatNovca(); AutomatNovca au1 = new AutomatNovca(); au.ulaganje(10); // Linija A au1.ulaganje(15); // Linija B } }

Izgled operativne memorije - Linija A:

23

Page 24: Objekti i klase

 30 30 10 10

au stanje Stanje 1

       50 50 15 15

 

Ulaganje:: this

50

Izgled operativne memorije - Linija B:

3.4.5. Sakrivanja atributa klasa preko parametara metoda

U Javi je za razliku od C++ moguće da parametri metoda i lokalne promenljive imaju isti naziv kao i atributi klase. Na taj način dolazi do preklapanja naziva, pri čemu parametri ili lokalne promenljive metode sakrivaju atribute klase. Atributu klase u tom slučaju, ne može se pristupiti jer poziv atributu klase preuzima parametar ili lokalna promenljiva metode.

class AutomatNovca { double Stanje; AutomatNovca(){ Stanje = 0;} void Ulaganje(double Stanje) {Stanje = Stanje + 10;} //Linija A

// U navedenom slucaju se poziva parametar Stanje a ne // atribut Stanje. Navedeni problem se resava tako sto se // ispred atributa klase stavlja this. // {this.Stanje = Stanje + 10;} // Linija B // this.Stanje – pristupa se atributu klase // Stanje – pristupa se parametru klase.

public static void main(String args[]) { AutomatNovca au = new AutomatNovca(); au.ulaganje(100); } … }

Izgled operativne memorije – Linija A:

24

Page 25: Objekti i klase

30 30 0 110100

au AutomatNovca::Stanje Ulaganje::Stanje

   30 30 0 110100

au AutomatNovca::Stanje Ulaganje::Stanje

110

 

Ulaganje:: this

30

Izgled operativne memorije – Linija B:

3.4.6. Sakupljanje smeća

-Za razliku od C++ koji ima specijalnu metodu destruktor, Java nema takvu metodu. Pošto je uloga destruktora vezana za uništavanje objekta, postavlja se sledeće pitanje: Koji mehanizam kod Jave obezbeđuje uništavanje objekata koji se više ne koriste? Navedeni mehanizam se naziva garbage collection (sakupljanje smeća), koji radi na sledećem principu: analiziraju se objekti programa i traže se oni objekti na koje više ne ukazuju referentni objekti. Takvi objekti se sakupljaju i uništavaju. Vreme pokretanja navedenog mehanizma nije vezano za izlazak objekta iz oblasti njegovog važenja već se to radi s vremena na vreme i nije pod neposrednom kontrolom onoga ko pravi program, kao što je to kod C++.

3.4.7. Metoda finalize

-Metoda finalize() se pokreće svaki put kada mehanizam garbage collection pokuša da uništi objekat. Navedene metoda se pokreće neposredno pre uništenja objekta.

Opšti oblik navedene metode je:

protected void finalize()

{ // kod finalizacije

}

25

Page 26: Objekti i klase

Pošto se ne zna vreme kada će se pokrenuti mehanizam garbage collection, ne može se sa sigurnošću tvrditi kada će se i da li će se uopšte pokrenuti metoda finalize().

3.4.8. Preklapanje metoda

-U Javi kao i u C++ moguće je definisati istoimene metode u okviru jedne klase. U tom slučaju se kaže da su metode preklopljene (overloaded). Preklapanje metoda predstavlja jedan oblik polimorfizma (polimorfno - nešto što ima više oblika). Međutim u okviru jedne klase preklopljene metode moraju da se razlikuju po potpisu (po broju i/ili tipu parametara).

Primer neregularnog preklapanja metoda:

class AutomatNovca

{ double Stanje;

void Ulaganje(double Stanje1)

{ Stanje = Stanje + Stanje1;}

// Nize navedena metoda preklapa vise navedenu metodu i one se razlikuju po tipu

// onoga sto vracaju. Medjutim broj i tip argumenata je isti tako da ce se kod

// kompajliranja javiti greska: Ulaganje(double ) is already defined in AutomatNovca

double Ulaganje(double Stanje1) { Stanje = Stanje + Stanje1; return Stanje;}

…}

Sledeći primer pokazuje regularno preklapanje istoimenih metoda:

class AutomatNovca

{ double Stanje;

void Ulaganje(double Stanje1) { Stanje = Stanje + Stanje1;}

// Nize navedena metoda preklapa vise navedenu metodu i one se razlikuju po tipu

// tipu parametraStanje1. To je dovoljan uslov da se regularno kompajlira program.

void Ulaganje(int Stanje1) { Stanje = Stanje + Stanje1;}

}

Iz metode main() koja je deklarisana u okviru klase AutomatNovca preklopljena metoda Ulaganje() se poziva na sledeći način:

26

Page 27: Objekti i klase

AutomatNovca au = new AutomatNovca();

au.Ulaganje(5); // Poziva se metoda Ulaganje() koja kao parametar ima int.

au.Ulaganje(5.5); // Poziva se metoda Ulaganje() koja kao parametar ima double.

3.4.9. Preklapanje konstruktora

-Kao i bilo koje druge metode tako se i konstruktor metode mogu preklopiti.

class AutomatNovca

{ double Stanje;

// Preklopljeni konstruktori

AutomatNovca(){ Stanje = 0;}

AutomatNovca(double Stanje1){ Stanje = Stanje1;}

public static void main(String args[])

{ // Kod deklaracije objekta poziva se default konstruktor .

AutomatNovca au = new AutomatNovca();

AutomatNovca au1 = new AutomatNovca(15.5);

}

…}

3.4.10. Prenos argumenata metoda

- Postoje dva načina prenosa argumenata:

a) preko vrednost (call-by-value) Kod navedenog pristupa se vrednost argumenta kopira u formalni parametar metode3. Formalni parametar predstavlja posebnu kopiju koja ima vrednost istu kao što je vrednost argumenta. Sve što se dešava sa kopijom neće se odraziti na argument.

class AutomatNovca { double Stanje; AutomatNovca(){ Stanje = 0;}

27

Page 28: Objekti i klase

 

au

30 30 (.) 25

0

25

25(.)

AutomatNovca::Stanje Main1::Stanje Ulaganje::Stanje

VratiStanjePrekoParametra::Stanje1

// Navedeni parametar Stanje1, ima smisla da se prenese preko // vrednosti, jer je on u navedenom slucaju samo ulazni parametar. void Ulaganje(double Stanje1) { Stanje = Stanje + Stanje1;} … // Navedeni parametar Stanje1 nece izvrsiti postavljeni zahtev jer // parametar Stanje1 nece, kada se vrati u main() imati vrednost // zeljenog atributa Stanje. U navedenom slucaju od parametra se // zahteva da bude ulazno/izlazni parametar sto on ne moze biti kod // prenosa parametara preko vrednosti. void VratiStanjePrekoParametra(double Stanje1) { Stanje1 = Stanje; }

public static void main(String args[]) { AutomatNovca au = new AutomatNovca(); double Stanje1 = 0; au.Ulaganje(25); … au.VratiStanjePrekoParametra(Stanje1); } // Stanje1 će na kraju da prikaže 0 umesto željene vrednosti 25. }

Izgled operativne memorije:

b) preko reference (call-by-reference) Kod navedenog pristupa se formalnom parametru metode prosleđuje referenca na argument. To znači da sve što se bude radilo sa formalnim parametrom imaće uticaj na argument koji je prosleđen do formalnog parametra. Ukoliko bi želeli da postignemo efekat vraćanja vrednosti preko parametra, što ne može da se ostvari prenosom parametara preko vrednosti, potrebno je proslediti objekat čiji je atribut realnog tipa. class AutomatNovca

{ double Stanje; AutomatNovca(){ Stanje = 10;} void VratiStanjePrekoParametra(KDouble Stanje1) { Stanje1.S = Stanje; }

public static void main(String args[])

28

Page 29: Objekti i klase

30

au AutomatNovca::Stanje main::Stanje1

30 10 150

5150

KDouble::S

  

30

au AutomatNovca::Stanje main::Stanje1

30 10 150

5150

KDouble::S

10150

VratiStanjePrekoParametra::Stanje1

{ AutomatNovca au = new AutomatNovca(); KDouble Stanje1 = new KDouble(); // Linija A … au.VratiStanjePrekoParametra(Stanje1);//LinijaB System.out.println(“Vrednost stanja je:” + Stanje1.S); // Stanje1.S će na kraju da prikaže željenu vrednost 25. }} class KDouble { double S; KDouble() { S = 5;}}

Izgled operativne memorije – Linija A:

Izgled operativne memorije – Linija B:

• Kod Jave prosti tipovi se uvek prenose preko vrednosti dok se objekti uvek prenose preko reference

3.4.11. Ključna reč static

-Kada se javi potreba da neka od članica klase bude deljiva, kako za objekte klase kojoj pripada tako i za objekte drugih klasa, ispred nje se stavlja ključna reč static. Na taj način static članica, ukoliko je:

a) atribut, ponaša se kao globalna promenljiva,

b) metoda, ponaša se kao sopstvena funkcija.

29

Page 30: Objekti i klase

0

5

5

main::stanje1

AutomatNovca::pom AutomatNovca::Stanje1

Pristup do static članica je sledeći:

Ime_Klase.ime_static_članice pri čemu Ime_Klase označava klasu kojoj pripada static članica.

Kod poziva nekog programa pre kreiranja bilo kog objekta, poziva se static metoda main(). Ukoliko main() metoda ne bi bila static metoda, poziv programa ne bi mogao da se izvrši jer se ne static metode mogu pozvati tek nakon kreiranja objekta, koji će ih pozvati.

Static metode mogu da: • pozivaju direktno druge static metode. • direktno pristupaju static atributima.

class AutomatNovca { static double Stanje; static double pom = 0; // 1 korak double Stanje2; public static void main(String args[]) //3 korak { double Stanje1; Stanje1 = Stanje; // direktan poziv static atributa // Linija A … System.out.println(“Vrednost stanja je:” + Stanje1); // Isto tako moglo je da se napise System.out.println(“Vrednost stanja je:” + Stanje); Ulaganje(10); // direktan poziv druge static metode Linija B Podizanje (5); // ne moze se direktno pozvati ne static metoda Stanje2 = 15;// ne moze se direktno pristupiti ne static atributu } static // 2 korak { Stanje = 5;} static void Ulaganje(double Stanje1) { Stanje = Stanje + Stanje1;} void Podizanje(double Stanje1) { Stanje = Stanje – Stanje1;} }

Izgled operativne memorije – Linija A:

30

Page 31: Objekti i klase

   0

5

15

main::stanje1

AutomatNovca::pom AutomatNovca::Stanje1

5

  10

Ulaganje::Stanje1

Izgled operativne memorije – Linija B:

Static metode ne mogu da:• pozivaju direktno ne static metode. • pristupaju direktno ne static atributima. • koriste ključne reči this i super.

Kod izvršenja klase koja ima static članice redosled izvršenja je sledeći: 1. Inicijalizuju se static atributi ukoliko im je dodeljena neka vrednost.

static double pom = 0; // 1 korak 2. Izvršava se static blok6 koji vrši inicijalizaciju static atributa.

static // 2 korak { Stanje = 5;} 3. Poziva se main() metoda.

public static void main(String args[]) //3 korak {…} Pomoću static atributa i metoda može da se simulira klasičan proceduralni pristup u programiranju. Jedino razlika, između klasičnog proceduralnog programa i “objektnog proceduralnog (static) programa”, se odnosi na okvir u kome se pišu ti programi. Okvir kod klasičnog proceduralnog programa je datoteka u okviru koje se piše program, dok je kod “ objektno proceduralnog programa” okvir i datoteka i klasa u kojoj se piše program.

31

Page 32: Objekti i klase

4. Zaključak

Objektno-orijentisano programiranje je sve više u upotrebi, jer su softveri koji se danas koriste izuzetno složeni, a korisnici zahtevaju da softver koji koriste bude što jednostavniji. Zbog toga programeri se često odlučuju za primenu razvojnog okruženja kao što je Java NetBeans, koje je besplatno i sa kojim će moći da naprave aplikativne softver kojiće biti što jednostavniji za korisnike. Java NetBeans se može koristiti i za razvoj Web aplikacija i apleta, i mogu će je bez pisanja velikog broja linija koda kreirati aplet ili aplikaciju. Zbog toga učenje Java programskog jezika moguće je i u školama, a ne samo na fakultetima.

Ovaj programski jezik je mnogo jednostavniji za učenje od C++, jer ne koristi pokazivače koje je obično najteže objasniti učenicima i studentima.

32

Page 33: Objekti i klase

5. Literatura

1. Laslo Kraus: Programski jezik Java sa rešenim zadacima. Akadmeska Misao, Beograd (2013)

Internet:

http://www.fonis.rs/download/ku1/02%20-%20Klase%20i%20Objekti.pdf

http://www.acs.uns.ac.rs/sites/default/files/Java_0.pdf

http://imi.pmf.kg.ac.rs/component/docman/doc_view/223-oop-java-cas-3-objekti-klase-primeri.html

http://www.link-elearning.com/kurs-Internet-Programerski-Alati---Java-programiranje_16_4

33