Java 1

Nastanak
• Programski jezik C
• Programski jezik C++
• Programski jezik Java
Uvod u programski jezik Java
1 2
Programski jezik C Programski jezik C++

• Karakteristike • Potreba da se u C dodaju nove mogućnosti
– jjezik opšte
p namena – Objektno orijentisano programiranje
– pisanje strukturiranih programa • Nastao 1980. godine u Bell-ovim laboratorijama
– pristup hardveru računara
• Autor: Bjarne
j Stroustrup
p
• Razlog nastanka
– potreba za jezikom sa osobinama viših programskih jezika • Ime C++ dobio 1983
koji može da zameni simboličke mašinske jezike – prvobitno ime je bilo “C sa klasama”
• Nastao 1972. godine u Bell-ovim laboratorijama • Razvijan duži niz godina
• Autor: Dennis Ritchie • ANSI standard za C++ usvojen 1997
– Brian Karnighan,
Karnighan Dennis Ritchie: The C Programming • Odnos C i C++
Language, Prentice-Hall, 1978
– više od 95% jezika C preneto je u C++
• Standardizovan 1989, ANSI C
– u C++ su dodate nove mogučnosti
g ((klase,, ...))
3 4
Programski jezik Java Programski jezik Java
• Razlog nastanka: potreba za programskim jezikom koji • Jezik je koncipirao tim firme Sun Microsystems, Inc.
je nezavisan od platforme računara 1991. godine
– C i C++ zavise od platforme računara • Od 1993. godine razvija se prvenstveno zbog Interneta
• Prvobitni motiv: programiranje kućnih aparata – različite vrste računara, operativih sistema, procesora
• Najjači motiv za razvoj: Internet, World Wide Web • Ime Java dobija 1995 . godine
– prvobitni naziv je bio Oak
• Većinu
V ći osobina
bi JJava jje nalsedila
l dil odd jjezika
ik C i C
C++
5 6
Prenosivost na druge platforme Java apleti i aplikacije

• Prevodilac za Javu pravi “bajt kod” a ne izvršni kod • Aplikacije su programi
• Bajt kod (bytecode) je visokooptimizovan skup instrukcija – izvršavaju pod operativnim sistemom računara
• Tumači ga Javi izvršni sistem – Javina virtuelna mašina – za aplikaciju pisanu na Javi potrebno ja da bude
(Java virtual machine, JVM) instalirana i Java virtuelna mašina
– interpretator koda (bajt koda) • Apleti su programi (uglavnom mali)
– za različite platforme prave se različite virtuelne mašine – prenose se preko Interneta, odnosno WWW servisa, kao
delovi HTML stranica
• C++
C se prevodi
di u iizvršni
š i kkod,
d ne iinterpretira
t ti se
– pokreću se u okviru WWW čitača (Web browser-a)
– potrebni različiti prevodioci za različite platforme
– aplet nije animacija
• Program koji se interpretira izvršava se sporije od
izvršnog programa • Apleti se prave samo u Javi
• JIT prevodilac (Just In Time) za bajt kod – brže • Bezbednost apleta
izvršavanje – ograničeni na okruženje za izvršavanje Java programa
7 8
Koncepti
• Objektna-orijentisanost – moderan OO jezik: klase, nasleđivanje,
polomorfizam, interfejsi
• Jednostavnost – C/C++ sintaksna sličnost, ali harmoničniji i
jednostavniji OO model
• Prenosivost – p postiže se interpretacijom
p j bajtkoda
j
• Sigurnost – JVM pruža zaštitu od virusa koji bi se prenosili kroz
izvršni kod (firewall)
• Robusnost – stroga provera tipova, proveravani izuzeci, automatsko
sakupljanje đubreta
• Efiksanost – JIT prevodioci
• Konkurentnost – bibliotečka podrška programiranju kroz više
programskih niti
• Distribuiranost – bibliotečka podrška za RMI i servlete
• Komponentizacija
Komponenti acija –JavaJa a Beans i Enterprise Ja
Java
a Beans
9 10
11 12
Jednostavan program
/*
Ovo je jednostavan Java program.
Datoteka se zove "Primer
Primer.java
java".
*/
class Primer {
Pregled jezika Java // Program
g p
pocinje
j ppozivanjem
j metoda main().
()
public static void main(String args[]) {
System.out.println("Ovo je jednostavan Java program.");
}
}
• Prevođenje programa
C:\>javac Primer.java
Primer java
• Pokretanje programa
C:\>java Primer
• Rezultat izvršavanja programa
13 Ovo je jednostavan Java program. 14
Drugi jednostavan program Treći jednostavan program

// Datoteka se zove "Primer2.java". class PrimerZaIf {
class Primer2 {
int x, y; // deklaracija dve promenljive
public static void main(String args[]) { x = 10;
int broj; // deklaracija promenljive broj tipa int y = 20;
broj = 100; // dodela vrednosti promenljivoj if (x < y)
// Sabiranje podataka različitih tipova System.out.println("x je manje od y");
x = x * 2;
System.out.println("Ovo je broj: " + broj); if (x < y)
broj = broj * 2; System.out.println("x
y p ( j
je j
još uvek manje
j od yy");
);
System.out.print("Promenljiva broj je sada: "); if (x == y) {
System.out.println(broj); System.out.print("x je sada jednako y");
System.out.println(", x je " + x + ", y je " + y);
}
}
} }
}
• Rezultat izvršavanja programa
Ovo je broj: 100 • Rezultat izvršavanja programa
x je manje od y
Promenljiva broj je sada: 200 15 x je sada jednako y, x je 20, y je 20 16
for petlja Primer za for petlju i blok
for(inicijalizacija; uslov; korak) naredba; class PrimerZaBlok Rezultat
{ izvršavanja
i je:
j 0
• Primer for petlje sa jednom naredbom public static void main(String args[])
y je: 10
for(i=0; i<10; i=i+1) naredba; {
int i,
i y=10; i je: 1
• Primer for petlje sa blokom for(i=0; i<5; i++) y je: 7
for(i=0; i<10; i++) { {
i je: 2
naredba1; System.out.println("i je: " + i);
y je: 4
System.out.println("y je: " + y);
naredba2;
System.out.println(); i je: 3
... y = y - 3; y je: 1
naredbaN; }
i je: 4
} }
y je: -2
}
17 18
Elementi jezika Prazna mesta

• Prazna mesta • Prazna mesta su
• Komentari – prazan znak (‘
( ‘))
• Identifikatori – tabulator
• Literali – prelazak u novi red
• Operatori • Obavezna su između elemenata jezika koji nisu
– operatori
• Separatori
– separatori
t i
• Rezervisane reči
int i,y=10;
int i, y = 10;
int i
, y =
10 ;
19 20
Komentari Identifikatori
• Komentar u jednom redu • Imena klasa, metoda, promenljivih
// Proizvoljan tekst do kraja reda • Koriste se
– velika i mala slova
• Komentar u proizvoljnom broju redova
– brojevi
/*
– znakovi: ’_’ i ’$’
tekst napisan u proizvoljnom broju redova
*/ • Primeri identifikatora
a4
4 srednja_vrednost
d j d S
SrednjaVrednost
d j d
/* može i unutar jednog reda */
_a4 $test srednjaVrednost
int i/*komentar*/=2;
• Neispravno napisani identifikatori
• Dokumentacioni komentar 4a srednja-vrednost srednja vrednost
/** Služi za pravljenje HTML datoteke
za dokumentovanje
d k j programa *//
21 22
Literali Separatori
• Konstantne vrednosti koje se navode doslovno () Zagrade služe za liste parametara metoda,
naglašavanje prioriteta, grupisanje izraza,
100 // Celobrojni literal
zadavanje tipa pri konverziji
1.23 // Broj u pokretnom zarezu
{} Vitičaste zagrade služe za definisanje klasa, metoda,
’x’ // Znak blokova naredbi, automatsku inicijalizaciju nizova
”Ovo je test” // Znakovni niz [] Uglaste zagrade služe za deklarisanje nizova
i pristupanje pojedinačnim članovima niza
; Znak tačka zarez označava krajj naredbe
, Zarez služi za razdvajane identifikatora u deklaraciji
promenljivih i za povezivanje naredbi
. Tačka razdvaja ime paketa od potpaketa i klasa
klasa,
razdvaja promenljive i metode od imena objekata
23 24
Rezervisane reči Javine biblioteke
abstract const finaly int public this
• Java sadrži biblioteke klasa
boolean continue float interface return throw • Klase su grupisane prema funkcijama kojima se bave
break default for long short throws – ulaz i izlaz podataka
byte do goto native static transient
– rad sa tekstom
– rad sa grafikom
case doube if new strictfp try
– rad u mreži
catch else implements package super void
– k
komunikcija
ik ij sa SQL bbazama podataka
d t k
char extends import private switch volatile – ...
class final instanceof protected synchronized while
• Ne koriste se rezervisane reči const i goto

• Rezervisane
R i reči
či su i vrednosti:
d ti true, false,
f l null
ll
25 26
27 28
Tipovi podataka
• Vrste tipova
– Prosti tipovi (vrednosti koje nisu objekti)
– Klasni tipovi (objekti)
Tipovi podataka,
podataka promenljive
• Java je strogo tipiziran jezik
29 30
Prosti tipovi Celi brojevi

• Tipovi za cele brojeve • Označeni (pozitivni i negativni)
byte // 8 bita • Negativni brojevi se zapisuju u drugom komplementu
short // 16 bita (kratak ceo broj) • Dužina celobrojnog tipa određuje ponašanje
int // 32 bita (ceo broj) – dužinu ne treba shvatiti kao stvarnu količinu memorije za
long // 64 bita (dugačak ceo broj) vrednost datog tipa
• Tipovi za brojeve u pokretnom zarezu – moguće je da vrednost zauzme više memorije, npr. byte i
short da zauzmu 32 bita
float // 32 bit
bita
double // 64 bita (broj dvostruke tačnosti) • Opseg brojeva predstavljenih sa n bita
• Tip za znakove
char // 16 bita − 2 n−1 do 2 n−1 − 1
• Tip za logičke vrednosti
boolean // dve vrednoti, true i false
31 32
Jedan način konverzije celog broja
Numerički sistemi
iz decimalnog sistema u sistem sa osnovom N
• Decimalni • Broj se uzastopno deli osnovom sistema N sve dok
– osnova 10 rezultat deljenja ne postane nula
– cifre: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 • Zapisuje se ostatak pri svakom deljenju, svaki ostatak je
• Binarni jedna cifra u sistemu sa osnovom N
– osnova 2 • Cifre koje predstavljaju ostatke napišu se u obrnutom
– cifre: 0, 1 redosledu u odnosu na redosled kojim su dobijene
• Oktalni
Okt l i deljenjem
– osnova 8
– cifre: 0, 1, 2, 3, 4, 5, 6, 7
• Heksadecimalni, osnova 16
– osnova 16
– cifre: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F
33 34
Konverzija broja iz sistema sa osnovom b

Primer konverzije iz decimalnog u binarni sistem
u decimalni numerički sistem
n−1 • Prevodi se broj 109 • Kraći način pisanja
b j(10 ) =
broj ∑c ⋅ b
i =− m
i
i 109 : 2 = 5454, ostatak
54 : 2 = 27, ostatak
1
0
109
54
1
0
27 : 2 = 13, , ostatak 1 27 1
• n je broj celih mesta 13 : 2 = 6, ostatak 1 13 1
6 : 2 = 3, ostatak 0 6 0
• m je broj razlomljenih mesta
3 : 2 = 1, ostatak 1 3 1
• b je osnova sistema iz kojeg se prevodi broj 1 : 2 = 0, ostatak 1 1 1
• ci su
s cifre sistema iiz kojeg se pre
prevodi
odi broj • Zapis broja je 0
• i je pozicija cifre 109(10) = 1101101(2)
• bi je težina cifre na poziciji i
35 36
Primer konverzije broja iz decimalnog
Primer konverzije iz binarnog u decimalni sistem
u heksadecimalni numerički sistem
• Za decimalni broj 109:
1 0 9 • Prevodi se broj 109 • Kraći način p
pisanja
j
109 : 16 = 6, ostatak 13 109 13 = D
2 1 0 - pozicije cifara
– težine cifara su 6 : 16 = 0, ostatak 6 6 6
109 = 1×102 + 0×101 + 9×100 0
• Zapis broja je
• Prevođenje binarnog broja 1101101 u decimalni 109(10) = 6D(16)
1 1 0 1 1 0 1
6 5 4 3 2 1 0 - pozicije cifara
1101101(2)
= 1×26 + 1×25 + 0×24 + 1×23 + 1×22 + 0×21 + 1×20
= 64 + 32 + 0 + 8 + 4 + 0 + 1
= 109(10) 37 38
Konverzija iz binarnog
Zapis negativnih celih brojeva u binarnom sistemu
u heksadecimalni numerički sistem i obrnuto
• Za osnove sistema važi: 24=16 • Prva cifra za pozitivne brojve je 0
– četiri binarne cifre odgovaraju jednoj heksadecimalnoj cifri • Negativni brojevi se zapisuju u drugom komplementu
• Prevođenje iz binarnog u heksadecimalni sistem: • Prvi komplement broja: sve nule se zamene jedinicama,
– počevši od cifre najmanje težine grupišu se po četiri a sve jedinice nulama
binarne cifre i zamene se jednom heksadecimalnom cifrom – ili: prvi komplement = 2n – 1 – broj, n je broj cifara
– ako poslednja grupa ima manje od četiri cifre dopisuje se • Drugi komplement broja: na prvi komplement se doda 1
potreban broj nula sa prednje strane
– ili:
ili d t = 2n – broj,
drugii kkomplement
l b j n jje b
brojj cifara
if
• Primer: binarni broj 1101101:
• Pravilo za prevođenje u drugi komplement:
110 1101(2) = 0110 1101(2) = 6 D(16)
– idući od cifre najmanje težine
težine, sve uzastopne nule se
• Prevođenje broja iz heksadecimalnog u binarni sistem prepišu, a takođe i prva jedinica na koju se naiđe
– svaka heksadecimalna cifra zameni se kombinacijom četiri – preostale cifre: sve nule se zamene jedinicama, a jedinice
binarne cifre koja odgovara toj heksadecimalnoj cifri nulama
39 40
Primeri određivanja drugog komplementa Primer: drugi komplement broja –1
• Za decimalni broj 109: • Za decimalni broj 16: • Zapis pozitivnog broja:
109(10) = 01101101(2) 16(10) = 00010000(2) 1(10) = 0000 0001(2)
• Drugi komplement: • Drugi komplement: • Drugi komplement:
0 1 1 0 1 1 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1
1 0 0 1 0 0 1 1 1 1 1 1 0 0 0 0 1 1 1 1 1 1 1 1
• Negativan broj: • Negativan broj: • Negativan broj:
-109(10) = 10010011(2) -16(10) = 11110000(2) -1(10) = 1111 1111(2)
41 42
Drugi komplement: primeri sabiranja Predstavljanje celih brojeva u računaru

• Sabiranje 5 i 3: • Sabiranje 5 i -3: • Pozitivni brojevi imaju vodeću nulu
prenos 0000 111 prenos 1 1111 101 • Negativni brojevi se zapisuju u drugom komplementu
komplementu,
5(10) 0000 0101(2) 5(10) 0000 0101(2) imaju vodeću jedinicu
3(10) 0000 0011(2) -3(10) 1111 1101(2) • Nula ima jedinstven zapis: 00 ... 000
8(10) 0000 1000(2) 2(10) 1 0000 0010(2) • Negativnih brojeva ima više za 1 nego pozitivnih, tj. ako
se brojevi zapisuju sa N bita:
– negativnih
ti ih b
brojeva
j iima 2N–1
N 1
• Sabiranje -5 i -3: • Sabiranje -5 i 3:
– pozitivnih brojeva ima 2N–1–1
prenos 1 1111 111 prenos 0000 011
-5(10) 1111 1011(2) -5(10) 1111 1011(2)
-3(10) 1111 1101(2) 3(10) 0000 0011(2)
-8(10) 1 1111 1000(2) -2(10) 1111 1110(2)
43 44
byte short
• Dužina 8 bita • Dužina 16 bita

• Opseg: –128
128 do 127 • Opseg: –32768
32768 do 32767
127(10) = 0111 1111(2) = 0x7F(16) 32767 = 0x7FFF
-128(10) = 1000 0000(2) = 0x80(16) -32768 = 0x8000
• Big-Endian format
• Deklaracija promenljive: • Deklaracija promenljive:
byte a
a; short
h t s;
byte b, c;
45 46
Little-Endian i Big-Endian formati (primer za int) int
Little-Endian Big-Endian • Dužina 32 bita

byte3 byte2 byte1 byte0 byte0 byte1 byte2 byte3 • Opseg: –22 147 483 648 do 2 147 483 647
2147483647 = 0x7FFFFFFF
-2147483648 = 0x80000000
Osnovna adresa+0: byte0 Osnovna adresa+0: byte3
• Deklaracija promenljive:
int i, j;
Osnovna adresa+2: byte2
y Osnovna adresa+2: byte1
y
• Little-Endian: Intelovi procesori x86 koje se koriste u PC

• Big-Endian: Motorola procesori koji se koriste za Mac
47 48
long Standard IEEE 754, brojevi u pokretnom zarezu
• Dužina 64 bita Znak (z) Eksponent (e) Mantisa (m) Bias (b)
• Opseg: –99 223 372 036 854 775 808 do float 1 bit [31] 8 bita [30-23]
[30 23] 23 bita [22
[22-0]
0] 127
9 223 372 036 854 775 807 double 1 bit [63] 11 bita [62-52] 52 bita [51-0] 1023
9223372036854775807 = 0x7FFFFFFFFFFFFFFF
-9223372036854775808
9223372036854775808 = 0x8000000000000000
0 8000000000000000 • Mantisa sadrži zapis o razlomljenom delu
• Normalizovana mantisa ima oblik 1.m,
• Deklaracija promenljive: – Zapisuje se "m", a "1." se podrazumeva
long broj_sekundi;
broj sekundi; – Tip
Ti float ima
i 24 ttačne
č binarne
bi cifre,
if a double 53
– Zapis broja je: (–1)z × 1.m × 2e-b
• Denormalizovana mantisa ima oblik 0.m i
– mantisa je denormalizovana ako je m ≠ 0, e = 0
– Zapis broja je: (–1)z × 0.m × 2-126
49 50
Standard IEEE 754, brojevi u pokretnom zarezu Standard IEEE 754, opsezi brojeva
Znak Eksponent Mantisa Bias Sa normalizovanom mantisom (eksponent ≠ 0)
float 1 bit [31] 8 bita [30-23]
[30 23] 23 bita [22
[22-0]
0] 127
min
i max približni
ibliž i opseg
double 1 bit [63] 11 bita [62-52] 52 bita [51-0] 1023
float 2–126 (2–2–23)·2127 10–37.93 ÷ 1038.53
• Znak
– 0 za pozitivne brojeve
double 2–1022 (2–2–52)·21023 10–307.65 ÷ 10308.25
– 1 za negativne brojeve
• Eksponent je za osnovu 2 S denormalizovanom
Sa d li mantisom
ti ((eksponent
k t = 0)
– Vrednost u memoriji je <stvatna vrednost eksponenta> + Bias
– Eksponenti 00...00 i 11...11 imaju specijalno značenje min max približni opseg
– Primeri za float
float 2–149 (1–2–23)·2–126 10–44.85 ÷ 10–37.93
• Zapis 200 predstavlja eksponent 73 (200–127=73)
• Najmanja vrednost eksponenta je 1–127=–126 double 2–1074 (1–2
(1 2–52))·2
2–1022 10–323.3 ÷ 10–307.65
• Najveća vrednost eksponenta je 254–127=127
51 52
Standard IEEE 754, opsezi brojeva Standard IEEE 754, specijalne vrednosti
Sa normalizovanom mantisom (eksponent ≠ 0) • Nula: eksponent sadrži nule, mantisa sadrži sve nule
min
i max približni
ibliž i opseg – ne može da se zapiše sa normalizovanom mantisom
– postoje +0 i –0 koje su jednake pri poređenju
float 2–126 (2–2–23)·2127 1,17·10–38 ÷ 3,40·1038
• Beskonačno (±∞): eksponent sadrži sve jedinice,
double 2–1022 (2–2–52)·21023 2,22·10–308 ÷ 1,79·10308 mantisa sadrži sve nule
• NaN (Not a Number): eksponent sadrži sve jedinice,
S denormalizovanom
Sa d li mantisom
ti ((eksponent
k t = 0) mantisa je različita od nule (ne sadrži sve nule)
– QNaN (Quiet NaN): MSB mantise je 1, označava rezultat
min max približni opseg matematičke operacije koji nije nedefinisan
float 2–149 (1–2–23)·2–126 1,40·10–45 ÷ 1,75·10–38 – SNaN (Signalling NaN): MSB mantise je 0, nevažeća
operacija, izuzetak
double 2–1074 (1–2–52))·2
2–1022 4,94·10
4,94 10–324 ÷ 2,22
2,22·10
10–308
53 54
Standard IEEE 754, specijalne operacije Standard IEEE 754, sumarna tabela
Znak Eksponent (e) Mantisa (m) Vrednost
Operacija Rezultat
0 00..00 00..00 +0
n / ±b k
±beskonačno
č 0 0 00..00 00..01 ÷ 11..11 0.m × 2-b+1
±beskonačno × ±beskonačno ±beskonačno 0 00..01 ÷ 11..10 XX..XX 1.m × 2e-b
0 11 11
11..11 00 00
00..00 +beskonačno
±<ne_nulta_vrednost> / 0 ±beskonačno
0 11..11 00..01 ÷ 01..11 QNaN
beskonačno + beskonačno beskonačno 0 11..11 10..01 ÷ 11..11 SNaN
±0 / ±0 NaN 1 00...00 00...00 –0

1 00...00 00..01 ÷ 11..11 –0.m × 2-b+1
beskonačno – beskonačno NaN 1 00 01 ÷ 11..10
00..01 11 10 XX XX
XX..XX –1 m × 2e-b
–1.m
±beskonačno / ±beskonačno NaN 1 11..11 00..00 –beskonačno
1 11..11 00..01 ÷ 01..11 QNaN
±beskonačno × 0 NaN
1 11..11 10..01 ÷ 11..11 SNaN
55 56
float double
• Dužine 32 bita • Dužina 64 bita

• Opseg za pozitivne brojeve je: • Opseg za pozitivne brojeve je:
(3.4e–38?) 1.18e–38 do 3.4e+38 (1.74e-308?) 2.2e–308 do 1.7e+308
• Negativni brojevi imaju isti opseg po apsolutnoj vrednosti • Negativni brojevi imaju isti opseg po apsolutnoj vrednosti
kao i pozitivni brojevi kao i pozitivni brojevi
• Tip float se koristi kad nije potrebna velika tačnost • Matematičke funkcije iz klase Math kao rezultat vraćaju
• Deklaracija
D kl ij promenljive:
lji tip double
float temperatura; sin(), cos(), sqrt(), ...
• Izračunavanje je brže nego sa float
• Deklaracija promenljive:
double r;
57 58
Znakovni tip - char Primer za znakovni tip

• Dužina 16 bita class PrimerZaChar {
• Koristi se UNICODE char znak = ’X’;
• Opseg: 0 do 65535 System.out.println(znak);
• ASCII znakovi imaju
j nepromenjene
p j vrednosti 0-127,, znak++;
odnosno od 0-255 je ISO-Latin-1 System.out.println(znak);
}
• Mogu da se izvode računske operacije sa znakovnim }
tipom
• Deklaracija promenljive: Rezultat izvršavanja programa:
char z, znak;
X
Y
59 60
Logički tip - boolean Celobrojni literali
• Vrednosti: true, false • Decimalni sistem: 7, 123
• Operatori poređenja vraćaju rezultat tipa boolean • Oktalni sistem,
sistem prva cifra je 0: 07,
07 056
• Heksadecimalni sistem, brojevi počinju sa 0x ili 0X
boolean b = true; – cifre od A do F mogu da se pišu malim ili velikim slovima
System.out.println(b); // Prikazuje "true" • Podrazumeva se da je tip int
• Može se dodeliti promenljivoj tipa byte ili short ako
j vrednost
je d liliterala
l unutar opsega tipa:
i
byte b = 26;
• Literal tipa long označava se slovom L na kraju:
0x7FL, 0xac23l
61 62
Literali u pokretnom zarezu Logički literali

• Standardna forma: 8.53, 0.021, 375.63 • Postoje dve vrednosti:
• Naučna forma: 6.022E23,
6 022E23 314259e
314259e-05
05, -5e24
5e24 true
false
• Podrazumeva se tip double
• p float se označava slovom F na kraju
Tip j ((malo ili
veliko slovo): 20.3F, -2.3f, 7.1e-4F
• Tip double može da se označi slovom D ili d na
k j alili jje tto suvišno
kraju, iš
63 64
Znakovni literali Literali znakovnog niza
• Vidljivi znakovi mogu da se pišu unutar polunavodnika: • Unose se između navodnika:
a , 'A',, 'x',, '8',
'a', 8 , '@',
@ , '!'
! "Tekst koji se ispisuje u jednom redu."
"Tekst koji\nse ispisuje\nu tri reda."
• Specijalni znakovi se označavaju kosom crtom:
'\'' (polunavodnik), '\"' (navodnik), '\t' (tabulator), "\"Tekst koji se ispisuje unutar navodnika.\""
\ (prelazak
'\n' ( l k u novii red),
d) '\r'
\ (vraćanje
( ć j na početak
č t k
reda), '\f' (prelazak na novu stranicu) • Naredba System.out.println() bi gornje
• Znak može da se unese pomoću vrednosti: znakovne nizove ispisala
p ovako:
oktalna vrednost se unosi kao trocifren broj '\ddd': Tekst koji se ispisuje u jednom redu.
'\044', '\101' Tekst koji
heksadecimalna vrednost se unosi kao četvorocifren broj se ispisuje
i i j
dodatno označen kosom crtom i slovom u: '\u0065', u tri reda.
'\ua075' "Tekst
e st se ispisuje
sp suje u
unutar
uta navodnika."
a od a.
65 66
Deklarisanje promenljive Oblast važenja i životni vek promenljive

tip identifikator[=vrednost][,identifikator[=vrednost]]; • Oblast važenja
– unutar klase
• Primeri: – unutar metode
int i, j; // deklaracija dve promenljive tipa int – unutar bloka
int x=3, z, y=-10; // deklaracija i inicijalizacija • Životni vek
char znak = ’w’;
– nastaju kad se uđe u njihovu oblast važenja
double a=3, b=4;
– uništavaju
išt j se kkad
d se iizađe
đ iz
i njihove
jih oblasti
bl ti važenja
ž j
double c=Math.sqrt(a*a+b*b); //dinamička inicijalizacija
• Di
Dinamička
ičk iinicijalizacija
i ij li ij je
j iinicijalizacija
i ij li ij iizračunavanjem
č j
izraza koji važi u trenutku izvršavanja (sve promenljive u
izrazu moraju dobiti vrednost pre pozivanja izraza)
67 68
Oblast važenja promenljive Ilustrovanje oblasti važenja
• Promenljiva se ne može koristiti pre deklaracije class OblastVazenja {
{ public static void main(String args[]) {
int p = 3; int x=10; // vidljiva unutar metode main
{ if(x==10){ // početak nove oblasti važenja
... int y=20; // vidljiva samo u ovom bloku
broj = 10; // Greška, promenljiva nije deklarisana System.out.println("x i y: " + x + " " + y);
int broj; x = y * 2; // u ovom bloku se vide x i y
int m = p; }
... //y = 100; // Greška, y se ovde ne vidi
} // x se ovde vidi
int k = m; // Greška, m ne postoji u ovom bloku System.out.println("x je " + x);
int r = p; }
... }
} 69 70
Životni vek promenljive Oblast važenja

• Promenljive deklarisane u bloku koji se ponavlja u petlji • Promenljive sa istim imenom ne mogu da se deklarišu u
gube vrednost između dva prolaska kroz blok dva bloka od kojih je jedan spoljašnji, a drugi unutrašnji
class ZivotniVek { // Ovaj program se ne prevodi
public static void main(String args[]) { class PogresnaOblastVaznja {
int x; public static void main(String args[]) {
for(x=0; x<3; x++){ int g = 1;
int y = -1;
1; // svaki put kad se uđe u blok { // nova oblast važenja
System.out.println("y je: " + y); //uvek -1 int g = 2; // greška u prevođenju
y = y + 101; // promenljiva g već postoji
S t
System.out.println("y
t i tl (" = " + y);
) //
//uvek
k 100 }
} }
} }
}
71 72
Konverzije Automatsko unapređivanje tipova u izrazima
• Automatska konverzija • byte i short se uvek konvertuju u tip int kad se
– tipovi su međusobno kompatibilni pojavljuju
poja juju kao
ao ope
operandi
a d nekog
e og izraza
a a
– odredišni tip je veći (složeniji) od polaznog • Primer:
• Izričita (eksplicitna) konverzija byte a=5, b=8;
byte c=a*b; // Izaziva grešku u prevođenju
• Javin prevodilac uvek proverava usaglašenost tipova byte d = (byte)(a*b); // Ispravno
byte e = (byte)a*b; // Pogrešno
73 74
Pravila za automatsku konverziju (unapređivanje)

Primer za automatsku konverziju
tipova u izrazima
class Unapredjivanje {
• byte i short se automatski unapređuju u int
• ako je jedan operand izraza long,
long ceo izraz se b
byte b = 2
2;
unapređuje u long short s = 300;
• ako je jedan operand izraza float, ceo izraz se char z = 'a';
unapređuje u float int i = 10, j = 5;
long k = 0xFFFFFFFFFFL;
• ako je jedan operand izraza double, ceo izraz se
float f = 5.1f;
unapređuje u double double d = .1;
double r = (f*b) + (i/z) – (j+k) + (d*s);
System.out.println((f*b) + " + " + (i/z) + " – "
+ (j+k) + " + " + (d*s));
System.out.println("rezultat = " + r);
}
}
75 76
Primer za eksplicitnu konverziju Primer: eksplicitna konverzija int u byte
• Mogući su i neočekivani rezultati, npr. kad je broj koji se • Tip int je dužine 32 bita, tj. 4 bajta
konvertuje izvan opsega tipa u koji se konvertuje • Pri konverziji tipa int u tip byte rezultat je jednak
class Konverzija { najnižem bajtu (biti na pozicijama od 0 do 7), a tri gornja
public static void main(String args[]) { bajta se gube (biti na pozicijama od 8 do 31)
i t i = 257
int 257; // 0...0
0 0 0001 0000 0001
• Zavisno od vrednosti bita na poziciji 7, rezultat može
double d = 129.142;
byte b = (byte)i; // b=1 0000 0001
promeniti znak
i = (i
(int)d;
t)d // ii=129
129 0 0 0000 1000 0001
0...0
b = (byte)d; // b=-127 1000 0001
int → byte
// 130 = 0...0
0 0 0000 1000 0010 byte3 byte2 byte1 byte0 → byte0
i = -130; // -130 = 1...1 1111 0111 1110
b = (byte)i; // b=126 0111 1110 00110100 10011010 01101110 11111111 → 11111111
} ↑
} 77 pozicija 7 78
79 80
Nizovi
• Grupe promenljivih istog tipa
• Jedna ili više dimenzija
Nizovi
81 82
Jednodimenzionalni nizovi Kreiranje niza

• Lista (niz) promenljivih istog tipa • Deklaracija a zatim kreiranje niza
• Deklaracija tip ime
ime_niza[];
niza[];
tip ime_niza[]; ime_niza = new tip[velicina];
p[] ime_niza; // alternativna mogućnost
tip[] g deklarisanja
j • Primer
int meseci[];
• Primer meseci = new int[12];
int meseci[];
int[] meseci; Deklaracija i pravljenje niza u istoj naredbi
tip ime_niza[] = new tip[velicina];
• Deklaracija ne rezerviše mesto u memoriji za niz • Primer
int meseci[] = new int[12];
83 84
Primer za jednodimenzionalni niz Inicijalizacija jednodimenzionalnog niza
class Niz {
public static void main(String args[]) { • Ne koristi se operator new za rezervisanje prostora
int meseci[] = new int[12];
meseci[0] = 31; // januar class InicijalizacijaNiza {
meseci[1] = 28; // februar public static void main(String args[]) {
meseci[2] = 31; // mart [] = {
int meseci[] {31,
, 28,, 31,
, 30,
, 31,
, 30,
, 31,
,
// ... 31, 30, 31, 30, 31};
meseci[10] = 30; // novembar System.out.println("April ima " + meseci[3] +
meseci[11] = 31; // decembar " dana
dana.");
");
System.out.println("April ima " + meseci[3] + }
" dana."); }
}
} April ima 30 dana.
A il iima 30 d
April dana.
85 86
Višedimenzionalni nizovi Predstavljanje dvodimenzionalnog niza

• Dvodimenzionalni niz je matrica
int matrica[][] = new int[3][4];
• Deklaracija dvodimenzionalnog niza
• Prvi indeks određuje vrstu (red) a drugi kolonu
tip ime_niza[][];
• Primer [0][0] [0][1] [0][2] [0][3]

int matrica[][] = new int[3][4];
[1][0] [1][1] [1][2] [1][3]
• Ovim se rezerviše 3x4=12 lokacija u memoriji za tip int [2][0] [2][1] [2][2] [2][3]
87 88
Primer za pristupanje članovima matrice Inicijalizacija dvodimenzionalnog niza
class DvodimenzionalniNiz { class DvodimenzionalniNizInit {
public static void main(String args[]) { public static void main(String args[]) {
int matrica[][]= new int[3][4]; int m[][]= { { 0, 1, 2, 3 },
int i, j, k = 0; { 4, 5, 6, 7 },
for(i=0; i<3; i++) { 8, 9, 10, 11 } };
for(j=0; j<4; j++) { int i,
i j;
matrica[i][j] = k; for(i=0; i<3; i++) {
k++; for(j=0; j<4; j++)
} System.out.print(m[i][j] + " ");
for(i=0; i<3; i++) { System.out.println();
for(j=0; j<4; j++) }
System.out.print(matrica[i][j] + " "); }
System.out.println(); }
} 0 1 2 3
} 4 5 6 7
89 90
} 8 9 10 11
Drugi način kreiranja višedimenzionalnog niza Različit broj elemenata u nekoj dimenziji niza
class DvodimenzionalniNizDrugiNacin { class DvodimenzionalniNizSpec {
int m[][]= new int[3][]; int dd[][]= new int[3][];
m[0] = new int[4]; dd[0] = new int[1];
// Isto se dobija sa int i, j, k=0;
// int matrica[][]= new int[3][4]; for(i=0; i<3; i++)
... for(j=0; j<i+1; j++) {
} dd[i][j] = k;
} k++;
}
}
}
91 92
Različit broj elemenata u nekoj dimenziji niza
[0][0]
[1][0] [1][1]
[2][0] [2][1] [2][2]
93 94
95 96
Operatori
• Aritmetički operatori
• Operatori nad bitima
• Operatori poređenja
Operatori • Logički operatori
• Operator dodeljivanja
• Operator ?:
97 98
Primer osnovnih operacija sa tipom int

Aritmetički operatori
class OsnovneOperacijeSaIneger {
+ Sabiranje
– Oduzimanje i unarni minus int a = 1 + 1;
* Množenje int b = a * 3;
/ Deljenje int c = b / 4;
int d = c - a;
% Moduo
int e = -d;
++ Uvećavanje za jedan
System.out.println("a = " + a + "\nb = " + b +
–– j j za jjedan
Umanjivanje \nc = " + c + "\nd
"\nc \nd = " + d + "\ne
\ne = " + e);
+= Dodeljivanje uz sabiranje }
–= Dodeljivanje uz oduzimanje }
*= Dodeljivanje uz množenje a=2
/= Dodeljivanje uz deljenje b=6
c=1
%
%= D d lji
Dodeljivanje
j uz moduo
d
d = -1
99 100
e=1
Primer osnovnih operacija sa tipom double Operator moduo
class OsnovneOperacijeSaDouble {
class Moduo {
double a = 1 + 1;
int x = 7;
double b = a * 3;
int y = x % 3;
double c = b / 4;
System.out.println("7 % 3 = " + y);
double d = c - a;
double d = 5
5.5;
5;
double e = -d;
double d1 = d % 2; // d1=1.5
System.out.println("a = " + a + "\nb = " + b +
System.out.println("d1 = " + d1);
\nc = " + c + "\nd
"\nc \nd = " + d + "\ne
\ne = " + e);
double d2 = d % 2.5; // d2=0.5
}
System.out.println("d2 = " + d2);
}
}
a = 2.0 }
b = 6.0 7 % 3=1
c = 1.5
d1 = 1
1.5
5
d = -0.5
101 d2 = 0.5 102
e = 0.5
Aritmetički operatori dodeljivanja Uvećavanje i umanjivanje

x = x + 1;
promenljiva = promenljiva operator izraz; x++;
promenljiva
lji operator=
t i
izraz; x = x – 1;
1
x--;
• Primeri • Mogu da budu prefiksi ili sufiksi

a = a / 4; • Primer za sufiks
a /= 4; x = 5;
y = x++; // vrednost koju vraća x++ je ona pre povećanja
b = b % c; // x uveća i dobije vrednost 6, a y dobija vrednost 5
b %= c; • Primer za prefiks
x = 5;
d = d + e * f; y = ++x; // vrednost koju vraća x++ je ona posle povećanja,
d +=
+ e * f; // x uveća
ć id
dobije
bij vrednost
d t 6,
6 i y dobija
d bij iistu
t vrednost
d t6
103 104
Operatori nad bitima
Tabela operatora nad bitima
~ Negacija bita jednog operanda (NE – NOT)
& Konjunkcija nad bitima (I – AND) A B A|B A&B A^B ~A
| Disjunkcija nad bitima (ILI – OR)
0 0 0 0 0 1
^ Isključiva disjunkcija nad bitima (EXOR)
0 1 1 0 1 1
>> Pomeranje udesno
>>> Pomeranje udesno sa unošenjem nula 1 0 1 0 1 0
<< Pomeranje ulevo 1 1 1 1 0 0
&= Dodeljivanje uz konjunkciju nad bitima
|= Dodeljivanje uz disjunkciju nad bitima
^= Dodeljivanje uz isključivu disjunkcija nad bitima
>>= Dodeljivanje uz pomeranje udesno
>>>= Dodeljivanje uz pomeranje udesno sa unošenjem nula
<<
<<= D d lji
Dodeljivanjej uz pomeranjej ulevo
l
105 106
Operatori nad bitima Pomeranje ulevo

00101010 42 vrednost << broj_bita_za_koliko_se_pomera;
~ 00101010 42 | 00001111 15 • Sa desne strane se dodaju nule
11010101 –43 00101111 47 • Biti sa leve strane se gube
• Primer:
int i = 1 << 3; // i dobija vrednost 8
00101010 42 00101010 42
int p = 0x7FFFFFFF; // p ima vrednost najvećeg int
& 00001111 15 ^ 00001111 15 p = p << 1; // p je 0xFFFFFFFE tj
tj. -2
2
00001010 10 00100101 37 p <<= 1; // p je 0xFFFFFFFC tj. -4
• Pomeranje
P j ulevo
l za N bita
bit odgovara
d množenju
ž j sa 2N, pod
d uslovom
l
da ne dođe do promene znaka broja
107 108
Pomeranje udesno Pomeranje udesno uz dodavanje nula
vrednost >> broj_bita_za_koliko_se_pomera; vrednost >>> broj_bita_za_koliko_se_pomera;

• Pri pomeranju se čuva znak, tj. sa leve strane se dodaje • Sa leve strane se dodaju nule
bit jednak bitu koji je prethodno bio na poziciji 31 • Biti sa desne strane se gube
• Biti sa desne strane se gube • Primer:
• Primer: int k = -1; // 0xFFFFFFFF
int a = 35; // a = 0...0 00100011 k = k >>> 1; // 0x7FFFFFFF (k je sad najveći int)
a = a >> 2; // a = 0
0...0
0 00001000 (tj
(tj. a=8)
a 8) k = k >>> 23; // 0x000000FF (k je sad 255)
a = a >> 4; // a = 0...0 00000000 (tj. a=0) byte b = (byte)0xff;
int b = -8; // b = 1...1 11111000 b = (byte)(b >>> 4); // b i dalje ima vrednost 0xff
b = b >> 2
2; // b = 1
1...1
1 11111110 (
(tj.
j bb=-2)
2) // prvo j
je unapređen
đ u int:
i t 0xffffffff
0 ffffffff
b = b >> 1; // b = 1...1 11111111 (tj. b=-1) // zatim je pomeren udesno: 0x0fffffff
b = b >> 1; // b = 1...1 11111111 (b ostaje -1) // na kraju je konverzija u byte: 0xff
109 110
Primeri za operacije nad bitima Operatori

p p
poređenja
j
byte b = (byte)0xff;
b = b >>> 4; // Greška, rezultat je tipa int
== Jednako
b >>>= 28; // Ispravno
Ispravno, b je sad 0x0f
!= Različito
b = (byte)0xff; > Veće
b = (byte)((b & 0xff) >> 4); // b je sad 0x0f, jer: < Manje
// b se unapređuje u int: 0xffffffff >= Veće ili jednako
// AND p
po bitima sa 0xff: 0x000000ff
<
<= Manje ili jednako
// pomeranje udesno za 4: 0x0000000f
// posle konverzije int u byte: 0x0f
• Rezultat operacija je logički tip (boolean)
• Operatori == i != rade sa svim tipovima
p
• Operatori redosleda ((>, <, >=, <=)) rade sa numeričkim
tipovima i char
111 112
Logički operatori
Primeri za operatore poređenja
& Konjunkcija (I – AND)
int a=1, b=4; | Disjunkcija (ILI – OR)
boolean c = a < b; // c ima vrednost true ^ Isklučiva (ekskluzivna) disjunkcija (EXILI – EXOR)
if(c) naredba;
&& Kratkospojena konjunkcija
if(a<b) naredba;
|| Kratkospojena disjunkcija
! Unarna negacija (NE – NOT)
== Jednako
!= Različito
?: Ternarni operator uslovne dodele
&=
& Dodeljivanje
Dodelji anje uz konjunkciju
konj nkcij
|= Dodeljivanje uz disjunkciju
^= Dodeljivanje uz isklučivu disjunkciju
113 114
Primer za logičke operatore

Tabela logičkih operatori
class
l B lL i {
BoolLogic
A B A|B A&B A^B !A
boolean a = true, b = false;
false false false false false true boolean c = a | b;
false true true false true true boolean d = a & b;
boolean
boo ea e = a ^ b;
true false true false true false boolean f = (!a & b) | (a & !b);
true true true true false false boolean g = !a;
S t
System.out.println("a
t i tl (" = " + a + "\"\nb
b = " + b +
"\na|b = " + c + "\na&b = " + d + "\na^b = " +
e + "\n!a&b | a&!b = " + f + "\n!a = " + g);
}
}
a = true a&b = false !a = false
b = false a^b = true
115 116
a|b = true !a&b | a&!b = true
Kratkospojeni logički operatori Ternarni operator ?:
boolean c = izraz1 || izraz2;
izraz1 ? izraz2 : izraz3;
• Ako jje izraz1=true,, izraz2 se ne izračunava,, pošto
p je
j u tom slučaju
j • Rezultat izraz1 mora biti logičkog tipa
rezultat true bez obzira na vrednost izraza2
– ako izraz1 ima vrednost true izvršava se izraz2
boolean c = izraz1 | izraz2; // Oba izraza se izračunavaju – ako izraz1 ima vrednost false izvršava se izraz3
• Ternarni operator ?: vraća vrednost izračunatog izraza
if(d!=0 && b/d>100) naredba; // Ne dolazi do deljenja nulom • Izrazi izraz2 i izraz3 moraju da budu istog tipa i ne
smaju da budu tipa void (vraćaju rezultat nekog tipa)
if(c==1 & e++<100) naredba; // e se uvećava i kad je c=1
k = i<0 ? –i : i; // Izračunavanje apsolutne vrednosti i
• Operatori && i || se koriste češće od & i |
117 118
Prioritet operatora
Operator dodeljivanja
() [] .
promenljiva = izraz; ++ -- ~ !
* / %
• Operator dodeljivanja vraća vrednost izraza sa desne + -
strane >> >>> <<
> >= < <=
int a, b, c, d; == !=
a = b = c = d = 10; &
^
• Sve četiri promenljive dobijaju vrednost 10 |
• Izraz d=10
d 10 vraća rezultat 10 koji se dodeljuje &&
promenljivoj c i tako redom do a ||
?:
= operator= (*=, /=, %=, +=, <<= ...)
119 120
Korišćenje zagrada
• Zagrade služe za definisanje redosleda izračunavanja
(prioriteta)
(p o e a) i za
appisanje
sa je jas
jasnijih
j izraza
a a
a >> b + 3; // prvo se b uvećava za 3,

// zatim
ti se sadržaj
d ž j a pomera udesno
d
// ("+" ima veći prioritet od ">>")
a >> (b + 3); // ekvivalentno gornjem
(a >> b) + 3; // prvo se sadržaj a pomera udesno,

// zatim se uvećava za 3
121 122
123 124
Upravljačke naredbe
• Naredbe uslovljavanja
– upravljanje izvršavanjem programa na osnovu uslova koji
su poznati u trenutku izvršavanja
Upravljačke naredbe • Naredbe ciklusa
– izvršavanje (ponavljanje) jedne naredbe ili bloka naredbi
potreban broj puta, zavisno od uslova
• Naredbe
N db skoka
k k
– prekidanje izvršavanja redosleda naredbi i nastavljanje na
definisanom mestu, tj.j p
preskakanje
j naredbi
125 126
Upravljačke naredbe Naredba if
• Naredbe uslovljavanja • Uslovno grananje na dva različita puta

– if • Opšti oblik
– switch if(uslov) naredba1;
• Naredbe ciklusa else naredba2;
– while • uslov je izraz koji vraća vrednost tipa boolean,
– do while ili jedna promenljiva tipa tipa boolean
– for • naredba je jedna naredba ili blok naredbi
• Naredbe skoka • deo else nije obavezan
– break
b k • Izvršavanje
– continue – ako uslov vrati vrednost true izvršava se naredba1
– return – inače se izvršava naredba2 ((ako else deo p
postoji)
j)
127 128
Primeri za if Ugnježdeni uslovi
int a, b;
// a i b dobijaju neke vrednosti ... if(i == 10) {
if(a < b) a = 0; if(j < 20) a = b;
else b = 0; if(k > 100) c = d;
else a = c; // ovaj else se odnosi na uslov if(k > 100)
int brojPodataka,
brojPodataka n; }
// ... else a = d; // ovaj else se odnosi na uslov if(i == 10)
if(brojPodataka > 0) {
ObradiPodatke(); // Blok od dve naredbe u if delu
brojPodataka -= n;
}
else
PrikupiPodatke(); // Jedna naredba u else delu
int i = n; // Naredba koja ne pripada if-else delu
129 130
Ugnježdeni uslovi if else if

if(uslov1)
( ) if(uslov1)
( )
naredba1; naredba1;
if(i == 10) {
else if(uslov2) else
if(j < 20) {
naredba2; if(uslov2)
a = b;
else if(uslov3) naredba2;
if(k > 100) c = d;
naredba3; else
}
else if(uslov4) if(uslov3)
else a = c; // ovaj else se odnosi na uslov if(j < 20)
naredba4; naredba3;
}
else else
else a = d;
d // ovaj else
l se odnosi na uslov if(i == 10)
naredba5; if(uslov4)
naredba4;
else
naredba5;
131 132
Primer za if else if
class GodisnjaDobaSaIfElseIf {
Naredba switch
public static void main(String args[]) { • Grananje
G j u više
iš putanja
t j zavisno
i od
d vrednosti
d ti iizraza
int mesec = 4; // April
• Opšti oblik
String godisnjeDoba;
switch(izraz) {
if(mesec==12 || mesec==1 || mesec==2)
godisnjeDoba = "zima"; case vrednost1:
else if(mesec==3 || mesec==4 || mesec==5) niz_naredbi1;
godisnjeDoba
di j D b = "proleće";
" l ć " [b
[break;]
k ]
else if(mesec==6 || mesec==7 || mesec==8) case vrednost2:
godisnjeDoba= "leto";
niz_naredbi2;
else if(mesec==9 || mesec==10 || mesec==11)
godisnjeDoba = "jesen"; [break;]
else ...
godisnjeDoba = "nepostojeći
nepostojeći mesec
mesec";
; default:
System.out.println("Kada je mesec april, godišnje doba niz_naredbiN;
je " + godisnjeDoba + ".");
}
}
}
Kada je mesec april, godišnje doba je proleće. 133 134
Primer za switch
Naredba switch class PrimerZaSwitch {
• izraz je
i j jjedan
d od d ti
tipova: byte,
b t short,
h t inti t ili char
h public static void main(String args[]) {
• Svaka od vrednosti je jedinstven literal (konstanta) for(int i=0; i<6; i++)
• Ne sme se pponoviti ista vrednost u istom switch switch(i) {
case 0: System.out.println("i je nula."); break;
• Sa break se završava switch
case 1: System.out.println("i je jedan."); break;
• Ako ne postoji break nastavlja se izvršavanje sledećeg case 2: System.out.println("i je dva."); break;
case case 3: System.out.println("i je tri."); break;
• Deo default je opcioni default: System.out.println("i je veće od tri.");
}
}
}
i jje nula.
i je jedan.
i je dva.
i jje tri.
i je veće od tri.
135 i je veće od tri. 136
Primer za switch bez break Godišnja doba sa switch
class PrimerBezBreak { class GodisnjaDobaSaSwitch {
public
bli static
t ti void
id main(String
i (St i args[])
[]) {
int mesec = 4;
for(int i=0; i<9; i++) String godisnjeDoba;
switch(i) { switch (mesec) {
case 0: System.out.println("i = 0"); case 12:
case 1:
case 1: case 2: godisnjeDoba = "zima"; break;
case 2: System.out.println("i < 3"); break; case 3:
case 3: case 4:
case 5: godisnjeDoba = "proleće"; break;
case 4: System.out.println("i < 5"); break;
case 6:
default: System.out.println("i >= 5"); case 7:
} case 8: godisnjeDoba = "leto"; break;
} case 9:
case 10:
} case 11: godisnjeDoba = "jesen";
jesen ; break;
default: godisnjeDoba = "nepostojeći mesec";
i=0 i<5
}
i<3 i >= 5 System.out.println("Kada je mesec april, godišnje deoba je " +
i<3 i >= 5 godisnjeDoba + "
".");
");
i<3 i >= 5 }
137 } 138
i<5 i >= 5
Ugnježdena naredba switch

Poređenje if i switch
switch (izraz_spoljasnjeg_switch) {
case 1: • switch proverava samo jednakost, a if proizvoljan
switch (izraz_unutrasnjeg_switch) { logički izraz
case 0: • switch je efikasniji od ugnježdenih if else if
System.out.println("unutra je 0");
break;
case 1: // ne smeta spoljašnjem switch
System.out.println("unutra je 1");
break;
}
break;
case 2:
...
}
139 140
Naredbe ciklusa Petlja while
• Izvršavanje (ponavljanje) jedne naredbe ili bloka naredbi • Opšti oblik while petlje
potreban broj puta, zavisno od uslova
while(uslov)
telo_petlje
• Naredbe ciklusa (petlje)
– while • uslov je proizvoljan logički izraz
– do while • telo_petlje je jedna naredba (može biti i prazna
– for naredba) ili blok naredbi
• telo_petlje se ponavlja sve dok uslov ima
vrednost true
• while petlja je sa proverom na vrhu, tj. ako uslov
ima vrednost false pri prvoj proveri, ne ulazi se u
petlju tj.
petlju, tj telo_petlje
telo petlje se ne izvršava nijednom
141 142
Primer za while petlju Primer za while bez tela petlje

class PrimerZaWhile {
class WhileBezTelaPetlje {
int n = 5; // Za n=0 p
petlja
j se ne bi izvršila nijednom
j
int i = 100 100, j = 200;
while(n > 0) {
// U petlji se nalazi sredina između i i j
System.out.println("Vrednost n je " + n);
while(++i < --j) ; // Petlja bez tela ima samo znak ";"
n--;
System.out.println("Sredina je " + i);
}
}
}
}
}
Vrednost n je 5 Sredina je 150

Vrednost n je 4
Vrednost n je 3
Vrednost n je 2
Vrednost n je 1
143 144
Petlja do while Primer za do while
class PrimerZaDoWhile {
• Opšti oblik do while petlje public static void main(String args[]) {
int n = 5; // Za n=0 petlja bi se izvršila jednom
do do {
telo_petlje System.out.println("Vrednost n je " + n);
while(uslov); n--;
} while(n > 0);
• uslov je proizvoljan logički izraz }
• telo_p
petljej jje jjedna naredba ili blok naredbi }
• do while petlja je sa proverom na dnu: Vrednost n je 5
– telo_petlje se izvršava jednom a posle toga se Vrednost n je 4
Vrednost n je 3
proverava uslov
l
Vrednost n je 2
– ako uslov ima vrednost true, telo_petlje se Vrednost n je 1
izvršava ponovo, a ako je vrednost false izlazi se iz
petlje Za n=0 rezultat bi bio
145 Vrednost n je 0 146
Kraće napisan primer za do while

Petlja for
class PromenjenPrimerZaDoWhile {
public static void main(String args[]) { • Opšti oblik for petlje
int n = 5; for(inicijalizacija; uslov; iteracija)
do
telo_petlje
System.out.println("Vrednost n je " + n);
while(--n > 0);
}
}
Vrednost n je 5
Vrednost n je 4
Vrednost n je 3
Vrednost n je 2
Vrednost n je 1
147 148
Petlja for
Primer za for
• inicijalizacija je izraz
– izvršava se samo jednom na početku pri ulasku u petlju class PrimerZaFor {
– obično inicijalizuje upravljačku promenljivu petlje
int n;
• uslov je logički izraz, proverava se pre izvršavanja tela
for(n=5; n>0; n--)
petlje System.out.println("Vrednost n je " + n);
– ako
k je
j vrednost
d t true
t i š
izvršava se ttelo
l petlje
tlj }
– ako je false ne izvršava se telo petlje i izlazi se iz petlje }
– obično zavisi od upravljačke promenljive petlje
• telo_petlje je jedna naredba ili blok naredbi Vrednost n je 5
Vrednost n je 4
• iteracija je izraz Vrednost n je 3
– izvršava se posle tela petlje Vrednost n je 2
– obično menja upravljačku promenljivu petlje Vrednost n je 1
• petlja
tlj se nastavlja
t lj proverom usloval i iizvršavanjem
š j ttela
l
petlje i iteracije sve dok je uslov tačan 149 150
Deklaracija promenljive unutar for petlje Primer: provera da li je broj prost

class ProstBroj {
• Upravljačka promenljiva petlje se često deklariše unutar
petlje u delu inicijalizacija
int broj = 14;
• Takva
T k promenljiva lji postoji
t ji samo unutar
t petlje
tlj
boolean prost_broj = true;
for(int i=2; i < broj/2; i++) {
class DeklaracijaUnutarFor
j {
if((b j % i) == 0) {
if((broj
prost_broj = false;
for(int n=5; n>0; n--)
break;
System out println("Vrednost n je " + n);
System.out.println("Vrednost
}
}
}
}
if(prost broj) System.out.println("Prost");
if(prost_broj) System.out.println( Prost );
else System.out.println("Nije prost");
}
}
151 152
Više upravljačkih promenljivih for petlje Uslov ne zavisi
• U inicijalizaciji se može deklarisati i inicijalizovati više od upravljačke promenljive for petlje
upravljačkih promenljivih petlje class ForSaProizvoljnimUslovom {
• U iteraciji se može menjati više promenljivih
• Izrazi u inicijalizaciji i iteraciji se razdvajaju zarezima
boolean kraj = false;
class VisePromenljivihForPetlje { for(int i=0; !kraj; i++) {
public static void main(String
p ( g args[])
g []) { System out println("i
System.out.println( i je " + i);
for(int a=1, b=4; a<b; a++, b--) { if(i == 5) kraj = true;
System.out.println("a = " + a); }
System out println("b = " + b);
System.out.println("b }
} }
}
i jje 0
} i je 1
a=1 i je 2
b=4 i je 3
a=2 i je 4
b=3 153 i je 5 154
for petlja bez inicijalizacije i iteracije

Beskonačna for petlja
• Delovi for petlje inicijalizacija ili iteracija, ili oba dela, mogu
for( ; ; ) {
da se izostave
// ...
class ForBezInicijalizacijeIIteracije { if(uslov)
public static void main(String args[]) { break;
j = false;
boolean kraj ; // ...
int i = 0; }
for( ; !kraj; ) {
System out println("i je " + i);
System.out.println("i
if(i == 5) kraj = true;
i++;
}
}
}
155 156
Ugneždene for petlje Naredbe skoka
class UgnjezdeneForPetlje {
public static void main(String args[]) { • Prekidanje izvršavanja redosleda naredbi i nastavljanje
for(int i=0; i<5; i++) { na definisanom mestu,
mestu tjtj. preskakanje naredbi
for(int j=i; j<5; j++) – break
System.out.print(i); – continue
System.out.println();
– return
}
}
}
00000
1111
222
33
4
157 158
Naredba break Završavanje niza naredbi u naredbi switch

class PrimerBezBreak {
• Završavanje niza naredbi u naredbi switch, tj. izlazak
iz naredbe
a edbe s
switch
tc
for(int i=0; i<9; i++)
• Izlazak iz petlje u specijalnim slučajevima (uobičajeno je switch(i) {
da se iz petlje izlazi na osnovu uslova) case 0: System.out.println("i = 0");
• Vaijanta naredbe goto case 1:
case 3:
default: System.out.println("i >= 5");
}
}
}
159 160
Izlazak iz for petlje sa break Izlazak iz while petlje sa break
class BreakPrekidaForPetlju { class
l B
BreakPrekidaWhilePetlju
kP kid Whil P tlj {
for(int i=0; i<100; i++) { int i=0;
if(i == 5) break; // prekidanje petlje kad je i=5 while(i<100) {
System.out.println("i: " + i); if(i == 5) break; // prekidanje petlje kad je i=5
} System.out.println("i:
Syste .out.p t ( : " + i); );
System.out.println("Petlja je završena."); i++;
} }
} S t
System.out.println("Petlja
t i tl ("P tlj j je završena.");
š ")
}
i: 0 }
i: 1
i: 0
i: 2
i: 1
i: 3 i: 2
i: 4 i: 3
Petlja je završena. i: 4
161 Petlja je završena. 162
break u ugnježdenim petljama Naredba break sa oznakom

• break prekida samo najdublje ugnježdenu petlju u kojoj se nalazi • Opšti
O šti oblik
blik
class BreakUUgnjezdenimPetljama {
public static void main(String args[]) { oznaka:{
f
for(int
i i
i=0; i
i<3; i
i++) { ...
System.out.print("i = " + i + "; j: "); if(uslov) break oznaka;
for(int j=0; j<100; j++) {
...
if(j == 10) break; // prekida
kid unutrašnju
t š j petlju
tlj za j=10
j 10
System.out.print(j + " ");
}
} • oznaka označava blok naredbi iza kojeg se nastavlja
System.out.println(); program posle izvršavanja označene naredbe break koja
}
mora biti obuhvaćena blokom
System.out.println("Petlja je završena.");
}
• Može se izaći iz više ugnježdenih blokova
} • Ne može se preskočiti blok koji ne obuhvata označenu
i = 0; j: 0 1 2 3 4 5 6 7 8 9
naredbu break
i = 1; j: 0 1 2 3 4 5 6 7 8 9 • Naredba
N db if je j obavezna,
b iinače
č se naredbe
db iiza naredbe
db
i = 2; j: 0 1 2 3 4 5 6 7 8 9 break nikad ne bi izvršavale, što je greška u prevođenju 164
163
Petlja je završena.
Primer za označeni break
class BreakSaOznakom {
Primer za for i označeni break
public static void main(String args[]) { class ForIBreakSaOznakom {
boolean t = true; public static void main(String args[]) {
prvi: {
spoljna: for(int i=0; i<3; i++) {
drugi: {
System.out.print("i = " + i + ": j:");
treci: {
System.out.println("Pre naredbe break."); for(int j=0; j<100; j++) {
if(t) break drugi;
d i if(j == 10) break spoljna;
System.out.println("Posle naredbe break."); System.out.print(j + " ");
} }
System out println("U
System.out.println( U drugom bloku
bloku.");
);
System.out.println("Ovo se preskače.");
}
System.out.println("U prvom bloku.");
}
} System.out.println("Petlja završena.");
} }
} }
Pre naredbe
P db break.
b k i = 0: j: 0 1 2 3 4 5 6 7 8 9 Petlja završena.
U prvom bloku.
165 166
Primer sa greškom Naredba continue

• Opšti oblik
class PogresanBreak {
public static void main(String args[]) { petlja {
prvi: for(int i=0; i<3; i++) { ...
System.out.print("i = " + i + ": j:"); if(uslov) continue;
} ...
}
for(int j=0; j<100; j++) {
if(j == 10) break prvi;
pr i // Pogrešno • Služi za p
preskakanje
j naredbi tela p
petlje
j od naredbe
continue do kraja tela petlje, ali se ne napušta petlja
System.out.print(j + " ");
} – u while i do while petljama posle continue se
} prelazi na proveru uslova
} – u for petlji posle continue se prelazi na iteraciju
• Naredba if je obavezna, inače se naredbe iza naredbe
continue nikad ne bi izvršavale, što je greška u prevođenju
167 168
Primer za continue
Naredba continue sa oznakom
class PrimerZaContinue {
public static void main(String args[]) { • Opšti oblik
for(int i=0; i<10; i++) {
oznaka:
k petlja1
tlj 1 {
System.out.print(i + " ");
if(i%2 == 0) continue;
petlja2 {
System out println("");
System.out.println( ); ...
} if(uslov) continue oznaka;
} ...
} }
}
01
23 • oznaka označava
č petlju
tlj koja
k j će
ć se nastaviti
t iti posle
l
45 izvršavanja označene naredbe continue
67 • Naredba if je obavezna, inače se naredbe iza naredbe
89 continue nikad ne bi izvršavale, što je greška u prevođenju
169 170
Primer za označeni continue

class ContinueSaOznakom { Naredba return
spoljna: for(int i=0; i<5; i++) { • Opšti oblik
for(int j=0; j<5; j++) {
if(j > i) { ti i
tip ime_metode(lista_parametara)
t d (li t t ) {
System.out.println(); ...
continue spoljna; ( ) return [
if(uslov) [vrednost];
];
}
...
System.out.print(i + " ");
} }
}
• Služi za izlazak iz metode
• Posle naredbe return kontrola se vraća pozivaocu metode
}
} • Naredba
N db if je j obavezna
b ako
k naredba
db return nije ij
0
poslednja naredba u metodi, inače se naredbe iza naredbe
1 1 return nikad ne bi izvršavale, što je greška u prevođenju
2 2 2 • vrednost ne postoji ako je tip metode void, inače postoji
3 3 3 3 171 172
4 4 4 4 4
Primer za return
class PrimerZaReturn {
boolean t = true;
System.out.println("Pre naredbe return.");
if(t) return;
t // povratak
t k pozivaocu
i
System.out.println("Ovo se ne izvršava.");
}
}
Pre naredbe return.

return
173 174
175 176
Klasa
• Klasa je novi tip podataka

• Klasa je šablon za objekte
• Objekat je primerak (instanca) klase
Uvod u klase • Klase koje se izvršavaju imaju metod main
177 178
Klase i datoteke Opšti oblik klase (nije kompletan)

• Klasa se piše u jednoj datoteci class imeKlase {
tip promenljiva1;
• Imena datoteke i klase moraju da budu jednaka
tip promenljiva2;
• Ekstenzija datoteke je *.java ...
tip promenljivaN;
tip imeMetoda1(lista_parametara) {
telo_metoda
}
...
tip imeMetodaM(lista
imeMetodaM(lista_parametara)
parametara) {
telo_metoda
}
}
179 180
Termini Primer jednostavne klase
• Objekat se naziva i instanca klase • Klasa za opisivanje kutije za koju su bitne samo
• Podaci (promenljive) definisane u klasi nazivaju se polja dimenzije
(takođe se koriste i termini: promenljive instance, atributi
ili članovi podaci)
• Kod se piše u metodima class Kutija {
• Metodi i promenljive deklarisane u klasi nazivaju se double sirina;
članovi klase double visina;
double duzina;
}
181 182
Pravljenje objekta – operator new Operator tačka "."

• Objekat se pravi operatorom new • Operator tačka služi za pristupanje članu objekta
• Pravljenjem objekta se u memoriji rezerviše prostor za • Primer
Pi za pristupanje
i t j poljima:
lji
smeštanje tog objekta
k1.sirina = 1;
• Primer:
Kutija k1 = new Kutija(); k1.visina = 2;
– k1 je referenca koja ukazuje na objekat u memoriji k1.duzina = 3;
k1 sirina
visina
duzina
183 184
Primer 2. sa dva objekta klase Kutija
Primer 1. sa klasom Kutija class PrimerSaDveKutije1 {
class PrimerSaKutijom1 {
Kutija k1 = new Kutija();
j k2 = new Kutija();
Kutija j
Kutija k = new Kutija();
// dodela vrednosti clanovima objekta k1
// dodela vrednosti poljima
k1.sirina = 1; k1.visina = 2; k1.duzina = 3;
k.sirina = 1;
k.visina = 2;
k.duzina = 3;
// Izračunavanje i ispisivanje zapremina
// Računanje zapremine kutije
double z = k1.sirina * k1.visina * k1.duzina;
double zapremina = k.sirina * k.visina * k.duzina;
System.out.println("Zapremina k1 je " + z);
System.out.println("Zapremina je " + zapremina);
z = k2.sirina * k2.visina * k2.duzina;
}
}
}
Zapremina je 6.0 }
Zapremina k1 je 6.0
185 186
Zapremina k2 je 40.0
Reference i objekti Reference i objekti

• Deklaracija promenljive Kutija k1 = new Kutija(); k1 sirina
Kutija k1; k1 je null
Kutija k2; visina
• Postoji samo referenca k1, • Referenca k2 ne ukazuje na duzina
k2 je null
objekat
a objekat još nije napravljen
• Stvaranje objekta
k1 = new Kutija();j (); k1 sirina
• Operator new kreira objekat, tj. visina
k2 = k1; k1 sirina
rezerviše prostor u memoriji za duzina
• Reference k1 i k2 sad imaju iste visina
čuvanje objekta vrednosti, tj. ukazuju na isti objekat duzina
k2
• Referenca k1 ukazuje na objekat • Kopiranje reference ne kopira
• Preko refernce se pristupa objektu objekat
187 188
Reference i objekti - nastavak Opšti oblik primene operatora new
k1 sirina
k1 = new Kutija(); ImeKlase promenljiva = new ImeKlase();
visina
• Kreiran jje jjoš jjedan objekat
j na kojij k2 • ImeKlase označava tip promenljive
duzina
sad ukazuje referenca k1
• ImeKlase() označava konstruktor
sirina
visina
duzina • Operator new dodeljuje memoriju dinamički
• Količina memorije je ograničena
k2 = new Kutija();
K tij ()
k1 sirina • Ako nema dovoljno memorije da se kreira objekat javlja
• Kreiran je treći objekat na koji sad visina
ukazuje referenca k2 se izuzetak
k2 duzina
• Na prvi objekat više ne ukazuje • Operator new se ne koristi za proste tipove (byte
(byte,
nijedna referenca i njemu ne može sirina sirina short, int, long, float, double, char,
da se pristupi visina visina boolean).
duzina duzina Promenljive ovih tipova nisu objekti.
189 190
Osnovno o konstruktorima Metodi

• Konstruktor definiše šta se radi pri stvaranju objekta • Opšti oblik metoda
tip imeMetoda(lista_parametara) {
• Ako u klasi nije napisan konstruktor Java obezbeđuje
telo_metoda
podrazumevani konstruktor
}
• Klasa može da ima više konstruktora • tip je tip podatka koji vraća metod; ako metod ne vraća vrednost
tip metoda je void
• imeMetoda je identifikator
• li t
lista_parametarat je niz parova tip
ti id identifikator
tifik t
razdvojenih zarezima, a može biti prazna
• Parametri su promenljive koje prihvataju vrednosti argumenata
prosleđenih
l đ ih metodu
t d u ttrenutku
tk pozivanja
i j
• Metod vraća vrednost pomoću naredbe return
return vrednost;
191 192
Šta je loše u klasi Kutija? Metod za izračunavanje zapremine u klasi Kutija
class Kutija { class Kutija {
double sirina; double sirina;
double visina; double visina;
double duzina; double duzina;
} double zapremina() {
return sirina * visina * duzina;
• U klasi Kutija nije ugrađeno "znanje" kako se izračunava zapremina, }
pa bi to znanje moralo da se ugradi u svaku klasu koja radi sa
}
klasom Kutija, ako je potrebna zapremina objekta tipa Kutija
• Ne postoji dobar način da se postave početne vrednosti polja, ili da • U metodu zapremina direktno se pristupa poljima pošto je i
se promene vrednosti (pristupa se poljima direktno) metod zapremina član klase Kutija
• Tip vrednosti koji vraća metod mora da bude kompatibilan sa tipom
metoda
• Tip promenljive koja prihvata vrednost koju vraća metod mora biti
kompatibilan sa tipom metoda
193 194
Primer: klasa Kutija ima metod zapremina

Kraći način pisanja u prethodnom primeru
class
l P i
PrimerSaDveKutije2
S D K tij 2 {
• Zapremina se izračunavala samo da bi se ispisala na
Kutija k1 = new Kutija();
ekranu, i korišćene su dve naredbe
Kutija k2 = new Kutija(); double z = k1.zapremina();
// dodela vrednosti clanovima objekta k1 System.out.println("Zapremina je " + z);
.s a = 1;
k1.sirina ; k1.visina
. s a = 2; ; k1.duzina
.du a = 3;
• Prethodne dve naredbe se mogu zameniti jednom
System.out.println("Zapremina je " + k1.zapremina());
// I
Izračunavanje
č j i iispisivanje
i i j zapremina
i
double z = k1.zapremina();
z = k2.zapremina();
}
}
195 196
Primer: klasa Kutija ima metod postaviDimenzije
Metod za postavljanje vrednosti polja u klasi Kutija
class
l P i
PrimerSaDveKutije3
S D K tij 3 {
class Kutija { public static void main(String args[]) {
double sirina; Kutija k1 = new Kutija();
double visina; Kutija k2 = new Kutija();
double duzina; // dodela vrednosti clanovima objekta k1
double zapremina() { .posta e je( , 2,
k1.postaviDimenzije(1, , 3);
return sirina * visina * duzina; // dodela vrednosti clanovima objekta k2
} k2.postaviDimenzije(2, 4, 5);
void postaviDimenzije(double s, double v, double d){ // I
Izračunavanje
č j i iispisivanje
i i j zapremina
i
sirina = s; System.out.println("Zapremina k1 je " +
visina = v; k1.zapremina());
duzina = d; System.out.println("Zapremina k2 je " +
} k2.zapremina());
} }
}
197 198
Parametri i argumenti Konstruktori

• Parametar je promenljiva deklarisana u listi parametara • Konstruktor može da inicijalizuje objekat odmah posle
metoda i kao promenljiva postoji samo unutar metoda stvaranja objekta, i u tom slučaju ne mora se pozivati
• Argument je vrednost koja se prosleđuje metodu pri metod za postavljanje vrednosti poljima
pozivanju metoda • Konstruktor ima isto ime kao i klasa
• Parametar dobija (prihvata) vrednost argumenta • Za konstruktore se ne piše tip jer se podrazumeva da
konstruktor vraća tip klase
• Ako se ne napiše konstruktor,
konstruktor automatski postoji
podrazumevani konstruktor koji svim poljima dodeljuje
vrednost nula
• Ako se napiše konstruktor ne može se više koristiti
podrazumevani konstruktor
199 200
Konstruktor sa parametrima u klasi Kutija
class Kutija {
Konstruktor sa parametrima u klasi Kutija
double sirina;
• U klasi Kutija koja ima konstruktor sa parametrima ne
double visina;
mora postojati metod za postavljanje dimenzija, ako se
double duzina;
pretpostavi da objektu Kutija ne treba menjati dimenzije
// Konstruktor sa listom parametara • Korišćenje podrazumevanog konstruktora u ovoj klasi
Kutija(double s, double v, double d) { i
izaziva
i grešku
šk u prevođenju
đ j programa
sirina = s; • Može se napisati više konstruktora u jednoj klasi
visina = v; (sledeće poglavlje)
duzina = d;
}
double zapremina() {
}
} 201 202
Primer: korišćenje konstruktora sa parametrima

Rezervisana reč this
class PrimerSaDveKutije4 {
public static void main(String args[]) { • Koristi se unutar metoda da ukaže na objekat za koji je metod pozvan
Kutija k1 = new Kutija(1, 2, 3); • j
Primer za konstruktor klase Kutija:
Kutija k2 = new Kutija(2, 4, 5); Kutija(double s, double v, double d) {
// Izračunavanje i ispisivanje zapremina sirina = s;
S t
System.out.println("Zapremina
t i tl ("Z i k1 j
je " + visina = v;
k1.zapremina()); duzina = d;
System.out.println("Zapremina k2 je " + }
k2.zapremina());
// Gornji konstruktor promenjen tako da se (nepotrebno) koristi this
}
Kutija(double s, double v, double d) {
}
this.sirina = s;
this.visina = v;
this.duzina = d; ;
}
203 204
Skrivanje polja Sakupljanje smeća (Garbage collection)
• Ne mogu postojati dve lokalne promenljive sa istim • Operator new rezerviše (dodeljuje) memoriju objektu
imenom • Programer ne mora da vodi računa o oslobađanju
• Lokalna promenljiva ili parametar metoda mogu imati memorije
isto ime kao i polje • Oslobađanje memorije
– lokalna promenljiva (ili parametar) skriva polje – ako više nijedna referenca ne ukazuje na objekat, taj
– polju se može pristupiti pomoću rezervisane reči this objekat više nije potreban i može se osloboditi memorija
koju on zauzima
• Primer u kojem je korišćenje this obavezno
– oslobađanje memorije radi sakupljač smeća koji se
Kutija(double sirina, double visina, double duzina){
povremeno uključuje
;
this.sirina = sirina;
this.visina = visina;
this.duzina = duzina;
}
205 206
Metod finalize
• Koristi se za oslobađanje resursa koji ne potiču iz Jave,

npr. pokazivač na datoteku, Windows font, ... kad se
uništava objekat koji je rezervisao te resurse
• Metod finalize se poziva neposredno pre nego što
sakupljč
k ljč smećać uništi
išti objekat
bj k t
• Metod finalize se ne poziva kad neki objekat izađe
iz opsega važenja
• Opšti oblik metoda finalize
protected void finalize() {
kod_za_finalizaciju
}
207 208
Preklapanje metoda
• Dva ili više metoda u klasi mogu da imaju isto ime i to se

zove preklapanje
kl j metoda
t d (method
( th d overloading)
l di )
• Preklopljeni metodi moraju da se razlikuju po tipu
Klase parametara ili p
p po broju
j pparametara ((ili p
po oba))
• Tip preklopljene metode nije bitan tj. ne pravi se razlika
između preklopjenih metoda na osnovu tipa koji metoda
vraća
ć kao
k rezultat
lt t
209 210
Primer klase sa preklopljenim metodom

Ilustracija rada klase sa preklopljenim metodom
public class Preklapanje
p p j {
void test(){ public class PreklapanjeMain {
System.out.println("Bez parametara"); public static void main(String[] args){
} Preklapanje obj = new Preklapanje();
void test(int a){ obj.test();
int i = 5; Rezultat izvršavanja
System.out.println("Parametar int, a: " + a);
obj.test(i); programa je:
}
void test(int a, int b){ // Greška, metod sa par. int ne vraća rezultat
//double d = obj.test(i); Bez parametara
System.out.println("Parametri int, int: a, b: "+a+" "+b);
double d = obj.test((double)i); Parametar int, a: 5
}
byte b = 4; P
Parametar
t double,
d bl a = 5 5.0
0
double test(double a){
obj.test(b); Parametar int, a: 4
System.out.println("Parametar double, a = " + a);
obj.test(1,2); Parametri int, int, a, b: 1 2
return a;
;
float f = 3.0f; P
Parametar
t double,
d bl a = 3 3.0
0
}
obj.test(f);
//void test(double a){ // Greška, već postoji metod sa parametrom double
// System.out.println("Parametar
System.out.println( Parametar double, a = " + a); }
//} }
} 211 212
Pozivanje preklopljenih metoda Preklapanje konstruktora
• Koji se metod poziva određuje se na osnovu broja i / ili • Konstruktori se mogu preklopiti, slično kao i metodi
tipova argumenata – Preklopljeni konstruktori moraju da se razlikuju po tipu
• Određivanje koji od preklopljenih metoda se poziva radi parametara ili po broju parametara (ili po oba)
se u vreme prevođenja programa – Može se napisati i kostruktor bez parametara
213 214
Preklapanje konstruktora u klasi Kutija Preklapanje konstruktora u klasi Kutija – nastavak

class
l K tij {
Kutija // Konstruktor
Konstr ktor sa jednim parametrom (kutija
(k tija je kocka)
double sirina; Kutija(double stranica) {
double visina; sirina = visina = duzina = stranica;
double duzina; }
// Metod za postavljanje vrednosti polja (dimenzija kutije)
// Konstruktor bez parametara o d posta
void postaviDimenzije(double
e je(doub e s, doub double e v, , doub
double
e d){
Kutija() { sirina = s;
} visina = v;
d i
duzina = d
d;
// Konstruktor sa parametrima za sve tri dimenzije }
Kutija(double s, double v, double d) { // Metod za izračunavanje zapremune kutije
sirina = s; double zapremina() {
visina = v; return sirina * visina * duzina;
duzina = d; ; }
} }
215 216
Primer za Kutiju sa preklopljenim konstruktorima
Upotreba metoda za postavljanje vrednosti polja class PrimerPreklapanjeKonstruktora1 {
• Metod postaviDimenzije u klasi Kutija treba da Kutija k1 = new Kutija(1, 2, 3);
postoji u sledećim slučajevima: j k2 = new Kutija();
Kutija j
– ako postoji konstruktor bez parametara, zato što npr. u Kutija k3 = new Kutija(2);
trenutku kad se pravi objekat nisu poznate dimenzije // Izračunavanje i ispisivanje zapremina
objekta,
j , pa
p ih treba naknadno p postaviti System out println("Zapremina
System.out.println( Zapremina k1 je " +
– ako ima smisla da se objektu kutije menjaju dimenzije k1.zapremina());
System.out.println("Zapremina k2 je " +
k2.zapremina());
System.out.println("Zapremina k3 je " +
k3.zapremina());
}
}
Zapremina k1 je 6
6.0
0
Zapremina k2 je 0.0
217 218
Zapremina k3 je 8.0
Pozivanje preklopljenih konstruktora Korišćenje objekta kao parametra

• Važi isto pravilo kao i kod metoda • Objekat se može koristiti kao parametar metode
– koji se konstruktor poziva određuje se na osnovu broja i /
ili tipova argumenata
– određivanje koji od preklopljenih konstruktora se poziva
radidi se u vreme prevođenja
đ j programa
219 220
Klasa sa metodom čiji je parametar objekat Primer kad je objekat parametar
class Test { class PrimerProsledjivanjaObjekta {
int a, b; public static void main(String args[]) {
Test obj1 = new Test(10, 2);
Test(int _a, int _b) { Test obj2 = new Test(10, 2);
a = _a;
a; Test obj3 = new Test(10,
Test(10 5);
b = _b; System.out.println("obj1 == obj2: " +
} obj1.equals(obj2));
// Metod equals proverava da li su objekti jednaki System.out.println("obj1 == obj3: " +
boolean equals(Test obj) { obj1.equals(obj3));
if(a == obj.a && b == obj.b) return true; }
else return false; }
} obj1 == obj2: true
} obj1 == obj3: false
221 222
Klasa Kutija - parametar konstruktora je objekat

Konstruktor čiji je parametar objekat class Kutija {
double sirina, visina, duzina;
• Konstruktor čiji je parametar objekat može da se iskoristi
// Konstruktor čiji je parametar objekat, ovde služi za kopiranje objekta
da se napravi kopija postojećeg objekta
Kutija(Kutija obj) {
sirina = obj.sirina;
visina = obj.visina;
duzina = obj.duzina;
}
// Konstruktor bez parametara
Kutija() {
}
// Konstruktor
K t kt sa parametrima ti za sve tri
t i dimenzije
di ij
sirina = s; visina = v; duzina = d;
}
223 224
Preklapanje konstruktora u klasi Kutija – nastavak Preklapanje konstruktora u klasi Kutija – nastavak
// Konstruktor
Konstr ktor sa jednim parametrom (k(kutija
tija je kocka) // Metod za
a posta
postavljanje
ljanje vrednosti
rednosti polja (dimen
(dimenzija
ija kkutije)
tije)
Kutija(double stranica) { void postaviDimenzije(Kutija ref){
sirina = visina = duzina = stranica; sirina = ref.sirina;
} visina = ref.visina;
// Metod za postavljanje vrednosti polja (dimenzija kutije) duzina = ref.duzina;
o d posta
void postaviDimenzije(double
e je(doub e s, doub double e v,
, doub
double
e d){ }
sirina = s; // Metod za izračunavanje zapremune kutije
visina = v; double zapremina() {
d i
duzina = dd; ret rn sirina
return i i * visina
i i * d duzina;
i
} }
void postaviDimenzije(double x){ }
sirina = visina = duzina = x;
}
225 226
Primer za Kutiju sa preklopljenim konstruktorima

class PrimerPreklapanjeKonstruktora2 { Stek
Kutija k1 = new Kutija(1, 2, 3); • Stek je memorija koja privremeno čuva podatke
Kutija k2 = new Kutija(); • Podatak koji se poslednji stavi na stek prvi se uzme sa
Kutija k3 = new Kutija(2); steka, i obrnuto podatak koji je prvi stavljen na stek
Kutija k4 = new Kutija(k1); // k4 je kopija objekta k1
poslednji će se uzeti
// Izračunavanje i ispisivanje zapremina
System.out.println("Zapremina k1 je " + k1.zapremina()); • Stek ima operacije za stavljanje na stek (push) i
System.out.println("Zapremina k2 je " + k2.zapremina()); uzimanje sa steka (pop)
System out println("Zapremina
System.out.println( Zapremina k3 je " + k3
k3.zapremina());
zapremina()); • Postoji pokazivač koji pokazuje na tekuću vrednost na
System.out.println("Zapremina k4 je " + k4.zapremina()); steku (vrh steka)
}
}
Zapremina k1 je 6.0
Zapremina k2 je 0.0
Zapremina k3 je 8.0
Zapremina k4 je 6.0 227 228
Dodavanje jedne vrednosti na stek Uzimanje jedne vrednosti sa steka
Stanje pre dodavanja Stanje posle dodavanja
nove vrednosti na stek nove vrednosti na stek Stanje pre uzimanja sa steka Stanje posle uzimanja sa steka
Push(a) Pop()
a a
vrh vrh vrh vrh
r r r r
q q q q
p p p p
229 230
Jednostavna klasa – ilustracija steka Jednostavna klasa, ilustracija steka – nastavak

class
l St k {
Stack
// Uzimanje jedne vrednosti sa steka
int stck[] = new int[10];
int pop() {
int vrh;
if(vrh < 0) {
System.out.println("Stek je prazan.");
Stack() {
return 0;
;
vrh = -1; // Inicijalizacija
c ja ac ja vrha
a ste
steka
a
}
}
else
return stck[vrh--];
// D
Dodavanje
d j jjedne
d vrednosti
d ti na stek
t k
}
void push(int broj) {
}
if(vrh == 9)
System.out.println("Stek je popunjen.");
else
• U realnom slučaju umseto naredbe za štampanje koristio
[ ] = broj;
stck[++vrh] j;
bi se izuzetak
}
231 232
Primer rada jednostavne klase za stek
Rezultat
class PrimerRadaSteka {
public static void main(String args[]) { Stek stck1: Stek stck2:
Stack stack1 = new Stack(); 9 19
Stack stack2 = new Stack(); 8 18
// Stavljanje na stek 7 17
for(int i=0; i<10; i++) stack1.push(i);
6 16
5 15
// Uzimanje sa steka
System.out.println("Stek stack1:"); 4 14
for(int i=0; i<10; i++) 3 13
System.out.println(stack1.pop()); 2 12
System.out.println("Stek stack2:"); 1 11
for(int i=0; i<10; i++) 0 10
System.out.println(stack2.pop());
}
}
233 234
Prosleđivanje argumenata u metode Prosleđivanje argumenata u metode

• Argumenti između metoda koji poziva (pozivajući) i • Prema tome da li se prosleđuju argumenti prostih tipova
metoda koji se poziva (pozvani) prosleđuju se preko ili klasnih tipova, može se govoriti o dva načina
steka prosleđivanja (pozivanja) argumenata:
• Pozivajući metod stavlja argumente na stek – po vrednosti
• Pozvani metod uzima argumente sa steka – po referenci
• Tek kad se pozvani metod završi pomera se pokazivač
vrha steka • Po vrednosti se prosleđuju prosti tipovi (na stek se
stavlja vrednost argumenta)
• Po referenci se prosleđuju klasni tipovi tj. objekti (na stek
se stavlja referenca na objekat)
235 236
Prosleđivanje (pozivanje) po vrednosti Prosleđivanje (pozivanje) po vrednosti
class PozivanjePoVrednosti {
• Tip argumenta je neki od prostih tipova public static void main(String args[]) {
• Po
P završetku
š tk metoda
t d vrednost
d t prosleđenog
l đ argumenta
t Test obj = new Test();
ostaje nepromenjena int a = 2, b = 10;
System.out.println("Pre pozivanja a, b: " +
a + " " + b);
class Test {
int c = obj.izracunaj(a, b);
int izracunaj(int i, int j) {
y p
System.out.println("Posle pozivanja
p j a, , b: " +
i *
*= 3
3;
a + " " + b);
j /= 2;
System.out.println("c: " + c);
return i * j;
}
}
}
}
Pre pozivanja a, b: 2 10
Posle
P l pozivanja
i j a, b:
b 2 10
237
c: 30 238
Objašnjenje prosleđivanja (pozivanja) po vrednosti Prosleđivanje (pozivanje) po referenci

• Argument je prost tip čija se vrednost prilikom pozivanja • Tip argumenta je klasni tip
metoda stavlja na stek • Metod koji poziva stavlja argument – referencu
• Pozvani metod uzima vrednost sa steka, dodeljuje je (tj. vrednost reference) na stek
parametru • Pozvani metod uzima vrednost reference sa steka i
• Parametru se može menjati vrednost u metodu, ali ta dodeljuje je parametru
promena nema uticaja na promenljivu čija je vrednost • Parametar ukazuje na isti objekat na koji ukazuje i
prosleđena parametru argument
• Unutar metoda može se promeniti objekat kojem se
pristupa preko parametra
• Sama referenca se prosleđuje po vrednosti
239 240
Prosleđivanje po referenci Prosleđivanje (pozivanje) po referenci
class Test {
• Vrednost argumenta (promenljive koja postoji u metodu int a, b;
koji poziva) je kopirana u parametar (promenljivu koja
postoji u pozvanom metodu), tako da ukazuju na isti Test(int _a, int _b) {
objekat koji je negde u memoriji a = _a;
• Objekat
Obj k t se može ž promenitiiti unutar
t metoda
t d b = _b;
}
int izracunaj(Test o) {
argument polje 0
o.a *= 3;
polje 1
o b /= 2;
o.b
parametar ...
return o.a * o.b;
polje N }
}
241 242
Prosleđivanje (pozivanje) po referenci Objekat kao rezultat metoda

class PozivanjePoReferenci {
• Unutar metoda može da se napravi objekat i da se
referenca na tajj novi objekat
j vrati kao rezultat metoda
Test obj = new Test(2, 10);
System.out.println("Pre pozivanja obj.a, obj.b: " class Test {
+ obj.a + " " + obj.b); int a;
int c = obj.izracunaj(obj); Test(int _a) {
System.out.println("Posle pozivanja obj.a, obj.b: " a = _a;
+ obj
obj.a
a + " " + obj
obj.b);
b); }
System.out.println("c: " + c); Test uvecajZaTri() {
} Test privremeniObj = new Test(a + 3);
} return privremeniObj;
Pre pozivanja obj.a, obj.b: 2 10 }
Posle pozivanja obj.a, obj.b: 6 5 }
c: 30
243 244
Primer za objekat koji je rezultat metoda
class
l V
VracanjeObjekta
j Obj kt {
Test obj1 = new Test(2);
Test obj2;
obj2 = obj1.uvecajZaTri();
System.out.println("obj1.a:
Syste .out.p t ( obj .a: " + obj
obj1.a);
.a);
System.out.println("obj2.a: " + obj2.a);
obj2 = obj2.uvecajZaTri();
S t
System.out.println("Drugo
t i tl ("D uvećanje
ć j obj2.a:
bj2 "
+ obj2.a);
}
}
obj1.a: 2
obj2.a: 5
Drugo uvećanje obj2.a: 8
245 246
247 248
Rekurzija
• Rekurzija je pojava kad metod poziva samog sebe

• Primer: faktorijel
1! = 1
Rekurzija upravljanje pristupom
Rekurzija, pristupom, static
static, final
final, ... 2! = 2 × 1! = 2 × 1
3! = 3 × 2! = 3 × 2 × 1
4! = 4 × 3! = 4 × 3 × 2 × 1
5! = 5 × 4! = 5 × 4 × 3 × 2 × 1
...
n! = n × (n – 1)!
249 250
Rekurzivan metod Primer za rekurzivan metod

class Faktorijel { class PrimerRekurzije {
// faktorijel je rekurzivan metod public static void main(String args[]) {
int faktorijel(int n) { Faktorijel f = new Faktorijel();
int rezultat; for(int i=1; i<=5; i++)
if(n==1) // uslov za završavanje rekurzivnog pozivanja System out println(i + "!
System.out.println(i ! = " +
return 1; f.faktorijel(i));
rezultat = faktorijel(n-1) * n; }
return rezultat; }
}
} 1! = 1
2! = 2
• U rekurzivnom metodu mora postojati uslov za 3! = 6
završavanje
j rekurzivnog
gppozivanja
j 4! = 24
5! = 120
251 252
Iterativno rešenje za faktorijel Rekurzivni metodi
class FaktorijelIterativni { • Svaki rekurzivan poziv kopira (dodaje) argumente na
int faktorijel(int n) { stek, a argumenti se uklanjaju sa steka kad se metod
int rezultat = 1; završi
for(int i=n; i>1; i--)
• Kad se zadnji put pozove rekurzivan metod, argumenti
rezultat *=
= i;
svih
ih prethodnih
th d ih poziva
i su na steku
t k
return rezultat;
}
• Ako postoji veliki broj rekurzivnih poziva može doći do
}
prekoračenja steka
steka, pri čemu se javlja izuzetak
• Rekurzivno rešenje može biti sporije od iterativnog ako
je broj pozivanja metoda veliki
253 254
Rekurzivno ispisivanje niza

Rekurzivni metodi
class RekIspisNiza {
• Neki problemi su takvi da se lakše (prirodnije) rešavaju int vrednosti[];
rekurzivnim metodima, odnosno jednostavniji je kod za
rekurzivno nego za iterativno rešenje RekIspisNiza(int i) {
• Problemi koji po prirodi nisu rekurzivni se takođe mogu vrednosti = new int[i];
rešiti
šiti rekurzivno,
k i npr. ispisivanje
i i i j elemenata
l t niza
i }
// rekurzivan metod za ispisivanje niza

void ispisivanjeNiza(int i) {
if(i==0) return;
else ispisivanjeNiza(i
ispisivanjeNiza(i-1);
1);
System.out.println("[" + (i-1) + "] = " +
vrednosti[i-1]);
}
255
} 256
Ilustracija rekurzivnog ispisivanja niza Kapsuliranje
class IlustracijaRekurzivnogIspisivanja { • Povezivanje podataka i koda koji sa njima radi
• Upravljanje pristupom – koji delovi programa mogu da
RekIspisNiza obj = new RekIspisNiza(5);
pristupaju članovima klase
for(int i=0; i<5; i++) obj.vrednosti[i] = i;
obj ispisivanjeNiza(5);
obj.ispisivanjeNiza(5);
}
}
[0] = 0
[1] = 1
[2] = 2
[3] = 3
[[4]] = 4
257 258
Upravljanje pristupom Specifikatori pristupa

• Način pristupanja članu klase određuje se specifikatorom • public – član klase je dostupan svim drugim klasama
pristupa koje je koriste
• Spacifikator pristupa piše se u deklaraciji člana klase • protected – biće objašnjen kasnije
ispred specifikatora tipa • private – član klase se može koristiti samo unutar
• Specifikatori pristupa su svoje klase
– public za javni način pristupanja • standardni način pristupanja – unutar paketa kojem
– protected za zaštićeni način pristupanja pripada klasa pristup je javan
javan, izvan paketa pristup je
– private za privatni način pristupanja onemogućen
– bez specifikatora za standardni način pristupanja
259 260
Ilustracija javnog i privatnog pristupanja
Specifikator pristupa se piše ispred specifikatora tipa
class Test {
public int i; int a; // podrazumevani pristup
private double j; public int b; // javni pristup
private int c; // privatni pristup
private int nazivMetoda(int

p ( a,
, char b)
) {
// postavljanje
t lj j vrednosti
d ti polja
lj c
telo_metoda void setC(int i) {
} c = i;
}
// dohvatanje vrednosti polja c

int getC() {
return c;
}
261
} 262
Ilustracija javnog i privatnog pristupanja Popravljena klasa za stek

class
l St k {
Stack
class ProbaPristupa {
private int stck[] = new int[10];
private int vrh;
Test ob = new Test();
// Poljima a i b se može pristupati direktno
public Stack() {
ob.a = 10;
; // Inicijalizacija
vrh = -1; c ja ac ja vrha
a ste
steka
a
ob.b
b b = 20
20;
}
// Polju c se ne može pristupati direktno
// Ovo bi bila greška u prevođenju
// D
Dodavanje
d j jjedne
d vrednosti
d ti na stek
t k
//ob.c = 100;
public void push(int broj) {
ob.setC(100);
if(vrh == 9)
System.out.println("a,
System.out.println( a, b, and c: " + ob.a +
System.out.println("Stek je popunjen.");
" " + ob.b + " " + ob.getC());
else
}
[ ] = broj;
stck[++vrh] j;
}
}
263 264
Popravljena klasa za stek – nastavak Primer rada jednostavne klase za stek
class PrimerRadaSteka {
// Uzimanje jedne vrednosti sa steka public static void main(String args[]) {
public int pop() { Stack stack1 = new Stack();
Stack stack2 = new Stack();
if(vrh < 0) {
// Stavljanje na stek
return 0;
} // Uzimanje sa steka
else System.out.println("Stek stack1:");
return stck[vrh--]; for(int i=0; i<10; i++)
} System.out.println(stack1.pop());
} System.out.println("Stek stack2:");
for(int i=0; i<10; i++)
• Klasa je popravljena tako da se mogu koristiti samo //stack1.vrh = -2; //ove dve naredbe su neispravne,
metodi push i pop, tj. ne mogu se direktno menjati //stack2.stck[3] = 10; //pristupaju privatnim članovima
vrh i stck }
265 } 266
Rezervisana reč static Statički članovi podaci (polja)

• Klasa može imati član koji se može koristiti samostalno, • Statička polja se ponašaju kao globalne promenljive
odnosno nezavisan je od objekata • Objekat ne sadrži statička polja
polja, tj.
tj pri pravljenju objekta
• Deklaracija takvih članova sadrži rezervisanu reč ne rezerviše se prostor za statička polja, već samo za
static, a članovi se nazivaju statički ona koja nisu statička
• Statički članovi mogu biti i podaci i metodi
• Statički članovi se mogu koristiti i kad nije napravljen
nijedan objekat klase
267 268
Statički metodi Primer za statičke članove: objekti imaju redni broj
• Statički metodi mogu da pristupaju samo statičkim • Potrebno je da se izbroje objekti koji su napravljeni, i da
poljima svaki napravljeni objekat ima redni broj:
• Statički metodi mogu da pozivaju samo statičke metode – broj napravljenih objekata je statički član
• U statičkim metodima ne mogu da se koriste rezervisane – u konstruktoru se dodeljuje redni broj novom objektu i
reči this i super i k
inkrementira
ti se ukupan
k broj
b j napravljenih
lj ih objekata
bj k t
class RedniBroj {
private static int broj_objekata
broj objekata = 0;
private int id;
public RedniBroj() { id = broj_objekata++; }
public int id() { return id; }
public static int brojObjekata() {
return broj_objekata;
}
269 270
}
Primer: korišćenje objekata koji imaju redni broj Inicijalizacija statičkih promenljivih
class PrimerZaObjekatSaRednimBrojem {
public static void main(String[] args) { • Statičko polje se može inicijalizovati prilikom deklaracije
RedniBroj objA = new RedniBroj(); • Ako se ne uradi inicijalizacija,
inicijalizacija statičko polje će imati
RedniBroj objB = new RedniBroj(); vrednost 0
RedniBroj objC = new RedniBroj();
• U klasi može postojati statički blok u kojem se mogu
S t
System.out.println("Ukupan
t i tl ("Uk b
broj
j objekata:
bj k t " +
inicijalizovati statičke promenljive
RedniBroj.brojObjekata());
• Statički blok se izvršava samo jednom, kad se klasa
System.out.println("objA, RB: " + objA.id());
učita prvi put
System.out.println("objB, RB: " + objB.id());
System.out.println("objC, RB: " + objC.id());
}
}
Ukupan broj objekata: 3
objA RB: 0
objA,
objB, RB: 1
271 272
objC, RB: 2
Primer za statičke promenljive, blokove i metode
class StatickiClanoviM { Rezultat izvršavanja klase StatickiClanoviM
static int a = 3;
static int b; Statički blok je izvršen.
static void statickiMetod(int x) { x = 10
System.out.println("x = " + x);
a=3
System.out.println("a = " + a);
System out println("b = " + b);
System.out.println("b b=6
}
static {
System.out.println("Statički blok je izvršen.");
b = a * 2;
}

statickiMetod(10);
}
} 273 274
Drugi primer za statičke članove Ilustracija rada drugog primera za statičke članove
public class StatickiClanovi { public class IlustracijaStatic {
StatickiClanovi() { public static void main(String[] args) {
System.out.println("Konstruktor izvršen."); StatickiClanovi sc1;
} System out println("Prvo
System.out.println( Prvo ispisivanje.
ispisivanje ");
);
sc1 = new StatickiClanovi(); //Ovde se prvo izvrši statički blok
int i;
System.out.println("sc1.i = " + sc1.i);
static int a = 3;
StatickiClanovi sc2 = new StatickiClanovi();
static int b;
sc2.i = 8;
static void statickiMetod(int x) { System.out.println("sc2.i = " + sc2.i);
System.out.println("x
System.out.println( x = " + x); }
System.out.println("a = " + a); }
System.out.println("b = " + b);
Prvo ispisivanje.
}
Statički blok izvršen.
static { Konstruktor izvršen.
System.out.println("Statički blok izvršen."); sc1.i = 0
} Konstruktor izvršen.
} 275 sc2.i = 8 276
Pristupanje statičkim članovima Pristupanje statičkom metodu preko imena klase
• Statičkim članovima se može pristupati pre nego što je public class PristupanjePrekoImenaKlase {
napravljen objekat klase public static void main(String[] args) {
StatickiClanovi.statickiMetod(5);
• Javnim statičkim članovima se pristupa preko imena
StatickiClanovi.statickiMetod(10);
klase i operatora tačka
<ime_klase>.<statički_član>
i ič i č }
}
• Statičkim članovima se može pristupati i preko reference
na objekat,
objekat ali to treba izbegavati
– kada se članu pristupa preko imena klase jasno je da se Statički blok izvršen.
pristupa statičkom članu x=5
a=3
– kada
k d se statičkom
ičk članu
čl pristupa
i preko k reference
f nije
ij
b=0
odmah uočljivo da li je član statički ili ne
x = 10
a=3
b=0
277 278
Rezervisana reč final Dužina niza

• Može se specificirati da se vrednost promenljive ne • Nizovi se realizuju kao objekti
može promeniti, tj. promenljiva je u stvari konstanta • Svi nizovi imaju polje length čija vrednost pokazuje
• Za ovo se koristi rezervisana reč final koliko elemenata ima niz
• Vrednost konstante se mora zadati pri deklaraciji
• Imena konstanti se obično pišu velikim slovima
final int OVO_JE_KONSTANTA = 5;
final double MINIMUM = 1.7;
• Rezervisana reč final može da se primeni i na
metode i na klase
klase, a značenje će biti objašnjeno kasnije
279 280
Ilustracija rada drugog primera za statičke članove
Popravljanje klase Stek
class DuzinaNiza {
public static void main(String args[]) { • Primer za klasu stek koja je ranije korišćena može da se
int
t a
a1[]
[] = new
e int[10];
t[ 0]; popravi tako što se omogući pravljenje steka zadate
int a2[] = {3, 5, 7, 1, 8, 99, 44, -10}; veličine
int a3[] = {4, 3, 2, 1};
• Veličina steka treba da bude parametar konstruktora
System.out.println("Dužina niza a1 je " + a1.length); • Koristi se polje length koje sadrži dužinu niza
System.out.println("Dužina niza a2 je " + a2.length);
System.out.println("Dužina
System.out.println( Dužina niza a3 je " + a3.length);
}
}
Dužina niza a1 je 10
281 282
Popravljena klasa za stek – stek različite dužine Popravljena klasa za stek – nastavak
class
l St k {
Stack // Uzimanje jedne vrednosti sa steka
private int stck[]; public int pop() {
private int vrh; if(vrh < 0) {
public Stack(int velicina) {
return 0;
stck = new int[velicina];
}
vrh
h = -1;
1
else
}
return stck[vrh--];
// Dodavanje jedne vrednosti na stek }
public void push(int broj) { }
if(vrh == stck.length-1)
System.out.println("Stek
i j popunjen.");
je j
• U odnosu na prethodu verziju, klasa je popravljena tako
else
da se može napraviti stek proizvoljnog kapaciteta
stck[++vrh] = broj; • Kapacitet je parametar konstruktora, a u prethodnoj
} verziji
iji kkapacitet
it t jje bi
bio 10)
283 284
Primer rada jednostavne klase za stek
class PrimerRadaSteka { Ugnježdene klase
Stack stack1 = new Stack(5); • Unutar jedne klase (klasa A) može da se definiše druga
Stack stack2 = new Stack(8); klasa (klasa B), i tada je klasa B ugnježdena u klasu A, a
// Stavljanje na stek klasa A je obuhvatajuća klasa
for(int i=0; i<5; i++) stack1.push(i); • Za ugnježdenu klasu zna samo obuhvatajuća klasa
f (i t i=0;
for(int i 0 ii<8;
8 i++)
i ) stack2.push(i);
k2 h(i) – ugnježdena klasa se ne može koristiti izvan obuhvatajuće
// Uzimanje sa steka klase
System.out.println("Stek stack1:");
• Ugnježdena klasa može da pristupa svim članovima
obuhvatajuće klase, čak i privatnim članovima
System.out.println("Stek
System.out.println( Stek stack2:
stack2:");
);
• Obuhvatajuća klasa ne može da pristupa poljima
(članovima podacima) unutrašnje klase, ali može da
pristupa metodima unutrašnje klase, bez obzira na
}
specifikatore
p p
pristupa
p
} 285 286
Primer unutrašnje klase

Vrste ugnježdenih klasa class Spoljasnja {
int sp_x = 100;
• Ugnježdena klasa može biti statička void prikaziUnutrasnju() {
– Statička ugnježdena klasa se retko koristi Unutrasnja un = new Unutrasnja();
un.prikazi();
– Ne može direktno da pristupa poljima obuhvatajuće klase,
}
već samo preko reference (objekta)
// Unutrašnja klasa
• Ugnježdena klasa koja nije statička naziva se unutrašnja class Unutrasnja {
klasa int un_y = 10;
– Unutrašnja klasa može da pristupa poljima i metodima void prikazi() {
obuhvatajuće klase direktno preko imena polja i metoda System.out.println("sp_x = " + sp_x);
kao što se radi i u obuhvaćenoj klasi }
} // kraj unutrašnje klase
void prikaziY() {
Unutrasnja un = new Unutrasnja();
System.out.println("un
System.out.println( un_y
y = "+un.un y); //Greška u prevođenju
+un.un_y);
}
287 } 288
Ilustracija korišćenja klase Spoljasnja Unutrašnje klase u bloku
class PrimerSpoljasnja { • Unutrašnja klasa može da se definiše i unutar bilo kojeg
public static void main(String args[]) { metoda ili bloka spoljašnje klase
Spoljasnja spoljasnja = new Spoljasnja(); • Oblast važenja unutrašnje klase je blok u kojem je
spoljasnja.prikaziUnutrasnju(); definisana
}
}
sp_x = 100
289 290
Korišćenje ugnježdenih klasa Osnovno o klasi String
• Ugnježdene klase nisu postojale u verziji Java 1.0, • Klasa String je ugrađena u Javu
uvedene su u verziji 1.1 • Služi za rad sa znakovnim nizovima
• Ugnježdene klase se koriste u apletima • Svi znakovni nizovi su objekti klase String
j
• Objekti tipa
p String g su nepromenljivi
p j
– Postojećem objektu tipa String ne može da se promeni
znak na nekoj poziciji
– Pravi
P i se novii znakovni
k i niz
i sa potrebnim
t b i sadržajem
dž j
291 292
Znakovni niz i niz znakova Operator + za znakovne nizove
• Znakovni niz je objekat klase String • Služi za nadovezivanje (konkatenaciju) znakovnih
• Niz znakova je niz elemenata tipa char o a, tj.j obje
nizova, objekata
a a tipa
pa St
String
g
• Rezultat je novi objekat tipa String čiji je sadržaj
• Primer za niz znakova dobija spajanjem sadržaja dva objekta tipa String
char niz_znakova1[]
niz znakova1[] = new char[5];
• Primeri:
• Primer inicijalizacije niza znakova String str1 = "prvi " + "drugi";
char niz_znakova2[]
niz znakova2[] = { {'a',
a , 'b',
b , 'c',
c , '3'};
3 }; St i
String str2
t 2 = "
"prvii d
drugi";
i"
• Primer inicijalizacije znakovnog niza String str3 = "prvi ";
String znakovni
znakovni_niz1 niz1 = "abc3";
abc3 ; String str4 = "drugi";
drugi ;
String str5 = str3 + str4;
293 294
Primer nadovezivanja znakovnih nizova Neki metodi klase String

class PrimerZaString1 { • Metod za proveru da li dva znakovna niza imaju isti
public static void main(String args[]) { sadržaj
String strObj1 = "Prvi znakovni niz"; boolean equals(String objekat)
String strObj2 = "Drugi znakovni niz";
String strObj3 = strObj1 + " i " + strObj2;
• Metod koji vraća dužinu znakovnog niza
System.out.println(strObj1);
int length()
System.out.println(strObj2); – Napomena: nizovi imaju polje length
System.out.println(strObj3); • M
Metod
d koji
k ji vraća
ć znakk sa zadate
d pozicije
i ij
} char charAt(int indeks)
}
Prvi znakovni niz

Drugi znakovni niz
Prvi znakovni niz i Drugi znakovni niz 295 296
Primer za metode znakovnog niza Primer za metode znakovnog niza
class PrimerZaString2 {
class PrimerZaString4 { public static void main(String args[]) {
public static void main(String args[]) { String obj1 = "Prvi znakovni niz";
String obj = "Prvi znakovni niz"; String obj2 = "Drugi znakovni niz";
System.out.println("Dužina obj je " + obj.length()); String obj3 = obj1; // obj1 i obj3 ukazuju na isti objekat
System.out.println("Znak na poziciji 0 u obj je: " + if(obj1.equals(obj2))
obj.charAt(0)); System.out.println("obj1 i obj2 su jednaki");
System.out.println("Znak na poziciji 2 u obj je: " + else
obj.charAt(2)); System.out.println("obj1 i obj2 su različiti");
System.out.println("Znak na poslednjoj poziciji " + if(obj1.equals(obj3))
(obj.length()-1) + " u obj je: " + System.out.println("obj1 i obj3 su jednaki");
obj.charAt(obj.length()-1)); else
} System.out.println("obj1 i obj3 su različiti");
} }
Znak na poziciji 0 u obj je: P }
Znak na poziciji 2 u obj je: v
297 obj1 i obj2 su različiti 298
Znak na poslednjoj poziciji 16 u obj je: z obj1 i obj3 su jednaki
Neki konstruktori klase String Primer: poređenje objekata i referenci

• Klasa String ima više konstruktora među kojima su i class PrimerZaString3 {
sledeći:
String obj1 = "Prvi znakovni niz";
– Podrazumevani konstuktor String obj2 = obj1; // obj1 i obj2 ukazuju na isti objekat
String() String obj3 = new String(obj1);
– Konstuktor čiji je parametar objekat tipa String System.out.println("Reference obj1 i obj2 ukazuju na
isti objekat: " + (obj1 == obj2));
String(String objekat)
System.out.println("Reference obj1 i obj3 ukazuju na
– Konstuktor čiji je parametar niz znakova isti objekat: " + (obj1 == obj3));
String(char niz_znakova[]) System.out.println("Objekti na koje ukazuju reference
obj1 i obj3 su jednaki: " + obj1.equals(obj3));
}
}
Reference obj1 i obj2 ukazuju na isti objekat: true
Reference obj1 i obj3 ukazuju na isti objekat: false
299 300
Objekti na koje ukazuju reference obj1 i obj3 su jednaki: true
Argumenti u komandnoj liniji
class KomandnaLinija {
for(int i
i=0;
0; i<args.length; i++)
System.out.println("args[" + i + "]: " +
args[i]);
}
}
java K
j KomandnaLinija
d Li ij 5 proba
b kkomandne
d li
linije
ij -1
1 10
args[0]: 5
args[1]: proba
args[2]: komandne
args[3]: linije
args[4]: -11
args[5]: 10
301 302
303 304
Nasleđivanje
• Za grupu srodnih pojava može da se napravi klasa u
kojoj su sve zajedničke karakteristike srodnih pojava
• Specifičnije klase, za svaku od srodnih pojava, mogu da
se izvedu iz opštije kase i da naslede sve njene
Nasleđivanje k kt i tik
karakteristike
• Opštija klasa se naziva natklasa (superclass)
• Klasa koja se izvodi iz natklase naziva se potklasa
(subclass)
• Potklasa ima samo jednu natklasu
• Za izvođenje se koristi rezervisana reč extends
305 306
Primer izvođenja (nasleđivanja)

class A { Pravljenje objekata klasa A i B
int i, j;
A objA = new A();
void prikaziIJ() { objA i
System.out.println("i,
System.out.println( i, j: " + i + " " + j);
Klasa A (objekat klase A) j
}
ima dva polja: i, j
}
// potklasa B se izvodi iz klase A

class B extends A {
int k;
void prikaziK() { B objB = new B();
System.out.println("k: " + k); objB i
} Klasa B (objekat klase B) j
void PrikaziZbir() { ima tri polja: i, j, k k
System.out.println("i+j+k: " + (i+j+k)); (i,
( , j su nasleđena iz
} klase A)
} 307 308
Primer za nasleđivanje
class PrimerNasledjivanja { Rezultat izvršavanja PrimerNasledjivanja
A objA = new A(); Sadržaj objA:
j = new B();
B objB
i,i j: 10 20
objA.i = 10; objA.j = 20;
objB.i = 7; objB.j = 8; objB.k = 9;
System out println("Sadržaj
System.out.println( Sadržaj objA: ");
); Sadržajj objB:
j
objA.prikaziIJ(); i, j: 7 8
System.out.println(); k: 9
System.out.println("Sadržaj objB: ");
objB.prikaziIJ();
Zbir i, j, k iz objB:
objB.prikaziK();
System.out.println(); i+j+k: 24
System.out.println("Zbir i, j, k iz objB:");
objB prikaziZbir();
objB.prikaziZbir();
}
309 310
}
Primer
Kontrola pristupa i nasleđivanje class A {
int i;
• Potklasa ne može pristupati privatnim članovima private int j;
natklase void postaviIJ(int _i,
i int _j)
j) {
i = _i;
j = _j;
}
}
class
l B extends
t d A {
int zbir() {
return i + j; // Greška, ovo se ne prevodi
}
}
• Klasa B je nasledila polje j, ali se tom polju ne može pristupiti
direktno u klasi B, pošto je polje privatno u klasi A
311 312
Klasa Kutija
Primer nasleđivanja sa klasom Kutija class Kutija {
double sirina, visina, duzina;
• Klasa Kutija će biti osnovna klasa (natklasa)
// Konstruktor čiji je parametar objekat, ovde služi za kopiranje objekta
• Iz klase Kuija će biti izvedene dve klase
klase, Kutija(Kutija obj) {
KutijaSaTezinom i ObojenaKutija sirina = obj.sirina;
– Klasa KutijaSaTezinom će naslediti klasu Kutija, i visina = obj.visina;
imaće dodatno polje tezina duzina = obj.duzina;
– Klasa ObojenaKutija će naslediti klasu Kutija, i }
imaće dodatno p
polje
j boja
j // Konstruktor bez parametara
Kutija() {
}
// Konstruktor
K t kt sa parametrima ti za sve tri
t i dimenzije
di ij
sirina = s; visina = v; duzina = d;
}
313 314
Klasa Kutija – nastavak Kutija sa težinom – potklasa klase Kutija

// Konstruktor
Konstr ktor sa jednim parametrom (kutija
(k tija je kocka) class KutijaSaTezinom extends Kutija {
Kutija(double stranica) { double tezina;
sirina = visina = duzina = stranica;
} KutijaSaTezinom(double s, double v, double d,
// Metod za postavljanje vrednosti polja (dimenzija kutije) double t) {
void
o d posta
postaviDimenzije(double
e je(doub e s, doub double e v,
, doub
double
e d){ sirina = s;
sirina = s; visina = v;
visina = v; duzina = d;
d i
duzina = dd; tezina = t;
} }
// Metod za izračunavanje zapremune kutije }
double zapremina() {
}
}
315 316
Primer za kutiju sa težinom Konstruktor klase KutijaSaTezinom je loše napisan
class PrimerZaKutijuSaTezinom1 {
public static void main(String args[]) { • Konstruktor potklase KutijaSaTezinom je
KutijaSaTezinom kt1 = new KutijaSaTezinom(1,2,5,3.3); KutijaSaTezinom(double s, double v, double d, double t){
KutijaSaTezinom kt2 = new KutijaSaTezinom(2,3,4,0.01); sirina = s;
visina = v;
System.out.println("Zapremina kt1: " + kt1.zapremina()); duzina = d;
System.out.println("Težina kt1: " + kt1.tezina); tezina = t;
System.out.println(); }
• Konstruktor natklase Kutija je
System.out.println("Zapremina kt2: " + kt2.zapremina()); Kutija(double s, double v, double d) {
System.out.println("Težina kt2: " + kt2.tezina); sirina = s;
} visina = v;
} duzina = d;
Zapremina kt1: 10.0 }
Težina kt1: 3.3 • Bolje je da konstruktor podklase KutijaSaTezinom pozove
konstruktor klase Kutija j negog da p
ponavlja
j sve naredbe koje
j već
Zapremina kt2: 24.0
postoje u konstruktor klase Kutija.
317 318
Težina kt2: 0.01
Popravljena klasa KutijaSaTezinom

Rezervisana reč super
class KutijaSaTezinom extends Kutija {
• Konstruktor natklase se poziva pomoću rezervisane reči double tezina;
super
p
• Pomoću rezervisane reči super može se pristupiti KutijaSaTezinom(double s, double v, double d,
double t) {
članu natklase koji je sakriven članom potklase
super(s v,
super(s, v d);
tezina = t;
}
}
319 320
Pozivanje konstruktora natklase Referenciranje objekta potklase
• Opšti oblik je • Promenljivoj natklase može se dodeliti referenca na
super(lista argumenata);
super(lista_argumenata); objekat bilo koje potklase izvedene iz te natklase
• Ako se u konstruktoru ppotklase ppoziva konstruktor

natklase, taj poziv mora biti prva naredba u konstruktoru
potklase
– Primer
Pi kkad
d nijedan
ij d kkonstruktor
t kt nema parametre
t
ImePotklase() { // konstruktor potklase
super(); // pozivanje konstruktora natklase
...
}
321 322
Primer referenciranja objekta potklase Primer referenciranja objekta potklase

A refA = new A(); refA i
class A {
B refB = new B(); j
int i, j;
}
refB i
class B extends A {
j
int k;
k
}
refA = refB;
• Referenca natklase A (refA) može refA i
ukazivati na objekat potklase B j
• Preko refA može se pristupiti samo
poljima
lji i,i j pošto
št refA
fA zna samo za
refB i
članove koji su definisani u klasi A
• Polju k se ne može pristupiti preko j
refA zato što je to polje definisano u k
klasi B
323 324
Referenca potklase ne može ukazivati na objekat natklase
Primer za referenciranje objekta potklase
class PrimerReferenciranja {
A refA = new A(); public static void main(String args[]) {
refA i
B refB = new B(); Kutija refK = new Kutija(2, 4, 5);
j KutijaSaTezinom refKST = new KutijaSaTezinom(2,3,4,0.1);
System.out.println("Zapremina kutije: " +
refB i
refK.zapremina());
j System.out.println();
k System.out.println("Zapremina kutije sa težinom: " +
refKST.zapremina());
refB = refA; // Greška System.out.println("Težina kutije sa težinom: " +
• Referenca potklase B zna za polje k refA i refKST.tezina);
(može da pristupi polju k), a to polje j System.out.println();
ne postoji u objektu klase A, pa zato refK = refKST; //referenca natklase refK ukazuje na objekat potklase
referenca potklase B ne može
refB i System.out.println("Zapremina: " + refK.zapremina());
ukazivati na objekat natklase A
j // Greška: referenca natklase ne zna za članove definisane u potklasi
//System.out.println("Težina: " + refK.tezina);
k
}
325 } 326
Klasa KutijaSaTezinom sa više konstruktora

Rezultat izvršavanja primera za referenciranje class KutijaSaTezinom extends Kutija {
double tezina;
Zapremina kutije: 40.0
// Konstruktor čijij jje p
parametar objekat
j
Zapremina kutije sa težinom: 24.0 KutijaSaTezinom(KutijaSaTezinom obj) {
Težina kutije sa težinom: 0.1 // Objekat klase KutijaSaTezinom može da se prosledi
// konstruktoru klase Kutija čiji je parametar tipa Kutija
Zapremina: 24.0 super(obj);
tezina = obj.tezina;
}
// Konstruktor bez parametara

KutijaSaTezinom() {
// Ako se ne navede, poziva se konstruktor bez parametara
//super();
}
327 328
Klasa KutijaSaTezinom – nastavak Primer za kutiju sa težinom
class PrimerZaKutijuSaTezinom2
P i Z K tij S T i 2 {
// Konstruktor sa parametrima za sva polja natklase i potklase
KutijaSaTezinom(double s, double v, double d, KutijaSaTezinom kt1 = new KutijaSaTezinom(1,2,5,3.3);
double t) { K tij S T i
KutijaSaTezinom kt2 = new KutijaSaTezinom();
K tij S T i ()
super(s, v, d); KutijaSaTezinom kt3 = new KutijaSaTezinom(2, 3);
tezina = t; KutijaSaTezinom kt4 = new KutijaSaTezinom(kt1);
} S t
System.out.println("Zapremina
t i tl ("Z i kt1:
kt1 " + kt1
kt1.zapremina());
i ())
System.out.println("Težina kt1: " + kt1.tezina + "\n");
// Konstruktor za kutiju u obliku kocke System.out.println("Zapremina kt2: " + kt2.zapremina());
S t
System.out.println("Težina
t i tl ("T ži kt2:
kt2 " + kt2.tezina+
kt2 t i "\ ")
"\n");
KutijaSaTezinom(double stranica, double t) {
System.out.println("Zapremina kt3: " + kt3.zapremina());
super(stranica);
System.out.println("Težina kt3: " + kt3.tezina+ "\n");
tezina = t; System.out.println("Zapremina
i l (" i k
kt4:
4 " + k
kt4.zapremina());
4 i ())
} System.out.println("Težina kt4: " + kt4.tezina+ "\n");
} }
}
329 330
Primer pristupanja članu natklase

Rezultat izvršavanja primera za kutiju sa težinom class A {
int i;
Zapremina kt1: 10.0 }
Težina kt1: 3.3
class B extends A {
int i; // novo polje, ima isto ime kao i nasleđeno polje iz klase A
Zapremina kt2: 0.0
Težina kt2: 0
0.0
0 B(int a,
a int b) {
super.i = a; // polje i iz klase A
Zapremina kt3: 8.0 i = b; // polje i iz klase B
Težina kt1: 3.0 }
void prikazi() {
p
Zapremina kt4: 10.0
System out println("i iz natklase: " + super
System.out.println("i super.i);
i);
Težina kt4: 3.3
System.out.println("i iz potklase: " + i);
}
}
331 • Polje i u klasi B sakriva nasleđeno polje i iz klase A 332
Primer pristupanja članu natklase – nastavak Pristupanje članu natklase
class PrimerPristupanja {
public static void main(String args[]) { • Rezervisana reč super se koristiti za pristupanje
B obj = new B(1, 2); članu,
č a u, sslično
č o kao
ao i rezervisana
e e sa a reč
eč t s, ali
this, a je razlika
a au
obj.prikazi(); tome što rezervisana reč super ukazuje na natklasu
} • Primer:
} super.član;
č // član
čl jje polje
lj ili metod
t d natklase
tkl
• Članovima natklase se pristupa pomoću rezervisane reči
i iz natklase: 1
super kad su članovi natklase sakriveni članovima
i iz potklase: 2 potklase, tj. kad članovi natklase i potklase imaju ista
imena
333 334
Višestepena hijerarhija Primer: klasa Isporuka

class A { • Iz klase KutijaSaTezinom može Kutija
... se dalje izvesti klasa Isporuka sirina
} koja ima polje troskovi
t k i visina
duzina
class B extends A { • Na dijagramu su prikazane klasa za
... ovajj p
primer sa svojim
j p poljima
j
}
KutijaSaTezinom
class C extends B {
tezina
...
}
• Klasa C je nasledila sve članove iz klase B, što znači da je nasledila Isporuka

i članove klase A troskovi
• Referenca klase A može da ukazuje na objekte klasa A A, B i C
335 336
Klasa Kutija Klasa Kutija – nastavak
public class Kutija
p j { public void postaviDimenzije(double s, double v,
private double sirina, visina, duzina; double d) {
sirina = s;
public Kutija() {} visina = v;
public Kutija(Kutija obj) { duzina = d;
sirina = obj.sirina; }
visina = obj.visina; public double sirina() { return sirina; }
duzina = obj.duzina; public double visina() { return visina; }
} public double duzina() { return duzina; }
public Kutija(double s,
s double v,
v double d) { public double zapremina() {
sirina = s; return sirina * visina * duzina;
visina = v; }
d i
duzina = d
d;
} public String toString() {
return "sirina " + sirina + ", visina " + visina +
public Kutija(double stranica) { ", duzina " + duzina;
sirina = visina = duzina = stranica; }
} 337
} 338
Klasa KutijaSaTezinom Klasa KutijaSaTezinom – nastavak

public class KutijaSaTezinom
p j extends Kutija
j {
private double tezina; public double tezina() { return tezina; }
public KutijaSaTezinom() { } public void postaviTezinu(double t) { tezina = t; }
public KutijaSaTezinom(KutijaSaTezinom obj) { public String toString() {

super(obj); return super.toString() + ", tezina " + tezina;
tezina = obj.tezina; }
} }
public KutijaSaTezinom(double s, double v, double d,
double t) {
super(s, v, d);
tezina = t;
}
public KutijaSaTezinom(double stranica, double t) {

super(stranica);
tezina = t;
} 339 340
Klasa Isporuka Klasa Isporuka – nastavak
public class Isporuka
p p extends KutijaSaTezinom
j {
private double troskovi; public double troskovi() { return troskovi; }
public Isporuka() { } public void postaviTroskove(double tr) {

troskovi = tr;
public Isporuka(Isporuka obj) {
}
super(obj);
troskovi = obj.troskovi; public String toString() {
} return super.toString() + ", troskovi " + troskovi;
}
public Isporuka(double s, double v, double d,
}
double t,
t double tr) {
super(s, v, d, t);
troskovi = tr;
}
public Isporuka(double stranica, double t, double tr) {

super(stranica, t);
troskovi = tr;
} 341 342
Primer za klasu Isporuka

class PrimerZaIsporuku { Rezultat izvršavanja primera za isporuku
Isporuka is1 = new Isporuka(1, 2, 5, 3.3, 81.2); Zapremina is1: 10.0
Isporuka is2 = new Isporuka(2, 1.1, 2.2); Težina is1: 3.3
Isporuka is3 = new Isporuka(is1); Troškovi is1: 81.2
System.out.println("Zapremina is1: " + is1.zapremina());
System.out.println("Težina is1: " + is1.tezina());
Zapremina is2: 8.0
80
System.out.println("Troškovi is1: " + is1.troskovi());
Težina is2: 1.1
System.out.println("Zapremina is2: " + is2.zapremina()); Troškovi is2: 2.2
System.out.println("Troškovi is2: " + is2.troskovi()); Zapremina is3: 10.0
y p Težina is3: 3.3
System.out.println("Zapremina is3: " + is3.zapremina()); Troškovi is3: 81.2
y p
System.out.println("Troškovi is3: " + is3.troskovi());
}
} 343 344
Ilustracija redosleda pozivanja konstruktora
Redosled pozivanja konstruktora class A {
A() { System.out.println("Izvršen konstruktor klase A"); }
• Konstruktor natklase se izvršava pre konstruktora }
potklase class B extends A {
• Ako se poziva konstruktor natklase, pozivanje metoda B() { System.out.println("Izvršen konstruktor klase B"); }
super mora biti prva naredba u konstruktoru potklase }
• Ako se u konstruktoru potklase ne poziva metod super class C extends B {

C() { System.out.println("Izvršen konstruktor klase C"); }
tada će biti pozvan podrazumevani konstruktor natklase,
}
ili odgovarajući konstruktor bez argumenata koji će se
izvršiti prvi class RedosledIzvrsavanjaKonstruktora {
C c = new C();
}
}
Izvršen konstruktor klase A
Izvršen konstruktor klase B
345 346
Izvršen konstruktor klase C
Primer redefinisanja metoda

Redefinisanje metoda class A {
int i, j;
• U potklasi može da se napiše metod koji ima isto ime i
A(int _i, int _j) { i = _i; j = _j; }
istu listu parametara (broj i tip parametara) kao i metod
natklase, i to se naziva redefinisanje metoda natklase void prikazi() {
• Kad se u potklasi pozove redefinisani metod izvršava se System.out.println("i, j: " + i + " " + j);
metod
t d potklase
tkl tj.
tj metod
t d definisan
d fi i u potklasi
tkl i }
}
• Ako metod potklase ima isto ime kao i metod natklase, a
razlikuje se lista parametara,
parametara to je preklapanje metoda a class B extends A {
ne redefinisanje int k;
B(int _i, int _j, int _k) { super(_i, _j); k=_k; }
void prikazi() {
System.out.println("k: " + k);
}
347 } 348
Primer redefinisanja metoda Pristupanje redefinisanom metodu natklase
class PrimerRedefinisanja {
• Redefinisani metod natklase je sakriven u potklasi, tj. ne
B obj = new B(1, 2, 3);
može mu se pristupiti direktno preko imena
obj.prikazi(); // poziva se metod prikazi iz klase B • Redefinisanom metodu natklase se može pristupiti
A objA = new A(5, 6); pomoću rezervisane reči super
objA.prikazi(); // poziva se metod prikazi iz klase A • Primer pozivanja redefinisanog metoda natklase:
} super.imeRedefinisanogMetoda(lista_argumenata)
}
k: 3
i,i j: 5 6
349 350
Popravljena potklasa B iz primera za redefinisanje Primer redefinisanja sa popravljenom klasom B

class A {
int i, j; class PrimerRedefinisanja {
A(int _i, int _j) { i = _i; j = _j; }
B obj = new B(1, 2, 3);
void prikazi() {
obj.prikazi(); // poziva se metod prikazi iz klase B
System.out.println("i, j: " + i + " " + j);
A objA = new A(5, 6);
}
}
objA.prikazi(); // poziva se metod prikazi iz klase A
}
class B extends A {
}
int k;
B(int _i, int _j, int _k) { super(_i, _j); k = _k; } i, j: 1 2

void prikazi() { k: 3
super.prikazi(); i, j: 5 6
System.out.println("k: " + k);
}
} 351 352
Primer za preklapanje metoda Primer preklapanja
class A {
int i, j; class PrimerPreklapanja {
A(int _i, int _j) { i = _i; j = _j; }
B obj = new B(1, 2, 3);
void prikazi() {
System.out.println("i, j: " + i + " " + j); // Pozivanje metoda definisanog u klasi A
} obj prikazi();
obj.prikazi();
}
// Pozivanje preklopljenog metoda u klasi B
class B extends A { j p
obj.prikazi("Vrednost k j
je: ");
int k; obj.prikazi("");
B(int _i, int _j, int _k) { super(_i, _j); k = _k; } }
}
void prikazi(String tekst) {
if(tekst.length() == 0) tekst = "k: "; i, j: 1 2
System.out.println(tekst + k);
Vrednost k je: 3
}
k: 3
} 353 354
Ilustracija dinamičkog razrešavanja

Dinamičko razrešavanje metoda pri izvršavanju class A {
void prikazi() {
• Referenca natklase može da ukazuje na objekat System.out.println("Izvršen metod klase A");
potklase }
• Ako se redefinisani metod poziva referenciranjem iz }
natklase, u trenutku pozivanja se određuje koji se metod
class B extends A {
poziva
i na osnovu ti tipa objekta
bj kt na kkojiji referenca
f t
trenutno
t
void prikazi() {
ukazuje
System.out.println("Izvršen metod klase B");
• Drugačije,
Drugačije tip referenciranog objekta određuje koji će }
metod biti pozvan, a ne tip reference koja ukazuje na }
objekat
class C extends B {
• Ovo ponašanje se naziva polimorfizam
void prikazi() {
– postoji jedan način pristupa, a može se pozvati više
System.out.println("Izvršen metod klase C");
različitih metoda
}
355 } 356
Ilustracija dinamičkog razrešavanja
class DinamickoRazresaanje { Redefinisanje metoda
A a = new A(); // objekat klase A • Omogućava polimorfizam u trenutku izvršavanja
B b = new B(); // objekat klase B
C c = new C(); // objekat klase C
• Omogućava da se u opštoj klasi definišu svi metodi koje
A ref; // referenca na objekat klase A treba da imaju objekti izvedenih klasa od kojih će neki
biti redefinisani u izvedenim klasama
ref = a; // ref ukazuje na objekat klase A
ref.prikazi(); // poziva se metod prikazi iz klase A
ref = b; // ref ukazuje na objekat klase B

ref.prikazi(); // poziva se metod prikazi iz klase B
ref = c; // ref ukazuje na objekat klase C

ref prikazi(); // poziva se metod prikazi iz klase C
ref.prikazi();
}
}
Izvršen metod klase A
Izvršen metod klase B
357 358
Izvršen metod klase C
Primer sa redefinisanjem metoda Primer sa redefinisanjem metoda - nastavak

public class GeometrijskaSlika {
public double obim() { return 0; } // Loše napisan metod public class Kvadrat extends GeometrijskaSlika {
public double povrsina() { return 0; } // Takođe i ovaj private double a;
} public Kvadrat(double a_) { a = a_; }
public double obim() { return 4 * a; }
public class Trougao extends GeometrijskaSlika {
public double povrsina() { return a * a; }
private double a, b, c;
}
public Trougao(double a_, double b_, double c_) {
_ b = b_;
a = a_; _ c = c_;
_ public class Krug extends GeometrijskaSlika {
} private double r;
public double obim() { return a + b + c; } public Krug(double r_) { r = r_; }
public double povrsina() { public double obim() { return 2 * Math.PI
Math PI * r; }
double s = (a + b + c)/2; public double povrsina() { return Math.PI * r*r; }
return Math.sqrt(s*(s-a)*(s-b)*(s-c)); }
}
} 359 360
Primer sa redefinisanjem metoda - nastavak
Primer sa redefinisanjem metoda – rezultat
public class PrimerGeometrijskeSlike {
public static void main(String[] args) {
i: 0, obim: 12.0
Trougao tr = new Trougao(3, 4, 5);
Krug kr = new Krug(1); i: 0,
0 površina: 6 6.0
0
Kvadrat kv = new Kvadrat(10); i: 1, obim: 6.283185307179586
GeometrijskaSlika slike[] = new GeometrijskaSlika[3];
i: 1,, površina:
p 3.141592653589793
slike[0] = tr;
slike[1] = kr; i: 2, obim: 40.0
slike[2] = kv; i: 2, površina: 100.0
for(int i=0; i<3; i++) {
System.out.println("i: " + i + ", obim: " +
slike[i].obim());
System.out.println("i: " + i + ", površina: " +
slike[i].povrsina());
}
}
} 361 362
Lepše napisan poslednji primer Apstraktne klase

public class PrimerGeometrijskeSlike { • Često natklasa ne može da definiše metod, ali mora da
definiše njegov potpis (deklariše metod) da bi potklase
mogle da redefinišu metod
slike[0] = new Trougao(3, 4, 5);
slike[1] = new Krug(1); • Takođe treba obezbediti da potklase moraju da
slike[2] = new Kvadrat(10); redefinišu
d fi iš metod
t d
for(int i=0; i<3; i++) { • Ovo se obezbeđuje pomoću apstraktnog metoda, tj.
System.out.println("i: " + i + ", obim: " + korišćenjem modifikatora abstract
slike[i].obim());
System.out.println("i: " + i + ", površina: " + • Apstraktni metod nema telo
slike[i].povrsina()); • Opšti oblik deklaracije apstraktnog metoda je
} abstract tip imeMetoda(listaParametara);
}
}
363 364
Apstraktne klase Popravljanje primera sa geometrijskim slikama
• Klasa koja ima bar jedan apstraktan metod je apstraktna • U prethodnom primeru nije dobro napisana klasa
klasa GeometrijskaSlika,
Geo et js aS a, jer:
je
• Deklaracija apstraktne klase mora imati modifikator – u njoj su definisani metodi za izračunavanje obima i
abstract površine iako ta klasa ne zna ništa o tome kako će se
izračunavati obim i površina u potklasama
• Apstraktna klasa može imati metode koji nisu apstraktni
– potklase ne moraju da redefinišu metode za izračunavanje
• Apstraktna klasa može imati članove podatke obima i površine, a greška je ako se to ne uradi
• N može
Ne ž se napravitiiti objekat
bj k t apstraktne
t kt kl klase – može se napraviti objekat tipa GeometrijskaSlika
• U potklasi apstraktne klase za koju treba instancirati iako nema smisla da postoji takav objekat
objekte moraju biti redefinisani svi apstraktni metodi • Rešenje je da se klasa GeometrijskaSlika bude
• Može se koristiti referenca apstraktne klase i ona može apstraktna, i da oba metoda (obim i povrsina) budu
referencirati objekte svih potklasa apstraktni
365 366
Popravljanje primera sa geometrijskim slikama Popravljanje primera sa geometrijskim slikama

public class PrimerGeometrijskeSlike {
public abstract class GeometrijskaSlika { public static void main(String[] args) {
public abstract double obim(); // Može se deklarisati referenca apstraktne klase,
// i može se napraviti niz referenci apstraktne klase
public abstract double povrsina();
}
slike[0] = new Trougao(3, 4, 5);
slike[1] = new Krug(1);
• Ostale klase iz prethodnog primera (Trougao, Kvadrat slike[2] = new Kvadrat(10);
i Krug) ostaju nepromenjene for(int i=0; i<3; i++) {
System.out.println("i: " + i + ", obim: " +
slike[i].obim());
System.out.println("i: " + i + ", površina: " +
slike[i].povrsina());
}
}
}
367 368
Rezervisana reč final Sprečavanje redefinisanja metoda
• Ima tri namene: class A {

final void prikazi() {
– služi za deklarisanje konstanti
System.out.println("Ne može se redefinisati.");
– sprečava redefinisanje metoda
}
– sprečava izvođenje iz klase
}
class B extends A {
void ik i() { // Greška,
id prikazi() G šk metod
t d se ne može
ž redefinisati
d fi i ti
System.out.println("Pogrešno!");
}
}
369 370
Sprečavanje redefinisanja metoda Sprečavanje izvođenja
• Pošto se metodi označeni modifikatorom final ne final class A { // Klasa A ne može imati podklase
mogu redefinisati prevodilac može umesto poziva // ...
metoda da doda ceo bajt kod metoda }
• Prevodilac ovo radi samo za kratke metode

class B extends A { // Greška! Ne može se izvoditi iz klase A
• Ovaj postupak se naziva inlining // ...
}
• Ako je klasa označena modifikatorom final, i svi njeni

metodi p
postaju
j final
371 372
Klasa Object Metodi klase Object
protected native Object clone()
• Klasa Object je natklasa svih klasa u Javi public boolean equals(Object obj)
• Referenca tipa Object može da referencira objekte protected void finalize()
svih ostalih klasa public final native Class getClass()
protected native int hashCode()
public
bli final
fi l native
ti void
id notify()
tif ()
public final native void notifyAll()
public String toString()
public final void wait()
public final native void wait(long timeout)
public final void wait(long timeout, int nanos)
• Metod toString se najčešće redefiniše pošto se

pomoću
ć njega
j objekat
bj k prevodi
di u S
String
i
373 374
Primer sa redefinisanjem metoda Primer sa redefinisanjem metoda

public class Trougao
p g extends GeometrijskaSlika
j {
public abstract class GeometrijskaSlika { private double a, b, c;
public abstract double obim(); public Trougao(double a_, double b_, double c_) {
public abstract double povrsina(); a = a_; b = b_; c = c_;
} }
public double a() { return a; }
public class Krug extends GeometrijskaSlika {
public double b()
p () { return b;
; }
private double r; public double c() { return c; }
public Krug(double r_) { r = r_; } public double obim() { return a + b + c; }
public double r() { return r; } public double p
p povrsina()
() {
public double obim() { return 2 * Math.PI * r; } double s = (a + b + c)/2;
public double povrsina() { return Math.PI * r*r; } return Math.sqrt(s*(s-a)*(s-b)*(s-c));
public String toString() { }
return "Krug: poluprečnik=" + r + ", obim=" + public String toString() {
return "Trougao: stranice a=" + a + ", b=" + b + ", c="
obim() + ", površina=" + povrsina();
+ c + ",
, obim="
obim + obim() + ",
, površina="
površina + povrsina();
}
}
} 375 } 376
Primer sa redefinisanjem metoda - nastavak Primer sa geometrijskim slikama
public class Kvadrat extends GeometrijskaSlika { public class PrimerGeometrijskeSlike {
private double a; public static void main(String[] args) {
public Kvadrat(double a_) { a = a_; } GeometrijskaSlika slike[] =
public double a() { return a; } new GeometrijskaSlika[3];
public double obim() { return 4 * a; } slike[0] = new Trougao(3, 4, 5);
public double povrsina() { return a * a; } slike[1] = new Krug(1);
public String toString() { slike[2] = new Kvadrat(10);
return
t "
"Kvadrat:
d stranica
i a="
" + a + "
", obim="
bi " + f (i t i=0;
for(int i 0 ii<3;
3 ii++)
)
obim() + ", površina=" + povrsina(); System.out.println(slike[i]);
} }
} }
377 378
Primer sa redefinisanjem metoda – rezultat

Trougao: stranice a=3.0, b=4.0, c=5.0, obim=12.0, površina=6.0
Krug: poluprečnik=1.0, obim=6.283185307179586, površina= 3.141592653589793
Kvadrat: stranica a=10.0, obim=40.0, površina=100.0
379 380
Izuzetak
• Izuzetak je greška (vanredno stanje) pri izvršavanju
programa
• Java ima mehanizam za obradu izuzetaka
Izuzeci • Izuzetak može da se:
– izazove (baci) - rezervisana reč throw
– uhvati radi obrade - rezervisana reč catch
• IIzuzetak
t k je
j objekat
bj k t koji
k ji se pravii kkad
d nastane
t vanredno
d
stanje u nekom metodu
• Izuzetak može da napravi Javin izvršni sistem ili može
da se napravi u kodu kad se otkrije greška
• Metod može da obradi izuzetak ili da ga prosledi dalje
pozivajućem
i j ć metodu
t d
381 382
Rezervisane reči za obradu izuzetaka Obrada izuzetka

• try • Unutar try bloka su naredbe koje mogu da izazovu
• catch izuzetak
• throw • Izuzetak se hvata pomoću rezervisane reči catch
• throws • Rezervisana reč throw služi za bacanje izuzetka
• finally • Ako unutar metoda A može da nastane izuzetak koji se
prosleđuje pozivajućem metodu B, tada u metodu A taj
tip izuzetka mora da se označi pomoću rezervisane reči
throws
• Naredbe koje moraju da se izvrše i kad se pojavi
izuzetak treba staviti u blok finally
383 384
Primer za izuzetak koji se ne obrađuje u kodu
Neuhvaćeni izuzeci
class Izuzetak0 {
public static void main (String args[]) {
• Ako se u kodu ne obradi izuzetak, obrađuje ga Javin int d = 0;
izvršni sistem koji ispisuje tekst sa opisom izuzetka, int a = 7 / d;
stanje steka za metode od trenutka nastanka izuzetka i System.out.println(a);
završava program
p g }
• Primer: }
– Pri deljenju nulom Javin izvršni sistem pravi izuzetak tipa java.lang.ArithmeticException: / by zero
ArithmeticException
i h i i ib
baca ga at Izuzetak0.main(Izuzetak0.java:4)
Exception in thread "main"
• Vidi se da je izuzetak nastao u klasi Izuzetak0, metod main,

u naredbi koja je u četvrtoj liniji fajla
• IIzuzetakk je
j tipa
i ArithmeticException
385 386
Novi primer neobrađenog izuzetka

Opšti oblik bloka za obradu izuzetaka
class Izuzetak1 {
try {
static void izracunaj() {
// blok u kojem može da se pojavi izuzetak
int d = 0;
}
int a = 7 / d;
catch (TipIzuzetka1 excObj) {
System.out.println(a);
// kod za obradu izuzetka tipa TipIzuzetka1
}
}
public static void main (String args[]) {
catch (TipIzuzetka2 excObj) {
Izuzetak1.izracunaj();
p TipIzuzetka2
// kod za obradu izuzetka tipa p
}
}
}
...
java.lang.ArithmeticException: / by zero finally {
at Izuzetak1.izracunaj(Izuzetak1.java:4) // blok koda koji mora da se izvrši
at Izuzetak1.main(Izuzetak1.java:8) // pre kraja bloka try
Exception in thread "main" }
387 388
Primer obrađenog izuzetka
class Izuzetak2 { Korišćenje try i catch
int d, a;
• try i catch su jedinstvena celina
t
try { • catch se odnosi samo na prethodni try
d = 0; • Iza naredbi try uvek dolazi blok unutar vitičastih
a = 7 / d; zagrada (vitičaste zagrade su obavezne), a isto važi i za
System.out.println("Ovo se ne prikazuje."); catch
} • catch služi da uhvati izuzetak koji se obrađuje unutar
catch (ArithmeticException e) { tog catch bloka,
bloka posle čega se program nastavlja
System.out.println("Deljenje nulom."); prvom naredbom ispod svih catch blokova jedne
} naredbe try
S t
System.out.println("Posle
t i tl ("P l naredbe
db catch.");
t h ")
}
}
Deljenje nulom.
389 390
Posle naredbe catch.
Tipovi izuzetaka Prikazivanje opisa izuzetka

• Throwable je nadklasa svih • U klasi Throwable redefinisan je metod toString
klasa za izuzetke tako da vraća opis izuzetka
• Error je klasa za izuzetke
Javinog izvršnog sistema, npr. Throwable
prekoračenje steka, i programi
obično ne obrađuju ove izuzetke
• Exception je nadklasa za
Exception Error
izuzetke koje obrađuju programi
• RuntimeException je
nadklasa za neproveravane
izuzetke npr. aritmetičke greške RuntimeException
(ArithmeticException), )
indeksiranje niza izvan opsega
(ArrayIndexOutOfBoundsEx
ti )
ception
391 392
Primer prikazivanja opisa izuzetka
Višestruki catch
class
l OpisIzuzetka
i {
static void izracunaj() {
• Ako se unutar bloka try može pojaviti više različitih
int d = 0;
izuzetaka
u e a a treba
eba sstaviti
a više še od
odredbi
edb catc
catch,, po jed
jednaa za
a
int a = 7 / d;
System.out.println(a); svaki tip izuzetka koji se obrađuje
} • Posle pojave izuzetka izvršava se prvi catch blok čiji
public static void main (String args[]) { ti izuzetka
tip i tk odgovara
d nastalom
t l iizuzetku,
tk a svii ostali
t li
try { catch blokovi se preskaču
OpisIzuzetka.izracunaj();
}
catch (ArithmeticException e) {
System.out.println(e);
}
}
}
java.lang.ArithmeticException: / by zero
393 394
Primer višestrukog catch

class DvaTipaIzuzetka { Rezultat izvršavanja programa
try { • Prvo izvršavanje programa, ne zadaju se argumenti
int a = args.length; C:\java
j DvaTipaIzuzetka
p
System.out.println("Broj argumenata = " + a); Broj argumenata = 0
int b = 7 / a; Deljenje nulom: java.lang.ArithmeticException: / by zero
int c[] = { 1 }; Iza try/catch
y/ blokova.
c[2] = 9;
}
• Drugo izvršavanje programa, zadaju se dva argumenta
catch(ArithmeticException e) {
C:\java
C \j D Ti I
DvaTipaIzuzetka
tk dve
d reci
i
System.out.println("Deljenje nulom: " + e);
Broj argumenata = 2
}
Nevažeći indeks niza: java.lang.ArrayIndexOutOfBoundsException
catch(ArrayIndexOutOfBoundsException
y p e) {
I
Iza t / t h bl
try/catch blokova.
k
System.out.println("Nevažeći indeks niza: " + e);
}
y p
System.out.println("Iza try/catch
y blokova.");
}
} 395 396
Primer višestrukog catch sa greškom
Višestruki catch class IzuzetakPotklasePreNatklase {
• Ako iza bloka try ima više blokova catch, potklase
try {
izuzetaka
u e a a moraju
o aju da se poja
pojave
eppre
e ssvojih
oj natklasa
a asa je
jer
int a = 0;
catch sa tipom natklase hvata i izuzetke svih svojih
int b = 7 / a;
potklasa
}
catch(Exception e) {
System.out.println("catch tipa Exception.");
}
// ArithmeticException je potklsa klase Exception i mora se
// pojaviti
j iti u catch
t h pre klase
kl E
Exception
ti (greška
( šk u prevođenju)
đ j )
System.out.println("Nedostupan kod.");
}
}
397 } 398
Primer ugnježdenog try

Ugnježdene naredbe try class UgnjezdeniTry {
public
bli static
t ti void id main(String
i (St i args[])
[]) {
try { // Spoljašnji try blok
• Naredba try može da bude unutar druge naredbe int a = args.length;
tryy System.out.println("Broj
y p j argumenata
g = " + a);
int b = 42 / a; // Deljenje nulom za a=0
• Ako se izuzetak ne uhvati u catch delovima untrašnje try { // Unutrašnji try blok
naredbe try, preuzima ga spoljašnja naredba try if(a==1) a = a/(a-a); // Deljenje nulom za a=1
if(a 2) {
if(a==2)
• Nastavlja se sve dok nek catch blok ne uhvati int c[] = { 1 };
izuzetak, ili dok izuzetak ne dođe do Javinog izvršnog c[42] = 99; // Greška u indeksiranju za a=2
sistema }
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Unutrašnji try: " + e);
}
}
System.out.println("Spoljašnji try: " + e);
}
}
399 400
}
Rezultat izvršavanja programa Ugnježdeni try u metodima
• Prvo izvršavanje programa, ne zadaju se argumenti • try naredbe su ugnježdene i u sledećem slučaju:
C:\java
j UgnjezdeniTry
g j y – metod A ima try blok
Broj argumenata = 0
– metod B ima try blok
Spoljašnji try: java.lang.ArithmeticException: / by zero
– metod A se poziva unutar try bloka metoda B
• Drugo izvršavanje programa, zadaje se jedan argument • U ovom primeru try blok metoda A je ugnježden
C:\java UgnjezdeniTry x unutar try bloka metoda B
B j argumenata
Broj t = 1
Spoljašnji try: java.lang.ArithmeticException: / by zero
• Treće izvršavanje programa, zadaju se dva argumenta

C:\java UgnjezdeniTry dve reci
Broj argumenata = 2
Unutrašnji try: java.lang.ArrayIndexOutOfBoundsException
401 402
Primer ugnježdenog try

class UgnjezdeniTry1 {
static void unutrasnjiTry(int a) {
Rezervisana reč throw
try {
if(a==1) a = a/(a-a); // Deljenje nulom za a=1 • Izuzetak se baca pomoću naredbe throw
if(a==2) { // Greška u indeksiranju za a=2
int c[] = { 1 }; c[2] = 99; • Opšti oblik naredbe je
}
} throw objekatIzuzetka;
catch(ArrayIndexOutOfBoundsException e) {
System out println("Unutrašnji
System.out.println( Unutrašnji try: " + e); • objekatIzuzetka
j jje objekat
j klase Throwable ili neke
} potklase ove klase
}
• objekatIzuzetka se može napraviti operatorom new
try { ili može biti objekat uhvaćen
h aćen u naredbi catch t h
int a = args.length;
System.out.println("Broj argumenata = " + a); • Posle bacanja izuzetka prelazi se na hvatanje izuzetka u
int b = 42 / a; // Deljenje nulom za a=0 y bloka kojij obuhvata naredbu throw
naredbi try
UgnjezdeniTry1.unutrasnjiTry(a);
}
System.out.println("Spoljašnji try: " + e);
}
}
} 403 404
Primer za throw
class PrimerZaThrow { Rezultat izvršavanja programa
static void bacanjeIzuzetka() {
try { C:\java PrimerZaThrow
throw new NullPointerException("proba"); Hvatanje unutar metoda.
} Ponovo uhvaćen: java.lang.NullPointerException: proba
catch(NullPointerException e) {
System.out.println("Hvatanje unutar metoda.");
throw e; // novo bacanje izuzetka
}
}
public
bli static
t ti void
id main(String
i (St i args[])
[]) {
try {
PrimerZaThrow.bacanjeIzuzetka();
}
catch(NullPointerException e) {
System.out.println("Ponovo uhvaćen: " + e);
}
}
} 405 406
Konstruktori izuzetaka Proveravani i neproveravani izuzeci

• Javini ugrađeni izuzeci imaju dva konstruktora, jedan
bez parametara i jedan čiji je parametar znakovni niz koji
je opis izuzetka
• Opis izuzetka se može dohvatiti metodom
getMessage() kojik ji jje d
definisan
fi i u kl
klasii Throwable
407 408
Rezervisana reč throws Primer za throws sa greškom
• Za metod koji baca izuzetke mora da se označi koje class PrimerZaThrows {

izuzetke baca static void bacanjeIzuzetka() {
System.out.println("Unutar metoda.");
• Moraju se navesti svi izuzeci koje baca metod izuzev
izuzetaka tipa Error i RuntimeException ili njihovih throw new IllegalAccessException("proba");
}
potklasa
tkl
• Izuzeci koji ne moraju da se navode nazivaju se PrimerZaThrows.bacanjeIzuzetka();
neproveravani izuzeci
izuzeci, a oni koji moraju da se navode }
nazivaju se proveravani izuzeci }
• Ako se ne navedu izuzeci koje metod baca javlja se
greška u prevođenju • IIzuzetak
t k tipa
ti IllegalAccessException
ll l i j
je
• Opšti oblik deklaracije metoda je proveravani izuzetak i ako se ne u deklaraciji metoda koji
tip imeMetoda(listaParametara) throws listaIzuzetaka ga baca jjavlja
g j se ggreška u p
prevođenju
j
409 410
Ispravan primer za throws

class PrimerZaThrows { Tipovi izuzetaka izvedeni iz RuntimeException
static void bacanjeIzuzetka() throws
IllegalAccessException { • AritmeticException
System.out.println("Unutar metoda.");
• ArrayIndexOutOfBoundException
throw new IllegalAccessException("proba");
} • ArrayStoreException
public static void main(String args[]) { • p
ClassCastException
try {
• IllegalArgumentException
PrimerZaThrows.bacanjeIzuzetka();
} • ...
catch(IllegalAccessException e) {
System.out.println("Uhvaćen: " + e);
}
}
}
Unutar metoda.
Uhvaćen: java.lang.IllegalAccessException: proba 411 412
Primer za finally
Rezervisana reč finally class PrimerZaFinally {
static void metodA() {
• Prilikom pojavljivanja i obrade izuzetka dolazi do try { // Izuzetak unutar try bloka
preskakanja pojedinih naredbi System.out.println("Unutar metoda A");
throw new RuntimeException("proba");
• Naredbe koje se ne smeju peskočiti, npr. zatvaranje }
fajla, stavljaju se u blok finally finally {
• Blok finally se izvršava uvek bez obzira da li se System.out.println("Metod A: finally blok");
}
pojavljuje izuzetak ili ne }
• Ako se metod prekida iz bloka try/catch zbog static
t ti voidid metodB()
t dB() {
pojave izuzetka ili zbog naredbe return, blok try {
finally se izvršava neposredno pre izlaska iz metoda System.out.println("Unutar metoda B");
return;
t // return
t unutar
t try
t bloka
bl k
• Blok finally nije obavezan }
• Naredba try mora imati bar jednu od naredbi catch finally {
ili finally System out println("Metod
System.out.println( Metod B: finally blok
blok");
);
}
413 } 414
Primer za finally
static void metodC() { Rezultat izvršavanja programa
try { // try bloka koji se ne prekida
System.out.println("Unutar metoda C"); C:\java PrimerZaFinally
} Unutar metoda A
finally { Metod A: finally blok
System.out.println("Metod C: finally blok"); Uhvaćen izuzetak
} Unutar metoda B
}
Metod B: finally blok
Unutar metoda C
try {
Metod C: finally blok
metodA();
t dA()
}
catch (Exception e) {
System out println("Uhvaćen
System.out.println( Uhvaćen izuzetak
izuzetak");
);
}
metodB();
metodC();
}
} 415 416
Ugrađeni izuzeci Pravljenje novih klasa za izuzetke
• Klase za nove izuzetke se prave da bi se obrađivale
specifične greške programa koji se piše
• Klase za nove izuzetke treba izvoditi iz klase Exception
• Klasa Exception ne definiše nijedan metod već sve
nasleđuje od klase Throwable
• U novim klasama za izuzetke ne mora se redefinisati
nijedan metod
metod, ali se to može uraditi
417 418
Primer za pravljenje izuzetka

Primer za pravljenje izuzetka
class
l PrimerZaIzuzetak
i {
static void racunaj(int a) throws Izuzetak {
class Izuzetak extends Exception {
System.out.println("racunaj(" + a + ")");
private int p
p podatak;
;
if(a > 10)
throw new Izuzetak(a);
Izuzetak(int a) { System.out.println("Normalan izlaz");
podatak = a; }
} public static void main(String args[]) {
try {
public String toString() { PrimerZaIzuzetak.racunaj(1);
return "Izuzetak[" + podatak + "]"; PrimerZaIzuzetak.racunaj(20);
}
}
catch (Izuzetak e) {
}
System.out.println("Uhvaćen " + e);
}
}
419 } 420
Rezultat izvršavanja programa Korišćenje izuzetaka
C:\java PrimerZaIzuzetak • Za obradu grešaka i vanrednih situacija programa uvek
racunaj(1)
N
Normalan
l i
izlaz
l treba koristiti izuzetke
racunaj(20) • Uvek kad metod ne može da obavi posao treba da baci
Uhvaćen Izuzetak[20]
izuzetak
• Nikad ne treba koristiti vraćanje šifre greške kao način
na koji metod prijavljuje da se pojavila greška
421 422
423 424
Funkcije paketa
• Paket deli imenski prostor (u dva paketa mogu postojati
klase sa istim imenom)
• Paket služi za upravljanje vidljivošću
– može postojati klasa koja se može koristiti samo unutar
Paketi paketa, izvan je nevidljiva
– u klasi mogu postojati članovi koji se vide samo unutar
p
paketa
425 426
Sadržaj datoteke *.java Definisanje paketa

• Datoteka *.java može da sadrži sledeća četiri dela • Paket se definiše naredbom package koja treba da
– jedan iskaz za obrazovanje paketa (neobavezno) bude p
prvaa naredba
a edba u fajlu
aj u Ja
Javine
e izvorne
o e da
datoteke
oe e
– proizvoljan broj naredbi za uvoz (neobavezno) package imePaketa;
– jednu definiciju javne klase, ime klase je jednako imenu • Klase iz fajla u kojem je ova naredba pripadaju paketu
datoteke (obavezno) imePaketa
– proizvoljan broj klasa bez specifikatora pristupa • Fajlovi koji pripadaju jednom paketu moraju biti u istom
(
(neobavezno) ) direktorijumu čije je ime isto kao i ime paketa (raspored
malih i velikih slova u imenu paketa i direktorijuma mora
biti isti)
• U svim fajlovima koji pripadaju paketu mora da postoji
naredba package koja određuje kojem paketu pripada
fajl
427 428
Hijerarhija paketa Sistemska promenljiva CLASSPATH
• Paketi mogu da obrazuju hijerarhiju, i tada se piše npr. • Određuje osnovni direktorijum hijerarhije paketa
package paket1.paket2.paket3;
paket1 paket2 paket3;
• a direktorijum je: paket1\paket2\paket3
429 430
Starovanje programa iz komandne linije Specifikatori pristupa za članove klase

• Program se nalazi u nekom paketu • public za javni način pristupanja
• Radni direktorijum treba da bude onaj koji je određen – javnim članovima mogu da pristupaju sve klase
sistemskom promenljivom CLASSPATH • protected za zaštićeni način pristupanja
• Navodi se cela hijerarhija paketa (direktorijuma) počevši – zaštićenim članovima mogu da pristupaju sve klase iz
od direktorijuma određenog sa CLASSPATH, istog paketa i podklase iz drugih paketa
razdvojenih tačkom i na kraju je ime klase koja se staruje • private za privatni način pristupanja
• Prmer: – privatnim članovima može da pristupa samo klasa u kojoj
C:\java imePaketa1.imePaketa2.imeKlase su definisani
• bez specifikatora za podrazumevani način pristupanja
– članovima bez specifikatora pristupa mogu da pristupaju
sve klase iz istog paketa
431 432
Specifikatori pristupa za klase Pristupanje klasi iz drugog paketa
• public za javni način pristupanja • Klasi koja se nalazi u nekom drugom paketu može se
– javnim klasama mogu da pristupaju sve klase pristupiti navođenjem hijerarhije paketa razdvojenih
• bez specifikatora za podrazumevani način pristupanja tačkom i klase
– klasama bez specifikatora pristupa mogu da pristupaju sve • Lakši način je da se klasa iz drugog paketa, ili ceo paket,
klase iz istog paketa i
importuje
t j i ttada
d se kl
klasii pristupa
i t preko
k iimena
• Za importovanje paketa služi naredba import
433 434
Importovanje Primer: natklasa je u drugom paketu

• Za importovanje klase ili paketa služi naredba import • Natklasa iz drugog paketa mora da bude javna
koja
oja se p
piše
še iza
a naredbe
a edbe pac age a ispred
package sp ed de
definicije
c je
klase • Primer sa importovanjem paketa:
• Opšti oblik naredbe je p
import java.util.*;
j
import paket1[.paket2].(imeKlase | *) class MojDatum extends Date {
}
• P
Primeri:
i i
import java.util.Date;
• Primer bez importovanja paketa:
import java.util.
java util *;
; class MojDatum extends java.util.Date {
import java.io.*; }
435 436
Klasa sa istim imenom postoji u dva paketa
• Da bi se koristila jedna od dve klase treba importovati
paket u kojem se nalazi
• Ako se importuju oba paketa i upotrebi se ime klase koje
se nalazi u oba paketa javlja se greška
Interfejsi
437 438
Interfejsi Definisanje interfejsa

• Interfejs sadrži potpise metoda, tj. definicija interfejsa je • Opšti oblik je:
slična apstraktnoj klasi čiji su svi metodi apstraktni pristup interface imeInterfejsa {
• Interfejs nema polja tip metod1 ( listaParametara );
• Klasa može da implementira interfejs tip p metod2 ( listaParametara );
)
• Klasa koja implementira interfejs mora da sadrži sve // ...
metode iz interfejsa tj. da definiše tela svih metoda iz tip metodN ( listaParametara );
interfejsa
• Klasa može da implementira više interfejsa final tip promenljiva1 = vrednost;
• Potpuno različite klase mogu da implementiraju isti final tip promenljiva2 = vrednost;
interfejs // ...
final tip promenljivaN = vrednost;
}
439 440
Specifikator pristupa za interfejs Realizovanje interfejsa
• Kao i klasa, i interfejs može imati samo javni i • Rezervisana reč implements služi za označavanje
podrazumevani način pristupa interfejsa koje implementira klasa
• Značenje je isto kao i kod klase • Opšti oblik definicije klase koja implementira interfejs je:
pristup class imeKlase [extends imeNatklase]
[implements interfejs1 [,interfejs2 ...]] {
// telo klase
}
441 442
Primer: geometrijska slika je natklasa

Primer
public abstract class GeometrijskaSlika {
interface InterfejsTest { public abstract double obim();
void test(int par); public abstract double povrsina();
} }
public class Trougao extends GeometrijskaSlika {

class Klasa1 implements InterfejsTest { private double a, b, c;
void test(int p) { public Trougao(double a, double b_, double c_) {
// telo metoda iz interfejsa _ b = b_;
a = a_; _ c = c_;
_
} }
double d; public double obim() { return a + b + c; }
int metod() { public double povrsina() {
// telo metoda koji nije iz interfejsa double s = (a + b + c)/2;
} return Math.sqrt(s*(s-a)*(s-b)*(s-c));
} }
443 } 444
Primer: geometrijska slika je natklasa Primer: geometrijska slika je natklasa
public class Kvadrat extends GeometrijskaSlika { public class PrimerGeometrijskeSlike1 {
private double a; public static void main(String[] args) {
public Kvadrat(double a_) { a = a_; } Trougao tr = new Trougao(3, 4, 5);
public double obim() { return 4 * a; } Krug kr = new Krug(1);
public double povrsina() { return a * a; } Kvadrat kv = new Kvadrat(10);
} GeometrijskaSlika rn;
rn = tr; // referenca natklase ukazuje na objekat trougla
public class Krug extends GeometrijskaSlika {
d bl o = rn.obim();
double bi () // obim
bi ttrougla
l
private double r;
rn = kr; // referenca natklase ukazuje na objekat kruga
public Krug(double r_) { r = r_; }
double p = rn.povrsina(); // površina kruga
public double obim() { return 2 * Math.PI
Math PI * r; }
rn = kv; // referenca natklase ukazuje na objekat kvadrata
public double povrsina() { return Math.PI * r*r; }
o = rn.obim(); // obim kvadrata
}
}
}
445 446
Primer: geometrijska slika je interfejs Primer: geometrijska slika je interfejs

public interface GSInterface {
public double obim(); public class Kvadrat implements GSInterface {
public double povrsina(); private double a;
} public Kvadrat(double a_) { a = a_; }
public double obim() { return 4 * a; }
public class Trougao implements GSInterface {
public double povrsina() { return a * a; }
private double a, b, c;
}
public Trougao(double a, double b_, double c_) {
_ b = b_;
a = a_; _ c = c_;
_ public class Krug implements GSInterface {
} private double r;
public double obim() { return a + b + c; } public Krug(double r_) { r = r_; }
public double povrsina() { public double obim() { return 2 * Math.PI
Math PI * r; }
double s = (a + b + c)/2; public double povrsina() { return Math.PI * r*r; }
return Math.sqrt(s*(s-a)*(s-b)*(s-c)); }
}
} 447 448
Primer: geometrijska slika je interfejs Izvođenje iz natklase ili implementiranje interfejsa?
public class PrimerGeometrijskeSlike2 { • Ako su klase srodne, kao što je slučaj sa geometrijskim
public static void main(String[] args) { slikama (trougao, krug, kvadrat, ...) treba definisati
Trougao tr = new Trougao(3, 4, 5); natklasu i iz nje izvesti potklase
Krug kr = new Krug(1);
• Ako su klase potpuno različite i nije logično da imaju
Kvadrat kv = new Kvadrat(10);
zajedničku
j d ičk natklasu,
tkl a iimaju
j nekek slične
lič ((zajedničke)
j d ičk )
GSInterface ri;
metode, tada treba koristiti interfejse
ri = tr; // referenca tipa interfejsa ukazuje na objekat trougla
– u interfejs se stave zajednički metodi raznorodnih klasa
d bl o = ri.obim();
double i bi () // obim
bi ttrougla
l
koje sve klase treba da implementiraju
ri = kr; // referenca tipa interfejsa ukazuje na objekat kruga
double p = ri.povrsina(); // površina kruga
ri = kv; // referenca tipa interfejsa ukazuje na objekat kvadrata
o = ri.obim(); // obim kvadrata
}
}
449 450
Referenciranje preko interfejsa Dva interfejsa imaju isti metod

• Može se definisati referenca tipa interfejsa • Klasa koja implementira dva interfejsa koji imaju isti
• Referenca tipa interfejsa može ukazivati na objekte svih metod realizuje taj metod samo jednom, tj. isti je metod
klasa koje implementiraju interfejs za oba interfejsa
• Preko reference tipa interfejsa može se pristupiti samo
metodima koje postoje u interfejsu
• Razrešavanje je dinamičko, tj. koji se metod poziva
određuje se u trenutku izvršavanja na osnovu tipa
objekta na koji ukazuje referenca tipa interfejsa
451 452
Delimična realizacija interfejsa Promenljive u interfejsu
• Klasa koja implementira interfejs, a ne definiše tela za • Interfejs ne može imati promenljivem, može imati samo
sve metode iz interfejsa je apstraktna konstante
• Primer:
interface ZajednickeKonstante {
int NE = 0;
int DA = 1;
int MOZDA = 2;
}
• Ovaj interfejs sadrži samo konstante (nema metode)
• Sve klase koje implementiraju ovaj interfejs imaju
konstante definisane u njemu
j
453 454
Nasleđivanje interfejsa
Izvođenje interfejsa
interface A {
void metod_A();
• Jedan interfejs može da se izvede iz drugog i tada }
nasleđuje sve njegove metode i
interface
f B extends
d A {
void metod_B();
}
class
l Test implements
i l B {
public void metod_A() {
// telo metoda iz interfejsa A
}
public void metod_B() {
// telo metoda iz interfejsa B
}
public void metod_T() {
// telo metoda koji ne postoji u interfejsu
}
}
455 456
Nasleđivanje interfejsa
public class PrimerNasledjivanja {
Test test = new Test();
test.metod_A();
test.metod_B();
test.metod_T();
B rib = test;
rib.metod_A();
();
rib.metod_B();
rib.metod_T(); // greška, nije iz interfejsa B
A ria = test;
rib.metod_A();
rib.metod_B(); // greška, nije iz interfejsa A
}
}
457

Java 1

Uploaded by

Copyright:

Available Formats

You might also like

Java 1

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Java 1

Uploaded by

Copyright:

Available Formats

Nastanak

Programski jezik C Programski jezik C++

Prenosivost na druge platforme Java apleti i aplikacije

Drugi jednostavan program Treći jednostavan program

Elementi jezika Prazna mesta

• Ne koriste se rezervisane reči const i goto

Prosti tipovi Celi brojevi

Konverzija broja iz sistema sa osnovom b

Drugi komplement: primeri sabiranja Predstavljanje celih brojeva u računaru

• Dužina 8 bita • Dužina 16 bita

Little-Endian i Big-Endian formati (primer za int) int

Little-Endian Big-Endian • Dužina 32 bita

• Little-Endian: Intelovi procesori x86 koje se koriste u PC

±0 / ±0 NaN 1 00...00 00...00 –0

• Dužine 32 bita • Dužina 64 bita

Znakovni tip - char Primer za znakovni tip

Literali u pokretnom zarezu Logički literali

Deklarisanje promenljive Oblast važenja i životni vek promenljive

Životni vek promenljive Oblast važenja

Pravila za automatsku konverziju (unapređivanje)

Jednodimenzionalni nizovi Kreiranje niza

Višedimenzionalni nizovi Predstavljanje dvodimenzionalnog niza

• Primer [0][0] [0][1] [0][2] [0][3]

[2][0] [2][1] [2][2]

Primer osnovnih operacija sa tipom int

Aritmetički operatori dodeljivanja Uvećavanje i umanjivanje

• Primeri • Mogu da budu prefiksi ili sufiksi

Operatori nad bitima Pomeranje ulevo

vrednost >> broj_bita_za_koliko_se_pomera; vrednost >>> broj_bita_za_koliko_se_pomera;

Primeri za operacije nad bitima Operatori

Primer za logičke operatore

a >> b + 3; // prvo se b uvećava za 3,

(a >> b) + 3; // prvo se sadržaj a pomera udesno,

Upravljačke naredbe Naredba if

• Naredbe uslovljavanja • Uslovno grananje na dva različita puta

Ugnježdeni uslovi if else if

Ugnježdena naredba switch

Primer za while petlju Primer za while bez tela petlje

Vrednost n je 5 Sredina je 150

Kraće napisan primer za do while

Deklaracija promenljive unutar for petlje Primer: provera da li je broj prost

for petlja bez inicijalizacije i iteracije

Naredba break Završavanje niza naredbi u naredbi switch

break u ugnježdenim petljama Naredba break sa oznakom

Primer sa greškom Naredba continue

Primer za označeni continue

Pre naredbe return.

• Klasa je novi tip podataka

Klase i datoteke Opšti oblik klase (nije kompletan)

Pravljenje objekta – operator new Operator tačka "."

Reference i objekti Reference i objekti

Osnovno o konstruktorima Metodi

Primer: klasa Kutija ima metod zapremina

Parametri i argumenti Konstruktori

Primer: korišćenje konstruktora sa parametrima

• Koristi se za oslobađanje resursa koji ne potiču iz Jave,

• Dva ili više metoda u klasi mogu da imaju isto ime i to se

Primer klase sa preklopljenim metodom