Embed Size (px)
Citation preview
Matematički fakultet
Univerzitet u Beogradu
Master rad
Elektronske lekcije o osnovnim konceptima objektno
orijentisanog programiranja u programskom jeziku Java
Mentor: Student:
prof. dr Mirosalav Marić Jovana Radosavljević
Beograd,
2017.
Članovi komisije:
1. prof. dr Mirosalav Marić - mentor
2. prof. dr Dušan Tošić
3. prof. dr Vladimir Filipović
Sadržaj Uvod ................................................................................................................................................ 5
1. Elektronske lekcije o programskom jeziku Java ......................................................................... 6
2. Uvod u Javu ................................................................................................................................ 8
2.1. Istorijat i poreklo programskog jezika Java ......................................................................... 8
2.2. Podešavanje okruženja ......................................................................................................... 9
2.3. Kreiranje prvog programa .................................................................................................... 9
2.3.1. Unošenje programa ..................................................................................................... 13
2.3.2. Prevođenje programa .................................................................................................. 14
2.3.3. Pokretanje programa ................................................................................................... 14
2.4. Elementi jezika Java .......................................................................................................... 15
3. Tipovi podataka ........................................................................................................................ 16
3.1. Primitivni tip podataka ....................................................................................................... 16
3.1.1. Celi brojevi.................................................................................................................. 16
3.1.2. Brojevi u pokretnom zarezu ........................................................................................ 17
3.1.3. Znakovi ....................................................................................................................... 18
3.1.4. Logičke vrednosti........................................................................................................ 19
3.2. Referentni tip podatka ........................................................................................................ 20
4. Elementarne konstrukcije .......................................................................................................... 21
4.1. Identifikatori ...................................................................................................................... 21
4.2. Literali ................................................................................................................................ 21
4.2.1. Cleobrojni literali ........................................................................................................ 21
4.2.2. Literali za brojeve u pokretnom zarezu ...................................................................... 22
4.2.3. Logički literali ............................................................................................................. 22
4.2.4. Znakovni i String literali ............................................................................................. 22
4.3. Operatori ............................................................................................................................ 23
4.4. Ključne reči ........................................................................................................................ 27
4.5. Komentari .......................................................................................................................... 27
5. Modifikatori .............................................................................................................................. 28
5.1. Pristupni modifikatori ........................................................................................................ 28
5.2. Ostali Modifikatori............................................................................................................. 29
6. Upravljačke naredbe ................................................................................................................. 30
6.1. Uslovne naredbe................................................................................................................. 30
6.1.1. Naredba if .................................................................................................................... 30
6.1.2. Naredba switch ............................................................................................................ 33
6.2. Naredbe za iteraciju ........................................................................................................... 34
6.2.1. Petlja for ...................................................................................................................... 34
6.2.2. Petlja while .................................................................................................................. 36
6.2.3. Petlja do-while ............................................................................................................ 37
6.3. Naredbe za skokove ........................................................................................................... 38
6.3.1. Naredba break ............................................................................................................. 38
6.3.2. Naredba continue ........................................................................................................ 39
6.3.3. Naredba return ............................................................................................................ 40
7. Upoznavanje sa metodama, objektima i klasama ..................................................................... 42
7.1. Metode ............................................................................................................................... 42
7.1.1. Kreiranje metode ......................................................................................................... 42
7.1.2. Pozivanje metode ........................................................................................................ 43
7.1.3. Preopterećenje metoda ................................................................................................ 44
7.2. Objekti i Klase ................................................................................................................... 45
7.2.1. Opšti oblik klase ......................................................................................................... 46
7.2.2. Vrste promenljivih ...................................................................................................... 48
7.2.3. Statički i nestatički članovi klase ................................................................................ 49
7.2.4. Kreiranje objekta ......................................................................................................... 51
7.2.5. Konstruktori ................................................................................................................ 52
7.2.6. Ključna reč this ........................................................................................................... 54
8. Osnovni koncepti objekno orijentisanog programiranja ........................................................... 56
8.1. Nasleđivanje ....................................................................................................................... 56
8.2. Polimorfizam...................................................................................................................... 58
8.3. Apstrakcija ......................................................................................................................... 60
8.4. Enkapsulacija ..................................................................................................................... 62
8.5. Interfejsi ............................................................................................................................. 63
9. Zaključak................................................................................................................................... 65
Literatura ....................................................................................................................................... 66
5
Uvod
Kako se današnji svet ne može zamisliti bez upotrebe savremene tehnologije (računara,
pametnih telefona, tableta, itd.), potražnja za stručnjacima iz oblasti informacionih tehnologija je
u stalnom porastu, a samim tim i potreba za učenjem programskih jezika je sve veća. Programski
jezik Java uživa veliku popularnost zbog svoje jednostavnosti, platformske nezavisnosti i objektne
orjentisanosti. Imajući u vidu sve veću primenu u izradi aplikacija za mobilne telefone i tablet
uređaje, koji koriste Android operativni sistem, Java je postala jedan od najzastupljenijih
programskih jezika. Iz navedenih razloga korisno je približiti osnove programskog jezika Java
mladim programerima, kako bi stekli neophodno znanje za dalje učenje i napredovanje u svetu
programiranja.
Ovaj rad ima za cilj da kroz elektronske lekcije osobama koje se prvi put susreću sa
programiranjem na jednostavan način približi osnovne principe objektno orjentisanog
programiranja u programskom jeziku Java.
Uvodni deo rada je posvećen istoriji i karakteristikama programskog jezika Java, podešavanju
okruženja, kreiranju i pokretanju prvog programa..
U glavnom delu rada obrađivaće se elektronske lekcije, koje bi trebalo da obezbede upoznavanje
sa objektima, klasama i metodama, načinom njihovog kreiranja i svim pojmovima potrebnim za
njihovo međusobno funkcionisanje (promenljive, elementarne konstrukcije, modifikatori,
upravljačke naredbe, itd.). Pored osnovnih pojmova, biće obrađeni i osnovni koncepti na kojima
se zasniva objektno orjentisano programiranje - apstrakcija, nasleđivanje, polimorfizmi,
enkapsulacija.
U zaključku će biti istaknute mogućnosti, prednosti, mane kao i značaj učenja i popularizovanja
programskog jezika Java.
6
1. Elektronske lekcije o programskom jeziku Java
Elektronske lekcije o programskom jeziku Java kreirane su za potrebe lakšeg učenja i
razumevanja objektno orijentisanog programiranja kroz programski jezik Java. Zamišljene su kao
materijali koji se mogu koristiti u toku nastave ili kao priručnik učenicima za samostalno učenje.
Elektronske lekcije obuhvataju 7 poglavlja i to su:
Uvod u Javu;
Tipovi podataka;
Elementarne konstrukcije;
Modifikatori;
Upravljačke naredbe;
Upoznavanje sa metodama, objektima i klasama;
Osnovni koncepti objektno orijentisanog programiranja.
Svako poglavlje sadrži po nekoliko lekcija koje su koncipirane tako da sadrže osnovne definicije
i kratak opis pojmova potrebnih za razumevanje konkretne teme. Pojedine lekcije iz prvog
poglavlja imaju formu uputstva, gde se kroz niz koraka čitaocu predstavljaju prvi koraci,
neophodni za učenje i programiranje u programskom jeziku Java. Lekcije su propraćene primerima
kojima se konkretizuje ono što lekcija opisuje.
Elektronske lekcije su javno dostupne i nalaze se na adresi:
http://alas.matf.bg.ac.rs/~ml08170/elektronske%20lekcije/java/index.html
Početna stranica sajta se može videti na slici 1.1.
Slika 1.1 – Početna stranica
7
Nakon pritiska na dugme Start sa početne strane pristupa se stranici sa materijalima. Sa leve strane
nalazi se sadržaj, tačnije spisak svih obrađenih lekcija, i u svakom trenutku korisnik može
pritiskom na naslov otvoriti željenu lekciju. Glavni deo sadrži primere, slike i tekst o izabranoj
temi. Na dnu glavnog dela nalaze se strelice kojima se može preći na sledeću ili vratiti na prethodnu
lekciju (slika 1.2).
Slika 1.2 – Prikaz lekcije
8
2. Uvod u Javu
„Ono što se želelo postići programskim jezikom Java, a što je najvećim delom i ostvareno,
predstavlja povezivanje velikog broja različitih domena, tako da se omogućava funkcionisanje
aplikacionog servera i funkcionisanje mobilnog telefona, kreiranje naučnih programa, razvoj
softvera, implementacija međuplanetarne navigacije i još mnogo štošta....“ – James Gosling
Java je jednostavan, objektno orijentisan, nezavisan od platforme, prenosiv, bezbedan, robustan,
interpretiran, distribuiran i dinamički programski jezik.
Jednostavan – programeri mogu lako da nauče i efikasno koriste Javu.
Objektno orijentisan – programi se grade pomoću grupe objekata koji zajedno
funkcionišu.
Nezavisan od platforme – programi mogu da se izvršava bez modifikacija u okviru
različitih okruženja.
Prenosiv – isti kôd radi na svim računarima.
Bezbedan – Java omogućava konstrukciju sistema koji su zaštićeni od virusa i
zlonamerne modifikacije.
Robustan - jezik Java je namenjen za pisanje programa koji moraju biti pouzdani na
mnogo načina. Java se u velikoj meri ističe u ranoj proveri mogućih problema, kasnijoj
dinamičkoj proveri (tokom izvršavanja) i eliminaciji situacija koje su sklone generisanju
greške.
Interpretiran - Java interpreter može direktno da izvršava Java bajtkôd na bilo kojoj
mašini, na kojoj se taj interpreter postavi.
Distribuiran – program može da zahteva izvršavanje procedure koja se nalazi bilo gde na
mreži.
2.1. Istorijat i poreklo programskog jezika Java
Priča o programskom jeziku Java počinje 1995. godine kada su James Gosling i grupa
programera radeći na projektu kompanije Sun Mycrosistems razvili novi programski jezik.
Tačnije, početkom 1991. kreirani su prvi koncepti jezika koji je prvobitno dobio ime Oak, ali je
1995. godine promenjen i predstavljen kao Java.
Osnovni motiv je bila potreba za jednostavnim jezikom koji će biti lak za korišćenje, pouzdan
i nezavisan od platforme. Bio je potreban jezik koji bi se mogao koristiti za pravljenje softvera,
namenjenog različitim elektronskim uređajima u domaćinstvu, kao što su mikrotalasne pećnice i
daljinski upravljači. Problem sa jezicima C i C++ (kao i sa većinom drugih jezika), leži u tome što
se pri prevođenju u binarni oblik oni moraju usmeriti na određeni procesor. Iako se program pisan
na jeziku C++ može prevesti za bilo koji procesor, za to je potreban prevodilac namenjen
konkretnom procesoru. Problem je bio u tome što su prevodioci skupi i sporo se prave. Očigledno
je bilo potrebno lakše i jeftinije rešenje. U pokušaju da dođu do njega, Gosling i ostali počeli su
da rade na prenosivom jeziku koji ne zavisi od platforme i čiji bi kôd mogao da se izvršava na
9
različitim procesorima i u različitim okruženjima. Ovi napori su konačno doveli do rađanja Jave
[1].
Java je srodnik jezika C++, koji je direktan potomak jezika C. Veći deo svojih osobina Java
je nasledila od ova dva jezika. Iz jezika C je preuzela sintaksu, a mnoge objektno orijentisane
osobine Jave nastale su pod uticajem jezik C++. Zapravo, više karakteristika koje definišu Javu
potiču od njenih prethodnika ili su nastale u procesima njihovog poboljšavanja. Kako svaka
inovacija programskog jezika nastaje iz potreba da se reši određeni temeljni problem, tako ni Java
nije izuzetak u tom pogledu. Nakon izlaska Jave u jesen 1995. Java programi mogli su da se
izvršavaju kao deo veb stranica u Netscape Navigator čitaču veba. Ova funkcionalnost pomogla je
u reklamiranju Jave i privuklo nekoliko stotina hiljada programera u prvih šest meseci postojanja
novog programskog jezika.
Čak i nakon što Java više nije bila nov programski jezik, korist od primene ovog programskog
jezika je postala potpuno jasna, a programeri su i dalje bili privučeni njome. Danas postoji više
profesionalnih programera koji koriste programski jezik Java nego onih koji koriste programski
jezik C++ [2].
2.2. Podešavanje okruženja
Kada se govori o Javi važno napraviti razliku između Java programskog jezika i Java platforme.
Java programski jezik je formalni jezik za prezentaciju računarskih programa, pomoću njega se
računaru, čoveku čitljivim tekstom, daju instrukcije i naredbe za izvršenje različitih zadataka. Kada
se napiše program on se ne izvršava direktno na računaru već pomoću standardizovanog okruženja
koje se zove Java platforma. Najpre Java prevodilac (javac) prevodi program sa izvornog koda u
bajtkod koji razume Java virtualna mašina (Java Virtual Machine - JVM) i na njoj se program
izvršava. Java interpreter tumači bajtkod i izvršava akcije koje su specificirane u bajtkodu, unutar
JVM. Java platforma pored Java virtualne mašine podrazumeva i skup unapred definisanih Java
klasa koje postoje pri svakoj instalaciji Jave. Ove klase su dostupne za korišćenje od strane Java
programa. Java platforma se još i naziva izvršno okruženje (Java Runtime Environment - JRE) [3].
Za razvoj aplikacija potreban je Java Development Kit - JDK. On se sastoji od Java Runtime
Environment-a i alata za razvoj, prevođenje, praćenje i debagovanje aplikacija. Ako se za JRE
kaže da je to okruženje za pokretanje Java programa, onda JDK predstavlja okruženje za razvijanje
i pokretanje Java programa.
JDK se može preuzeti na http://www.oracle.com/technetwork/java/javase/downloads/index.html .
Iz ponuđene liste, treba izabrati onu instalaciju koja odgovara operativnom sistemu koji se koristi
na datom računaru (x86 je instalacija za 32-bitnu, a x64 za 64-bitnu mašinu). Da bi preuzimanje
bilo moguće, potrebno je označiti opciju Accept License Agreement. Trenutno aktuelna verzija je
jdk-8u5 (slika 2.1).
Kada je instalaciona (.exe) datoteka preuzeta, potrebno je dvoklikom na nju pokrenuti instalaciju.
Zatim, prateći uputstvo, dovoljno je prihvatati ponuđena podešavanja, prelazeći na sledeći korak
klikom na Next (slike 2.2 i 2.3).
10
Slika 2.1 – Preuzimanje JDK-a
Slika 2.2 – Pokretanje instalacije JDK-a
Slika 2.3 – Instalacija JDK-a
11
Kada se došlo do završnog koraka, trebalo bi da u izabranom direktorijumu (ako smo prihvaćena
podrazumenavana podešavanja C:\Program Files\Java) postoje dva nova foldera "jre1.8.0_51" i
"jdk1.8.0_51".
Pored instalacije JDK potrebno je dodati putanju do jdk1.8.0_51 direktorijuma u PATH
environment promenljivu. Na taj način kompajler i interpreter se mogu pokretati bilo gde, bez
navođenja putanja do njih.
Koraci za podešavanje ove putanje su sledeći:
desni klik na "Computer",
zatim klik na "Properties""Advanced system settings",
izabrati "Environment Variables""System variables""New" (slika 2.4) ,
kreirati novu promenljivu "JAVA_HOME" , a kao vrednost postaviti putanju do lokacije
gde se nalazi instalacija JDK na računaru (slika 2.5) ,
izabrati "PATH" sistemsku promenljivu, a zatim izmeniti postojeću vrednost Path
promenljive, dodavanjem sledećeg izraza ;%JAVA_HOME%\bin (slika 2.6).
Slika 2.1.4 – kreiranje sistemske promenljive
Slika 2.4 – Kreiranje sistemske promenljive
Slika 2.5 – Kreiranje sistemske promenljive
12
Za kreiranje programa potreban je i razvojni alat, u kome će se pisati izvorni kôd i pokretati
program. Programerima su na raspolaganju mnoga grafička razvojna okruženja NetBeans, Eclipse,
DrJava, BlueJ, JCreator, itd. Među ovim okruženjima ne može se izdvojiti jedno koje je najbolje,
jer svako ima svoje prednosti i mane, a izbor je najčešće stvar ličnog ukusa. Za potrebe ovog
elektronskog kursa korišćen je razvojni alat - Eclipse IDE (slika 2.7).
Nakon uspešnog preuzimanja, potrebno je raspakovati paket na željenoj lokaciji i u folderu
pronaći eclipse.exe datoteku, pa dvoklikom na nju otvoriti razvojno okruženje. Pri pokretanju
Slika 2.7 – Preuzimanje Eclipse
Slika 2.6 – Podešavanje sistemske proemneljive
13
eclipse.exe najpre treba izabrati Workspase, tj. folder u kome će se čuvati vaš java projekat. Može
se ostaviti podrazumevani, ponuđeni direktorijum ili izabrati željeni.
Kada je instaliran JDK, podešena JAVA_HOME varijabla, preuzet i pokrenut Eclipse razvojni
alat, može se reći da je okruženje podešeno za kreiranje prvog programa u jeziku Java.
2.3. Kreiranje prvog programa
Kreiranje programa obuhvata tri glavna koraka: unošenje, prevođenje (kompajliranje) i pokretanje
programa.
2.3.1. Unošenje programa
Program u jeziku Java se na logičkom nivou sastoji od jedne ili više klasa. Izvorni tekst svake
klase se piše u posebnoj datoteci čiji naziv mora početi imenom klase koju sadrži, a ekstenzija te
datoteke mora biti .java.
Slika 2.8 – Pokretanje Eclipse
14
U nastavku je prikazan primer 1. koji se sastoji od samo jedne klase Zdravo.
U ovom primeru, koristeći bilo koji editor, tekst klase treba sačuvati u datoteku pod nazivom
Zdravo.java. Treba voditi računa i o tome da raspored velikih i malih slova u imenu klase i
imenu datoteke mora biti isti. Java pravi razliku između malih i velikih slova.
2.3.2. Prevođenje programa
Pre izvršavanja program u programskom jeziku Java se mora prevesti u odgovarajući bajtkod.
Svaka klasa u programu može se prevoditi nezavisno od drugih klasa programa. Prevođenje jedne
klase obavlja Java prevodilac koji se pokreće iz komandne linije kao na slici 2.8.
Prevodilac javac napraviće datoteku pod nazivom Zdravo.class koja sadrži bajtkod programa.
Kao što je ranije pomenuto, bajtkod je međuproizvod sačinjen od naredbi koje treba da izvrši Java
virtualna mašina.
2.3.3. Pokretanje programa
Pokretanjem izvršavanja neke klase započinje se izvršavanje metode u toj klasi sa službenim
imenom main.U datom primeru klase Zdravo ta metoda se sastoji od samo jedne naredbe kojom
se ispisuje određena poruka na ekranu.
Izvršavanje dobijenog bajtkoda neke klase obavlja se Java interpreterom koji se pokreće
komandom java. Za konkretan primer to izgleda kao na slici 2.9.
public class Zdravo {
public static void main(String[] args) {
System.out.println("Zdravo svete!");
}
}
C:\> javac Zdravo.java
C:\> java Zdravо
Primer 1. – Prvi program „Zdravo svete!“
Slika 2.8. – Komanda za prevođenje koda
Slika 2.9 – Komanda za pokretanje programa
15
Кada se program izvrši na ekranu se ispisuje poruka data na slici 2.10.
2.4. Elementi jezika Java
Skup znakova (engl. character set) koji se koristi u jeziku Java čine mala i velika slova engleskog
alfabeta, mala i velika slova većine alfabeta sveta, deset decimalnih cifara i veći broj znakova
interpunkcije. Pravi se razlika između malih i velikih slova kako u službenim delovima programa
tako i unutar običnih tekstova .
Leksički simboli (engl. tokens) su nedeljivi nizovi znakova. U jeziku Java dele se na identifikatore,
konstante, ključne reči, komentare, operatore i separatore. Leksički simboli mogu da se pišu, uz
nekoliko izuzetaka, spojeno ili međusobno razdvojeno proizvoljnim brojem „belih” znakova. Beo
znak između leksičkih simbola je neophodan, ako bi se njegovim izostavljanjem dobio drugi
postojeći leksički simbol [4].
U bele znakove (engl. white spaces) spadaju znak za razmak, tabulacija, vertikalna tabulacija,
prelazak u novi red i prelazak na novi list.
U širem smislu u bele znakove se ubrajaju i komentari, jer ih prevodilac zanemaruje prilikom
prevođenja.
Naredbe (engl. statements) su nizovi leksičkih simbola. Postoje deklarativne i izvršne naredbe.
Deklarativnim naredbama definišu se neki elementi programa (podaci, metode, klase...), dok se
izvršnim naredbama izvode neke obrade.
Programi su nizovi naredbi pomoću kojih se ostvaruju složene obrade podataka.
Zdravо svete!
Slika 2.10 – Prikaz poruke na ekranu
16
3. Tipovi podataka
Java je strogo tipiziran jezik. To proizilazi iz činjenica da u programskom jeziku Java svaka
promenljiva ima svoj tip, svaki izraz ima svoj tip, a svaki tip je strogo definisan. Takođe u svim
operacijama dodeljivanja vrednosti – bilo da su eksplicitne ili da se obavljaju prosleđivanjem
parametara u pozivima metoda – proverava se kompatibilnost tipova. Nema automatskog
nametanja niti pretvaranja nekompatibilnih tipova. Java prevodilac proverava sve izraze i
parametre i utvrđuje da li su svi tipovi međusobno saglasni. Svako neslaganje tipova predstavlja
grešku koja se mora ispraviti da bi prevodilac završio prevođenje klase.
3.1. Primitivni tip podataka
U programskom jeziku Java je definisano osam elementarnih tipova podataka: bajt (byte), kratak
celobrojni (short), celobrojni (int), dugačak celobrojni (long), znakovni (char), broj u pokretnom
zarezu (float), broj u pokretnom zarezu dvostruke tačnosti (double) i logički tip (boolean).
Primitivni tipovi predstavljaju jednostavne vrednosti, a ne složene objekte. Iako je Java u principu
potpuno objektno orijentisana, njeni primitivni tipovi podataka to nisu. Svi primitivni tipovi imaju
tačno određenu veličinu memorije u bajtovima za zapisivanje odgovarajućih vrednosti. Zbog toga
svi primitivni tipovi podataka imaju tačno definisan opseg vrednosti koje im pripadaju.
3.1.1. Celi brojevi
U jeziku Java su definisana četiri tipa celobrojnih podataka: byte, short, int i long. Sve su to
pozitivni i negativni brojevi sa predznakom. Dužinu celobrojnog tipa podataka ne treba shvatati
kao količinu memorije koju on zauzima, već kao ponašanje koje on nameće promenljivama i
izrazima tog tipa. Izvršno okruženje jezika Java je slobodno da koristi bilo koju veličinu sve dok
se tipovi podataka ponašaju onako kako su deklarisani. Veličina i opseg celobrojnih tipova
podataka široko variraju, i prikazani su u tabeli 1.
Slika 3.1 – Primitivni tipovi
17
Tip Veličina Opseg vrednosti
long 64 od -9.223.372.036.854.775.808 do 9.223.372.036.854.775.807
int 32 od -2.147.483.648 do 2.147.483.647
short 16 od -32.768 do 32.767
byte 8 od -128 do 127
byte – najmanji celobrojni tip podatka, to je 8-bitni ceo broj u opsegu -128 do 127. Podrazumevana
vrednost promenljive tipa byte je 0. Promenljive tipa byte posebno su korisne pri radu s tokovima
podataka sa mreže ili iz datoteke. Promenljive tipa byte deklariše se pomoću rezervisane reči byte,
na sledeći način:
short – je 16-bitni broj s predznakom. Opseg vrednosti mu je između -32.768 i 32.767.
Podrazumevana vrednost promenljive tipa short je 0. Verovatno je to tip koji se najmanje koristi.
int – tip celobrojnih podataka koji se najčešće koristi. To je 32-bitni ceo broj s predznakom, čiji je
opseg vrednosti od -2.147.483.648 do 2.4832.147.647. Podrazumevana vrednost promenljive tipa
int je 0. Promenljiva tipa int se često koristi za upravljanje petljama i za indeksiranje nizova.
long – je 64-bitni ceo broj sa predznakom koji je pogodan kada tip int nije dovoljan za datu
vrednost. Podrazumevana vrednost promenljive tipa long je 0. Opseg vrednosti tipa long veoma
je velik. To ga čini pogodnim kada treba raditi sa veoma velikim brojevima.
3.1.2. Brojevi u pokretnom zarezu
Brojevi u pokretnom zarezu poznatiji kao realni brojevi koriste se za izračunavanje izraza gde je
potreban i decimalan deo. Postoje dva tipa brojeva u pokretnom zarezu: float i double, koji
predstavljaju brojeve jednostruke i dvostruke tačnosti. Njihova veličina i opseg vrednosti prikazani
su u tabeli 3.2.
byte a; byte b;
short s; short t;
int i; int j;
long l;
long k;
Tabela 1 – Opseg vrednosti celobrojnih tipova podataka
18
Tip Veličina Opseg vrednosti
double 64 od 4.9e-324 do 1.8e+308
float 32 od 1,4e-045 do 3,4e+038
float – predstavlja brojeve sa jednostrukom tačnošću i zauzima 32 bita memorije. Podrazumevana
vrednost promenljive tipa float je 0.0f. Rad sa brojevima jednostruke tačnosti na nekim
procesorima je brži i zahteva dva puta manje memorije od brojeva dvostruke tačnosti, ali rezultati
postaju netačni kada su argumenti vrlo veliki ili vrlo mali. Promenljive tipa float korisne su
potrebne vrednosti s decimalnim delom, ali ne i velika preciznost.
double – decimalni broja, dvostruke tačnosti, zauzima 64 bita memorije. Podrazumevana vrednost
promenljive tipa double je 0.0d. Računanje s brojevima dvostruke tačnosti na nekim savremenim
procesorim, optimizovanim za brze matematičke proračune, brže je nego sa brojevima jednostruke
tačnosti.matematičke funkcije npr. sin(), cos() i sqrt() kao rezultat daju vrednosti tipa double. Kada
tokom mnogobrojnih iteracija treba održati tačnost ili raditi sa brojevima koje imaju više značajnih
cifara, najbolji je tip double.
3.1.3. Znakovi
U programskom jeziku Java je char tip koji se koristi za predstavljanje znakova. Međutim treba
imati u vidu da char u programskom jeziku Java nije isto što i char u jezicima C i C++. U jezicima
C i C++ tip char je veličine 8 bitova. To nije slučaj u programskom jeziku Java, jer Java za
predstavljanje znakova koristi standard Unicode. Unicode definiše potpun skup međunarodnih
znakova koji može da prikaže znake iz svih svetskih jezika. Za jedinstveno predstavljanje svakog
znaka Unicode koristi 16 bitova – zato u jeziku Java tip char zauzima 16 bitova. Opseg vrednosti
tipa char je između 0 i 65536, nema negativnih vrednosti. U primeru 2. ilustrovana je upotreba
promenljive tipa char.
double d;
float f;
float l;
Tabela 2 – Opseg vrednosti realnih tipova podataka
19
Nakon pokretanja ovog programa, na ekranu se ispisuje poruka kao na slici 3.2.
3.1.4. Logičke vrednosti
Za logičke vrednosti u jeziku Java koristi se primitivni tip podataka boolean. Može imati samo
jednu od dve moguće vrednosti true (tačno) ili false (netačno). Podrazumevana vrednost
promenljive tipa boolean je false. Vrednost tog tipa daju svi operatori za poređenje. Tip boolean
je takođe obavezan tip u uslovnim izrazima koji upravljaju kontrolnim naredbama, kao što su if ,
for, while.
Primer 3. prikazuje upotrebu logičke vrednosti.
Ovaj program će pri pokretanju imati ispis na ekranu kao na slici 3.3.
ch1 i ch2: X Y
public class PrimerBoolean { public static void main(String[] args) {
boolean b; // deklaracija promenljive
// ispisuje podrazumevanu vrednost prom. tipa boolean
System.out.println("Vrednost b je: " + b);
b = true;
// ispisuje novu dodeljenu vrednost prom. tipa boolean
System.out.println("Vrednost b je: " + b);
}
}
public class PrimerChar { public static void main(String[] args) {
char ch2 = 'Y'; // inicijalizacija promenljive
char ch1 = 88; // kod za slovo X
// ispis vrednosti prom. tipa char
System.out.println("ch1 i ch2: " + ch1 + " " + ch2);
}
}
Vrednost b je: false
Vrednost b je: true
Primer 2. – Upotreba proemnljive tipa char
Slika 3.2 – Prikaz poruke ne ekranu
Primer 3. – Upotreba promenljive tipa boolean
Slika 3.3 – Prikaz poruke ne ekranu
20
3.2. Referentni tip podatka
Promenljiva referentnog tipa (klasni tip) sadrže reference na podatke, odnosno adresu na kojo se
mogu naći odgovarajući podaci. Podaci su smešteni u objektima. Dok promenljiva primitivnog
tipa sadrži binarnu reprezentaciju neke vrednosti, promenljiva referentnog tipa sadrži binarnu
reprezentaciju adrese nekog objekta.
Promenljiva referentnog tipa se kreira pomoću definisanih konstruktora neke klase. Te klase mogu
biti definisane od strane programera ili se koriste neke već postojeće klase iz biblioteke jezika Java
(npr.String). Kreiranje objekata vrši se pomoću ključne reči new.
Ako bi se ovaj izraz raščlanio, zapravo se izvršavaju sledeće tri akcije:
1. Dog pas = new Dog(); - deklaracija promenljive, alocira se prostor u memoriji za
referentnu promenljivu čije ime je pas koja je tipa Dog, ona je od tog trenutka pa zauvek
tipa Dog;
2. Dog pas = new Dog(); - kreiranje objekta, alocira se prostor za novi objekat tipa
Dog;
3. Dog pas = new Dog(); - dodeljuje se novi objekat tipa Dog referentnoj promenljivoj pas,
pa se od ovog trenutka objektu tipa Dog pristupa preko reference pas [5].
Tip objekta je određen klasom. U programskom jeziku Java, referenca na objekat ne mora da bude
isto što i adresa objekta u memoriji. Referenca je jednostavno vrednost na osnovu koje Java
virtualna mašina može da pristupi objektu.
Slika 3.4 – Referentni tip
Dog pas = new Dog();
21
4. Elementarne konstrukcije
Elemente jezika koje prevodilac izdvaja tokom prevođenja programa kao nedeljive celine
(tokene) čine: identifikatori, literali, separatori, operatori, ključne reči, komentar.
4.1. Identifikatori
Identifikatori (engl. identifiers) služe za označavanje svih vrsta elemenata programa: podataka,
simboličkih konstanti, tipova podataka koje definiše programer, potprograma i oznaka koje služe
kao odredišta za naredbe skokova. Pravila kojih se moramo pridržavati pri korišćenju
identifikatora su sledeće:
Svi identifikatori počinju slovom, donjom crtom (_) ili znakom dolar ($). Prvi znak ne sme
da bude cifra;
Posle prvog znaka identifikator može da sadrži bilo koju kombinaciju znakova;
Ključne reči se ne smeju koristiti za identifikatore;
Pravi se razlika između malih i velikih slova (engl. case sensitivity), tako da su A i a dva
različita identifikatora.
4.2. Literali
Literali (engl. literals) se koriste da izraze konkretne vrednosti bilo kog tipa unutar programa.
Literal može biti konstantna vrednost primitivnog tipa ili String objekta.
4.2.1. Cleobrojni literali
Celi brojevi su verovatno najčešći tip podataka u programiranju. Svaka celobrojna vrednost
predstavlja celobrojni literal. Za celobrojne literale važi sledeće:
celobrojne vrednosti mogu biti izražene dekadnim, oktalnim ili heksadekadnim
literalima,
dekadni - nikada ne počinju cifrom 0,
oktalni - počinju cifrom 0,
heksadekadni - počinju znacima 0x ili 0X,
literali tipa long imaju sufiks L ili l.
int a = 75; // u dekadnom sistemu
int b = 0113; // u oktalnom sistemu
int c = 0x4b; // u heksadekadnom
22
4.2.2. Literali za brojeve u pokretnom zarezu
Brojevi u pokretnom zarezu (realni brojevi) predstavljaju vrednosti iz dekadnog sistema koje
sadrže i decimalni deo. Oni se mogu prikazivati u standardnom ili naučnom formatu. Standardni
format se sastoji od celobrojnog dela, decimalne tačke i decimalnog dela. Naučni format koristi
broj u pokretnom zarezu, napisan u standardnom formatu, kojem sledi sufiks koji označava stepen
broja 10 s kojim treba pomnožiti navedeni broj. Stepen broja 10 označava se slovom e ili E, iza
koga sledi pozitivan ili negativan ceo broj.
Za ove literale važi sledeće:
predstavljaju brojeve sa decimalama, stoga oni uključuju i decimalnu tačku ili e karakter,
literali za brojeve u pokretnom zarezu su podrazumevano tipa double, može stajati sufiks
D ili d,
literali za brojeve u pokretnom zarezu tipa flaot sadrži sufiks F ili f .
4.2.3. Logički literali
Logički literali su jednostavni. Postoje samo dve vrednosti koje podatak tipa boolean može imati:
true i false. Vrednosti true i false ne pretvaraju se ni u kakav numerički ekvivalent. Literal true
nije jedinica, niti je literal false jednak null. U jeziku Java se logički literali mogu dodeliti samo
promenljivama tipa Boolean ili koristiti u izrazima s logičkim operatorima.
4.2.4. Znakovni i String literali
Znakovi u programskom jeziku Java predstavljaju indekse u skupu znakova Unicode. To su 16-
bitne vrednosti koje se mogu pretvariti u cele brojeve i obrađivati pomoću celobrojnih operatora
npr. operatorima za sabiranje i oduzimanje. Za ovaj tip literal važi sledeće:
znakovni literali predstavljaju konstante od jednog karaktera, između jednostrukih
navodnika,
String literali predstavljaju više karaktera, između dvostrukih navodnika,
bilo koji karakter može se izraziti njegovim numeričkim ASCII kodom stavljajući karakter
'\', a zatim ASCII kôd zapisan u oktalnom ili heksadekadnom zapisu.
double num1 = 3.01e25; // 3.01 * 10^25
double num2 = 7.69852;
char a = '\u0041'; // kod za slovo A char b = 'a';
String s = "zdravo svete";
23
U datoj tabeli 3 opisani su specijalni znakovni literali.
Tabela 3 – Specijalni znakovni literali
Literal Opis
'\n' novi red (newline)
'\r' povratak na početak reda (carriage return)
'\f' sledeća strana (formfeed)
'\b' brisanje znaka levo od kursora (backspace)
'\s' razmak (space)
'\t' tabulator (tab)
'\'' jednostruki navodnik
'\"' dvostruki navodnik
'\\' kosa crta nalevo (backslash)
'\ddd' oktalni kôd karaktera
'\uxxx' heksadekadni kôd karaktera iz UNICODE skupa
4.3. Operatori
Operatori (engl. operators) omogućavaju izvršavanje operacija nad promenljivim dajuci pri tom
određeni rezultat.
Aritmetički operatori su operatori koji se mogu primenjivati na vrednosti bilo kog numeričkog tipa
- byte, short, int, long, float, double. U aritmetičke operatore spadaju pet binarnih --, +, *, /, % i
dva unarna operatora ++, --. Primenjivanje binarnih operatora odgovara matematičkim
operacijama - sabiranje, oduzimanje, množenje, osim u slućaju deljenja. U programskom jeziku
Java operatorom / vrši se celobrojno deljenje (npr. pri deljenu vrednosti 5 / 2 rezultat bi bio 2, dok
se razlomljeni deo odbacuje).
Neka promenljiva a ima vrednost 10 i promenljiva b vrednost 5, u tabeli 4 opisani su svi aritmetički
operatori.
Operator Opis Primer
+ Binarni operator koji vraća vrednost zbira dva broja a + b bilo bi 15
- Binarni operator koji vraća vrednost razlike dva broja a – b bilo bi 5
* Binarni operator koji vraća vrednost proizvoda dva broja a * b bilo bi 50
/ Binarni operator koji vraća celobrojnu vrednost količnika dva broja, a eventualne decimale odbacuje
a / b bilo bi 2
% Binarni operator daje ostatak pri deljenju dve vrednosti a % b bilo bi 0
Tabela 4 – Aritmetički operatori
24
++ Unarni operator koji daje vrednost uvećanu za 1 a ++ bilo bi 11
-- Unarni operator koji daje vrednost umanjenu za 1 a – bilo bi 9
Relacijski operatori se koriste za upoređivanje vrednosti bilo kog numeričkog tipa ili tipa char.
Ovi operatori vraćaju vrednost true ili false (tipa boolean). Kada se upoređuju znakovi tipa char,
tj. karakteri, zapravo se porede njihove numeričke Unicode vrednosti (npr. 'a'<'z' vraća
vrednost true, jer kôd znaka a ima menjaju vrednost od kôda znaka z).
Neka promenljiva a ima vrednost 10 i promenljiva b vrednost 5, u tabeli 5 opisani su svi relacijski
operatori.
Operator Opis Primer
== Proverava da li su dve vrednosti jednake i ako jesu vraća vrednost true, u suprotnom false
(a == b) bi bilo netačno
!= Proverava da li su dve vrednosti različite ako jesu vraća vrednost true, u suprotnom false
(a != b) bi bilo netačno
> Proverava da li je leva vrednost veća od desne i ako jeste vraća vrednost true, u suprotnom false
(a > b) bi bilo tačno
< Proverava da li je leva vrednost manja od desne i ako jeste vraća vrednost true, u suprotnom false
(a < b) bi bilo tačno
>= Proverava da li je leva vrednost veća ili jednaka desnoj i ako jeste vraća vrednost true, u suprotnom false
(a >= b) bi bilo tačno
<= Proverava da li je leva vrednost manja ili jednaka desnoj i ako jeste vraća vrednost true, u suprotnom false
(a <= b) bi bilo tačno
Logički operatori se primenjuju na logičke izraze i daju isto logičke vrednost.
Neka promenljiva a ima vrednost true i promenljiva b vrednost false, u tabeli 6 opisani su svi
logički operatori.
Operator Opis Primer
&&
Logičko I (konjunkcija) - binarni logički operator koji daje rezultat true kada su oba izraza true, u svakom dugom slučaju vraća false
(a && b) bi bilo netačno
||
Logičko ILI (disjunkcija) - binarni logički operator koji daje rezultat true kada je bar jedan od izraza true, u suprotnom daje false
(a || b) bi bilo tačno
!
Negacija - unarni logički operator koji vraća true kada se primeni na operandu koja ima vrednost false i obrnuto.
!(a && b) bi bilo tačno
Tabela 5 – Relacijski operatori
Tabela 6 – Logički operatori
25
Operatori nad bitovima se mogu primenjivati nad tipovima int, long, short, char i byte.
Neka je a = 60 i b = 13 u binarnom zapisu ovi brojevi su a = 0011 1100 i b = 0000 1101, u tabeli
7 opisani su svi bitovski operatori.
Operator Opis Primer
& Bitovsko I (Konjukcija nad bitovima) - prepisuje jedinice iz binarnog zapisa u rezultat ukoliko one postoje u obe operande
(a & b) bi bilo 12, što je zapisano binarno - 0000 1100
| Bitovsko ILI (Disjunkcija nad bitovima) - prepisuje jedinice iz binarnog zapisa u rezultat ukoliko one postoje u bar jednoj operandi
(a | b) bi bilo 61, što je zapisano binarno - 0011 110
^ Bitovsko ekskluzivno ILI - prepisuje jedinice iz binarnog zapisau rezultat ukoliko one postoje u samo jednoj operandi, u drugoj ne
(a ^ b) bi bilo 49, što je zapisano binarno - 0011 0001
~ Bitovski unarni operator koji daje inverzni binarni zapis datog broja, tamo gde su jedinice u rezultat upisuje nule i tamo gde su nule u rezultat upisuje jedinice
( ~ a) bi bilo -61, što je binarno zapisano - 1100 0011
<< Levo pomeranje (šiftovanje) — primenom ovog operatora bitovi prve operande se pomeraju u levo za broj pozicija naveden kao druga operanda.
(a << 2) bi bilo 240, što je binarno zapisano - 1111 0000
>> Desno pomeranje (šiftovanje) — primenom ovog operatora bitovi prve operande se pomeraju u desno za broj pozicija naveden kao druga operandai.
(a >> 2) bi bilo 15, što je binarno zapisano - 1111
>>>
Desno pomeranje (šiftovanje) — primenom ovog operatora bitovi prve operande se pomeraju u desno za broj pozicija naveden kao druga operanda. Na početna upražnjena mesta upisuju se nule
(a >>> 2) bi bilo 15, što je binarno zapisano - 0000 1111
Operator izbora:
izraz1 ? izraz2 : izraz3;
Najpre se izračunava izraz1, ako on ima ne-nula vrednost (tj. ako je vrednost true), onda se
izračunava vrednost izraza izraz2 i to je rezultat čitavog uslovnog izraza, u suprotnom se
izračunava vrednost izraz3 i to je rezultat uslovnog izraza.
Tabela 7 – Bitovski operatori
26
Operator dodele je binarni operatori koji neku vrednost pridružuje datoj promenljivoj i obeležava
se simbolom =. Za većinu binarnih operatora postoje odgovarajući složeni operatori dodele +=, -=, /=, %=, &= itd.
U tabeli 8 su opisani svi operatori dodele koji se koriste u jeziku Java.
Operator Opis Primer
= Dodeljuje levoj operandi vrednost operande ili izraza sa desne strane.
c = a + b vrednost zbira a i b će biti dodeljena promenljivoj c
+= Dodeljuje levoj operandi vrednost zbira leve i desne operande
c += a je ekvivalentno sa c = c + a
-= Dodeljuje levoj operandi vrednost razlike leve i desne operande
c -= a je ekvivalentno sa c = c - a
*= Dodeljuje levoj operandi vrednost proizvoda leve i desne operande
c *= a je ekvivalentno sa c = c * a
/= Dodeljuje levoj operandi vrednost celobrojnog deljenja leve i desne operande
c /= a je ekvivalentno sa c = c / a
%= Dodeljuje levoj operandi ostatak pri deljenju leve i desne operande
c %= a je ekvivalentno sa c = c % a
<<= Pomeranje u levo za broj desne operande c <<= 2 je isto kao i c = c << 2
>>= Pomeranje u desno za broj desne operande c >>= 2 je isto kao i c = c >> 2
&= Bitovsko I sa operatorom dodele - primenjuje se na levu i desnu operandu, a rezultat smešta u levu
c &= 2 je isto kao i c = c & 2
^= Bitovsko ekskluzivno ILI sa operatorom dodele - primenjuje se na levu i desnu operandu, a rezultat smešta u levu
c ^= 2 je isto kao i c = c ^ 2
|= Bitovsko ILI sa operatorom dodele - primenjuje se na levu i desnu operandu, a rezultat smešta u levu
c |= 2 je isto kao i c = c | 2
Tabela 8 – Operatori dodele
27
4.4. Ključne reči
Ključne reči (engl. keywords) jezika Java su rezervisane reči i ne mogu biti korišćene kao
identifikatori. U ključne reči spadaju i const i goto, iako se ne koriste u jeziku Java, ali bi njihova
pojava u programu mogla da zbuni programere koji su ranije koristili jezike C i C++.
Sve ključne reči su pobrojane tabeli 9.
abstract assert boolean break byte case
catch char class continue const default
do double else enum extends false
final finally float for goto if
implements import instanceof int interface long
native new null package private protected
public return short static strictfp super
switch synchronized this throw throws transient
true try void volatile while
4.5. Komentari
Komentari (engl. comments) su tekstovi na prirodnom jeziku, namenjeni čitaocu programa radi
lakšeg razumevanja namene i funkcionisanja programa. Takve konstrukcije se zanemaruju
prilikom prevođenja programa. Iako za prevodilac komentari kao da ne postoje, to ne znači da su
oni nevažni. Bez komentara je jako teško shvatiti i malo složenije programe.
Postoje tri vrste komentara.
Komentari u jednom redu, započinju znakom // i obuhvataju tekst do kraja tog reda.
Komentari koji sadrže tekst koji se prostire u više redova, započinju znakom /* i završavaju
se znakom */.
Dokumentacioni komentari započinju /** i završavaju se znakom */ obuhvataju tekst u više
redova. Ovi komentari služe za pisanje dokumentacije o klasi direktno unutar njenog
izvornog koda. Pored običnog teksta dokumentacioni komentari mogu da sadrže i HTML
tagove i specijalne reči koje počinju znakom @.
Tabela 9 – Ključne reči
28
5. Modifikatori
Modifikatori (engl. modifiers) su ključne reči koje stoje u definiciji klasa, metoda ili
promenljivih i bliže ih određuju. Modifikatori su opcioni i njihov redosled nije bitan. U nekim
situacijama su implicitno definisani tj. podrazumeva se njihovo korišćenje. U programskom jeziku
Java se modifikatori mogu podeliti na dve grupe, oni koji se koriste za kontrolu pristupa i ostali
modifikatori.
5.1. Pristupni modifikatori
U programskom jeziku Java se koristi nekoliko modifikatora za određivanje nivoa pristupa nekoj
klasi, metodi ili promenljivoj.
Postoje 4 modifikatora pristupa i sledi opis za svaki od njih.
private - označava da je metoda ili promenljiva uz koju stoji vidljiva samo unutar klase u
kojo je definisana, znači da joj se iz druge klase ne može pristupati. Klase i interfejsi ne
mogu da budu private.
public - označava da je klasa, metoda ili promenljiva uz koju stoji javna, dakle, može joj
se pristupati iz bilo koje klase.
protected - označava da je metoda ili promenljiva vidljiva unutar klase u kojoj je
definisana, u potklasama koje su izvedene (nasleđene) od te klase i paketa unutar kojeg se
ta klasa nalazi.
podrazumevani pristupni modifikator - je zapravo slučaj kada pri deklaraciji modifikatori
ne bude definisan, tada je metoda ili promenljiva deklarisana bez modifikatora vidljiva u
svim klasama na nivou paketa [7].
public class Auto { private String boja; private int brzina; ... }
//metoda main() je uvek public
public void main (String[] arguments){ ...
}
class Vrata { //metoda je protected protected boolean otvoriVrata(Vrata d) { ... } }
29
5.2. Ostali Modifikatori
Pored modifikatora pristupa, u programskom jeziku Java je dostupno i nekoliko modifikatora koji
specificiraju odgovarajuće karakteristike određenih promenljivih, metoda ili klasa.
static - se koristi uz promenljive i metode. Promenljiva uz koju stoji modifikator static
postoji i kada nije kreirana instanca te klase - one se jos naziva klasne promenljiva (engl.
class variable). Metoda uz koju stoji modifikator static može biti pozivana preko imena
klase i kada nema kreiranih instanci te klase - one se jos nazivaju klasne metode (engl.
class methods).
final - se koristi uz promenljive, metode i klase. Promenljiva uz koju stoji final modifikator
se inicijalizuje samo jednom, vrednost se ne menja. Kod promenljivih referentnog tipa sa
modifikatorom final obezbeđuje da se ta promenljiva ne može preorjentisati da pokazuje
na neki drugi objekat. Metode uz koju stoji final modifikator ne može biti redefinisana u
okviru neke podklase. Iz klasa uz koju stoji final modifikator ne može se kreirati potklasa.
abstract - se koristi uz metode i klase. Metode uz koju stoji abstract modifikator je
deklarisana bez implementacije. Definicija te metode se mora obezbediti u okviru neke
neapstraktne podklase. Ako klasa sadrži bar jednu abstract metodu mora biti abstract. Ako
je klasa abstract ne mora da sadrži abstract metode. Klasa uz koju stoji abstract
modifikator ne može biti instancirana tj. ne može kreirati objekte te klase. Apstraktne klase
služe isključivo da budu nasleđene.
synchronized - se koristi za metode. Dve niti ne mogu simultano da izvršavaju metodu.
native - se koristi u specijalnim situacijama, kada je potreban pristup naredbama
operativnog sistema ili procesora, odnosno nekim metodama i nekom kodu koji nije Java
kôd. Sprečavanje kompajlera da tumači ono što se nalazi u okviru te metode, postiže se
modifikatorom native, koji komunicira sa kompajlerom omogućavajući da unutra postoji
kôd koji nije kôd programskog jezika Java.
volatile - koristi se za promenljive. Vrednost se moze menjati nezavisno od Java programa,
kompajler ne prati njene promene.
transient - je sigurnosni mehanizam, odnosi se isključivo na promenljive, i komunicira sa
promenljivom koja ima modifikator transient tako da ona ne može da napusti virtuelnu
mašinu. Bilo kakvo snimanje klase u kojoj se nalazi promenljiva tipa transient, ili puštanje
kroz mrežu instance klase koja u sebi ima promenljivu transient, će prouzrokovati da ta
promenljiva nestane iz klase, dakle neće više postojati, odnosno povećava sigurnost te
promenljive. Promenljiva može da postoji samo u okviru virtuelne mašine.
30
6. Upravljačke naredbe
Upravljačke naredbe se koriste za upravljanje toka programa na osnovu promena stanja u
programu. U programskom jeziku Java se koriste uslovne naredbe, naredbe za iteracije i naredbe
za skokove. Uslovne naredbe omogućuju da program izabere različit tok izvršavanja na osnovu
rezultata izračunavanja određenog izraza ili stanja određene promenljive. Naredbe za iteracije
omogućavaju programu da jednu ili više naredbi ponovi više puta. Naredbe za skokove
omogućavaju nelinearno izvršavanje programa.
6.1. Uslovne naredbe
Java podržava dve uslovne naredbe: if i switch. Po moću njih se upravlja izvršavanjem programa
na osnovu uslova koji su poznati samo u vreme izvršavanja.
6.1.1. Naredba if
Naredba if je naredba za uslovno grananje, koja omogućava da se program usmeri na jednu od dve
različite putanje. Opšti oblik naredbe if izgleda ovako:
if (uslov) naredba1; else naredba2;
Unutar naredbe if, svaka naredba može da bude prosta naredba ili složen iskaz unutar vitičastih
zagrada. Uslov je svaki izraz koji vraća vrednost tipa boolean. Odredba else nije obavezna.
Naredba if radi na sledeći način: testira dati uslov, koliko je on tačan (true) izvršava se naredba1,
ukoliko je uslov netačan (false) izvršava se naredba2 (ukoliko postoji odredba else).
U primeru 4. proverava se da li je vrednost promenljive a manja od 15 i ispisuje odgovarajuću
poruku ukoliko je uslov ispunjen.
Pri pokretanju ovog programa na ekranu se ispisuje poruka kao na slici 6.1
public class Test {
public static void main(String args[]) {
int a = 10; // inicijalizacija promenljive
// ukoliko je uslov ispunjen ispisuje se poruka
if (a < 15)
System.out.print("Uslov je tačan!");
}
}
Uslov je tačan!
Primer 4. – Ispitivanje uslova
Slika 6.1 – Ispis nakon provere uslova
31
Izraz koji upravlja naredbom if najčešće sadrži operatore za poređenje, ali to nije obavezno.
Naredbom if može se upravljati i samo pomoću promenljive tipa boolean.
U primeru 5. ilustruje se upotrebu uslova u obliku promenljive tipa boolean i odredbe else.
Na ekranu će biti ispisana poruka kao na slici 6.2.
Mogućnost da se jedna naredba if umetne unutar druge naredbe if ili else naziva se ugnježdeno
uslovljavanje. Kod ovog tipa uslovljavanja potrebno je voditi računa da se naredba else uvek
odnosi na najbližu naredbu if u istom bloku, koja je slobodna (tj. nije već povezana sa nekom
drugom else naredbom).
U primeru 6. prikazano je ugnježdeno uslovljavanje i grupisanje if i else naredbe
Unutrašnje else se odnosi na if (k>100), jer je to najbliže slobodno else unutar istog bloka.
Poslednja odredba else je povezana sa if( i == 10). Iako je prvo slobodno if(j<20), ono ne može
biti povezano sa poslednjim else jer nisu u istom bloku.
Stepenasta naredba if – else – if zasniva se na sekvenci ugnježdenih uslova i izgleda ovako:
public class Test {
public static void main(String args[]) {
boolean parnost = false; // inicijalizacija promenljive
// ukoliko je uslov ispunjen ispisuje se prva poruka
// u suprotnom ispisuje se poruka iz naredbe else
if (parnost)
System.out.print("Broj je paran!");
else
System.out.print("Broj je neparan!");
}
}
Broj je neparan!
if(i == 10) { if(j < 20) a = b;
if(k > 100) c = d;
else a = c; } else a = d;
Primer 5. – Ispitivanje uslova kroz if – else naredbu
Slika 6.2 – Ispis nakon nardebe if - else
Primer 6. – Ugnežđeno uslovljavanje
32
if (uslov1) naredba1; else if (uslov2) naredba2; else if (uslov3) naredba3; . . . else naredba;
Naredba if se izvršava odozgo na dole sve dok jedan od uslova ne bude ispunjen, tada se izvršava
naredba koja prati taj uslov. Ukoliko nijedan od uslova nije ispunjen izvršava se naredba iz krajnje
else odredbe. Dakle, krajnja else odredba je zapravo podrazumevana akcija, ukoliko nje nema, a
svi drugi uslovi su false nista se ne dešava.
U primeru 7. prikazuje se upotreba stepenaste if – else – if naredbe, ispisuje se ocena na osnovu
osvojenih bodova.
Pri pokretanju ovog programa, na ekranu se dobija poruku kao na slici 6.3.
public class Test {
public static void main(String args[]) {
int bodovi = 22; // inicijalizacija promenljive
// redom se proveravaju uslovi sve do prvog koji je ispunjen
if (bodovi < 10) {
System.out.println("nedovoljan 1");
} else if (bodovi >= 10 && bodovi < 20) {
System.out.println("dovoljan 2");
} else if (bodovi >= 20 && bodovi < 30) {
System.out.println("dobar 3");
} else if (bodovi >= 30 && bodovi < 40) {
System.out.println("vrlo dobar 4");
} else if (bodovi >= 40 && bodovi < 50) {
System.out.println("odličan 5");
} else {
System.out.println("Pogrešan unos!");
}
}
}
dobar 3
Primer 7. – Stepenasto uslovljavanje if-else-if
Slika 6.3. – Ispis nakon stepenastog uslovljavanja
33
6.1.2. Naredba switch
Naredba switch koristi se za testiranje uslova. Kod naredbe switch se izbor jednog od više
alternativnih blokova naredbi za izvršavanje vrši na osnovu jednog celobrojnog ili znakovnog
izraza (char, int, short ili byte). U zavisnosti od vrednosti tog izraza izvršava se niz naredbi
pridružen jednom od slučajeva označenih klauzulama case. Pri tom se redom traži prva konstanta
uz klauzulu case koja je jednaka vrednosti izraza i izvršava se niz naredbi pridružen tom slučaju.
Opšti oblik naredbe switch izgleda ovako:
switch (izraz) {
case vrednost1: naredbe1
break;
case vrednost2: naredbe2 break;
. . . default: podrazmevane naredbe }
Ukoliko se nijedna konstanta ne poklapa sa vrednošću izraza, izvršava se naredba default. Pošto
naredba default nije obavezna, u slučaju kada se nijedna konstanta ne poklopi sa vrednošću iz
izraza, a default ne postoji, ništa se ne dešava. Naredba break se koristi unutar naredbe switch kao
završetak grupe naredbi.
Upotreba naredbe switch može se videti u primeru 8.
public class Test {
public static void main(String[] args) {
int br = 20; // inicijalizacija promenljive
// promenljiva br se poredi vrednostima koje stoje uz case
// kada su vrednosti jednake izvršava se naredba
switch (br) {
case 10:
System.out.println("vrednost je 10");
break;
case 20:
System.out.println("vrednost je 20");
break;
case 30:
System.out.println("vrednost je 30");
break;
default:
System.out.println("nije nijedan od slučajeva");
}
}
}
Primer 8. – Ispitivanje uslova naredbeom switch
34
Nakon pokretanja ovog programa dobija se poruka kao na slici 6.4.
6.2. Naredbe za iteraciju
Kako je pri kreiranju programa nekada potrebno izvršiti određene naredbe više puta, u
programskim jezicima obezbeđene su strukture koje omogućavaju ciklično izvršavanje naredbi. U
programskom jeziku Java u tu svrhu koriste se sledeće naredbe: naredba for, while i do-while.
6.2.1. Petlja for
Petlja for koristi se za ciklično izvršavanje bloka naredbi više puta. Preporučuje se korišćenje ove
petlje kada unapred znamo koliko puta treba izvršiti neki deo koda. Postoje dva oblika for petlje -
prvi je tradicionalni oblik koji se koristi od prve verzije Jave, drugi oblik nazivamo „for-each” i
postoji od JDK 5.
Opšti oblik tradicionalne naredbe for izgleda ovako:
for (inicijalizacija; uslov; iteracija) {
//kôd koji se izvršava
}
Ukoliko je potrebno da se izvršava samo jedna naredba vitičaste zagrade nisu neophodne. Petlja
for funkcioniše na sledeći način:
Prvi korak je inicijalizacija (engl.initialization) koji se izvršava pri ulasku u petlju i on se izvršava
samo jednom. To je izraz kojim se zadaje neka početna vrednost kontrolne promenljive. Zatim se
izvršava uslov (engl. condition), to je izraz postavljen pomoću relacijskih operatora, koji
ima boolean vrednost. Ukoliko je uslov ispunjen izvršiće se kôd, a potom će se kontrolnoj
promenljivoj dodeliti nova vrednost koju definišemo na mestu iteracija. Ukoliko uslov nije
ispunjen izlazi se iz for petlje i program nastavlja dalje. Iteracija je uglavnom operator kojim se
menja vrednost kontrolne promenljive, najčešće je uvećavanje ili smanjenje za jedan
(increment/decrement). Dakle, ciklus se ponavlja, svaki put uz proveravanje uslova, izvršavanje
tela petlje i izvršavanja iterativnog izraza, sve dok uslov ne postane neispunjen.
vrednost je 20
Slika 6.4 – Ispis nakon izvršene switch naredbe
35
U primeru 9. koristeći for petlju ispisuju se brojevi od 1 do 10.
U ovom primeru kontrolna promenljiva je deklarisana unutar for petlje, time je obezbeđeno da ova
promenljiva postoji samo unutar petlje. Dakle, kada je ovu promenljivu potrebno koristiti izvan
for petlje, nikako ne sme biti deklarisana unutar petlje pri inicijlizaciji, jer ona prestaj da postoji
po završetku petlje.
Kada je potrebno da izraz za iteraciju ili inicijalizaciju sadrži više naredbi, taj slučaj se rešava
pomoću zareza. U odeljku za iteraciju ili inicijalizaciju moguće je uneti više izraza odvojenih
zarezom. To je obično slučaj kada petljom upravljaju dve ili više promenljivih.
U primeru 11. prikazana je for petlja kojom upravljaju dve promenljive.
Program daje ispis kao na slici 6.5.
Počev od JDK 5, definisana je i „for-each” verzija za petlju for. Ova petlja namenjena je strogo
sekvencijalnom kretanju kroz kolekcije objekata (kao što je niz) od njenog početka do kraja. Opšti
oblik „for-each” verzije petlje videti u nastavku:
public class Test {
public static void main(String args[]) {
//i se umanjuje za 1 sve dok je i>10 i svaki put kada je uslov
//ispunjen ispisuje se vrednost promenljive i
for (int i = 10; i > 0; i--)
System.out.println(i);
}
}
public class Test {
public static void main(String args[]) {
//i se povećava,a j umanjuje za 1 i
// sve dok je i<j stampaju se vrednosti obe promenljive
for (int i = 1, j = 4; i < j; i++, j--) {
System.out.println("i = " + i);
System.out.println("j = " + j);
}
}
}
Primer 9. – Jednostavna for petlja
Primer 10. – Dve promenljive u for petlji
i = 1
j = 4
i = 2
j = 3
Slika 6.5 – Ispis nakon izvršene for petlje
36
for (tip iteraciona promenljiva : kolekcija) {
//kôd koji se izvršava }
U ovoj deklaraciji tip označava tip promenljive, a iteraciona promenljiva je ime promenljive koja
će primati elemente kolekcije, jedan po jedan od njeno početka pa do kraja. U svakom ciklusu
iteraciona promenljiva prima vrednost jednog elementa kolekcije, zatim se izvršava blok naredbi,
ciklusi se ponavljaju onoliko puta koliko ima elemenata u datoj kolekciji. Pošto iteraciona
promenljiva prima vrednost elemenata kolekcije, ona mora biti istog tipa kao i tip elemenata
kolekcije.
Kroz primer 11. može se videti upotreba „for-each” petlje.
Pri pokretanju ovog programa dobija se ispis kao na slici 6.6.
6.2.2. Petlja while
While petlja je najosnovnija petlja programskog jezika Java. Ona ciklično izvršava naredbu ili
blok naredbi sve dok je upravljački izraz tačan. Opšti oblik izgleda ovako:
while (uslov) {
//kôd koji se izvršava }
Konstrukcija while se sastoji od bloka naredbi i uslova. Uslov se prvo ispituje – ako je uslov tačan,
naredbe unutar bloka se izvršavaju. Ovo se ponavlja sve dok uslov ne postane netačan. Zbog toga
public class Test {
public static void main(String args[]) {
int brojevi[] = { 1, 2, 3, 4, 5 };
//„for-each” prolazi kroz niz i ispisuje svaki element for (int i : brojevi)
System.out.println("i = " + i);
}
}
i = 1
i = 2
i = 3
i = 4
i = 5
Primer 11. – Jednostavna for-each petlja
Slika 6.6 – Ispis nakon izvršene for–each petlje
37
što while petlja proverava uslov pre nego što izvrši blok naredbi, upravljačka struktura je često
poznata i kao pred-test petlja. Uslov može da bude svako logički izraz.
Za razliku od for petlje kod while petlje promenljivu moramo prethodno definisati. Ova petlja se
u zavisnosti od uslova i promenljive koju odredimo može izvršiti ni jednom, jednom ili više puta.
U primeru 12. će kroz while petlju biti ispisani brojevi od 15 do 20.
Nakon izvršenja while petlje na ekranu se prikazuje ispis kaon a slici 6.7.
6.2.3. Petlja do-while
Kod while petlje uslov prekida se proverava na početku svake iteracije. U nekim slučajevima,
međutim, pogodnije je proveriti taj uslov na kraju svakog izvršavanja tela petlje. U takvim
slučajevima koristi se do-while petlja, koja uslov prekida proverava na kraju, a na početku se
nalazi ključna reč do.
Opšti oblik ove petlje je:
do {
//kôd koji se izvršava } while (uslov);
Ovo znači da se kôd mora uvek izvršiti prvo i onda se procenjuje izraz ili test stanja. Ako je tačno,
izvršava se telo petlje ponovo. Ovaj proces se ponavlja sve dok izraz ima tačnu vrednost.
public class Test {
public static void main(String args[]) {
int i = 15; // inicijalizacija promenljive
//počevši od inicijalne vrenosti za i, proverava se uslov
//dok je i<21 ispisuju se vrednosti, zatim se i uvećava za 1
while (i < 21) {
System.out.println(i);
i++;
}
}
}
15
16
17
18
19
20
Slika 6.7 – Ispis nakon izvršene while petlje
Primer 12. – Jednostavna while petlja
38
U primeru 13. prikazana je upotreba do-while petlje
Po izvršavanju programa na ekranu se ispisuju brojevi od 10 do 1 kao na slici 6.8.
Petlja iz prethodnog primera može se napisati i na sledeći način:
U ovom primeru u okviru uslova kombinuju se dva izraza - prvi umanjuje vrednost promenljive
za jedan, zatim se ta nova vrednost upoređuje sa nulom. Ako je uslov ispunjen, petlja se nastavlja,
u suprotnom se više ne izvršava.
6.3. Naredbe za skokove
Java obezbeđuje tri naredbe za skokove: break, continue i return. Njihova uloga je da preusmere
tok izvršavanje programa. Ove naredbe obezbeđuju da se izvršavanje programa ne nastavi od
sledeće naredbe po redu, već se tok prekida i usmerava na drugo mesto u programu, koje je
određeno naredbom koja je na datom mestu upotrebljena.
6.3.1. Naredba break
Naredba break u programskom jeziku Java ima dva mesta upotrebe: kada se koristi unutar petlje
i za završavanje niza naredbi u naredbi switch.
public class Test {
public static void main(String args[]) {
int i = 10; // inicijalizacija promenljive
// prvo se izvršavaju naredbe, zatim proverava uslov i sve dok
//je uslov ispunjen naredbe se ciklicno ponavljaju
do {
System.out.print(i);
i--;
} while (i > 0);
}
}
10 9 8 7 6 5 4 3 2 1
do{
System.out.println(i);
} while(--i > 0 );
Primer 13. – Jednostavna do-while petlja
Slika 6.8 – Ispis nakon izvršene do-while petlje
39
Pomoću break naredbe moguće je prekinuti rad petlje i izaći iz nje u nekoj vanrednoj okolnosti
kada za to ima potrebe, a uslov petlje je ispunjen. Kada program naiđe na naredbu break preskače
se sve što sledi u okviru te petlje I program nastavlja sa izvršavanjem prve naredbe koja sledi van
petlje.
Primer 14. ilustruje upotrebu break naredbe.
Ovaj program će dati sledeći izlaz kao na slici 6.9.
Naredbom break prekinuto je ispisivanje brojeva iz datog niza, iako je naredbom for predviđeno
da se ispišu svi brojevi datog niza.
Ova naredba se može koristiti na više mesta u istoj petlji. Kada se break koristi unutar naredbe
switch, ona utiče samo na nju , ne i na petlju koja je možda obuhvata.
6.3.2. Naredba continue
Nekada je potrebno da se ciklus petlje skrati, da se u određenom trenutku neke naredbe preskoče i
tok prebaci na kraj petlje. Takve situacije se rešavaju pomoću continue naredbe. U okviru while i
do–while petlje ova naredba preusmerava tok programa na izraz za proveru uslova koji upravlja
petljom. Kod for petlje naredba continue šalje tok programa na izraz za iteraciju, zatim se
proverava uslov i nastavlja dalje.
public class Test {
public static void main(String args[]) {
int[] numbers = { 10, 20, 30, 40, 50 };
//for-each petljom ispisuju se el. niza sve dok se ne ispuni
//ulov x==30, tada se break naredbom izlazi iz petlje
for (int x : numbers) {
if (x == 30)
break;
System.out.print(x);
System.out.print("\n");
}
}
}
Slika 6.9 – Ispis nakon prekida for petlje
10
20
Primer 14. – Upotreba break naredbe
40
Primer 15. ilustruje upotrebu continue naredbe kroz for petlju.
Ovaj program će imati ispis kao na slici 6.10.
Naredbom continue u ovom primeru se preskoči slučaj kada promenljiva x ima vrednost 30, tako
da taj element niza neće biti ispisan na ekranu.
6.3.3. Naredba return
Naredba return obezbeđuje bezuslovni izlazak iz metode. Programska kontrola se vraća
pozivaocu metode. O ovoj naredbi se može detaljnije govoriti u okviru upoznavanja sa metodama.
Naredba return se najviše koristi pri kreiranju rekurzivnih metoda. Ova naredba dopušta
specificiranje povratne vrednosti koja se vraća pozivaocu metode.
Kroz primer 16. prikazana je upotreba return naredbe.
public class Test {
public static void main(String args[]) {
int[] numbers = { 10, 20, 30, 40, 50 };
//for-each petljom ispisuju se el. niza,za x==30 naredba
//continue preskače korak za ispisivanje i petlja nastavlja
dalje
for (int x : numbers) {
if (x == 30)
continue;
System.out.print(x + " ");
}
}
}
public class Test {
public static void main(String args[]) {
boolean status = true;
//ispis pre return naredbe
System.out.print(("Pre naredbe return.");
//uslov je true, naredbom return prekida se izvršavanje metode
if (status)
return;
System.out.print("Ovo se neće izvršiti.");
}
}
Primer 15. – Upotreba continue naredbe
10 20 40 50
Slika 6.10 – Ispis nakon prekida for petlje
Primer 16. – Upotreba return naredbe
41
Nakon izvršenja programa dobija se poruka kao na slici 6.11.
Kao što se može primetiti kôd koji se nalazi nakon naredbe return nije se izvršio pri pokretanju
ovog programa. Na izlazu je ispisan samo tekst koji se zadaje naredbom pre return naredbe.
Naredba return bezuslovno prekida metodu u kojoj se izvrši, kontrola se vraća pozivaocu metode.
Pre naredbe return.
Slika 6.11 – Ipis poruke nakonreturn naredbe
42
7. Upoznavanje sa metodama, objektima i klasama
7.1. Metode
Koncept potprograma je sve prisutan u programskim jezicima, ali se pojavljuje pod različitim
imenima: metoda, procedura, funkcija i slično. Njegova glavna svrha je to da se složeni program
podeli u manje delove koji se mogu lakše i nezavisno razvijati. Osim što je deo programa i što
obično obavlja jednostavniji zadatak, potprogram ima sličnu logičku strukturu kao glavni program.
Metode (engl. methods) su potprogrami koji obavljaju neki specifični zadatak. Sastoje se od niza
naredbi i promenljivih koje predstavljaju neku funkcionalnu celinu. Metoda mora imati
jedinstveno ime koje se može koristiti na različitim mestima u programu kao zamena za ceo niz
naredbi. Za korišćenje metode koristi se termin "pozivanje" metode. Pri svakom pozivu izvršava
se niz naredbi koje sadrži ta metoda. Pre početka izvršavanja naredbi, metodi se mogu proslediti
neke vrednosti koje se nazivaju argumenti metode. Takođe na kraju izvršavanja naredbi, metod
može imati povratnu vrednost koju ta metoda vraća kao rezultat.
7.1.1. Kreiranje metode
Metoda se sastoji iz dva dela: zaglavlja i tela metode. Telo metode se sastoji od niza naredbi
između vitičastih zagrada. Zaglavlje metode sadrži sve informacije koje su neophodne za
pozivanje metode.
Opšti oblik pisanja metoda u programskom jeziku Java i opis svih pojmova iz njene sintakse:
modifikator povratniTip imeMetode (listaParametara ) {
//telo metode
}
modifikator - određuje nivo pristupa metode tj. definiše odakle se metoda može videti
(public, private, protected, ili nije naveden ako se koristi u istoj klasi),
povratniTip - pokazuje kog tipa će biti povratna vrednost metode, ukoliko metoda vraća
neku vrednost (int, double, float, ..., String, ArrayList...). Ukoliko metoda ne vraća neku
konkretnu vrednost ona je tipa void,
imeMetode - ovo je ime metode, koje bi po neformalnoj konvenciji trebalo da opisuje šta
je funkcija metode,
listaParametara - predstavljaju ulazne podatke metoda koji se obrađuju naredbama u telu
metode,
telo metode - sadrži blok naredbi koje se izvršavaju pozivanjem metode.
43
7.1.2. Pozivanje metode
Kreiranjem neke metode definiše se se kako ona radi, ali se ne izvršava sve dok se ne pozove na
nekom mestu u program. Pozivanje metode programskom jeziku Java može imati tri oblika.
Prvi i osnovni oblik je:
imeMetode (listaArgumenata );
Dakle, kada u programu, na mestu gde je potrebno izvršiti neki zadatak, navedemo ime metode i
argumente u zagradi. Ovaj način pozivanja metode je moguć samo ukoliko se naredba poziva i
definicija metode nalaze u istoj klasi.
U okviru primera 17. kreirana je metoda minDvaBroja() unutar iste klase u okviru koje je pozvana.
Nakon pokretanja ovog programa dobija se ispis kaon a slici 7.1.
Kada se poziva metoda koja je definisana u drugoj klasi korsti se notacija sa tačkom. Pri tom, način
pozivanja takve metode zavisi od toga da li je ta metoda statička(klasna) ili nestatička(objektna).
Ukoliko je metoda definisana modifikatorom static ona pripada celoj klasi u kojoj je kreirana i
poziva se na ovaj način:
imeKlase.imeMetode (listaArgumenata );
public class Test {
public static void main(String[] args) {
int a = 20;
int b = 8;
//pozivanje metode
int c = minDvaBroja(a, b);
System.out.println("Minimum je " + c);
}
//metoda koja upoređuje dve prosleđene vrednosti i vraća minimum
public static int minDvaBroja(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}
}
Minimum je 8
Primer 17. – Kreiranje i pozivanje metode
Slika 7.1 – Ipis poruke nakon poziva metode
44
Gde je imeKlase u ovom pozivu ime one klase u kojoj je definisana metoda koja se poziva. Treći
način pozivanja metode se koristi za nestatičke metode koje pripadaju pojedinim objektima, a ne
celoj klasi. Zato se one moraju pozivati uz odgovarajuće objekte. Opšti oblik poziva nestatičke
metode iz druge klase je –
imeObjekta.imeMetode (listaArgumenata );
U ovom zapisu imeObjekta predstavlja referentnu promenljivu koja pokazuje na onaj objekat za
koji se poziva metoda.
7.1.3. Preopterećenje metoda
Situaciju u kojoj neka klasa sadrži dve metode koje imaju isto ime, ali različite parametre naziva
se preopterećenje metoda (engl. overloading). Ovo je jedna od najkorisnijih osobina Java
programskog jezika i jedan od načina na koji Java podržava polimorfizam. Preopterećene metode
se razlikuju po tipu ili broji parametara. Kada se pozove jedna od metoda, na osnovu tipa ili broja
argumenata utvrđuje se o kojoj verziji metode je reč, zatim se izvršavaju naredbe u okviru te
metode.Ako bi, gledajući prethodni primer, bilo potrebno da se izračuna minimum dva broja koja
su tipa double, taj problem bi bio rešen koristeći postupak preopterećenja metoda.
U primeru 18. ilustrovana je upotreba preopterećenja metoda.
public class Test {
public static void main(String[] args) {
int a = 20;
int b = 8;
double c = 3.6;
double d = 7.1;
//poziv iste metode sa različitim tipovima promenljivih
int rez1 = minDvaBroja(a, b);
double rez2 = minDvaBroja(c, d);
System.out.println("Minimum je " + rez1);
System.out.println("Minimum je " + rez2);
}
//metoda koja upoređuje dve vrednosti tipa int i vraća minimum
public static int minDvaBroja(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}
//metoda koja upoređuje dve vrednosti tipa double i vrća minimum
public static double minDvaBroja(double n1, double n2) {
double min;
if (n1 > n2)
min = n2;
else
min = n1;
45
Pri pokretanju ovog programa, na ekranu bi se dobio ispis kao na slici 7.2.
7.2. Objekti i klase
Objekat (engl. object) je najvažniji pojam za shvatanje objektno orjentisanog koncepta
programiranja.
Prostim opažanjem može se uočiti bezbroj primera objekata iz stvarnog života - knjiga, mačka,
bicikl, sto, automobil, telefon... Za sve te objekte može se reći da imaju jedinstveni identitet i
svojstva - stanje i ponašanje.
Ako bi se za primer objekta uzela mačka, može se primetiti da ona ima svoja stanja (ime, boju,
starost, rasu) i razna ponašanja (spavanje, mjaukanje, trčanje, grebanje), pored toga ne mogu se
naći dve identične mačke, pa ima i svoj jedinstveni identitet.. Automobil, takođe, ima stanja (boju,
brzinu, marku) i svoja ponašanja (kretanje, ubrzavanje, kočenje). Pošto dva automobila istog tipa,
iste boje i sa istim dodacima izgledaju identično, oni moraju da imaju identifikacioni broj po kome
će se razlikovati.
Softverski objekti su konceptualno vrlo slični objektima iz realnog života, oni mogu predstavljati
ne samo realne, nego i apstraktne entitete (npr.bankarski sistem) iz odgovarajućeg problemskog
domena.
Svaki objekat u programiranju – ima svoj jedinstveni identitet, svoje stanje (engl. state) i ponašanje
(engl. behavior):
Stanje - (svojstva, atributi) predstavljaju polja podataka sa svojim trenutnim vrednostima;
Ponašanje - (akcije, operacije) definiše se metodama;
Identitet - nekog objekta se odnosi na neko njegovo svojstvo po kojem se on razlikuje od
bilo kojeg drugog objekta.
Po definiciji objekat je određeni primerak ili instanca (engl. instance) neke klase.
Klasa (engl. class) je šablon ili nacrt po kojem se kreiraju objekti. U stvarnom svetu svakodnevno
se nailazi na razne primerke jedne iste vrste. Postoje na hiljade automobila iste marke i istog
Minimum je 8
Minimum je 3.6
Primer 18. – Preoptrećene metode
Slika 7.2 – Ipis nakon pozivanje preopterećenih metoda
return min;
}
}
46
modela, i svaki napravljen po istom šablonu sa istim karakteristikama. U softverskom svetu se
kaže se da je jedan auto primerak (instanca) klase automobila. Svaka klasa poseduje informacije o
osobinama objekta koje se čuvaju u instancama promenljivih.
Klasa definiše sadržaj objekta (karakteristike i ponašanja), ali ga ne popunjava, tj. ne daje
konkretne vrednosti atributima. Klasa je softverski opis objekta. Ona definiše sadržaj i strukturu
objekta koji se, na osnovu toga, može kreirati. Popunjavanjem sadržaja i strukture dobija se
pojedinačni objekat. Dok klasa definiše od čega se sastoji neki objekat, objekat je stvarni primerak
klase. Na primer, recept za pravljenje soka od višnje je analogno klasi, a sam sok od višnje, koji
može da se pije, je objekat.
Na kraju. važno je zapamtiti da u programiranju klasa definišu novi tip podataka.
7.2.1. Opšti oblik klase
Klasa se deklariše pomoću ključne reči class. Opšti oblik definicije klase je:
class imeKlase {
tip promenljiva_instance1; tip promenljiva_instance2; … tip promenljiva_instanceN; tip imeMetode1 (lista-parametra) { //telo metode } tip imeMetode2 (lista-parametra) { //telo metode }
. . . tip imeMetodeN (lista-parametra) { //telo metode }
}
Promenljive definisane unutar klase nazivaju se promenljive instance. One definišu stanje objekata
(atributi), I svaki objekat sadrži sopstvenu kopiju tih promenljivih. Kôd klase se nalazi u
metodama. Metode i promenljive nazivaju se zajedničkim imenom članovi klase. U opštem
slučaju, metode klase određuju ponašanje objekta tj. akcije i operacije nad atributima.
47
Primer 19. prikazuje jednostavnu klasu koja ima samo tri atributa.
Nakon pokretanja, dobija se ispis na ekranu kao na slici 7.3.
Ova klasa definiše novi tip podataka koji se zove Kutija. To ime se koristi za deklarisanje objekta
tipa Kutija. Svaki objekat ove klase imaće svoje vrednosti za promenljive širina, visina, dubina.
U Test klasi napravljen je objekat ove klase i dodeljene su mu vrednosti za dimenzije. Za te
vrednosti program računa i ispisuje zapreminu.
U okviru primera 20. proširena je klasa Kutija iz prethodnog primera i pored promenljivih kreirana
je i jedna metoda koja izračunava zapreminu.
class Kutija {
double sirina;
double visina;
double dubina;
}
class Test {
public static void main(String[] args) {
//kreiranje objekta klase Kutija
Kutija mojaKutija = new Kutija();
double zapremina;
//dodela vrednosti atributima
mojaKutija.sirina = 10;
mojaKutija.visina = 15;
mojaKutija.dubina = 20;
zapremina = mojaKutija.sirina * mojaKutija.sirina *
mojaKutija.sirina;
System.out.println("Zapremina je " + zapremina);
}
}
Zapremina je 3000.0
Primer 19. – Kreiranje objekta klase Kutija
Slika 7.3 – Ispis zapremine za određeni kreirani objekat
class Kutija {
double sirina;
double visina;
double dubina;
//metoda koja vraća zapreminu konkretnog objekta
double zapremina(){
return sirina * visina * dubina;
} }
48
Nakon pokretanja programa dobija se ispis kao na slici 7.4.
U Test klasi kreirana su dva objekta klase Kutija i za oba je izračunata zapremina, pozivanjem
metode iz klase Kutija.
7.2.2. Vrste promenljivih
Promenljiva je imenovani prostor u memoriji kojim program može da manipuliše. Svaku
promenljivu karakterišu: ime, tip i vrednost. Ime promenljive je identifikator. Tip promenljive je
jedan od dostupnih tipova podataka koje Java obezbeđuje. Promenljiva sadrži vrednost ili je
pokazivač na objekat. Ako sadrži vrednost, ta vrednost je literal (primitivni tip).
Svaka promenljiva mora biti deklarisana pomoću naredbe za deklaraciju promenljivih. Pored
deklarisanja, naredbom za deklaraciju mogu biti zadate i početne vrednosti promenljivih.
Postoje tri vrste promenljivih u programskom jeziku Java:
class Test {
public static void main(String[] args) {
//kreiranje objekata klase Kutija
Kutija mojaKutija1 = new Kutija();
Kutija mojaKutija2 = new Kutija();
//dodela vrednosti atributima
mojaKutija1.sirina = 10;
mojaKutija1.visina = 15;
mojaKutija1.dubina = 20;
mojaKutija2.sirina = 5;
mojaKutija2.visina = 8;
mojaKutija2.dubina = 4;
double zapremina;
//pozivanje metode za izračunavanje zapremine prve kutije
zapremina = mojaKutija1.zapremina();
System.out.println("Zapremina prve kutije je " + zapremina);
//pozivanje metode za izračunavanje zapremine druge kutije
zapremina = mojaKutija2.zapremina();
System.out.println("Zapremina druge kutije je " + zapremina);
}
}
Zapremina prve kutije je 3000.0
Zapremina druge kutije je 160.0
Slika 7.4 – Ispis nakon proširenja klase Kutija
Primer 20. – Proširena klasa Kutija
49
Lokalna promenljive - deklarisane unutar metode, konstruktora ili bloka naredbi. One
postoje samo za vreme izvršavanja metode, kostruktora ili bloka, po završetku izvršavanja
one se brišu iz memorije. Zato se ni ne mogu koristiti negde izvan svoje metode.
Modifikatori pristupa se ne mogu koristiti uz lokalne promenljive. Ove promenljive moraju
imati eksplicitno dodeljenu vrednost pre korišćenja, jer im se pri alociranju ne dodeljuje
nikakav podrazumevana vrednost.
Instancne promenljive - deklarišu se u klasi ali izvan metoda, konstruktora ili bilo kakvih
blokova. Instancne promenljive se kreiraju u trenutku kreiranja objekat korišćenjem
ključne reči new i prestaju da postoje kada objekat bude uništen. Modifikatori pristupa se
mogu koristiti uz ovaj tip promenljive. Vidljive su za sve metode, konstruktore ili blokove
unutar klase. Instancne promenljive imaju podrazumevane vrednosti. Za brojeve,
podrazumevana vrednost je 0, za boolean je false, a za referencu objekata je null.
Vrednosti se mogu dodeliti tokom deklaracije ili unutar konstruktora. Može im se pristupiti
direktno pozivom imena promenljive unutar klase. Međutim, u okviru statičkih metoda,
treba ih pozvati koristeći sledeći poziv referencaObjekta.imePromenljive.
Klasne promenljive - nazivaju se i statičkim, deklarišu se unutar klase upotrebom
modifikatora static pri deklaraciji. Statičke promenljive se stvaraju kada se program
pokreće i prestaju da postoje kada se program zaustavi. Ove promenljive se automatski
inicijalizuju podrazumevanim vrednostima (iste kao kod instancnih promenljivih). Može
im se pristupiti i kada ne postoji instanca te klase, i to pozivanjem klase na sledeći način -
imeKlase.imepromenljive. Kada se statičke promenljive proglase javnim konstantama
pomoću modifikatora public i final, onda se imena takvih promenljivih pišu velikim
slovom .
7.2.3. Statički i nestatički članovi klase
Članovi klase mogu biti statički, oni koji u definiciji sadrže modifikator static,
ili nestatički (objektni).
Već je pomenuto da klasa opisuje objekte sa zajedničkim osobinama i da svaki objekat neke klase
ima istu strukturu, koja se sastoji od promenljivih (atributa) i metoda definisanih unutar njegove
klase. Preciznije je reći da nestatički deo neke klase opisuje objekte koji pripadaju toj klasi. To
znači da će promenljive koja ne sadrže static dobiti svoje aktuelne vrednosti pri kreiranju
konkretnog objekta. Pri tom različiti objekti mogu imati različite vrednosti za tu promenljivu. Za
statička polja aktuelne vrednosti se nalaze u samoj klasi i iste su za sve objekte [6].
Stoga se statičke promenljive i metode mogu koristiti nezavisno od objekta klase u kojoj su
definisane. Pristupa im se tako što se navede ime klase, zatim operator tačka i ime promenljive ili
metode.
Što se tiče metoda, najpoznatiji primer statičke metode je metoda main(). Ona mora biti static
jer se poziva pre kreiranja bilo kakvog objekta.
Međutim, važno napomenuti da statičke metode imaju neka ograničenja i to:
mogu direktno pozivati samo druge statičke metode,
50
mogu direktno pristupati samo statičkim podacima,
u njima se ne mogu koristiti ključne reči this i super.
Primer 21. prikazuje klasu koja sadrži statičku metodu, statičke promenljive i statički blok za
inicijalizaciju
Pri pokretanju programa, dobija se ispis na ekranu kao na slici 7.5.
Dakle, pošto se učita klasa Test, izvršavaju se svi njeni elementi označeni kao static. Najpre se
promenljivoj x dodeli vrednost 5, zatim se izvršava blok označen sa static koji ispisuje poruku I
dodeljuje promenljivoj y vrednost x*5. Potom se poziva metoda main()koja poziva metodu
stampaj().
U primeru 22 biće prikazan slučaj kada se statičkoj metodi I promenljivoj pristupa preko imena
klase u kojoj su definisani.
class Test {
//statičke promenljive
static int x = 5;
static int y;
//metoda za ispis vrednosti promenljivih
static void stampaj() {
System.out.println("x je " + x);
System.out.println("y je " + y);
}
//statički blok
static {
System.out.println("Statički blok za inicijalizaciju.");
y = x * 5;
}
public static void main(String[] args) {
stampaj();
}
}
Statički blok za inicijalizaciju.
x je 5
y je 25
Primer 21. – Statičke promenljive i statički blok
Slika 7.5 – Ispis nakon pokretanja programa
51
Primer 22. ilustruje upotrebu statičke metode i promenljive iz druge klase.
Nakon pokretanja, dobija se ispis kao na slici 7.6.
7.2.4. Kreiranje objekta
Objekat određene klase kreira se u dva koraka. Prvo se deklariše promenljiva čiji tip odgovara
klasi. Ta promenljiva ne definiše objekat, već samo može da pokazuje na njega. Zatim se kreira
stvarna fizička kopija objekta koja se dodeljuje toj promenljivoj. To se postiže pomoću ključne
reči new. Operator new dinamički dodeljuje memoriju za objekat i programu vraća reference na
taj blok memorije. Ta referenca se smešta u promenljivu, ona predstavlja adresu objekta koji je
napravljen u memoriji pomoću ključne reči new.
U primeru gde je kreirana klasa Kutija, kreiran je i objekat te klase i to na sledeći način:
Kutija mojaKutija = new Kutija( );
U ovom izrazu izvršena su oba opisana koraka koja se izvršavaju pri kreiranju objekta. Da bi
postupak bio jasniji ovaj izraz se može razložiti na dva izraza:
Kutija mojaKutija; mojaKutija = new Kutija( );
class Stampanje {
//statičke promenljive
static int x = 5;
static int y = 30;
//statička metoda
static void pozovi() {
System.out.println("x je " + x);
}
}
class Test {
public static void main(String[] args) {
//pozivanje statičke metode
Stampanje.pozovi();
System.out.println("y je " + Stampanje.y);
}
}
x je 5
y je 30
Primer 22. – Statičke metode i promenljive
Slika 7.6 – Ispis nakon pokretanja programa
52
U prvom izrazu deklariše se promenljiva mojaKutija koja će sadržati reference na objekat tipa
Kutija. Ta promenljiva ima podrazumevanu vrednost null i ne pokazuje ni na jedan objekat. U
drugom koraku najpre se pomoću ključne reči new kreira objekat u memoriji, zatim se operatorom
dodele promenljivoj mojaKutija dodeljuje referenca na njega. Zapravo mojaKutija sadrži
memorijsku adresu objekta.
7.2.5. Konstruktori
Kao što je već pomenuto operator new u trenutku izvršavanja dodeljuje memoriju objektu. Opšti
oblik upotrebe ovog operatora je:
promenljiva = new imeKlase( );
U ovom izrazu promenljiva je istog tipa kao i objekat koji se kreira, a imeKlase je klasa čija se
instanca kreira. Pomoću imena klase iza koga slede zagrade zadaje se konstruktor klase.
Konstruktor (engl. constructor) je specijalni tip metode koji se koristi da inicijalizuje objekt.
Konstruktor se poziva u trenutku kreiranja objekta. On konstruiše vrednosti, tj. obezbeđuje podatke
za objekt i otuda mu to ime. Svaka klasa ima bar jedan konstruktor. Ukoliko programer eksplicitno
ne kreira konstruktor za neku klasu, kompajler će automatski dodati podrazumevani (engl. default)
konstruktor.
Postoje dva definisana pravila za konstruktore.
Ime konstruktora mora biti isto kao ime njegove klase.
Konstruktor ne sme vraćati nikakav određeni tip.
Primer 23. prikazuje upotrebu konstruktora koji svakoj kutiji dodeljuje iste vrednosti.
class Kutija {
double sirina;
double visina;
double dubina;
// konstruktor koji dodeljuje iste vrednosti atributima za svaki
//objekat
Kutija() {
sirina = 5;
visina = 5;
dubina = 5;
}
// metoda koja vraća zapreminu
double zapremina() {
return sirina * visina * dubina;
}
}
53
Nakon pokretanja programa dobija se ispis kao na slici 7.7.
Podrazumevani konstruktor obezbeđuje podrazumevane vrednosti za objekt, i to 0 za numeričke
promenljive, false za logičke promenljive, \u0000 za znakovne promenljive, null za klasni tip
promenljive.
Kako konstruktor u ovom primeru nije preterano upotrebljiv, jer svim kutijama dodeljuje iste
dimenzije, potrebno je definisati konstruktor koji kreira objekte različitih dimenzija. U jednoj klasi
dozvoljeno je definisati više konstruktora i po potrebi pozivati odgovarajući.
U primeru 24. prikazana je upotreba konstruktora sa parametrima.
Zapremina je 125.0
class Test7 {
public static void main(String[] args) {
//kreiranje kutije čije su dimenzije zadate konstruktorom
Kutija mojaKutija = new Kutija();
double zapremina;
// pozivanje metode za izracunavanje zapremine
zapremina = mojaKutija.zapremina();
System.out.println("Zapremina je " + zapremina);
}
}
Primer 23. –Upotreba konstruktora
Slika 7.7 – Ispis nakon pokretanja programa
class Kutija {
double sirina;
double visina;
double dubina;
// konstruktor koji dodeljuje iste vrednosti atributima za svaki
//objekat
Kutija() {
sirina = 5;
visina = 5;
dubina = 5;
}
// konstruktor sa parametrima
Kutija(double s, double v, double d) {
sirina = s;
visina = v;
dubina = d;
}
54
Nakon pokretanja programa dobija se ispis kao na slici 7.8.
U Test klasi kreirana su dva objekta klase Kutija, pomoću konstruktora sa parametrima. Pri pozivu
konstruktora, svaki objekat se inicijalizuje vrednostima parametara konstruktora.
7.2.6. Ključna reč this
Ključna reč this u programskom jeziku Java koja se koristi kao referenca na objekat date klase.
Parametrima konstruktora često se daju ista imena koja imaju objektni atributi klase, pa je
neophodno napraviti razliku između lokalne promenljive i atributa objekta. To se postiže
umetanjem prefiksa this uz objektne atribute.
double zapremina() {
return sirina * visina * dubina;
}
}
class Test1 {
public static void main(String[] args) {
// kreiranje objekta pomoću konstruktor sa parametrima
Kutija mojaKutija1 = new Kutija(10, 15, 20);
Kutija mojaKutija2 = new Kutija(5, 8, 4);
double zapremina;
zapremina = mojaKutija1.zapremina();
System.out.println("Zapremina je " + zapremina);
zapremina = mojaKutija2.zapremina();
System.out.println("Zapremina je " + zapremina);
}
}
Zapremina je 3000.0
Zapremina je 160.0
class Kutija {
double sirina;
double visina;
double duzina;
// konstruktor sa paremetrima i ključna reč this
Kutija(double sirina, double visina, double duzina) {
this.sirina = sirina;
this.visina = visina;
this.duzina = duzina;
}
}
Slika 7.8 – Ispis nakon pokretanja programa
Primer 25. – Upotreba ključne reči this
Primer 24. – Konstruktor sa parametrom
55
U primeru 25. nazivi objektnih atributa i parametara konstruktora su isti. Iz tog razloga bi došlo
do greške i kreirani objekti ne bi dobili željene vrednosti za njihove atribute širinu, visinu i dužinu,
da se ključnom rečju this nije napravila razlika između naziva atributa i parametara.
Pored toga, rezervisana reč this može biti upotrebljena da pozove konstruktor date klase. Naime,
kada klasa ima više konstruktora, a želi se ponovna upotreba konstruktora koristi se - this(). Treba
imati u vidu jedno ograničenje kada se o ovoj upotrebi radi - Poziv nekog konstruktora pomoću
this mora biti prva naredba u drugom konstruktoru.
Primer 26. ilustruje upotrebu ključne reči this pri pozivu drugog konstruktora.
Pri pokretanju ovog programa dobija se ispis kao na slici 7.9.
class Kutija {
double sirina;
double visina;
double duzina;
// konstruktor sa parametrima
Kutija(double sirina, double visina, double duzina) {
this.sirina = sirina;
this.visina = visina;
this.duzina = duzina;
}
// konstruktor koji poziva konstruktor sa parametrima
Kutija() {
this(4, 6, 8);
}
double zapremina() {
return sirina * visina * duzina;
}
}
class Test {
public static void main(String[] args) {
// poziv konstruktor koji poziva konstruktor
Kutija mojaKutija = new Kutija();
double zapremina;
zapremina = mojaKutija.zapremina();
System.out.println("Zapremina je " + zapremina);
}
}
Zapremina je 192.0
Primer 26. – Konstruktor sa parametrom
Slika 7.9 – Ipis nakon pokretanja programa
56
8. Osnovni koncepti objekno orijentisanog programiranja
8.1. Nasleđivanje
Nasleđivanje (engl. inheritance) je jedan od osnovnih koncepata objektno orijentisanog
programiranja, ono predstavlja mehanizam koji obezbeđuje da jedna klasa nasleđuje sve atribute
(polja) i ponašanja (metode) neke druge klase. Ideja na kojoj se zasniva nasleđivanje je da se mogu
kreirati nove klase koje u potpunosti preuzimaju funkcionalnost postojeće klase. Ta nova klasa
sadrži sve sto i klasa od koje je nastala, ali i nove, samo svoje atribute ili metode.
Dakle, različite klase mogu imati neka zajednička svojstva koja se, recimo, čuvaju u nekoj opštoj
klasi, koju onda mogu deliti razne klase. Klasa koja nasleđuje neku drugu klasu naziva se izvedena
klasa ili potklasa (eng. subclass), a klasa čija se svojstva nasleđuju natklasa (engl. superclass).
Nasleđivanje se obezbeđuje ključnom rečju extends i sintaksa nasleđivanja izgleda ovako:
class imePodklase extends imeSuperklase {
//polja i metode
}
Klasa može da ima samo jednu natklasu, ali svaka klasa može da ima neograničeni broj izvedenih
klasa.
Za jednostavan primer nasleđivanja može se uzeti nova klasa UkrasnaKutija, koja nasleđuje već
poznatu klasu Kutija (primer 25). Primerak nove klase bi bila kutija pa bi imala sve osobine jedne
kutije, ali i nešto što je karakteristično samo za nju, a to je u ovom slučaju boja. Pozivanjem
konstruktora nove klase dodeliće se vrednosti svim atributima jedne ukrasne kutije, znači objekat
nove klase dobiće vrednosti za visinu, dužinu, širinu i boju.
Treba primetiti da se na ovaj način kôd duplira, time što se u okviru novog konstruktora eksplicitno
dodeljuju vrednosti promenljivama koje su zajedničke za obe klase - visina, dužina, širina. Pa se
na neki način kôd iz konstruktora natklase ponavlja u novom konstruktoru. Osim što je neefikasno,
ovaj postupak zahteva i da potklasi bude dozvoljen pristup tim članovima. Nekada je potrebno da
natklasa čuva svoje podatke tj. da joj pojedini članovi imaju modifikator pristupa private, pa u
tom slučaju potklasa ne bi mogla da pristupi tim promenljivama direktno, niti da ih inicijalizuje.
Ovaj problem u programskom jeziku Java je regulisan pomoću ključne reči super.
Kad god potklasa treba da se „obrati” svojoj natklasi ona to može učiniti pomoći ključne reči
super.
57
U primeru 27. prikazano nasleđivanje i upotreba ključne reči super za pozivanje konstruktora
natklase.
Nakon pokretanja ovog programa dobija se poruka kao na slici 8.1.
public class Kutija {
double sirina;
double visina;
double duzina;
// konstruktor sa parametrima
Kutija(double sirina, double visina, double duzina) {
this.sirina = sirina;
this.visina = visina;
this.duzina = duzina;
}
double zapremina() {
return sirina * visina * duzina;
}
}
public class UkrasnaKutija extends Kutija {
String boja;
//konstruktor izvedene klase
UkrasnaKutija(String boja, double sirina, double visina, double duzina){
//pozivanje konstruktora natklase
super(sirina, visina, duzina);
this.boja = boja;
}
}
class Test {
public static void main(String[] args) {
//kreiranje instance izvedene klase
UkrasnaKutija ukrasnaKutija = new UkrasnaKutija("plava",5,3,4);
double zapremina;
//pozivanje metode iz natklase
zapremina = ukrasnaKutija.zapremina();
System.out.println("Boja kutije je " + ukrasnaKutija.boja);
System.out.println("Zapremina je " + zapremina);
}
}
Boja kutije je plava
Zapremina je 60.0
Slika 8.1 – Ispis nakon kreiranja objekta izvedene klase
Primer 27. – Nasleđivanje
58
8.2. Polimorfizam
Polimorfizam (engl. polymorphism) u programskom jeziku Java je koncept objektno orijentisanog
programiranja koji predstavlja mogućnost da se jedan isti poziv metoda ponaša različito u
zavisnosti od tipa objekta nad kojim se metod primenjuje. Reč polimorfizam se izvodi iz dve grčke
reči: poly (više) i morphe (oblik). Dakle, polimorfizam znači više oblika.
Kada se posmatra promenljivu tipa bazne klase, npr. Zivotinja, osim što se u njoj može čuvati
referenca na objekat te klase, Zivotinja, što je uobičajno, može se takođe čuvati i referenca na
objekat proizvoljne potklase npr. Pas, Macka, Patka. Štaviše, to je jedan od uslova koji moraju biti
ispunjeni da bi polimorfizam funkcionisao.
Dakle, promenljiva tipa Zivotinja može da pokazuje na promenljivu tipa Pas, Macka, Patka, jer
sve su to životinje i nastale su iz klase Zivotinja. Pa u konstataciji - Pas je zivotinja. – nema greške,
jer pas jeste životinja. Kako je svaka klasa direktno ili indirektno izvedena iz klase Object, tako
se može reći - Pas je objekat - i da opet konstatacija bude istinita.
Imajući ovo u vidu, može se zaključiti da se reference na objekat neke klase mogu čuvati u
promenljivama tipa klase iz koje je izvedena. Koncept polimorfizma se ogleda u tome što se
metode mogu ponašati različito u zavisnosti od toga na koji objekat neka promenljiva pokazuje.
Metod koji će se polimorfno pozivati mora biti deklarisan i u baznoj i u izvedenim klasama za čije
se objekte poziva taj metod.
Polimorfizam se primenjuje isključivo na metode, ne i na atribute klase.
Uslovi koji moraju biti ispunjeni su:
u promenljivoj tipa bazne klase nalazi se referenca na objekat izvedene,
pozvani metod mora biti definisan u izvedenoj klasi,
potpisi metoda u baznoj i izvedenoj klasi moraju biti isti,
povratni tipovi metoda bazne i izvedene klase moraju biti isti,
pristupni nivo metoda izvedene klase ne sme biti restriktivniji od odgovarajućeg
pristupnog nivoa bazne.
U primeru 28. ilustrovano je kako funkcioniše princip polimorfizma kroz metod oglasavanje(), on
će se u zavisnosti od vrste životinje različito ponašati. Primer preuzet iz [6].
Slika 8.2 – Polimorfizam
59
class Zivotinja {
String vrsta;
//konstruktor
Zivotinja(String vrsta) {
this.vrsta = vrsta;
}
oglasavanje() {
}
}
class Pas extends Zivotinja {
String ime;
String rasa;
//konstruktor koji poziva super konstruktor natklase
Pas(String ime, String rasa){
super(“Pas”);
this.ime=ime;
this.rasa=rasa;
}
//metoda za oglasavanje pasa
oglasavanje() {
System.out.println("Av, Av!");
}
} class Patka extends Zivotinja {
String boja;
//konstruktor koji poziva super konstruktor natklase
public Patka(String boja){
super(“Patka”);
this.boja=boja;
}
//metoda za oglasavanje patke
public oglasavanje() {
System.out.println("Kva, Kva!");
}
} public class Test {
public static void main(String[] args) {
//prom. klase Zivotinja pokazuje na objekat njene potklase Pas
Zivotinja pas = new Pas("Badi", "labrador");
//prom. klase Zivotinja pokazuje na objekat njene potklse Patka
Zivotinja patka = new Patka("žuta");
// poziv polimorfne metode oglasavanje()
System.out.println("Pas kaže: ");
pas.oglasavanje();
System.out.println("Patka kaže: ");
patka.oglasavanje();
}
}
Primer 28. – Polimorfizam
60
Nakon pokretanja programa, dobija se sledeči kao na slici 8.3.
Metoda se ponaša polimorfno, u zavisnosti od tipa objekta ispisuje odgovarajuću poruku.
8.3. Apstrakcija
Mehanizmom nasleđivanja klase mogu da budu povezane hijerarhijskim vezama (superklasa-
potklasa). Potklasa nasleđuje sva svojstva (atribute i metode) svih superklasa u hijerarhiji. Klase
na višim hijerarhijskim nivoima su uopštenije, tj. sadrže opštija svojstva koja važe za veći broj
potklasa. Ponekad, superklasa postane toliko uopštena da ona ne može da ima direktnu svoju
primenu u vidu nekog objekta. Takva klasa se onda naziva apstraktnom klasom.
Apstraktna klasa je klasa koja je deklarisana ključnom reči abstract i ne može da kreira svoje
objekte. Potreba za apstraktnom klasom proizilazi iz potrebe za kreiranjem apstraktnih metoda,
koje omogućavaju korišćenje prednosti polimorfizma.
Za potrebe pojašnjavanja ovog koncepta može se razmotriti primer gde bi bazna klasa bila klasa
Povrs i njenje polimorfne metode obim() i povrsina(), a izvedene klase Krug i Pravougaonik. Telo
metoda bi u baznoj klasi ostalo prazno, jer nije moguće implementirati ga, pošto ne postoji
univerzalni način za računanje površine površi kada se ne zna o kojoj površ je reč. Međutim
prisustvo tog metoda u baznoj klasi je neophodno, jer to zahteva polimorfizam. Takav metod
moguće je proglasiti apstraktnim. To se čini navođenjem ključne reči abstract ispred povratnog
tipa metoda i tačka-zarez (;) umesto tela metoda:
abstract double povrsina();
Ako klasa ima bar jednu apstraktnu metodu i sama postaje apstraktna, te se i u prvom redu njene
definicije, ispred reči class, mora navesti ista ključna reč, abstract. Ukoliko se u klasi koja je
izvedena iz neke apstraktne klase ne predefinišu sve apstraktne nasleđene metode, onda će i sama
izvedena klasa biti apstraktna, i u tom slučaju neće biti moguće kreiranje ni objekata izvedene
klase.
Primer 29. prikazuje upotrebu apstrakne klase.
Pas kaže: Av, Av! Patka kaže: Kva, Kva!
public abstract class Povrs{
public abstract double obim();
public abstract double povrsina();
} //klasa pravougaonik izvedena iz klase Povrs
class Pravougaonik extends Povrs{
private double a;
private double b;
Slika 8.3 – Ispis nakon pokretanja programa
61
Nakon pokretanja programa dobika se ipis kao na slici 8.4.
Važno je zapamtiti da apstraktne metode ne smeju biti privatne (private), jer u tom slučaju neće
biti nasleđene, pa se ne mogu predefinisati u izvedenim klasama.
//konstruktor
public Pravougaonik(double a, double b) {
this.a = a;
this.b = b;
}
//implementacija apstraktnog metoda za racunanje obima pravougaonika
double obim() {
return 2 * a + 2 * b;
}
//impl. apstraktnog metoda za racunanje povrsine pravougaonika
double povrsina() {
return a * b;
}
}
// klasa Krug izvedena iz klase Provs
class Krug extends Povrs {
private double r;
//konstruktor
public Krug(double r) {
this.r = r;
}
//implementacija apstraktnog metoda za racunanje obima kruga
double obim() {
return 2 * r * Math.PI;
}
// implementacija apstraktnog metoda za racunanje povrsine kruga
double povrsina() {
return r * r * Math.PI;
}
}
class Test {
public static void main(String args[]) {
Povrs p = new Pravougaonik(2, 3);
System.out.println("obim pravougaonika je " + p.obim());
Povrs s = new Krug(3);
System.out.println("obim kruga je " + s.obim());
}
}
obim pravougaonika je 10.0 obim kruga je 18.84955592153876
Primer 29. – Apstrakcija
Slika 8.4 – ispis nakon pokretanja programa
62
8.4. Enkapsulacija
Enkapsulacija (eng. encapsulation) je još jedan od osnovnih principa objektno orijentisanog
programiranja. Enkapsulacija podrazumeva skrivanje podataka od spoljnih pristupa. Primena
enkapsulacije je izuzetno bitna, pogotovo kod velikih projekata. Poštovanjem pravila
enkapsulacije obezbeđuje se da objekti imaju strogo kontrolisane ulaze i izlaze, a samim tim se
smanjuje mogućnost greške, logičke nedoslednosti ili grešaka u programu.
Skrivanje podataka se postiže upotrebom ključne reči private. Na taj način niko van te klase ne
može neplanirano da promeni podatak. Svako pristupanje podacima vrši se isključivo preko javnih
metoda kreiranih za te potrebe a to su metode - getXXX() i setXXX().
Metoda getXXX() služi za dohvatanje podataka, tj. ona vraća vrednost neke promenljive, dok
metoda setXXX() služi za postavljanje neke nove vrednosti promenljive. Metode "geteri" moraju
vraćaju isti tip podatka koji je i promenljiva čiji su oni "geter". Metode koje setuju podatke,
"seteri", moraju da primaju podatak istog tipa kao što je i podatak koji setuju. Koristeći "seter" ili
"geter" metode, klasa može postati dostupna samo za čitanje (engl. read-only) ili samo za pisanje
(engl. write-only). Na taj način se obezbeđuje kontrola nad podacima.
Primer 30. prikazuje kako se upotrebljava enkapsulacija.
public class Student{
private String ime;
private String prezime;
//geter za promenljivu ime, vraca ime
public String getIme(){
return ime;
}
//seter za promenljivu ime, postavlja ime
public void setIme(String ime){
this.ime=ime;
}
//geter za promenljivu prezime, vraca prezime
public String getPrezime(){
return prezime;
}
//seter za promenljivu prezime, postavlja vrednost
public void setPrezime(String prezime){
this.prezime=prezime;
}
}
public class Test{
public static void main(String[] args){
Student s = new Student();
s.setIme("Petar");
s.setPrezime("Petrovic");
System.out.println(s.getIme()+" "+s.getPrezime());
}
}
Primer 30. – Enkapsulacija
63
Nakon pokretanja programa dobija se ispis kao na slici 8.5.
8.5. Interfejsi
Interfejsi (engl. interfaces) u programskom jeziku Java predstavljaju mehanizam za postizanje
potpune apstrakcije. Kada je potrebno specificirati zajednička svojstva povezanih klasa, ali i
nepovezanih klasa koristi se interfejs. To je zapravo kolekcija apstraktnih metoda i konstanti, a u
većini slučajeva, sadrži samo metode. Kako se za metode podrazumeva da su public i abstract, pa
se ove ključne reči ne navode. Metode u interfejsu ne mogu biti statičke. Interfejs se definiše kao
klasa, ali koristeći ključnu reč - interface.
public interface imeInterfejsa {
}
Interfejs se može posmatrati i kao jedna specifična klasa u jeziku Java. Svaki interfejs, pri
kompajliranju, se pretvara u posebnu datoteku sa bajtkodom. Može se koristiti kao tip podataka za
referencu promenljive. Kao i apstraktna klasa, interfejs ne može da ima svoj objekat.
Interfejs se koristi tako što ga implementira neke klasa, pomoću ključne reči - implements. To se
postiže na sledeći način: public class imeKlase implements imeInterfejsa {
}
Svaka metoda deklarisana u interfejsu mora imati definiciju unutar klase da bi bilo moguće kreirati
konkretne objekte te klase.
Važno je zapamtiti nekoliko pravila kojih se treba pridržavati u radu sa interfejsima.
Metode koje se definišu unutar klase koja implementira interfejs moraju biti javne (public).
Ukoliko se ne definiše bar jedna metoda u klasi koja implementira interfejs, ta klasa postaje
apstraktna.
Klasa može implementirati više interfejsa.
Interfejs može da nasleđuje interfejs (nasleđivanje).
Interfejs može da nasleđuje više interfejsa (višestruko nasleđivanje).
Petar Petrovic
Slika 8.5 – Ipis poruke nakon pokretanja programa
64
Primer 31. ilustruje implementiranje interfejsa. Primer preuzet iz [8].
Nakon pokretanja programa dobija se ipis kao na slici 8.6.
public interface Printable {
void print();
}
public interface Showable {
void show();
}
//klasa A1 implementira dva interfejsa
public class A1 implements Printable, Showable {
//implementacija metode iz interfejsa Printable
public void print() {
System.out.println("Thank you");
}
//implementacija metode iz interfejsa Showable
public void show() {
System.out.println("Bye");
}
public static void main(String args[]) {
A1 obj = new A1();
obj.print();
obj.show();
}
}
Thank you
Bye
Primer 31. - Interfejsi
Slika 8.6 – Ipis poruke nakon pokretanja programa
65
9. Zaključak
Java je savremeni programski jezik koji se zasniva na konceptima objektno
orijentisanostnog programiranja. Prvobitno je dizajniran sa ciljem da sa što manje dodataka,
omogući programerima razvoj aplikacija bilo koje vrste. Od svojih početaka programski jezik Java
je bio u središtu kulture inovacija. Prvo izdanje Jave promenilo je način programiranja za internet.
Java virtualna mašina i bajtkôd izmenili su način razmišljanja o problemima bezbednosti i
prenosivosti koda. Apleti su oživeli do tada statičan internet. Kako se Java koristi i za
programiranje aplikacija za Android operativni sistem, ona je sastavni deo revolucije koja je
pokrenuta sa pojavom pametnih telefona. Svet Jave nikada nije dugo stajao u mestu, aktuelna
verzija je Java SE 8.
U odnosu na druge programske jezike, Javu najčešće upoređuju sa programskim jezicima:
C, C++, C#, Pajton. Može se reći da su pojedini jezici brži i u određenim poljima su svakako lakši
za korišćenje, ali širok spektar mogućnosti i univerzalnost implementacije programa (princip
“napiši jednom, pokreni bilo gde”) čini programski jezik Java uvek korak ispred ostalih
programskih jezika. Ako je verovati statističkim podacima od četiri programera na svetu, jedan
programira na ovom jeziku.
Na prethodnim stranicama ovog rada predstavljene su elektronske lekcije o osnovnim
pojmovima i konceptima objektno orijentisanog programiranja u Javi. Treba imati u vidu da se
lekcije mogu koristiti i u svrhu razumevanja objektno orijentisanog programiranja kao tehnike
programiranja. Kako je objektna orijentisanost osobina i drugih programskih jezika (C++, C#,
Smalltalk,itd.), može se istrgnuti iz konteksta jezika Jave i iz ovih lekcija usvojiti koncept koji je
i za druge jezike isti.
S druge strane, svako ko želi da nauči programski jezika Java, trebalo bi da učenje započne
sa osnovama objektno orijentisnog programiranja. U ovom radu su prikazani i objašnjeni primeri
koda koji su neophodni za savladavanje početnog nivoa znanja. Stoga bi elektronske lekcije na
jednostavan i zanimljiv način trebalo da olakšaju razumevanje i učenje programskog jezika Java.
Takođe, zbog javne dostupnosti ove lekcije mogu biti od koristi i široj populaciji i na taj način
doprineti približavanju programskog jezika Java osobama koje se nisu susretale sa
programiranjem.
66
Literatura
[1] Herbert Schildt, Java kompletan priručnik, Mikro Knjiga, Beograd 2014.
[2] Marko Čupić, Programiranje u Javi:
http://java.zemris.fer.hr/nastava/opjj/book-2015-09-30.pdf
Pristupljeno aprila 2017.
[3] David Flanagan, Java in a Nutshell, O’REILLY, fifth edition, 2005.
[4] Laslo Kraus, Programski jezik Java, Akademska misao, Beograd 2015.
[5] Kathy Sierra, Bert Bates, Head First Java, O’REILLY, second edition, 2005.
[6] Sajt kompanije Oracle, Java documentation:
https://docs.oracle.com/javase
Pristupljeno jula 2017.
[7] Sajt za samostalno učenje sa materijalima iz oblasti programiranja Tutorials point:
https://www.tutorialspoint.com/java
Pristupljeno maja 2017.
[8] Elektronska baza edukacionih radova, priručnika i knjiga iz oblasti Računarstava Znanje.org:
http://www.znanje.org/knjige/computer/Java
Pristupljeno jula 2017.
