Professional Documents
Culture Documents
Java Kurs
Java Kurs
udemy.com
Sadržaj
Section 2: Java – A High-level Overview .................................................................................................. 4
5. What is Java & Who Use It ? ............................................................................................................. 4
7. Compilation ........................................................................................................................................ 4
8. Platform Dependency + Demo .......................................................................................................... 6
9. Interpreter ......................................................................................................................................... 7
10. Platform Independence in Java + Demo ....................................................................................... 10
11. Java Virtual Machine ...................................................................................................................... 12
12. An Overview of Java SE ..................................................................................................................15
16. Setting Classpath Environment Variable ...................................................................................... 16
17. WritingFirst Java Program ............................................................................................................ 16
18. Conclusion ...................................................................................................................................... 19
Section 3: Classes, Objects and their Members ...................................................................................... 20
20. Chapter Introduction..................................................................................................................... 20
21. Class & Objects ............................................................................................................................... 20
2
3
Section 2: Java – A High-level Overview
5. What is Java & Who Use It ?
Programski jezik Java je:
general-purpose – znači da nije ograničen na jedan konkretan domen i može da se koristi za
razvoj različitih tipova aplikacija
object-oriented – omogućava da se modeluju scenarija iz realnog života na prirodniji način
platform independent – Java-ina mantra je WORE (Write Once Run Anywhere) – jednom
kada napišete program morate biti u mogućnosti da ga pokrenete na bilo kojoj platformi bez
obzira na operativni sisitem i arhitekturu. Ovo je jedan od ključnih benefita Java-e.
concurrent – Java podržava multi-threading, što omogućava programima da izvode više
aktivnosti u otprilike iste vreme.
very fast – ima slične performanse kao C ili C++
7. Compilation
računar razume instrukcije, koje su napisane u nizovima jedinica i nula (1, 0) i to se naziva
mašinski jezik ili mašinski kod ili nativni kod (machine language, machine code, native
code)
4
npr. jedna mašinska instrukcija bi mogla da bude:
000000 00001 00010 00110 00000 100000
za programere bi bilo izuzetno teško da pišu svoje programe kao nizove jedinica i nula (1, 0) i da
tako prosleđuju instrukcije operativnom sisitemu
iz tog razloga je osmišljen asemblerski jezik (assembly language) , u kojima se mnogo lakše
pišu programi, npr. :
li $t1, 5
add $t0, $t1, 6
vidimo da je pisanje u asemblerskom jeziku, mnogo ekspresivnije nego u mašinskom kodu
dakle, asemblerski jezik obezbeđuje instrukcije višeg nivoa za pisanje instrukcija, ali računari
razumeju samo mašinski jezik, ne razumeju asemberski jezik
program koji se zove asembler (assembler) prevodi instrukcije sa asemblerskog jezika na
mašinski jezik, koje računar može da razume
i mašinski jezik i asemblerski jezik se nazivaju jezici niskog nivoa (low-level languages), jer
koriste nizak nivo detalja računara, kao što je npr. lokacija memorije (memory location) gde
skladištimo podatke
programiranje u asemblerskom jeziku je i dalje dosadno i iz tog razloga, kao i iz želje programera
da se uklone detalji niskog nivoa u samom jeziku, razvijeni su programski jezici visokog nivoa
(high-level languages)
neki od primera jezika visokog nivoa su: FORTRAN, C, C++, Java, C# i svi oni koriste reči na
engleskom (english-like words), matematičke notacije (math notation) i znakove interpunkcije
(punctuation), što ih čini mnogo jednostavnijim za čitanje i pisanje programa i takođe oni
sakrivaju detalje niskog nivoa računara
danas je trend da koristimo programske jezike visokog nivoa, dok se asemblerski jezik koristi
tamo gde su performanse kritične, kao kod operativnih sisitema i elektronskih uređaja
izvorni kod (source code) se odnosi na bilo koji kod koji je napisan u bilo kojem programskom
jeziku
računar ne može da razume izvorni kod, pa je potrebno da prebacimo izvorni kod u mašinski
jezik, a se vrši preko programa koji se zove kompajler (compiler)
nakon faze prevođenja, mašinski kod se u odvojenom koraku izvršava direktno na CPU-u
slika 1. prevođenje
na slici 1. se vidi da jezik u koji je transliran kod nazivamo željeni jezik (target language), a ne
mašinski jezik, a to je zato što u određenim slučajevima može postojati nešto drugo, npr. u
slučaju C i C++ željeni jezik će biti mašinski kod, u slučaju Java-e to će biti Java bajtkod
5
(bytecode), dok ponekad željeni jezik može biti drugi programski jezik (another programming
language)
Java kompajler sprovodi neke dodatne operacije, tako da sam proces kompajliranja može biti
spor usled složenosti kod prevođenja. Jednom iskompilovan mašinski kod, će biti brz i može biti
izvršen bilo kada, na bilo kojoj stvari. Bilo koja promena izvornog koda zahteva ponovnu
kompilaciju, tzv. rekompilaciju (recompilation).
8. Platform Dependency + Demo
Prikaza ćemo kratak demo o platformskoj zavisnosti (platform dependency). Pretpostavimo da
imamo Windows mašinu i pretpostavimo da imamo program napisan u C-u, pod nazivom Hello.c. Da
bi smo kompajlirali ovaj program, možemo da koristimo GCC kompajler i komanda bi bila:
gcc –o Hello Hello.c
, gde je Hello.c fajl koji sadrži C program, dok je povlaka (hyphen) opcija koja govori kompajleru, da
imenuju izlazi fajl Hello, a koji će imati ekstenziju .exe na Windows OS. Dakle, kompajliranjem fajla
Hello.c, dobiće se fajl Hello.exe, koji u sebi sadrži mašinski kod. Prilikom kompajliranja radi se i
linkovanje (linking). Generalno, bilo koji softver koji se sastoji iz mnogo fajlova izvornog koda i svaki
fajl se kompajlira u odvojeni fajl koji ze zove object file, koji ima ekstenziju .o ili .obj. npr. u ovom
slučaju to može da bude Hello.o. Nakon toga ovi object file-ovi se grupišu da formiraju krajnji izvršni
(executable) fajl. Ovo linkovanje obično radi sam kompajler, ali takođe može biti urađen manuelno,
upotrebom programa koji se zove linker. Dakle, u ovom slučaju kompajliranje, Hello.c, dobija se
izvršni fajl Hello.exe, koji se jednostavno može pozvati komandom Hello.
Na sličan način možemo kompajlirati program na Linux OS, upotrebom iste komande i to će takođe
proizvesti izvršni fajl, ali u Linux-u ekstenzija će biti .out, a fajl će biti Hello.out. Kasnije program
Hello.out se može izvršiti putem komande:
./Hello
Dakle, vidimo da oba izvršna fajla se uspešno izvršavaju, na mašinama na kojima su generisani, ali ne
bi bilo moguće da se izvršni fajl generisan na Windows mašini izvrši pod Linux-om i to je primer
platformske zavisnosti (platform dependency), dakle Hello.exe može biti izvršen samo na Windows
6
operativnom sistemu. Da bi smo pokrenuli Hello.c program, potrebno je da ga rekompilujemo na
Linux-u. Na sličan način Hello izvršni fajl generisan na Linux mašini, ne može biti izvršen na Windows
mašini, već je potrebno ponovo kompajlirati pomenuti fajl na Windows-u. Dakle generisani izvršni fajl
je specifičan u odnosu na operativni sisitem.
8
Pogledajmo sada interpreterov fetch-and-execute life cycle. Kao CPU interpreter dohvata svoje
instrukcije iz memorije, kako god u slučaju interpretera instrukcije su u osnovi naredbe (statement) u
izvornom kodu. Nakon toga interpreter razume šta je potrebno da bi izvršio tu naredbu. I ova 2 koraka
su ista kao kod kompajlera. Sledeći korak trebalo bi da bude izvršavanje naredbe programa. Ovde je
interesantna stvar. Interpreter održava (maintainance) biblioteku mašinskog kompajliranog koda i
samo izvršava i samo izvršava odgovarajući kompajlirani mašinski kod koji odgovara naredbi u
programu. Dakle, interpreter ne generiše mašinski kod, već jednostavno koristi svoj kompajlirani
mašinski kod izvrši oni što izvorni kod nalaže.
Pogledajmo sada primer:
imamo add naredbu u izvornom kodu
interpreter izvršava odgovarajući kompajlirani kod iz svoje biblioteke, što je verzija mašinskog
koda ovog bloka koda sa slike 6. Kod dohvata 2 broja koja se dodaju iz memorije. Nakon toga
sprovodi sabiranje. Na kraju, skladišti rezultat u memoriju.
slika 10. platformska nezavisnost Java bajt koda i platformska zavisnost JVM-a
11
U slučaju Java-e mi koristimo JVM da bi smo interpretirali bajt kod, umesto izvornog koda, kao kod
ranije pomenutih interpretera. Dakle JVM je interpreter. Zapravo proces interpretacije je urađen
preko Java interpretera, koji je pod komponenta JVM-e. Obzirom da JVM intrpretira Java bajt kod,
o Java-i možemo misliti kao o interpretiranom jeziku. Znamo da je interpretiranje sporo, pa kako se
Java to sprovodi brzo ?
Ključ je da je mnogo lakše interpretirati Java bajt kod, nego izvorni kod, to je iz razloga što je bajt kod
kompaktan, štaviše on je već kompajliran, što znači da je prošla provera sintakse i semantike,
takođe bajt kod je optimizovan.
Takođe, da bi se ubrzalo izvršavanje JVM izvodi dodatnu optimizaciju kroz proces koji se zove Just-
in-time (JIT) compilation. (- o kome diskutujemo kasnije)
Takođe potrebno je reći da je kompaktnost Java bajt koda, smišljena da se brzo prenese preko mreže,
jer je Java osmišljena kao jezik koji radi u mrežnom okruženju i prenosi se do različitih uređaja na
mreži.
11. Java Virtual Machine
Do sada smo naučili da interpretacija Java bajt koda od strane JVM-e omogućava platformsku
nezavisnost, bez kompromisa sa brzinom. JVM omogućava i drugim programskim jezicima kao što su
Scala i Ruby da se kompajliraju u Java bajt kod i pokrenu na JVM-i. Na taj način i oni dobijaju na
platformskoj nezavisnosti, pored brzine i sigurnosti koje JVM nudi. JVM je kamen temeljac Java
platforme, i pomaže da Java ostvari neke od svojih ciljeva kao što su: platformska nezavisnost, sigurnost
i brzo izvršavanje. JVM – Java Virtual Machine se naziva virtuelnom, jer je apstraktna računarska
mašina (abstract computing machine), a to znači da je kao prava računarska mašina jer ima skup
instrukcija koji se izvršava. Skup instrukcija je Java bajt kod, dok je skup instrukcija kod CPU-a
mašinski kod. Kao prava računarska mašina JVM vrši manipulaciju memorijom prilikom izvršenja
(runtime). Vreme izvršenja (runtime) se odnosi na vreme kada je program zapravo izvršen.
JVM ima nekoliko glavnih odgovornosti:
učitavanje i interpretacija Java bajt koda
sigurnost
automatsko upravljanje memorijom
Još jednom, interpretiranje Java bajt koda omogućava platformsku nezavisnost. Sigurnost je kritična
jer je Java razvijena za mrežno okruženje, gde se programi preuzimaju preko mreže i ne želi se da se
izvršavanjem programa proizvede bilo kakva štetna aktivnost na računaru korisnika. Za razliku od C-a
i C++ -a Java oslobađa programera od direktnog upravljanja memorijom i to rešava automatskim
upravljanjem memorijom. Na taj način programiranje u Java-i je lakše i bezbednije i eleminišu se
problemi neadekvatnog upravljanja memorijom. JVM ima nekoliko komponenti preko kojih sprovodi
pomenute odgovornosti.
Postoji nekoliko stvari koje je potrebno pomenuti u vezi JVM-e:
JVM specifikacija – to je dokument koji opisuje JVM karakteristike (features) i kako je
potrebno da one rade, takođe data je specifikacija skupa instrukcija bajt koda. Svako može da
iskoristi specifikaciju da bi implementirao svoju JVM-u. Postoji i specifikacija Java jezika
(Java Language Specification, skraćeno JLS), što je još jedan dokument koji daje opis sintakse i
semantike Java jezika, i jedan je od najobuhvatnijih resursa (materijala) za Java programski
jezik.
konekretna implementacija JVM specifikacije. Popularne implementacije su: Oracle
HotSpot JVM, IBM JVM. Potrebno je reći da sve JVM implementacije ne slede JVM specifikaciju
runtime instanca – instanca konkretne JVM implementacije
12
Pogledajmo primer:
Pretpostavimo da imamo Java program, sa nazivom Hello. Ovaj program izvršavamo putem komande:
java Hello
, instanca JVM je kreirana i učitana u memoriju, dakle to je runtime instanca, nakon toga JVM učitava
program Hello.class u memoriju i nakon toga ga izvršava. Kao što vidite na slici 11. oba su u memoriji
i JVM i program Hello.
15
16. Setting Classpath Environment Variable
Pre nego što krenemo na pisanje programa, a nakon instalacije JDK i podešavanje Environment
Variable-a, pogledaćemo Classpath promenljivu, čija vrednost je vidljiva na celom okruženju, što je kao
globalna promenljiva. Classpath je promenljiva, kao što joj ime kaže je putanja na fajl sisitemu za
lociranje Java klasa i može da uključi više od jedne putanje. Koristi se tokom kompilacije i izvršenja
Java programa. Classpath Environment Variable je specifična u odnosu na Java-u. Npr. ako
specificirate ranije pominjanu komandu java Hello, kompajler je potrebno da zna gde može da locira
pomenuti program, što je ništa do Hello.class. Da bi se pogledao program može da se koristi
Classpath. Na primer, recimo da je classpath uključuje 2 putanje: prvog gleda putanju .class fajla u
direktorijumu foo na c drajvu, to je prva putanja i ako nije nađena tu, pretražiće u drugoj putanji koja
uključuje bar direktorijum, u ovom slučaju pronalazi nešto u bar direktorijumu i zatim izvršava
Hello.class, slika 14.
Vratimo se sada u Notepad++ program i primetimo da se i klasa zove HelloWorld i fajl se zove
Helloworld.java. Ok, ne moraju da budu istog naziva. Promenimo ime klase iz HelloWorld u
HelloWorld1. Kompajliramo isto kao na pređašnji način, upotrebom komande:
javac Helloworld.java
Ukoliko sada pogledamo direktorijum na disku vidimo da imamo HelloWorld.java, kao i
HelloWorld.class, kao i HelloWorld1.class. Obrisaćemo ranije kreirani HelloWorld.class.
slika 20. greška kad se ime fajla i ime klase razlikuju, a klasa imam public modifikator
Za slučaj da imamo 2 klase u fajlu, što ponovo ne bi trebalo da se radi, kao u kodu ispod, gde imamo 2
klase jedna je HelloWorld, a druga GoodBye, pri čemu obe od njih imaju main metode u kojima ispisuju
tekst na ekran, dok samo klasa HelloWorld je klasa sa public modifikatorom (samo 1 klasa u fajlu može
imati public modifikator).
Ukoliko sada kompajliramo pomenuti kod, videćemo da smo kreirali 2 .class fajla, jedan
HelloWorld.class, a drugi GoodBye.class, kao na slici 21.
class GoodBye {
public static void main(String[] args) {
System.out.println("GoodBye!");
}
}
main metoda je metoda gde se vaš program počinje da se pokreće. Kada se izvrši komanda:
java HelloWorld
, JVM-a učitava Java bajtkod HelloWorld.class u memoriju i zatim poziva njegovu main() metodu.
main metoda mora biti deklarisana kao static, public i void. Iz main metode tipično pozivamo druge
klase, koje ne moraju da imaju main metodu. Samo klasa koja je izvršena sa komandne linije mora da
ima main metodu. Program se završava kada se završi main metoda.
18. Conclusion
Pokrili smo nekoliko važnih koncepata visokog nivoa Java-e:
Java je dizajnirana da radi u mrežnom okruženju, koje se sastoji iz heterogenih korisničkih
uređaja. Rad u takvom okruženju nameće nekoliko jedinstvenih izazova:
o platformska nezavisnost – ovo je važno zbog toga što će softverske komponente biti
prosleđene između korisničkih uređaja i ove softverske komponente bi trebalo da budu
pokrenute na ovim uređajima bez ikakvih problema, bez obzira na operativni sisitem i
hardversku arhitekturu ovih uređaja. Da bi se postigla nezavisnost platforme, izvorni kod
se prvo kompajlira u među platformski nezavisana Java bajtkod, koji je zatim
interpretiran od platformski zavisne JVM-e. Imajte na umu da je JVM apstraktna mašina,
a Java bajtkod služi kao njen skup instrukcija.
o robusnost (robustness) – Java bajtkod može da se preuzme sa Internet-a, i može da
bude generisan od strane zlonamernih korisnika. Da bi se obezbedila robusnost
bajtkodovi se verifikuju pre samog izvršenja bajtkod verifikatorom (bytecode verifier)
o visoke performanse – Java je potrebno da bude brza, iz tog razloga bajtkod je
dizajniran da bude interpretiran brzo. Tehnike kao što su JIT kompilacija, omogućavaju
da Java bude jedva različita od C – a i C++ - a.
o familijarna i jednostavna – većina programera tokom 90-ih koristi C i C++. Java
dizajneri su želeli da sintaksa bude familijarna i zato je ona familijarna sintaksi C – a i
C++ - a. Jednostavnost je bila jedan od osnovnih zadataka Java-inih kreatora, pa je bilo
cilj ukoniti greše u vezi sa upravljanjem memorijom, koje su se javile kod C – a i C++ -a.
To se obezbeđuje automatskim upravljanjem memorijom upotrebom tehnike garbage
collection-a. Takođe ovo Java programe čini robusnijim.
o objektna-orjentisanost i višenitnost – Java je čist objektno-orjentisan jezik i
podržava višenitnost (multi-threading)
19
Section 3: Classes, Objects and their Members
20. Chapter Introduction
Pogledaćemo klase, objekte, kao neke osnovne jedinice koje čine klase i objekte. Java je objektno-
orjentisani jezik, tako da ćemo govoriti o objektno-orjentisanom okruženju i njegovoj upotrebi u
modelovanju scenarija iz realnog sveta. I zbog ovog ćemo predstaviti 2 osnovna koncepta kao što su
klase i objekti. Ove koncepte ćemo razumeti konceptualno i videćemo kako se kreiraju u Java-i.
Pokrićemo promenljive u potpunosti, gde je promenljiva (variable) osnovna jedinica klase i njena uloga
je da sadrži podatke. Sa jedne strane imamo promenljivu koja može da sadrži vrednost, potrebne su
nam i promenljive koje mogu da sadrže grupu vrednosti. Za to ćemo korisiti niz (array), koji je
najjednostavnija struktura podataka u svim programskim jezicima. Sa jedne strane promenljive
koristimo da čuvamo određene podatke, potreban nam je neki koncept koji će sadržati i enkapsulirati
poslovnu logiku (business logic) i to su metode (methods). Metode su takođe osnovne jedinice klase,
kao i promenljive. Poslovna logika softvera ili njegova poslovna logika će biti deo metoda. Na kraju
ćemo proći nešto što se zovu konstruktori (constructors), i kao što im ime kaže oni konstruišu nešto, a
šta je to nešto – to su objekti (objects).
21. Class & Objects
Java je objektno-orjentisani jezik, a spomenuli smo da objektno-orjentisani jezici pomažu da se
aplikacije modeluju na realniji način, tj. da modeluje scenarija iz realnog sveta na realniji način.
Objektno-orjentisano programiranje, kako mu samo ime kaže, je kompletno u vezi objekata, dok je sam
objekat kreiran iz klase.
Objektno-orjentisano programiranje, skraćeno OOP, ima svoje korene još 1960-ih. Dakle stara
je paradigma sa idejom da omogući implementaciju velikih i složenih projekata na jednostavan način.
To znači da OOP modeluje scenarija iz realnog sveta, na prirodniji način. To je osnovna
prednost objektno-orjentisanog programiranja.
Jedan od primera je sledeći - jedan student (student) je registrovan na neki konkretan kurs (course),
koji je ponuđen od strane konkretnog smera (department). Drugi primer bi bio kupac (customer) koji
kupuje određeni proizvod (product). Slično imamo kada doktor (doctor) leči pacijenta (patient). Svi ovi
primeri mogu prirodno biti modelovani u objektno-orjentisanom okruženju.
Pogledajmo kako je to moguće. Uzmimo 1. primer sa studentom koji je registrovan na neki konkretan
kurs koji je ponuđen od nekog smera.
20
slika 23.
21