Uvod u programski jezik Java
1
Literatura • Herbert Schildt: J2SE 5, Mikro knjiga 2006. (do 255. strane)
• Laslo Kraus: Rešeni zadaci iz programskog jezika Java, Drugo dopunjeno izdanje, Akademska misao, Beograd, 2007 • The Java Tutorials na Oracle/Sun sajtu: http://download.oracle.com/javase/tutorial/index.html • Osnove jezika Java na istom sajtu: http://download.oracle.com/javase/tutorial/java/index.htm
2
1
Nastanak • Programski jezik C • Programski jezik C++ • Programski jezik Java
3
Programski jezik C • Karakteristike – pisanje strukturiranih programa – jezik opšte namene – za aplikacije – pristup hardveru računara – za sistemski softver • Razlog nastanka – potreba za jezikom sa osobinama viših programskih jezika (FORTRAN, COBOL) koji može da zameni simboličke mašinske jezike (asemblere) • Nastao 1972. godine u Bell-ovim laboratorijama, stvorili ga programeri • Autor: Dennis Ritchie – Brian Kernighan, Dennis Ritchie: The C Programming Language, Prentice-Hall, 1978 • Standardizovan 1989, ANSI C 4
2
Programski jezik C++ • Potreba da se u C dodaju nove mogućnosti – Objektno orijentisano programiranje
• Nastao 1980. godine u Bell-ovim laboratorijama • Autor: Bjarne Stroustrup • Ime C++ dobio 1983 – prvobitno ime je bilo “C sa klasama”
• Razvijan duži niz godina • ANSI standard za C++ usvojen 1997 • Odnos C i C++ – više od 95% jezika C preneto je u C++ – u C++ su dodate nove mogučnosti (klase, ...) 5
Programski jezik Java • Razlog nastanka: potreba za programskim jezikom koji je nezavisan od platforme računara – C i C++ zavise od platforme računara
• Prvobitni motiv: programiranje kućnih aparata • Najjači motiv za razvoj: Internet, World Wide Web
6
3
Programski jezik Java • Jezik je koncipirao tim firme Sun Microsystems, Inc. 1991. godine • Od 1993. godine razvija se prvenstveno zbog Interneta – različite vrste računara, operativih sistema, procesora
• Ime Java dobija 1995 . godine – prvobitni naziv je bio Oak
• Većinu osobina Java je nasledila od jezika C i C++
7
Prenosivost na druge platforme • Prevodilac za Javu pravi “bajt kod” a ne izvršni kod • Bajt kod (bytecode) je visokooptimizovan skup instrukcija • Tumači ga Javi izvršni sistem – Javina virtuelna mašina (Java virtual machine, JVM) – interpretator koda (bajt koda) – za različite platforme prave se različite virtuelne mašine
• C++ se prevodi u izvršni kod, ne interpretira se – potrebni različiti prevodioci za različite platforme
• Program koji se interpretira izvršava se sporije od izvršnog programa • JIT prevodilac (Just In Time) za bajt kod – brže izvršavanje 8
4
Java apleti i aplikacije • Aplikacije su programi – izvršavaju pod operativnim sistemom računara – za aplikaciju pisanu na Javi potrebno ja da bude instalirana i Java virtuelna mašina
• Apleti su programi (uglavnom mali) – prenose se preko Interneta, odnosno WWW servisa, kao delovi HTML stranica – pokreću se u okviru WWW čitača (Web browser-a) – aplet nije animacija
• Apleti se prave samo u Javi • Bezbednost apleta – ograničeni na okruženje za izvršavanje Java programa 9
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 – postiže se interpretacijom bajtkoda • 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 • Višenitno – podržava istovremeno izvršavanje više procesa. • Efikasnost – JIT prevodioci • Konkurentnost – bibliotečka podrška programiranju kroz više programskih niti • Distribuiranost – bibliotečka podrška za RMI i servlete • Komponentizacija –Java Beans i Enterprise Java Beans (Java EE) 10
5
Verzije • Java 1.1 kao poboljšanje Jave 1.0 • Java 2 (originalno Java 1.2) – značajne promene, prelomna faza, J2SE • Java 1.3 i Java 1.4 • Java 1.4 -> Java 1.5 (interni broj verzije) ->Java J2SE 5 – nova značajna promena
11
Alati • Sun: alati iz komandne linije Java 2 SDK i integrisano okruženje (IDE) Sun Java Studio Enterprise • NetBeans – open source okruženje • Microsoft: Visual Studio 8 J++ • Borland: J-Builder • Symantec: Visual Cafe • Tek-Tools: Kawa – samo integrisano okruženje
12
6
Pregled jezika Java
1
Dva modela • Procesno orijentisani model – u centru pažnje je dinamičko ponašanje programa – proceduralni jezici kao C
• Objektno-orijentisani model – u prvom planu je struktura podataka – objektno orijentisani jezici – C++, Java
2
1
Tri principa objektno orijentisanog programiranja • Kapsuliranje (encapsulation) – Osnova kapsuliranja je klasa, koja definiše strukturu i ponašanje (tj. podatke i naredbe) zajedničke za skup objekata – Članovi klase: članovi promenljive i članovi metode – privatni i javni članovi klase – objekti su primerci ili instance klase • Nasleñivanje – podklase nasleñuju članove nadklase (ili superklase) od koje su nastali i imaju sopstvene članove (primer: geometrijske figure, krug, pravougaonik, trougao) – bez hijerarhije morali bismo da definišemo ista svojstva za objekte više puta • Polimorfizam – primer sortiranja: za cele brojeve, za realne brojeve i za reči 3
Jednostavan program /* Ovo je jednostavan Java program. Datoteka se zove "Primer.java". */ class Primer { // Program pocinje pozivanjem metoda main(). public static void main(String args[]) { System.out.println("Ovo je jednostavan Java program."); } }
• Prevoñenje programa C:\>javac Primer.java
• Pokretanje programa C:\>java Primer
• Rezultat izvršavanja programa Ovo je jednostavan Java program.
4
2
Drugi jednostavan program // Datoteka se zove "Primer2.java". class Primer2 { public static void main(String args[]) { int broj; // deklaracija promenljive broj tipa int broj = 100; // dodela vrednosti promenljivoj // Sabiranje podataka različitih tipova System.out.println("Ovo je broj: " + broj); broj = broj * 2; System.out.print("Promenljiva broj je sada: "); System.out.println(broj); } }
• Rezultat izvršavanja programa Ovo je broj: 100 Promenljiva broj je sada: 200
5
Naredba if class PrimerZaIf { public static void main(String args[]) { int x, y; // deklaracija dve promenljive x = 10; y = 20; if (x < y) System.out.println("x je manje od y"); x = x * 2; if (x < y) System.out.println("x je još uvek manje od y"); if (x == y) { System.out.print("x je sada jednako y"); System.out.println(", x je " + x + ", y je " + y); } } }
• Rezultat izvršavanja programa x je manje od y x je sada jednako y, x je 20, y je 20
6
3
for petlja for(inicijalizacija; uslov; korak) naredba; • Primer for petlje sa jednom naredbom for(i=0; i<10; i=i+1) naredba; • Primer for petlje sa blokom for(i=0; i<10; i++) { naredba1; naredba2; ... naredbaN; } 7
Primer za for petlju i blok class PrimerZaBlok { public static void main(String args[]) { int i, y=10; for(i=0; i<5; i++) { System.out.println("i je: " + i); System.out.println("y je: " + y); System.out.println(); y = y - 3; } } }
Rezultat izvršavanja i je: 0 y je: 10 i je: 1 y je: 7 i je: 2 y je: 4 i je: 3 y je: 1 i je: 4 y je: -2 8
4
Elementi jezika • • • • • • •
Prazna mesta Komentari Identifikatori Literali (konstante) Operatori Separatori Rezervisane reči
9
Prazna mesta • Prazna mesta su – prazan znak (‘ ‘) – tabulator – prelazak u novi red
• Obavezna su izmeñu elemenata jezika koji nisu – operatori – separatori int i,y=10; int i, y = 10; int i , y = 10 ; 10
5
Komentari • Komentar u jednom redu // Proizvoljan tekst do kraja reda
• Komentar u proizvoljnom broju redova /* tekst napisan u proizvoljnom broju redova */ /* može i unutar jednog reda */ int i/*komentar*/=2;
• Dokumentacioni komentar /** Služi za pravljenje HTML datoteke za dokumentovanje programa */ 11
Identifikatori • Imena klasa, metoda, promenljivih • Koriste se – velika i mala slova – brojevi – znakovi: ’_’ i ’$’
• Primeri identifikatora a4 _a4 4a
srednja-vrednost $test srednja_vrednost
SrednjaVrednost srednjaVrednost srednja vrednost
12
6
Literali • Konstantne vrednosti koje se navode doslovno 100 1.23 ’x’ ”Ovo je
// Celobrojni literal // Broj u pokretnom zarezu // Znak test” // Znakovni niz
13
Separatori ()
{} [] ; , .
Zagrade služe za liste parametara metoda, naglašavanje prioriteta, grupisanje izraza, zadavanje tipa pri konverziji Vitičaste zagrade služe za definisanje klasa, metoda, blokova naredbi, automatsku inicijalizaciju nizova Uglaste zagrade služe za deklarisanje nizova i pristupanje pojedinačnim članovima niza Znak tačka zarez označava kraj naredbe Zarez služi za razdvajane identifikatora u deklaraciji promenljivih i za povezivanje naredbi Tačka razdvaja ime paketa od potpaketa i klasa, razdvaja promenljive i metode od imena objekata
14
7
Rezervisane reči abstract
const
finaly
int
public
this
boolean
continue
float
interface
return
throw
break
default
for
long
short
throws
byte
do
goto
native
static
transient
case
doube
if
new
strictfp
try
catch
else
implements
package
super
void
char
extends
import
private
switch
volatile
class
final
instanceof
protected
synchronized
while
• Ne koriste se rezervisane reči const i goto • enum dodato u J2SE 5 • Rezervisane reči su i vrednosti: true, false, null 15
Javine biblioteke • Java sadrži biblioteke klasa • Klase su grupisane prema funkcijama kojima se bave – – – – – –
ulaz i izlaz podataka rad sa tekstom rad sa grafikom rad u mreži komunikcija sa SQL bazama podataka ...
16
8
Tipovi podataka, promenljive
1
Tipovi podataka • Vrste tipova – Prosti tipovi (vrednosti koje nisu objekti) – Klasni tipovi (objekti)
• Java je strogo tipiziran jezik – svaka promenljiva i izraz imaju svoj tip, a svaki tip je strogo definisan – pri svim dodeljivanjima proverava se saglasnost tipova
2
1
Prosti tipovi • Tipovi za cele brojeve byte short int long
// // // //
8 bita 16 bita (kratak ceo broj) 32 bita (ceo broj) 64 bita (dugačak ceo broj)
• Tipovi za brojeve u pokretnom zarezu float double
// 32 bita // 64 bita (broj dvostruke tačnosti)
• Tip za znakove char
// 16 bita - Unicode
• Tip za logičke vrednosti boolean // dve vrednosti, true i false 3
Celi brojevi • Označeni (pozitivni i negativni) • Negativni brojevi se zapisuju u drugom komplementu • Dužina celobrojnog tipa odreñuje ponašanje – dužinu ne treba shvatiti kao stvarnu količinu memorije za vrednost datog tipa – moguće je da vrednost zauzme više memorije, npr. byte i short da zauzmu 32 bita (dužina reči računara)
• Opseg brojeva predstavljenih sa n bita
− 2 n−1 do 2 n−1 − 1 4
2
Numerički sistemi • Decimalni – osnova 10 – cifre: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
• Binarni – osnova 2 – cifre: 0, 1
• Oktalni – 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 5
Jedan način konverzije celog broja iz decimalnog sistema u sistem sa osnovom N • Broj se uzastopno deli osnovom sistema N sve dok rezultat deljenja ne postane nula • Zapisuje se ostatak pri svakom deljenju, svaki ostatak je jedna cifra u sistemu sa osnovom N • Cifre koje predstavljaju ostatke napišu se u obrnutom redosledu u odnosu na redosled kojim su dobijene deljenjem
6
3
Konverzija broja iz sistema sa osnovom b u decimalni numerički sistem n−1
broj(10 ) =
i c ⋅ b ∑i i=−m
• • • • • •
n je broj celih mesta m je broj razlomljenih mesta b je osnova sistema iz kojeg se prevodi broj ci su cifre sistema iz kojeg se prevodi broj i je pozicija cifre bi je težina cifre na poziciji i 7
Primer konverzije iz decimalnog u binarni sistem • Prevodi se broj 109 109 : 2 = 54, ostatak 54 : 2 = 27, ostatak 27 : 2 = 13, ostatak 13 : 2 = 6, ostatak 6 : 2 = 3, ostatak 3 : 2 = 1, ostatak 1 : 2 = 0, ostatak • Zapis broja je
1 0 1 1 0 1 1
• Kraći način pisanja 109 1 54 0 27 1 13 1 6 0 3 1 1 1 0
109(10) = 1101101(2) 8
4
Primer konverzije iz binarnog u decimalni sistem • Za decimalni broj 109: 1 0 9 2 1 0 - pozicije cifara – težine cifara su
109 = 1×102 + 0×101 + 9×100 • Prevoñenje binarnog broja 1101101 u decimalni 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)
9
Primer konverzije broja iz decimalnog u heksadecimalni numerički sistem • Prevodi se broj 109 109 : 16 = 6, ostatak 13 6 : 16 = 0, ostatak 6 • Zapis broja je
• Kraći način pisanja 109 13 = D 6 6 0
109(10) = 6D(16)
10
5
Konverzija iz binarnog u heksadecimalni numerički sistem i obrnuto • Za osnove sistema važi: 24=16 – četiri binarne cifre odgovaraju jednoj heksadecimalnoj cifri
• Prevoñenje iz binarnog u heksadecimalni sistem: – počevši od cifre najmanje težine grupišu se po četiri binarne cifre i zamene se jednom heksadecimalnom cifrom – ako poslednja grupa ima manje od četiri cifre dopisuje se potreban broj nula sa prednje strane
• Primer: binarni broj 1101101: 110 1101(2) = 0110 1101(2) = 6 D(16) • Prevoñenje broja iz heksadecimalnog u binarni sistem – svaka heksadecimalna cifra zameni se kombinacijom četiri binarne cifre koja odgovara toj heksadecimalnoj cifri 11
Zapis negativnih celih brojeva u binarnom sistemu • Prva cifra za pozitivne brojeve je 0 • Negativni brojevi se zapisuju u drugom komplementu • Prvi komplement broja: sve nule se zamene jedinicama, a sve jedinice nulama – ili: prvi komplement = 2n – 1 – broj, n je broj cifara
• Drugi komplement broja: na prvi komplement se doda 1 – ili: drugi komplement = 2n – broj, n je broj cifara
• Pravilo za prevoñenje u drugi komplement: – idući od cifre najmanje težine, sve uzastopne nule se prepišu, a takoñe i prva jedinica na koju se naiñe – preostale cifre: sve nule se zamene jedinicama, a jedinice nulama 12
6
Primeri odreñivanja drugog komplementa • Za decimalni broj 109: 109(10) = 01101101(2)
• Za decimalni broj 16: 16(10) = 00010000(2)
• Drugi komplement: 0 1 1 0 1 1 0 1 1 0 0 1 0 0 1 1
• Drugi komplement: 0 0 0 1 0 0 0 0 1 1 1 1 0 0 0 0
• Negativan broj: -109(10) = 10010011(2)
• Negativan broj: -16(10) = 11110000(2)
13
Primer: drugi komplement broja –1 • Zapis pozitivnog broja: 1(10) = 0000 0001(2) • Drugi komplement: 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 • Negativan broj: -1(10) = 1111 1111(2)
14
7
Drugi komplement: primeri sabiranja • Sabiranje prenos 5(10) 3(10) 8(10)
5 i 3: 0000 111 0000 0101(2) 0000 0011(2) 0000 1000(2)
• Sabiranje prenos 1 5(10) -3(10) 2(10) 1
5 i -3: 1111 101 0000 0101(2) 1111 1101(2) 0000 0010(2)
• Sabiranje prenos 1 -5(10) -3(10) -8(10) 1
-5 i 1111 1111 1111 1111
• Sabiranje prenos -5(10) 3(10) -2(10)
-5 i 0000 1111 0000 1111
-3: 111 1011(2) 1101(2) 1000(2)
3: 011 1011(2) 0011(2) 1110(2) 15
Predstavljanje celih brojeva u računaru • Pozitivni brojevi imaju vodeću nulu • Negativni brojevi se zapisuju u drugom komplementu, imaju vodeću jedinicu • Nula ima jedinstven zapis: 00 ... 000 • Negativnih brojeva ima više za 1 nego pozitivnih, tj. ako se brojevi zapisuju sa N bita: – negativnih brojeva ima 2N–1 – pozitivnih brojeva ima 2N–1–1
16
8
byte • Dužina 8 bita • Opseg: –128 do 127 127(10) = 0111 1111(2) = 0x7F(16) -128(10) = 1000 0000(2) = 0x80(16) • Deklaracija promenljive: byte a; byte b, c;
17
short • Dužina 16 bita • Opseg: –32768 do 32767 32767 = 0x7FFF -32768 = 0x8000 • Big-Endian format • Deklaracija promenljive: short s;
18
9
Little-Endian i Big-Endian formati (primer za int) Little-Endian byte3 byte2 byte1 byte0
Big-Endian byte0 byte1 byte2 byte3
Osnovna adresa+0: byte0 Osnovna adresa+1: byte1
Osnovna adresa+0: byte3 Osnovna adresa+1: byte2
Osnovna adresa+2: byte2 Osnovna adresa+3: byte3
Osnovna adresa+2: byte1 Osnovna adresa+3: byte0
• Little-Endian: Intelovi procesori x86 koje se koriste u PC • Big-Endian: Motorola procesori koji se koriste za Mac 19
int • Dužina 32 bita • Opseg: –2 147 483 648 do 2 147 483 647 2147483647 = 0x7FFFFFFF -2147483648 = 0x80000000 • U celobrojnom izrazu koji sadrži podateke tipa byte, short, int i literale, čitav izraz se unapreñuje u int pe nego što se zračunava • int je najefikasniji tip • Deklaracija promenljive: int i, j;
20
10
long • Dužina 64 bita • Opseg: –9 223 372 036 854 775 808 do 9 223 372 036 854 775 807 9223372036854775807 = 0x7FFFFFFFFFFFFFFF -9223372036854775808 = 0x8000000000000000 • Deklaracija promenljive: long broj_sekundi;
21
Standard IEEE 754, brojevi u pokretnom zarezu Znak (z)
Eksponent (e)
Mantisa (m)
Bias (b)
float
1 bit [31]
8 bita [30-23]
23 bita [22-0]
127
double
1 bit [63]
11 bita [62-52]
52 bita [51-0]
1023
• Mantisa sadrži zapis o razlomljenom delu • Normalizovana mantisa ima oblik 1.m, – Zapisuje se "m", a "1." se podrazumeva – Tip float ima 24 tačne binarne cifre, 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
22
11
Standard IEEE 754, brojevi u pokretnom zarezu Znak
Eksponent
Mantisa
Bias
float
1 bit [31]
8 bita [30-23]
23 bita [22-0]
127
double
1 bit [63]
11 bita [62-52]
52 bita [51-0]
1023
• Znak – 0 za pozitivne brojeve – 1 za negativne brojeve • Eksponent je za osnovu 2 – Vrednost u memoriji je
+ Bias – Eksponenti 00...00 i 11...11 imaju specijalno značenje – Primeri za float • Zapis 200 predstavlja eksponent 73 (200–127=73) • Najmanja vrednost eksponenta je 1–127=–126 • Najveća vrednost eksponenta je 254–127=127 23
Standard IEEE 754, opsezi brojeva Sa normalizovanom mantisom (eksponent ≠ 0) min
max
približni opseg
float
2–126
(2–2–23)·2127
10–37.93 ÷ 1038.53
double
2–1022
(2–2–52)·21023
10–307.65 ÷ 10308.25
Sa denormalizovanom mantisom (eksponent = 0) min
max
približni opseg
float
2–149
(1–2–23)·2–126
10–44.85 ÷ 10–37.93
double
2–1074
(1–2–52)·2–1022
10–323.3 ÷ 10–307.65 24
12
Standard IEEE 754, opsezi brojeva Sa normalizovanom mantisom (eksponent ≠ 0) min
max
približni opseg
2–126
(2–2–23)·2127
1,17·10–38 ÷ 3,40·1038
double 2–1022
(2–2–52)·21023
2,22·10–308 ÷ 1,79·10308
float
Sa denormalizovanom mantisom (eksponent = 0)
float
min
max
približni opseg
2–149
(1–2–23)·2–126
1,40·10–45 ÷ 1,75·10–38
double 2–1074 (1–2–52)·2–1022 4,94·10–324 ÷ 2,22·10–308 25
Standard IEEE 754, specijalne vrednosti • Nula: eksponent sadrži nule, mantisa sadrži sve nule – ne može da se zapiše sa normalizovanom mantisom – postoje +0 i –0 koje su jednake pri poreñenju
• Beskonačno (±∞): eksponent sadrži sve jedinice, mantisa sadrži sve nule • NaN (Not a Number): eksponent sadrži sve jedinice, mantisa je različita od nule (ne sadrži sve nule) – QNaN (Quiet NaN): MSB mantise je 1, označava rezultat matematičke operacije koji nije nedefinisan – SNaN (Signalling NaN): MSB mantise je 0, nevažeća operacija, izuzetak
26
13
Standard IEEE 754, specijalne operacije Operacija n
/
Rezultat
±beskonačno
0
±beskonačno × ±beskonačno
±beskonačno
± / 0
±beskonačno
beskonačno + beskonačno
beskonačno
±0 / ±0
NaN
beskonačno – beskonačno
NaN
±beskonačno / ±beskonačno
NaN
±beskonačno × 0
NaN 27
Standard IEEE 754, sumarna tabela Znak 0
Eksponent (e) 00..00
Mantisa (m) 00..00
Vrednost +0
0
00..00
00..01 ÷ 11..11
0.m × 2-b+1
0
00..01 ÷ 11..10
XX..XX
1.m × 2e-b
0
11..11
00..00
+beskonačno
0
11..11
00..01 ÷ 01..11
QNaN
0
11..11
10..01 ÷ 11..11
SNaN
1
00...00
00...00
–0
1
00...00
00..01 ÷ 11..11
–0.m × 2-b+1
1
00..01 ÷ 11..10
XX..XX
–1.m × 2e-b
1
11..11
00..00
–beskonačno
1
11..11
00..01 ÷ 01..11
QNaN
1
11..11
10..01 ÷ 11..11
SNaN 28
14
float • Dužine 32 bita • Opseg za pozitivne brojeve je: 1.18e–38 do 3.4e+38 • Negativni brojevi imaju isti opseg po apsolutnoj vrednosti kao i pozitivni brojevi • Tip float se koristi kad nije potrebna velika tačnost • Deklaracija promenljive: float temperatura;
29
double • Dužina 64 bita • Opseg za pozitivne brojeve je: 2.2e–308 do 1.7e+308 • Negativni brojevi imaju isti opseg po apsolutnoj vrednosti kao i pozitivni brojevi • Matematičke funkcije iz klase Math kao rezultat vraćaju tip double sin(), cos(), sqrt(), ... • Izračunavanje je brže nego sa float • Deklaracija promenljive: double r; 30
15
Znakovni tip - char • • • •
Dužina 16 bita Koristi se UNICODE Opseg: 0 do 65535 ASCII znakovi imaju nepromenjene vrednosti 0-127, odnosno od 0-255 je ISO-Latin-1 • Mogu da se izvode računske operacije sa znakovnim tipom • Deklaracija promenljive: char z, znak;
31
Primer za znakovni tip class PrimerZaChar { public static void main(String args[]) { char znak = ’X’; System.out.println(znak); znak++; System.out.println(znak); } }
Rezultat izvršavanja programa: X Y 32
16
Logički tip - boolean • Vrednosti: true, false • Operatori poreñenja vraćaju rezultat tipa boolean boolean b = true; System.out.println(b);
// Prikazuje "true"
33
Celobrojni literali • Decimalni sistem: 7, 123 • Oktalni sistem, prva cifra je 0: 07, 056 • Heksadecimalni sistem, brojevi počinju sa 0x ili 0X – cifre od A do F mogu da se pišu malim ili velikim slovima
• Podrazumeva se da je tip int • Može se dodeliti promenljivoj tipa byte ili short ako je vrednost literala unutar opsega tipa: byte b = 26;
• Literal tipa long označava se slovom L na kraju: 0x7FL, 0xac23l
34
17
Literali u pokretnom zarezu • • • •
Standardna forma: 8.53, 0.021, 375.63 Naučna forma: 6.022E23, 314259e-05, -5e24 Podrazumeva se tip double Tip float se označava slovom F na kraju (malo ili veliko slovo): 20.3F, -2.3f, 7.1e-4F • Tip double može da se označi slovom D ili d na kraju, ali je to suvišno
35
Logički literali • Postoje dve vrednosti: true false
36
18
Znakovni literali • Vidljivi znakovi mogu da se pišu unutar polunavodnika: 'a', 'A', 'x', '8', '@', '!' • Specijalni znakovi se označavaju kosom crtom: '\'' (polunavodnik), '\"' (navodnik), '\t' (tabulator), '\n' (prelazak u novi red), '\r' (vraćanje na početak reda), '\f' (prelazak na novu stranicu) • Znak može da se unese pomoću vrednosti: oktalna vrednost se unosi kao trocifren broj '\ddd': '\044', '\101' heksadecimalna vrednost se unosi kao četvorocifren broj dodatno označen kosom crtom i slovom u: '\u0065', '\ua075' 37
Literali znakovnog niza • Unose se izmeñu navodnika: "Tekst koji se ispisuje u jednom redu." "Tekst koji\nse ispisuje\nu tri reda." "\"Tekst koji se ispisuje unutar navodnika.\""
• Naredba System.out.println() bi gornje znakovne nizove ispisala ovako: Tekst koji se ispisuje u jednom redu. Tekst koji se ispisuje u tri reda. "Tekst se ispisuje unutar navodnika." 38
19
Deklarisanje promenljive tip identifikator[=vrednost][,identifikator[=vrednost]];
• Primeri: int i, j; // deklaracija dve promenljive tipa int int x=3, z, y=-10; // deklaracija i inicijalizacija char znak = ’w’; double a=3, b=4; double c=Math.sqrt(a*a+b*b); //dinamička inicijalizacija
• Dinamička inicijalizacija je inicijalizacija izračunavanjem izraza koji važi u trenutku izvršavanja (svim promenljivim u izrazu je već dodeljena vrednost) 39
Oblast važenja i životni vek promenljive • Oblast važenja – unutar klase – unutar metode – unutar bloka
• Životni vek – nastaju kad se uñe u njihovu oblast važenja – uništavaju se kad se izañe iz njihove oblasti važenja
40
20
Oblast važenja promenljive • Promenljiva se ne može koristiti pre deklaracije { int p = 3; { ... broj = 10; // Ovo je greška int broj; int m = p; // p je vidljivo ... } int k = m; // Ovo je greška int r = p; ... }
41
Ilustrovanje oblasti važenja class OblastVazenja { public static void main(String args[]) { int x=10; // vidljiva unutar metode main if(x==10){ // početak nove oblasti važenja int y=20; // vidljiva samo u ovom bloku System.out.println("x i y: " + x + " " + y); x = y * 2; // u ovom bloku se vide x i y } //y = 100; // Greška, y se ovde ne vidi // x se ovde vidi System.out.println("x je " + x); } } 42
21
Životni vek promenljive • Promenljive deklarisane u bloku koji se ponavlja u petlji gube vrednost izmeñu dva prolaska kroz blok class ZivotniVek { public static void main(String args[]) { int x; for(x=0; x<3; x++){ int y = -1; // svaki put kad se uñe u blok System.out.println("y je: " + y); //uvek -1 y = y + 101; System.out.println("y = " + y); //uvek 100 } } } 43
Oblast važenja • Promenljive sa istim imenom ne mogu da se deklarišu u dva bloka od kojih je jedan spoljašnji, a drugi unutrašnji // Ovaj program se ne prevodi class PogresnaOblastVaznja { public static void main(String args[]) { int g = 1; { // nova oblast važenja int g = 2; // greška u prevoñenju // promenljiva g već postoji } } } 44
22
Konverzije • Automatska konverzija kod dodele vrednosti – tipovi su meñusobno kompatibilni – odredišni tip je veći (složeniji) od polaznog
• Izričita (eksplicitna) konverzija – ako dodeljujemo vrednost celog broja bajtu, rezultat je jednak istatku celobrojnog delnjenja int sa opsegom tipa bajt (256) – ako dodeljujemo vrednost broja u pokretnom zarezu celom broju, doći će do odsecanja razlomljenog dela
• Javin prevodilac uvek proverava usaglašenost tipova
45
Automatsko unapreñivanje tipova u izrazima • byte i short se uvek konvertuju u tip int kad se pojavljuju kao operandi nekog izraza • Primer: byte a=5, b=8; byte c=a*b; // Izaziva grešku u prevoñenju byte d = (byte)(a*b); // Ispravno byte e = (byte)a*b; // Pogrešno
46
23
Pravila za automatsku konverziju (unapreñivanje) tipova u izrazima • byte i short se automatski unapreñuju u int • ako je jedan operand izraza long, ceo izraz se unapreñuje u long • ako je jedan operand izraza float, ceo izraz se unapreñuje u float • ako je jedan operand izraza double, ceo izraz se unapreñuje u double
47
Primer za automatsku konverziju class Unapredjivanje { public static void main(String args[]) { byte b = 2; short s = 300; char z = 'a'; int i = 10, j = 5; long k = 0xFFFFFFFFFFL; float f = 5.1f; 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); } } 48
24
Primer: eksplicitna konverzija int u byte • Tip int je dužine 32 bita, tj. 4 bajta • Pri konverziji tipa int u tip byte rezultat je jednak najnižem bajtu (biti na pozicijama od 0 do 7), a tri gornja bajta se gube (biti na pozicijama od 8 do 31) • Zavisno od vrednosti bita na poziciji 7, rezultat može promeniti znak int byte3
byte2
byte1
byte0
00110100 10011010 01101110 11111111
→
byte
→
byte0
→
11111111
↑ pozicija 7
49
Primer za eksplicitnu konverziju • Mogući su i neočekivani rezultati, npr. kad je broj koji se konvertuje izvan opsega tipa u koji se konvertuje class Konverzija { public static void main(String args[]) { int i = 257; // 0...0 0001 0000 0001 double d = 129.142; byte b = (byte)i; // b=1 0000 0001 i = (int)d; // i=129 0...0 0000 1000 0001 b = (byte)d; // b=-127 1000 0001
i = -130; b = (byte)i;
// 130 = 0...0 0000 1000 0010 // -130 = 1...1 1111 0111 1110 // b=126 0111 1110
} }
50
25
Nizovi
1
Nizovi • Grupe promenljivih istog tipa • Jedna ili više dimenzija
2
1
Jednodimenzionalni nizovi • Lista (niz) promenljivih istog tipa • Deklaracija tip ime_niza[]; tip[] ime_niza; // alternativna mogućnost deklarisanja • Primer int meseci[]; int[] meseci; • Deklaracija ne rezerviše mesto u memoriji za niz 3
Kreiranje niza • Deklaracija a zatim kreiranje niza tip ime_niza[]; ime_niza = new tip[velicina]; • Primer int meseci[]; meseci = new int[12]; Deklaracija i inicijalizacija tip ime_niza[] = new tip[velicina]; • Primer int meseci[] = new int[12]; 4
2
Primer za jednodimenzionalni niz class Niz { public static void main(String args[]) { int meseci[] = new int[12]; meseci[0] = 31; // januar meseci[1] = 28; // februar meseci[2] = 31; // mart // ... meseci[10] = 30; // novembar meseci[11] = 31; // decembar System.out.println("April ima " + meseci[3] + " dana."); } }
April ima 30 dana. 5
Inicijalizacija jednodimenzionalnog niza • Ne koristi se operator new za rezervisanje prostora class InicijalizacijaNiza { public static void main(String args[]) { int meseci[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; System.out.println("April ima " + meseci[3] + " dana."); } }
April ima 30 dana. 6
3
Višedimenzionalni nizovi • Dvodimenzionalni niz je matrica • Deklaracija dvodimenzionalnog niza tip ime_niza[][]; • Primer int matrica[][] = new int[3][4]; • Ovim se rezerviše 3x4=12 lokacija u memoriji za tip int
7
Predstavljanje dvodimenzionalnog niza int matrica[][] = new int[3][4]; • Prvi indeks odreñuje vrstu a drugi kolonu
[0][0]
[0][1]
[0][2]
[0][3]
[1][0]
[1][1]
[1][2]
[1][3]
[2][0]
[2][1]
[2][2]
[2][3]
8
4
Primer za pristupanje članovima matrice class DvodimenzionalniNiz { public static void main(String args[]) { int matrica[][]= new int[3][4]; int i, j, k = 0; for(i=0; i<3; i++) for(j=0; j<4; j++) { matrica[i][j] = k; k++; } for(i=0; i<3; i++) { for(j=0; j<4; j++) System.out.print(matrica[i][j] + " "); System.out.println(); } } }
9
Inicijalizacija dvodimenzionalnog niza class DvodimenzionalniNizInit { public static void main(String args[]) { int m[][]= { { 0, 1, 2, 3 }, { 4, 5, 6, 7 }, { 8, 9, 10, 11 } }; int i, j; for(i=0; i<3; i++) { for(j=0; j<4; j++) System.out.print(m[i][j] + " "); System.out.println(); } } } 0 1 2 3 4 5 6 7 8 9 10 11
10
5
Drugi način kreiranja višedimenzionalnog niza class DvodimenzionalniNizDrugiNacin { public static void main(String args[]) { int m[][]= new int[3][]; m[0] = new int[4]; m[1] = new int[4]; m[2] = new int[4]; // Isto se dobija sa // int matrica[][]= new int[3][4]; ... } }
11
Različit broj elemenata u nekoj dimenziji niza class DvodimenzionalniNizSpec { public static void main(String args[]) { int dd[][]= new int[3][]; dd[0] = new int[1]; dd[1] = new int[2]; dd[2] = new int[3]; int i, j, k=0; for(i=0; i<3; i++) for(j=0; j
6
Različit broj elemenata u nekoj dimenziji niza [0][0] [1][0]
[1][1]
[2][0]
[2][1]
[2][2]
13
7
Operatori
1
Operatori • • • • • •
Aritmetički operatori Operatori nad bitima Operatori poreñenja Logički operatori Operator dodeljivanja Operator ?:
2
1
Aritmetički operatori + – * /
Sabiranje Oduzimanje i unarni minus Množenje Deljenje
% ++ –– += –= *= /= %=
Moduo Uvećavanje za jedan Umanjivanje za jedan Dodeljivanje uz sabiranje Dodeljivanje uz oduzimanje Dodeljivanje uz množenje Dodeljivanje uz deljenje Dodeljivanje uz moduo 3
Primer osnovnih operacija sa tipom int class OsnovneOperacijeSaIneger { public static void main(String args[]) { int a = 1 + 1; int b = a * 3; int c = b / 4; int d = c - a; int e = -d; System.out.println("a = " + a + "\nb = " + b + "\nc = " + c + "\nd = " + d + "\ne = " + e); } } a=2 b=6 c=1 d = -1 e=1
4
2
Primer osnovnih operacija sa tipom double class OsnovneOperacijeSaDouble { public static void main(String args[]) { double a = 1 + 1; double b = a * 3; double c = b / 4; double d = c - a; double e = -d; System.out.println("a = " + a + "\nb = " + b + "\nc = " + c + "\nd = " + d + "\ne = " + e); } } a = 2.0 b = 6.0 c = 1.5 d = -0.5 e = 0.5
5
Operator moduo class Moduo { public static void main(String args[]) { int x = 7; int y = x % 3; System.out.println("7 % 3 = " + y); double d = 5.5; double d1 = d % 2; // d1=1.5 System.out.println("d1 = " + d1); double d2 = d % 2.5; // d2=0.5 System.out.println("d2 = " + d2); } } 7 % 3=1 d1 = 1.5 d2 = 0.5
6
3
Aritmetički operatori dodeljivanja promenljiva = promenljiva operator izraz; promenljiva operator= izraz; • Primeri a = a / 4; a /= 4; b = b % c; b %= c; d = d + e * f; d += e * f; 7
Uvećavanje i umanjivanje x = x + 1; x++; x = x – 1; x--;
• Mogu da budu prefiksi ili sufiksi • Primer za sufiks x = 5; y = x++; // prvo se radi dodela vrednosti tj. y dobije vrednost 5, // zatim se x uveća i dobije vrednost 6 • Primer za prefiks x = 5; y = ++x; // prvo se x uveća i dobije vrednost 6, // zatim se radi dodela vrednosti tj. y dobije vrednost 6 8
4
Operatori nad bitima ~ & | ^ >> >>> << &= |= ^= >>= >>>= <<=
Negacija bita jednog operanda (NE – NOT) Konjunkcija nad bitima (I – AND) Disjunkcija nad bitima (ILI – OR) Isključiva disjunkcija nad bitima (EXOR) Pomeranje udesno Pomeranje udesno sa unošenjem nula Pomeranje ulevo 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 Dodeljivanje uz pomeranje ulevo 9
Tabela operatora nad bitima A
B
A|B
A&B
A^B
~A
0
0
0
0
0
1
0
1
1
0
1
1
1
0
1
0
1
0
1
1
1
1
0
0
10
5
Operatori nad bitima ~ 00101010
42
00101010 | 00001111
42 15
11010101
–43
00101111
47
00101010 & 00001111
42 15
00101010 ^ 00001111
42 15
00001010
10
00100101
37
11
Pomeranje ulevo vrednost << broj_bita_za_koliko_se_pomera;
• Sa desne strane se dodaju nule • Biti sa leve strane se gube • Primer: int i int p p = p p <<=
= 1 << 3; = 0x7FFFFFFF; << 1; 1;
// // // //
i p p p
dobija vrednost 8 ima vrednost najvećeg int je 0xFFFFFFFE tj. -2 je 0xFFFFFFFC tj. -4
• Pomeranje ulevo za N bita odgovara množenju sa 2N, pod uslovom da ne doñe do promene znaka broja
12
6
Pomeranje udesno vrednost >> broj_bita_za_koliko_se_pomera;
• Pri pomeranju se čuva znak, tj. sa leve strane se dodaje bit jednak bitu koji je prethodno bio na poziciji 31 • Biti sa desne strane se gube • Primer: int a = a = int b = b = b =
a a a b b b b
= 35; >> 2; >> 4; = -8; >> 2; >> 1; >> 1;
// // // // // // //
a a a b b b b
= = = = = = =
0...0 0...0 0...0 1...1 1...1 1...1 1...1
00100011 00001000 00000000 11111000 11111110 11111111 11111111
(tj. a=8) (tj. a=0) (tj. b=-2) (tj. b=-1) (b ostaje -1) 13
Pomeranje udesno uz dodavanje nula vrednost >>> broj_bita_za_koliko_se_pomera;
• Sa leve strane se dodaju nule • Biti sa desne strane se gube • Primer: int k = -1; // 0xFFFFFFFF k = k >>> 1; // 0x7FFFFFFF (k je sad najveći int) k = k >>> 23; // 0x000000FF (k je sad 255) byte b = (byte)0xff; b = (byte)(b >>> 4); // b i dalje ima vrednost 0xff // prvo je unapreñen u int: 0xffffffff // zatim je pomeren udesno: 0x0fffffff // na kraju je konverzija u byte: 0xff 14
7
Primeri za operacije nad bitima byte b = (byte)0xff; b = b >>> 4; // Greška, rezultat je tipa int b >>>= 28; // Ispravno, b je sad 0x0f b = (byte)0xff; b = (byte)((b & 0xff) >> 4); // b je sad 0x0f, jer: // b se unapreñuje u int: 0xffffffff // AND po bitima sa 0xff: 0x000000ff // pomeranje udesno za 4: 0x0000000f // posle konverzije int u byte: 0x0f
15
Operatori poreñenja == != > < >= <=
Jednako Različito Veće Manje Veće ili jednako Manje ili jednako
• Rezultat operacija je logički tip (boolean) • Operatori == i != rade sa svim tipovima • Operatori redosleda (>, <, >=, <=) rade sa numeričkim tipovima i char 16
8
Primeri za operatore poreñenja int a=1, b=4; boolean c = a < b; if(c) naredba; if(a
// c ima vrednost true
17
Logički operatori & | ^
Konjunkcija (I – AND) Disjunkcija (ILI – OR) Isklučiva (ekskluzivna) disjunkcija (EXILI – EXOR)
&& || ! == != ?:
Kratkospojena konjunkcija Kratkospojena disjunkcija Unarna negacija (NE – NOT) Jednako Različito Ternarni operator uslovne dodele
&= |= ^=
Dodeljivanje uz konjunkciju Dodeljivanje uz disjunkciju Dodeljivanje uz isklučivu disjunkciju 18
9
Tabela logičkih operatora A
B
A|B
A&B
A^B
!A
false
false
false
false
false
true
false
true
true
false
true
true
true
false
true
false
true
false
true
true
true
true
false
false
19
Primer za logičke operatore class BoolLogic { public static void main(String args[]) { boolean a = true, b = false; boolean c = a | b; boolean d = a & b; boolean e = a ^ b; boolean f = (!a & b) | (a & !b); boolean g = !a; System.out.println("a = " + a + "\nb = " + b + "\na|b = " + c + "\na&b = " + d + "\na^b = " + e + "\n!a&b | a&!b = " + f + "\n!a = " + g); } } a = true b = false a|b = true
a&b = false a^b = true !a&b | a&!b = true
!a = false 20
10
Kratkospojeni logički operatori boolean c = izraz1 || izraz2; • Ako je izraz1=true, izraz2 se ne izračunava, pošto je u tom slučaju rezultat true bez obzira na vrednost izraza2 boolean c = izraz1 | izraz2; // Oba izraza se izračunavaju if(d!=0 && b/d>100) naredba; // Ne dolazi do deljenja nulom if(c==1 & e++<100) naredba; // e se uvećava i kad je c=1 • Operatori && i || se koriste češće od & i |
21
Ternarni operator ?: izraz1 ? izraz2 : izraz3; • Rezultat izraz1 mora biti logičkog tipa
– ako izraz1 ima vrednost true izvršava se izraz2 – ako izraz1 ima vrednost false izvršava se izraz3 • Ternarni operator ?: vraća vrednost izračunatog izraza • Izrazi izraz2 i izraz3 moraju da budu istog tipa i ne smeju da budu tipa void (vraćaju rezultat nekog tipa) k = i<0 ? –i : i; // Izračunavanje apsolutne vrednosti i
22
11
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 vraća rezultat 10 koji se dodeljuje promenljivoj c i tako redom do a
23
Prioritet operatora ()
[]
.
++
--
~
*
/
%
+
-
>>
>>>
<<
>
>=
<
==
!=
!
<=
& ^ | && || ?: =
operator=
(*=, /=, %=, +=, <<= ...) 24
12
Korišćenje zagrada • Zagrade služe za definisanje redosleda izračunavanja (prioriteta) i za pisanje jasnijih izraza a >> b + 3; // prvo se b uvećava za 3, // zatim se sadržaj a pomera udesno // ("+" 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
25
13
Upravljačke naredbe
1
Upravljačke naredbe • Naredbe uslovljavanja (selection statements) – upravljanje izvršavanjem programa na osnovu uslova koji su poznati u trenutku izvršavanja
• Naredbe ciklusa (iteration statements) – izvršavanje (ponavljanje) jedne naredbe ili bloka naredbi potreban broj puta, zavisno od uslova
• Naredbe skoka (jump statements) – prekidanje izvršavanja redosleda naredbi i nastavljanje na definisanom mestu, tj. preskakanje naredbi
2
1
Upravljačke naredbe • Naredbe uslovljavanja – if – switch
• Naredbe ciklusa – while – do while – for
• Naredbe skoka – break – continue – return 3
Naredba if • Uslovno grananje na dva različita puta • Opšti oblik if(uslov) naredba1; else naredba2; • uslov je izraz koji vraća vrednost tipa boolean, ili jedna promenljiva tipa tipa boolean • naredba je jedna naredba ili blok naredbi • deo else nije obavezan • Izvršavanje – ako uslov vrati vrednost true izvršava se naredba1 – inače se izvršava naredba2 (ako else deo postoji) 4
2
Primeri za if int a, // a i if(a < else b
b; b dobijaju neke vrednosti ... b) a = 0; = 0;
int brojPodataka, n; // ... 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 5
Ugnježdeni uslovi if(i == 10) { if(j < 20) a = b; if(k > 100) c = d; else a = c; // ovaj else se odnosi na uslov if(k > 100) } else a = d; // ovaj else se odnosi na uslov if(i == 10)
6
3
Ugnježdeni uslovi if(i == 10) { if(j < 20) { a = b; if(k > 100) c = d; } else a = c; // ovaj else se odnosi na uslov if(j < 20) } else a = d; // ovaj else se odnosi na uslov if(i == 10)
7
if else if if(uslov1) naredba1; else if(uslov2) naredba2; else if(uslov3) naredba3; else if(uslov4) naredba4; else naredba5;
if(uslov1) naredba1; else if(uslov2) naredba2; else if(uslov3) naredba3; else if(uslov4) naredba4; else naredba5;
8
4
Primer za if else if class GodisnjaDobaSaIfElseIf { public static void main(String args[]) { int mesec = 4; // April String godisnjeDoba; if(mesec==12 || mesec==1 || mesec==2) godisnjeDoba = "zima"; else if(mesec==3 || mesec==4 || mesec==5) godisnjeDoba = "proleće"; else if(mesec==6 || mesec==7 || mesec==8) godisnjeDoba= "leto"; else if(mesec==9 || mesec==10 || mesec==11) godisnjeDoba = "jesen"; else godisnjeDoba = "nepostojeći mesec"; System.out.println("Kada je mesec april, godišnje doba je " + godisnjeDoba + "."); } }
Kada je mesec april, godišnje doba je proleće.
9
Naredba switch • Grananje u više putanja zavisno od vrednosti izraza • Opšti oblik switch(izraz) { case vrednost1: niz_naredbi1; [break;] case vrednost2: niz_naredbi2; [break;] ... default: niz_naredbiN; }
10
5
Naredba switch izraz je jedan od tipova: byte, short, int ili char Svaka od vrednosti je jedinstven literal (konstanta) Ne sme se ponoviti ista vrednost u istom switch Sa break se završava switch Ako ne postoji break nastavlja se izvršavanje sledećeg case • Deo default je opcioni • • • • •
11
Primer za switch class PrimerZaSwitch { public static void main(String args[]) { for(int i=0; i<6; i++) switch(i) { case 0: System.out.println("i je nula."); break; case 1: System.out.println("i je jedan."); break; case 2: System.out.println("i je dva."); break; case 3: System.out.println("i je tri."); break; default: System.out.println("i je veće od tri."); } } } i je nula. i je jedan. i je dva. i je tri. i je veće od tri. 12 i je veće od tri.
6
Primer za switch bez break class PrimerBezBreak { public static void main(String args[]) { for(int i=0; i<9; i++) switch(i) { case 0: System.out.println("i = 0"); case 1: case 2: System.out.println("i < 3"); break; case 3: case 4: System.out.println("i < 5"); break; default: System.out.println("i >= 5"); } } } i i i i
=0 <3 <3 <5
i i i i i
<5 >= 5 >= 5 >= 5 >= 5
13
Godišnja doba sa switch class GodisnjaDobaSaSwitch { public static void main(String args[]) { int mesec = 4; String godisnjeDoba; switch (mesec) { case 12: case 1: case 2: godisnjeDoba = "zima"; break; case 3: case 4: case 5: godisnjeDoba = "proleće"; break; case 6: case 7: case 8: godisnjeDoba = "leto"; break; case 9: case 10: case 11: godisnjeDoba = "jesen"; break; default: godisnjeDoba = "nepostojeći mesec"; } System.out.println("Kada je mesec april, godišnje deoba je " + godisnjeDoba + "."); } }
14
7
Ugnježdena naredba switch switch (izraz_spoljasnjeg_switch) { case 1: switch (izraz_unutrasnjeg_switch) { case 0: System.out.println("unutra je 0"); break; case 1: // ne smeta spoljašnjem switch System.out.println("unutra je 1"); break; } break; case 2: ... } 15
Poreñenje if i switch • switch proverava samo jednakost, a if proizvoljan logički izraz • switch je efikasniji od ugnježdenih if else if
16
8
Naredbe ciklusa • Izvršavanje (ponavljanje) jedne naredbe ili bloka naredbi potreban broj puta, zavisno od uslova • Naredbe ciklusa (petlje) – while – do while – for
17
Petlja while • Opšti oblik while petlje while(uslov) telo_petlje • uslov je proizvoljan logički izraz • telo_petlje je jedna naredba (može biti i prazna 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. telo_petlje se ne izvršava nijednom 18
9
Primer za while petlju class PrimerZaWhile { public static void main(String args[]) { int n = 5; // Za n=0 petlja se ne bi izvršila nijednom while(n > 0) { System.out.println("Vrednost n je " + n); n--; } } } Vrednost n je 5 Vrednost n je 4 Vrednost n je 3 Vrednost n je 2 Vrednost n je 1 19
Primer za while bez tela petlje class WhileBezTelaPetlje { public static void main(String args[]) { int i = 100, j = 200; // U petlji se nalazi sredina izmeñu i i j while(++i < --j) ; // Petlja bez tela ima samo znak ";" System.out.println("Sredina je " + i); } } Sredina je 150
20
10
Petlja do while • Opšti oblik do while petlje do telo_petlje while(uslov); • uslov je proizvoljan logički izraz • telo_petlje je jedna naredba ili blok naredbi • do while petlja je sa proverom na dnu: – telo_petlje se izvršava jednom a posle toga se proverava uslov – ako uslov ima vrednost true, telo_petlje se izvršava ponovo, a ako je vrednost false izlazi se iz petlje 21
Primer za do while class PrimerZaDoWhile { public static void main(String args[]) { int n = 5; // Za n=0 petlja bi se izvršila jednom do { System.out.println("Vrednost n je " + n); n--; } while(n > 0); } } Vrednost n je 5 Vrednost n je 4 Vrednost n je 3 Vrednost n je 2 Vrednost n je 1 Za n=0 rezultat bi bio Vrednost n je 0
22
11
Kraće napisan primer za do while class PromenjenPrimerZaDoWhile { public static void main(String args[]) { int n = 5; do 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 23
Petlja for • Opšti oblik for petlje for(inicijalizacija; uslov; iteracija) telo_petlje
24
12
Petlja for • inicijalizacija je izraz – izvršava se samo jednom na početku pri ulasku u petlju – obično inicijalizuje upravljačku promenljivu petlje
• uslov je logički izraz, proverava se pre izvršavanja tela petlje – ako je vrednost true izvršava se telo petlje – 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 • iteracija je izraz – izvršava se posle tela petlje – obično menja upravljačku promenljivu petlje
• petlja se nastavlja proverom uslova i izvršavanjem tela petlje i iteracije sve dok je uslov tačan
25
Primer za for class PrimerZaFor { public static void main(String args[]) { int n; for(n=5; n>0; n--) System.out.println("Vrednost n je " + n); } } Vrednost n je 5 Vrednost n je 4 Vrednost n je 3 Vrednost n je 2 Vrednost n je 1
26
13
Deklaracija promenljive unutar for petlje • Upravljačka promenljiva petlje se često deklariše unutar petlje u delu inicijalizacija • Takva promenljiva postoji samo unutar petlje class DeklaracijaUnutarFor { public static void main(String args[]) { for(int n=5; n>0; n--) System.out.println("Vrednost n je " + n); } }
27
Primer: provera da li je broj prost class ProstBroj { public static void main(String args[]) { int broj = 14; boolean prost_broj = true; for(int i=2; i < broj/2; i++) { if((broj % i) == 0) { prost_broj = false; break; } } if(prost_broj) System.out.println("Prost"); else System.out.println("Nije prost"); } } 28
14
Više upravljačkih promenljivih for petlje • U inicijalizaciji se može deklarisati i inicijalizovati više upravljačkih promenljivih petlje • U iteraciji se može menjati više promenljivih • Izrazi u inicijalizaciji i iteraciji se razdvajaju zarezima class VisePromenljivihForPetlje { public static void main(String args[]) { for(int a=1, b=4; a
30
15
for petlja bez inicijalizacije i iteracije • Delovi for petlje inicijalizacija ili iteracija, ili oba dela, mogu da se izostave class ForBezInicijalizacijeIIteracije { public static void main(String args[]) { boolean kraj = false; int i = 0; for( ; !kraj; ) { System.out.println("i je " + i); if(i == 5) kraj = true; i++; } } } 31
Beskonačna for petlja for( ; ; ) { // ... if(uslov) break; // ... }
32
16
Ugneždene for petlje class UgnjezdeneForPetlje { public static void main(String args[]) { for(int i=0; i<5; i++) { for(int j=i; j<5; j++) System.out.print(i); System.out.println(); } } } 00000 1111 222 33 4 33
Naredbe skoka • Prekidanje izvršavanja redosleda naredbi i nastavljanje na definisanom mestu, tj. preskakanje naredbi – break – continue – return
34
17
Naredba break • Završavanje niza naredbi u naredbi switch, tj. izlazak iz naredbe switch • Izlazak iz petlje u specijalnim slučajevima (uobičajeno je da se iz petlje izlazi na osnovu uslova) • Vaijanta naredbe goto
35
Završavanje niza naredbi u naredbi switch class PrimerBezBreak { public static void main(String args[]) { for(int i=0; i<9; i++) switch(i) { case 0: System.out.println("i = 0"); case 1: case 2: System.out.println("i < 3"); break; case 3: case 4: System.out.println("i < 5"); break; default: System.out.println("i >= 5"); } } } 36
18
Izlazak iz for petlje sa break class BreakPrekidaForPetlju { public static void main(String args[]) { for(int i=0; i<100; i++) { if(i == 5) break; // prekidanje petlje kad je i=5 System.out.println("i: " + i); } System.out.println("Petlja je završena."); } } i: 0 i: 1 i: 2 i: 3 i: 4 Petlja je završena. 37
Izlazak iz while petlje sa break class BreakPrekidaWhilePetlju { public static void main(String args[]) { int i=0; while(i<100) { if(i == 5) break; // prekidanje petlje kad je i=5 System.out.println("i: " + i); i++; } System.out.println("Petlja je završena."); } } i: 0 i: 1 i: 2 i: 3 i: 4 Petlja je završena.
38
19
break u ugnježdenim petljama • break prekida samo najdublje ugnježdenu petlju u kojoj se nalazi class BreakUUgnjezdenimPetljama { public static void main(String args[]) { for(int i=0; i<3; i++) { System.out.print("i = " + i + "; j: "); for(int j=0; j<100; j++) { if(j == 10) break; // prekida unutrašnju petlju za j=10 System.out.print(j + " "); } System.out.println(); } System.out.println("Petlja je završena."); } } i = 0; j: 0 1 2 3 4 5 6 7 8 9 i = 1; j: 0 1 2 3 4 5 6 7 8 9 i = 2; j: 0 1 2 3 4 5 6 7 8 9 Petlja je završena.
39
Naredba break sa oznakom • Opšti oblik oznaka:{ ... if(uslov) break oznaka; ... } • oznaka označava blok naredbi iza kojeg se nastavlja program posle izvršavanja označene naredbe break koja mora biti obuhvaćena blokom • Može se izaći iz više ugnježdenih blokova • Ne može se preskočiti blok koji ne obuhvata označenu naredbu break • Naredba if je obavezna, inače se naredbe iza naredbe break nikad ne bi izvršavale, što je greška u prevoñenju
40
20
Primer za označeni break class BreakSaOznakom { public static void main(String args[]) { boolean t = true; prvi: { drugi: { treci: { System.out.println("Pre naredbe break."); if(t) break drugi; System.out.println("Posle naredbe break."); } System.out.println("U drugom bloku."); } System.out.println("U prvom bloku."); } } }
Pre naredbe break. U prvom bloku.
41
Primer za for i označeni break class ForIBreakSaOznakom { public static void main(String args[]) { spoljna: for(int i=0; i<3; i++) { System.out.print("i = " + i + ": j:"); for(int j=0; j<100; j++) { if(j == 10) break spoljna; System.out.print(j + " "); } System.out.println("Ovo se preskače."); } System.out.println("Petlja završena."); } } i = 0: j: 0 1 2 3 4 5 6 7 8 9 Petlja završena. 42
21
Primer sa greškom class PogresanBreak { public static void main(String args[]) { prvi: for(int i=0; i<3; i++) { System.out.print("i = " + i + ": j:"); } for(int j=0; j<100; j++) { if(j == 10) break prvi; // Pogrešno System.out.print(j + " "); } } }
43
Naredba continue • Opšti oblik petlja { ... if(uslov) continue; ... } • Služi za preskakanje naredbi tela petlje od naredbe continue do kraja tela petlje, ali se ne napušta petlja – 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 44
22
Primer za continue class PrimerZaContinue { public static void main(String args[]) { for(int i=0; i<10; i++) { System.out.print(i + " "); if(i%2 == 0) continue; System.out.println(""); } } } 01 23 45 67 89 45
Naredba continue sa oznakom • Opšti oblik oznaka: petlja1 { petlja2 { ... if(uslov) continue oznaka; ... } } • oznaka označava petlju koja će se nastaviti posle izvršavanja označene naredbe continue • Naredba if je obavezna, inače se naredbe iza naredbe continue nikad ne bi izvršavale, što je greška u prevoñenju 46
23
Primer za označeni continue class ContinueSaOznakom { public static void main(String args[]) { spoljna: for(int i=0; i<5; i++) { for(int j=0; j<5; j++) { if(j > i) { System.out.println(); continue spoljna; } System.out.print(i + " "); } } System.out.println(); } } 0 1 2 3 4
1 2 2 3 3 3 4 4 4 4
47
Naredba return • Opšti oblik tip ime_metode(lista_parametara) { ... if(uslov) return [vrednost]; ... } • Služi za izlazak iz metode • Posle naredbe return kontrola se vraća pozivaocu metode • Naredba if je obavezna ako naredba return nije poslednja naredba u metodi, inače se naredbe iza naredbe return nikad ne bi izvršavale, što je greška u prevoñenju • vrednost ne postoji ako je tip metode void, inače postoji 48
24
Primer za return class PrimerZaReturn { public static void main(String args[]) { boolean t = true; System.out.println("Pre naredbe return."); if(t) return; // povratak pozivaocu System.out.println("Ovo se ne izvršava."); } } Pre naredbe return.
49
25
Uvod u klase
1
Klasa • Klasa je novi tip podataka • Klasa je šablon za objekte - definiše oblik i ponašanje objekta • Objekat je primerak (instanca) klase • Klase koje se izvršavaju imaju metod main
2
1
Klase i datoteke • Klasa se piše u jednoj datoteci – i deklaracija i realizacija • Imena datoteke i klase moraju da budu jednaka • Ekstenzija datoteke je *.java
3
Opšti oblik klase (nije kompletan) class imeKlase { tip promenljiva1; tip promenljiva2; ... tip promenljivaN; tip imeMetode1(lista_parametara) { telo_metode } ... tip imeMetodeM(lista_parametara) { telo_metode } } 4
2
Termini • Objekat se naziva i instanca klase • Podaci (promenljive) definisane u klasi nazivaju se polja (takoñe se koriste i termini: promenljive instance, atributi ili članovi podaci) • Kod se piše u metodima • Metodi i promenljive deklarisane u klasi nazivaju se članovi klase
5
Primer jednostavne klase • Klasa za opisivanje kutije za koju su bitne samo dimenzije
class Kutija { double sirina; double visina; double duzina; }
6
3
Pravljenje objekta – operator new • Objekat se pravi operatorom new • Pravljenjem objekta se u memoriji rezerviše prostor za smeštanje tog objekta • Primer: Kutija k1 = new Kutija(); – k1 je referenca koja ukazuje na objekat u memoriji k1
sirina visina duzina
7
Operator tačka "." • Operator tačka služi za pristupanje članu objekta • Primer za pristupanje poljima: k1.sirina = 1; k1.visina = 2; k1.duzina = 3;
8
4
Primer 1. sa klasom Kutija //klasa Kutija i PrimerSaKutijom1 mogu, ali ne moraju //biti u istoj datoteci. Uvek se kreiraju dve .class //datoteke. class PrimerSaKutijom1 { public static void main(String args[]) { Kutija k = new Kutija(); // dodela vrednosti poljima k.sirina = 1; k.visina = 2; k.duzina = 3; // Računanje zapremine kutije double zapremina = k.sirina * k.visina * k.duzina; System.out.println("Zapremina je " + zapremina); } }
Zapremina je 6.0 9
Primer 2. sa dva objekta klase Kutija class PrimerSaDveKutije1 { public static void main(String args[]) { Kutija k1 = new Kutija(); Kutija k2 = new Kutija(); // dodela vrednosti clanovima objekta k1 k1.sirina = 1; k1.visina = 2; k1.duzina = 3; // dodela vrednosti clanovima objekta k2 k2.sirina = 2; k2.visina = 4; k2.duzina = 5; // Izračunavanje i ispisivanje zapremina double z = k1.sirina * k1.visina * k1.duzina; System.out.println("Zapremina k1 je " + z); z = k2.sirina * k2.visina * k2.duzina; System.out.println("Zapremina k2 je " + z); } } Zapremina k1 je 6.0 10 Zapremina k2 je 40.0
5
Reference i objekti • Deklaracija promenljive Kutija k1;
k1 je null
• Postoji samo referenca k1, a objekat još nije napravljen • Stvaranje objekta k1 = new Kutija();
k1
• Operator new kreira objekat, tj. rezerviše prostor u memoriji za čuvanje objekta • Referenca k1 ukazuje na objekat • Preko refernce se pristupa objektu
sirina visina duzina
11
Reference i objekti Kutija k1 = new Kutija(); Kutija k2; • Referenca k2 ne ukazuje na objekat
k2 = k1; • Reference k1 i k2 sad imaju iste vrednosti, tj. ukazuju na isti objekat • Kopiranje reference ne kopira objekat
k1
sirina visina
k2 je null
k1
duzina
sirina visina
k2
duzina
12
6
Reference i objekti - nastavak k1 = new Kutija(); • Kreiran je još jedan objekat na koji sad ukazuje referenca k1
k1
sirina visina
k2
duzina sirina visina duzina
k2 = new Kutija(); • Kreiran je treći objekat na koji sad ukazuje referenca k2 • Na prvi objekat više ne ukazuje nijedna referenca i njemu ne može da se pristupi
k1
sirina visina
k2
duzina sirina
sirina
visina
visina
duzina
duzina 13
Opšti oblik primene operatora new ImeKlase promenljiva = new ImeKlase(); • ImeKlase označava tip promenljive • ImeKlase() označava konstruktor • Operator new dodeljuje memoriju dinamički • Količina memorije je ograničena • Ako nema dovoljno memorije da se kreira objekat javlja se izuzetak • Operator new se ne koristi za proste tipove (byte, short, int, long, float, double, char, boolean). Promenljive ovih tipova nisu objekti. 14
7
Osnovno o konstruktorima • Konstruktor definiše šta se radi pri stvaranju objekta • Ako u klasi nije napisan konstruktor Java obezbeñuje podrazumevani konstruktor • Klasa može da ima više konstruktora
15
Metodi • Opšti oblik metoda tip imeMetoda(lista_parametara) { telo_metoda } • tip je tip podatka koji vraća metod; ako metod ne vraća vrednost tip metoda je void • imeMetoda je identifikator • lista_parametara je niz parova tip identifikator razdvojenih zarezima, a može biti prazna • Parametri su promenljive koje prihvataju vrednosti argumenata prosleñenih metodu u trenutku pozivanja • Metod vraća vrednost pomoću naredbe return return vrednost; 16
8
Šta je loše u klasi Kutija? class Kutija { double sirina; double visina; double 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 se promene vrednosti (pristupa se poljima direktno)
17
Metod za izračunavanje zapremine u klasi Kutija class Kutija { double sirina; double visina; double duzina; double zapremina() { return sirina * visina * duzina; } } • U metodu zapremina direktno se pristupa poljima pošto je i 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
18
9
Primer: klasa Kutija ima metod zapremina class PrimerSaDveKutije2 { public static void main(String args[]) { Kutija k1 = new Kutija(); Kutija k2 = new Kutija(); // dodela vrednosti clanovima objekta k1 k1.sirina = 1; k1.visina = 2; k1.duzina = 3; // dodela vrednosti clanovima objekta k2 k2.sirina = 2; k2.visina = 4; k2.duzina = 5; // Izračunavanje i ispisivanje zapremina double z = k1.zapremina(); System.out.println("Zapremina k1 je " + z); z = k2.zapremina(); System.out.println("Zapremina k2 je " + z); } } 19
Kraći način pisanja u prethodnom primeru • Zapremina se izračunavala samo da bi se ispisala na ekranu, i korišćene su dve naredbe double z = k1.zapremina(); System.out.println("Zapremina je " + z);
• Prethodne dve naredbe se mogu zameniti jednom System.out.println("Zapremina je " + k1.zapremina());
20
10
Metod za postavljanje vrednosti polja u klasi Kutija class Kutija { double sirina; double visina; double duzina; double zapremina() { return sirina * visina * duzina; } void postaviDimenzije(double s, double v, double d){ sirina = s; visina = v; duzina = d; } } 21
Primer: klasa Kutija ima metod postaviDimenzije class PrimerSaDveKutije3 { public static void main(String args[]) { Kutija k1 = new Kutija(); Kutija k2 = new Kutija(); // dodela vrednosti clanovima objekta k1 k1.postaviDimenzije(1, 2, 3); // dodela vrednosti clanovima objekta k2 k2.postaviDimenzije(2, 4, 5); // Izračunavanje i ispisivanje zapremina System.out.println("Zapremina k1 je " + k1.zapremina()); System.out.println("Zapremina k2 je " + k2.zapremina()); } } 22
11
Parametri i argumenti • Parametar je promenljiva deklarisana u listi parametara metoda i kao promenljiva postoji samo unutar metoda • Argument je vrednost koja se prosleñuje metodu pri pozivanju metoda • Parametar dobija (prihvata) vrednost argumenta
23
Konstruktori • Konstruktor može da inicijalizuje objekat odmah posle stvaranja objekta, i u tom slučaju ne mora se pozivati metod za postavljanje vrednosti poljima • Konstruktor ima isto ime kao i klasa • Za konstruktore se ne piše tip jer se podrazumeva da konstruktor vraća tip klase • Ako se ne napiše 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 24
12
Konstruktor sa parametrima u klasi Kutija class Kutija { double sirina; double visina; double duzina; // Konstruktor sa listom parametara Kutija(double s, double v, double d) { sirina = s; visina = v; duzina = d; } double zapremina() { return sirina * visina * duzina; } 25
}
Konstruktor sa parametrima u klasi Kutija • U klasi Kutija koja ima konstruktor sa parametrima ne mora postojati metod za postavljanje dimenzija, ako se pretpostavi da objektu Kutija ne treba menjati dimenzije • Korišćenje podrazumevanog konstruktora u ovoj klasi izaziva grešku u prevoñenju programa • Može se napisati više konstruktora u jednoj klasi (sledeće poglavlje)
26
13
Primer: korišćenje konstruktora sa parametrima class PrimerSaDveKutije4 { public static void main(String args[]) { Kutija k1 = new Kutija(1, 2, 3); Kutija k2 = new Kutija(2, 4, 5); // Izračunavanje i ispisivanje zapremina System.out.println("Zapremina k1 je " + k1.zapremina()); System.out.println("Zapremina k2 je " + k2.zapremina()); } }
27
Rezervisana reč this • Koristi se unutar metoda da ukaže na objekat za koji je metod pozvan • Primer za konstruktor klase Kutija: Kutija(double s, double v, double d) { sirina = s; visina = v; duzina = d; } // 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; } 28
14
Skrivanje polja • Ne mogu postojati dve lokalne promenljive sa istim imenom • Lokalna promenljiva ili parametar metoda mogu imati isto ime kao i polje – lokalna promenljiva (ili parametar) skriva polje – polju se može pristupiti pomoću rezervisane reči this
• Primer u kojem je korišćenje this obavezno Kutija(double sirina, double visina, double duzina){ this.sirina = sirina; this.visina = visina; this.duzina = duzina; } 29
Sakupljanje smeća (Garbage collection) • Operator new rezerviše (dodeljuje) memoriju objektu • Programer ne mora da vodi računa o oslobañanju memorije • Oslobañanje memorije – ako više nijedna referenca ne ukazuje na objekat, taj objekat više nije potreban i može se osloboditi memorija koju on zauzima – oslobañanje memorije radi sakupljač smeća koji se povremeno uključuje
30
15
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 sakupljač smeća uništi objekat • 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 } 31
Stek • Stek je memorija koja privremeno čuva podatke • Podatak koji se poslednji stavi na stek prvi se uzme sa steka, i obrnuto podatak koji je prvi stavljen na stek poslednji će se uzeti • Stek ima operacije za stavljanje na stek (push) i uzimanje sa steka (pop) • Postoji pokazivač koji pokazuje na tekuću vrednost na steku (vrh steka)
32
16
Jednostavna klasa – ilustracija steka class Stack { int stck[] = new int[10]; int vrh; Stack() { vrh = -1; }
// Inicijalizacija vrha steka
// Dodavanje jedne vrednosti na stek void push(int broj) { if(vrh == 9) System.out.println("Stek je popunjen."); else stck[++vrh] = broj; } 33
Jednostavna klasa, ilustracija steka – nastavak // Uzimanje jedne vrednosti sa steka int pop() { if(vrh < 0) { System.out.println("Stek je prazan."); return 0; } else return stck[vrh--]; } }
• U realnom slučaju umesto naredbe za štampanje koristio bi se izuzetak 34
17
Primer rada jednostavne klase za stek class PrimerRadaSteka { public static void main(String args[]) { Stack stack1 = new Stack(); Stack stack2 = new Stack(); // Stavljanje na stek for(int i=0; i<10; i++) stack1.push(i); for(int i=10; i<20; i++) stack2.push(i); // Uzimanje sa steka System.out.println("Stek stack1:"); for(int i=0; i<10; i++) System.out.println(stack1.pop()); System.out.println("Stek stack2:"); for(int i=0; i<10; i++) System.out.println(stack2.pop()); } } 35
Rezultat Stek stck1: 9 8 7 6 5 4 3 2 1 0
Stek stck2: 19 18 17 16 15 14 13 12 11 10
36
18
Klase
1
Preklapanje metoda • Dva ili više metoda u klasi mogu da imaju isto ime i to se zove preklapanje metoda (method overloading) • Preklopljeni metodi moraju da se razlikuju po tipu parametara ili po broju parametara (ili po oba) • Tip preklopljene metode nije bitan tj. ne pravi se razlika izmeñu preklopjenih metoda na osnovu tipa koji metoda vraća kao rezultat • Polimorfizam
2
1
Primer klase sa preklopljenim metodom public class Preklapanje { void test(){ System.out.println("Bez parametara"); } void test(int a){ System.out.println("Parametar int, a: " } void test(int a, int b){ System.out.println("Parametri int, int: } double test(double a){ System.out.println("Parametar double, a return a; } void test(double a){ //? System.out.println("Parametar double, a } }
+ a);
a, b: "+a+" "+b);
= " + a);
= " + a); 3
Ilustracija rada klase sa preklopljenim metodom public class PreklapanjeMain { public static void main(String[] args){ Preklapanje obj = new Preklapanje(); obj.test(); int i = 5; obj.test(i); // Greška, metod sa par. int ne vraća rezultat //double d = obj.test(i); double d = obj.test((double)i); byte b = 4; obj.test(b); obj.test(1,2); float f = 3.0f; obj.test(f); } }
Rezultat izvršavanja programa je: Bez parametara Parametar int, a: 5 Parametar double, a = 5.0 Parametar int, a: 4 Parametri int, int, a, b: 1 2 Parametar double, a = 3.0
4
2
Pozivanje preklopljenih metoda • Koji se metod poziva odreñuje se na osnovu broja i / ili tipova argumenata • Automatska konverzija • Odreñivanje koji od preklopljenih metoda se poziva radi se u vreme prevoñenja programa
5
Preklapanje konstruktora • Konstruktori se mogu preklopiti, slično kao i metodi – Preklopljeni konstruktori moraju da se razlikuju po tipu parametara ili po broju parametara (ili po oba) – Može se napisati i kostruktor bez parametara
6
3
Preklapanje konstruktora u klasi Kutija class Kutija { double sirina; double visina; double duzina; // Konstruktor bez parametara Kutija() { } // Konstruktor sa parametrima za sve tri dimenzije Kutija(double s, double v, double d) { sirina = s; visina = v; duzina = d; } 7
Preklapanje konstruktora u klasi Kutija – nastavak // Konstruktor sa jednim parametrom (kutija je kocka) Kutija(double stranica) { sirina = visina = duzina = stranica; } // Metod za postavljanje vrednosti polja (dimenzija kutije) void postaviDimenzije(double s, double v, double d){ sirina = s; visina = v; duzina = d; } // Metod za izračunavanje zapremune kutije double zapremina() { return sirina * visina * duzina; } } 8
4
Upotreba metoda za postavljanje vrednosti polja • Metod postaviDimenzije u klasi Kutija treba da postoji u sledećim slučajevima: – ako postoji konstruktor bez parametara, zato što npr. u trenutku kad se pravi objekat nisu poznate dimenzije objekta, pa ih treba naknadno postaviti – ako ima smisla da se objektu kutije menjaju dimenzije
9
Primer za Kutiju sa preklopljenim konstruktorima class PrimerPreklapanjeKonstruktora1 { public static void main(String args[]) { Kutija k1 = new Kutija(1, 2, 3); Kutija k2 = new Kutija(); Kutija k3 = new Kutija(2); // Izračunavanje i ispisivanje zapremina System.out.println("Zapremina k1 je " + k1.zapremina()); System.out.println("Zapremina k2 je " + k2.zapremina()); System.out.println("Zapremina k3 je " + k3.zapremina()); } } Zapremina k1 je 6.0 Zapremina k2 je 0.0 Zapremina k3 je 8.0
10
5
Pozivanje preklopljenih konstruktora • Važi isto pravilo kao i kod metoda – koji se konstruktor poziva odreñuje se na osnovu broja i / ili tipova argumenata – odreñivanje koji od preklopljenih konstruktora se poziva radi se u vreme prevoñenja programa
11
Korišćenje objekta kao parametra • Objekat se može koristiti kao parametar metode
12
6
Klasa sa metodom čiji je parametar objekat class Test { int a, b; Test(int i, int j) { a = i; b = j; } // Metod equals proverava da li su objekti jednaki boolean equals(Test obj) { if(a == obj.a && b == obj.b) return true; else return false; } } 13
Primer kad je objekat parametar class PrimerProsledjivanjaObjekta { public static void main(String args[]) { Test obj1 = new Test(10, 2); Test obj2 = new Test(10, 2); Test obj3 = new Test(10, 5); System.out.println("obj1 == obj2: " + obj1.equals(obj2)); System.out.println("obj1 == obj3: " + obj1.equals(obj3)); } } obj1 == obj2: true obj1 == obj3: false 14
7
Konstruktor čiji je parametar objekat • Konstruktor čiji je parametar objekat može da se iskoristi da se napravi kopija postojećeg objekta
15
Klasa Kutija - parametar konstruktora je objekat class Kutija { double sirina, visina, duzina; // Konstruktor čiji je parametar objekat, ovde služi za kopiranje objekta Kutija(Kutija obj) { sirina = obj.sirina; visina = obj.visina; duzina = obj.duzina; } // Konstruktor bez parametara Kutija() { } // Konstruktor sa parametrima za sve tri dimenzije Kutija(double s, double v, double d) { sirina = s; visina = v; duzina = d; } 16
8
Preklapanje konstruktora u klasi Kutija – nastavak // Konstruktor sa jednim parametrom (kutija je kocka) Kutija(double stranica) { sirina = visina = duzina = stranica; } // Metod za postavljanje vrednosti polja (dimenzija kutije) void postaviDimenzije(double s, double v, double d){ sirina = s; visina = v; duzina = d; } // Metod za izračunavanje zapremune kutije double zapremina() { return sirina * visina * duzina; } } 17
Primer za Kutiju sa preklopljenim konstruktorima class PrimerPreklapanjeKonstruktora2 { public static void main(String args[]) { Kutija k1 = new Kutija(1, 2, 3); Kutija k2 = new Kutija(); Kutija k3 = new Kutija(2); Kutija k4 = new Kutija(k1); // k4 je kopija objekta k1 // Izračunavanje i ispisivanje zapremina System.out.println("Zapremina k1 je " + k1.zapremina()); System.out.println("Zapremina k2 je " + k2.zapremina()); System.out.println("Zapremina k3 je " + k3.zapremina()); System.out.println("Zapremina k4 je " + k4.zapremina()); } } Zapremina k1 je 6.0 Zapremina k2 je 0.0 Zapremina k3 je 8.0 Zapremina k4 je 6.0
18
9
Prosleñivanje argumenata u metode • Argumenti izmeñu metoda koji poziva (pozivajući) i metoda koji se poziva (pozvani) prosleñuju se preko steka • Pozivajući metod stavlja argumente na stek • Pozvani metod uzima argumente sa steka • Tek kad se pozvani metod završi pomera se pokazivač vrha steka
19
Prosleñivanje argumenata u metode • Prema tome da li se prosleñuju argumenti prostih tipova ili klasnih tipova, može se govoriti o dva načina prosleñivanja (pozivanja) argumenata: – po vrednosti – po referenci
• 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)
20
10
Prosleñivanje (pozivanje) po vrednosti • Tip argumenta je neki od prostih tipova • Po završetku metoda vrednost prosleñenog argumenta ostaje nepromenjena class Test { int izracunaj(int i, int j) { i *= 3; j /= 2; return i * j; } }
21
Prosleñivanje (pozivanje) po vrednosti class PozivanjePoVrednosti { public static void main(String args[]) { Test obj = new Test(); int x = 2, y = 10; System.out.println("Pre pozivanja x, y: " + x + " " + y); int c = obj.izracunaj(x, y); System.out.println("Posle pozivanja x, y : " + x + " " + y); System.out.println("c: " + c); } } Pre pozivanja x, y : 2 10 Posle pozivanja x, y : 2 10 c: 30
22
11
Objašnjenje prosleñivanja (pozivanja) po vrednosti • Argument je prost tip čija se vrednost prilikom pozivanja metoda stavlja na stek • Pozvani metod uzima vrednost sa steka, dodeljuje je parametru • Parametru se može menjati vrednost u metodu, ali ta promena nema uticaja na promenljivu čija je vrednost prosleñena parametru
23
Prosleñivanje (pozivanje) po referenci • Tip argumenta je klasni tip • Metod koji poziva stavlja argument – referencu (tj. vrednost reference) na stek • Pozvani metod uzima vrednost reference sa steka i dodeljuje je parametru • Parametar ukazuje na isti objekat na koji ukazuje i argument • Unutar metoda može se promeniti objekat kojem se pristupa preko parametra • Sama referenca se prosleñuje po vrednosti
24
12
Prosleñivanje po referenci • Vrednost argumenta (promenljive koja postoji u metodu koji poziva) je kopirana u parametar (promenljivu koja postoji u pozvanom metodu), tako da ukazuju na isti objekat koji je negde u memoriji • Objekat se može promeniti unutar metoda
argument
polje 0 polje 1
parametar
... polje N
25
Prosleñivanje (pozivanje) po referenci class Test { int a, b; Test(int i, int j) { a = i; b = j; } int izracunaj(Test o) { o.a *= 3; o.b /= 2; return o.a * o.b; } } 26
13
Prosleñivanje (pozivanje) po referenci class PozivanjePoReferenci { public static void main(String args[]) { Test obj = new Test(2, 10); System.out.println("Pre pozivanja obj.a, obj.b: " + obj.a + " " + obj.b); int c = obj.izracunaj(obj); System.out.println("Posle pozivanja obj.a, obj.b: " + obj.a + " " + obj.b); System.out.println("c: " + c); } } Pre pozivanja obj.a, obj.b: 2 10 Posle pozivanja obj.a, obj.b: 6 5 c: 30 27
Objekat kao rezultat metoda • Unutar metoda može da se napravi objekat i da se referenca na taj novi objekat vrati kao rezultat metoda class Test { int a; Test(int i) { a = i; } Test uvecajZaTri() { Test privremeniObj = new Test(a + 3); return privremeniObj; } } 28
14
Primer za objekat koji je rezultat metoda class VracanjeObjekta { public static void main(String args[]) { Test obj1 = new Test(2); Test obj2; obj2 = obj1.uvecajZaTri(); System.out.println("obj1.a: " + obj1.a); System.out.println("obj2.a: " + obj2.a); obj2 = obj2.uvecajZaTri(); System.out.println("Drugo uvećanje obj2.a: " + obj2.a); } } obj1.a: 2 obj2.a: 5 Drugo uvećanje obj2.a: 8 29
15
Rekurzija, upravljanje pristupom, static, final, ...
1
Rekurzija • Rekurzija je pojava kad metod poziva samog sebe • Primer: faktorijel 1! = 1 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)!
2
1
Rekurzivan metod class Faktorijel { // faktorijel je rekurzivan metod int faktorijel(int n) { int rezultat; if(n==1) // uslov za završavanje rekurzivnog pozivanja return 1; rezultat = faktorijel(n-1) * n; return rezultat; } }
• U rekurzivnom metodu mora postojati uslov za završavanje rekurzivnog pozivanja 3
Primer za rekurzivan metod class PrimerRekurzije { public static void main(String args[]) { Faktorijel f = new Faktorijel(); for(int i=1; i<=5; i++) System.out.println(i + "! = " + f.faktorijel(i)); } } 1! = 1 2! = 2 3! = 6 4! = 24 5! = 120 4
2
Iterativno rešenje za faktorijel class FaktorijelIterativni { int faktorijel(int n) { int rezultat = 1; for(int i=n; i>1; i--) rezultat *= i; return rezultat; } }
5
Rekurzivni metodi • Svaki rekurzivan poziv kopira (dodaje) argumente na stek, a argumenti se uklanjaju sa steka kad se metod završi • Kad se zadnji put pozove rekurzivan metod, argumenti svih prethodnih poziva su na steku • Ako postoji veliki broj rekurzivnih poziva može doći do prekoračenja steka, pri čemu se javlja izuzetak • Rekurzivno rešenje može biti sporije od iterativnog ako je broj pozivanja metoda veliki
6
3
Rekurzivni metodi • Neki problemi su takvi da se lakše (prirodnije) rešavaju rekurzivnim metodima, odnosno jednostavniji je kod za rekurzivno nego za iterativno rešenje • Problemi koji po prirodi nisu rekurzivni se takoñe mogu rešiti rekurzivno, npr. ispisivanje elemenata niza
7
Rekurzivno ispisivanje niza class RekIspisNiza { int vrednosti[]; RekIspisNiza(int i) { vrednosti = new int[i]; } // rekurzivan metod za ispisivanje niza void ispisivanjeNiza(int i) { if(i==0) return; else ispisivanjeNiza(i-1); System.out.println("[" + (i-1) + "] = " + vrednosti[i-1]); } }
8
4
Ilustracija rekurzivnog ispisivanja niza class IlustracijaRekurzivnogIspisivanja { public static void main(String args[]) { RekIspisNiza obj = new RekIspisNiza(5); for(int i=0; i<5; i++) obj.vrednosti[i] = i; obj.ispisivanjeNiza(5); } } [0] = 0 [1] = 1 [2] = 2 [3] = 3 [4] = 4 9
Kapsuliranje • Povezivanje podataka i koda koji sa njima radi • Upravljanje pristupom – koji delovi programa mogu da pristupaju članovima klase
10
5
Upravljanje pristupom • Način pristupanja članu klase odreñuje se specifikatorom pristupa • Specifikator pristupa piše se u deklaraciji člana klase ispred specifikatora tipa • Specifikatori pristupa su – public za javni način pristupanja – protected za zaštićeni način pristupanja – private za privatni način pristupanja – bez specifikatora za standardni način pristupanja
11
Specifikatori pristupa • public – član klase je dostupan svim drugim klasama koje je koriste • protected – biće objašnjen kasnije • private – član klase se može koristiti samo unutar svoje klase • standardni način pristupanja – unutar paketa kojem pripada klasa pristup je javan, izvan paketa pristup je onemogućen
12
6
Specifikator pristupa se piše ispred specifikatora tipa public int i; private double j; private int nazivMetoda(int a, char b) { telo_metoda }
13
Ilustracija javnog i privatnog pristupanja class Test { int a; // podrazumevani pristup public int b; // javni pristup private int c; // privatni pristup // postavljanje vrednosti polja c void setC(int i) { c = i; } // dohvatanje vrednosti polja c int getC() { return c; } }
14
7
Ilustracija javnog i privatnog pristupanja class ProbaPristupa { public static void main(String args[]) { Test ob = new Test(); // Poljima a i b se može pristupati direktno ob.a = 10; ob.b = 20; // Polju c se ne može pristupati direktno // Ovo bi bila greška u prevoñenju //ob.c = 100; ob.setC(100); System.out.println("a, b, and c: " + ob.a + " " + ob.b + " " + ob.getC()); } } 15
Popravljena klasa za stek class Stack { private int stck[] = new int[10]; private int vrh; public Stack() { vrh = -1; // Inicijalizacija vrha steka } // Dodavanje jedne vrednosti na stek public void push(int broj) { if(vrh == 9) System.out.println("Stek je popunjen."); else stck[++vrh] = broj; } 16
8
Popravljena klasa za stek – nastavak // Uzimanje jedne vrednosti sa steka public int pop() { if(vrh < 0) { System.out.println("Stek je prazan."); return 0; } else return stck[vrh--]; } }
• Klasa je popravljena tako da se mogu koristiti samo metodi push i pop, tj. ne mogu se direktno menjati vrh i stck 17
Primer rada jednostavne klase za stek class PrimerRadaSteka { public static void main(String args[]) { Stack stack1 = new Stack(); Stack stack2 = new Stack(); // Stavljanje na stek for(int i=0; i<10; i++) stack1.push(i); for(int i=10; i<20; i++) stack2.push(i); // Uzimanje sa steka System.out.println("Stek stack1:"); for(int i=0; i<10; i++) System.out.println(stack1.pop()); System.out.println("Stek stack2:"); for(int i=0; i<10; i++) System.out.println(stack2.pop()); //stack1.vrh = -2; //ove dve naredbe su neispravne, //stack2.stck[3] = 10; //pristupaju privatnim članovima } 18 }
9
Rezervisana reč static • Klasa može imati član koji se može koristiti samostalno, odnosno nezavisan je od objekata • Deklaracija takvih članova sadrži rezervisanu reč static, a članovi se nazivaju statički • Statički članovi mogu biti i podaci i metodi • Statički članovi se mogu koristiti i kad nije napravljen nijedan objekat klase
19
Statički članovi podaci (polja) • Statička polja se ponašaju kao globalne promenljive • Objekat ne sadrži statička polja, tj. pri pravljenju objekta ne rezerviše se prostor za statička polja, već samo za ona koja nisu statička
20
10
Statički metodi • Statički metodi mogu da pristupaju samo statičkim poljima • Statički metodi mogu da pozivaju samo statičke metode • U statičkim metodima ne mogu da se koriste rezervisane reči this i super
21
Primer za statičke članove: objekti imaju redni broj • Potrebno je da se izbroje objekti koji su napravljeni, i da svaki napravljeni objekat ima redni broj: – broj napravljenih objekata je statički član – u konstruktoru se dodeljuje redni broj novom objektu i inkrementira se ukupan broj napravljenih objekata class RedniBroj { private static int broj_objekata = 0; private int id; public RedniBroj() { id = broj_objekata++; } public int id() { return id; } public static int brojObjekata() { return broj_objekata; } }
22
11
Primer: korišćenje objekata koji imaju redni broj class PrimerZaObjekatSaRednimBrojem { public static void main(String[] args) { RedniBroj objA = new RedniBroj(); RedniBroj objB = new RedniBroj(); RedniBroj objC = new RedniBroj(); System.out.println("Ukupan broj objekata: " + RedniBroj.brojObjekata()); System.out.println("objA, RB: " + objA.id()); System.out.println("objB, RB: " + objB.id()); System.out.println("objC, RB: " + objC.id()); } } Ukupan broj objekata: 3 objA, RB: 0 objB, RB: 1 objC, RB: 2
23
Inicijalizacija statičkih promenljivih • Statičko polje se može inicijalizovati prilikom deklaracije • Ako se ne uradi inicijalizacija, statičko polje će imati vrednost 0 • U klasi može postojati statički blok u kojem se mogu inicijalizovati statičke promenljive • Statički blok se izvršava samo jednom, kad se klasa učita prvi put
24
12
Primer za statičke promenljive, blokove i metode class StatickiClanoviM { static int a = 3; static int b; static void statickiMetod(int x) { System.out.println("x = " + x); System.out.println("a = " + a); System.out.println("b = " + b); } static { System.out.println("Statički blok je izvršen."); b = a * 2; } public static void main(String args[]) { statickiMetod(10); } }
25
Rezultat izvršavanja klase StatickiClanoviM Statički blok je izvršen. x = 10 a=3 b=6
26
13
Drugi primer za statičke članove public class StatickiClanovi { StatickiClanovi() { System.out.println("Konstruktor izvršen."); } int i; static int a = 3; static int b; static void statickiMetod(int x) { System.out.println("x = " + x); System.out.println("a = " + a); System.out.println("b = " + b); } static { System.out.println("Statički blok izvršen."); } }
27
Ilustracija rada drugog primera za statičke članove public class IlustracijaStatic { public static void main(String[] args) { StatickiClanovi sc1; System.out.println("Prvo ispisivanje."); sc1 = new StatickiClanovi(); //Ovde se prvo izvrši statički blok System.out.println("sc1.i = " + sc1.i); StatickiClanovi sc2 = new StatickiClanovi(); sc2.i = 8; System.out.println("sc2.i = " + sc2.i); } } Prvo ispisivanje. Statički blok izvršen. Konstruktor izvršen. sc1.i = 0 Konstruktor izvršen. sc2.i = 8
28
14
Pristupanje statičkim članovima • Statičkim članovima se može pristupati pre nego što je napravljen objekat klase • Javnim statičkim članovima se pristupa preko imena klase i operatora tačka . • Statičkim članovima se može pristupati i preko reference na objekat, ali to treba izbegavati – kada se članu pristupa preko imena klase jasno je da se pristupa statičkom članu – kada se statičkom članu pristupa preko reference nije odmah uočljivo da li je član statički ili ne
29
Pristupanje statičkom metodu preko imena klase public class PristupanjePrekoImenaKlase { public static void main(String[] args) { StatickiClanovi.statickiMetod(5); StatickiClanovi.statickiMetod(10); } }
Statički blok izvršen. x=5 a=3 b=0 x = 10 a=3 b=0 30
15
Rezervisana reč final • Može se specificirati da se vrednost promenljive ne može promeniti, tj. promenljiva je u stvari konstanta • Za ovo se koristi rezervisana reč final • 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, a značenje će biti objašnjeno kasnije
31
Dužina niza • Nizovi se realizuju kao objekti • Svi nizovi imaju polje length čija vrednost pokazuje koliko elemenata ima niz
32
16
Ilustracija dužine niza class DuzinaNiza { public static void main(String args[]) { int a1[] = new int[10]; int a2[] = {3, 5, 7, 1, 8, 99, 44, -10}; int a3[] = {4, 3, 2, 1}; System.out.println("Dužina niza a1 je " + a1.length); System.out.println("Dužina niza a2 je " + a2.length); System.out.println("Dužina niza a3 je " + a3.length); } }
Dužina niza a1 je 10 Dužina niza a2 je 8 Dužina niza a3 je 4 33
Popravljanje klase Stek • Primer za klasu stek koja je ranije korišćena može da se popravi tako što se omogući pravljenje steka zadate veličine • Veličina steka treba da bude parametar konstruktora • Koristi se polje length koje sadrži dužinu niza
34
17
Popravljena klasa za stek – stek različite dužine class Stack { private int stck[]; private int vrh; public Stack(int velicina) { stck = new int[velicina]; vrh = -1; } // Dodavanje jedne vrednosti na stek public void push(int broj) { if(vrh == stck.length-1) System.out.println("Stek je popunjen."); else stck[++vrh] = broj; } 35
Popravljena klasa za stek – nastavak // Uzimanje jedne vrednosti sa steka public int pop() { if(vrh < 0) { System.out.println("Stek je prazan."); return 0; } else return stck[vrh--]; } }
• U odnosu na prethodu verziju, klasa je popravljena tako da se može napraviti stek proizvoljnog kapaciteta • Kapacitet je parametar konstruktora, a u prethodnoj verziji kapacitet je bio 10) 36
18
Primer rada jednostavne klase za stek class PrimerRadaSteka { public static void main(String args[]) { Stack stack1 = new Stack(5); Stack stack2 = new Stack(8); // Stavljanje na stek for(int i=0; i<5; i++) stack1.push(i); for(int i=0; i<8; i++) stack2.push(i); // Uzimanje sa steka System.out.println("Stek stack1:"); for(int i=0; i<5; i++) System.out.println(stack1.pop()); System.out.println("Stek stack2:"); for(int i=0; i<8; i++) System.out.println(stack2.pop()); } }
37
Ugnježdene klase • Unutar jedne klase (klasa A) može da se definiše druga klasa (klasa B), i tada je klasa B ugnježdena u klasu A, a klasa A je obuhvatajuća klasa • Za ugnježdenu klasu zna samo obuhvatajuća klasa – ugnježdena klasa se ne može koristiti izvan obuhvatajuće klase
• Ugnježdena klasa može da pristupa svim članovima obuhvatajuće klase, čak i privatnim članovima • 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 pristupa 38
19
Vrste ugnježdenih klasa • Ugnježdena klasa može biti statička – Statička ugnježdena klasa se retko koristi – Ne može direktno da pristupa poljima obuhvatajuće klase, već samo preko reference (objekta)
• Ugnježdena klasa koja nije statička naziva se unutrašnja klasa – Unutrašnja klasa može da pristupa poljima i metodima obuhvatajuće klase direktno preko imena polja i metoda kao što se radi i u obuhvaćenoj klasi
39
Primer unutrašnje klase class Spoljasnja { int sp_x = 100; void prikaziUnutrasnju() { Unutrasnja un = new Unutrasnja(); un.prikazi(); } // Unutrašnja klasa class Unutrasnja { int un_y = 10; void prikazi() { System.out.println("sp_x = " + sp_x); } } // kraj unutrašnje klase void prikaziY() { Unutrasnja un = new Unutrasnja(); System.out.println("un_y = "+un.un_y); //Greška u prevoñenju } }
40
20
Ilustracija korišćenja klase Spoljasnja class PrimerSpoljasnja { public static void main(String args[]) { Spoljasnja spoljasnja = new Spoljasnja(); spoljasnja.prikaziUnutrasnju(); } }
sp_x = 100
41
Unutrašnje klase u bloku • Unutrašnja klasa može da se definiše i unutar bilo kojeg metoda ili bloka spoljašnje klase • Oblast važenja unutrašnje klase je blok u kojem je definisana
42
21
Korišćenje ugnježdenih klasa • Ugnježdene klase nisu postojale u verziji Java 1.0, uvedene su u verziji 1.1 • Ugnježdene klase se koriste u apletima
43
Osnovno o klasi String • • • •
Klasa String je ugrañena u Javu Služi za rad sa znakovnim nizovima Svi znakovni nizovi su objekti klase String Objekti tipa String su nepromenljivi – Postojećem objektu tipa String ne može da se promeni znak na nekoj poziciji – Pravi se novi znakovni niz sa potrebnim sadržajem
44
22
Znakovni niz i niz znakova • Znakovni niz je objekat klase String • Niz znakova je niz elemenata tipa char • Primer za niz znakova char niz_znakova1[] = new char[5]; • Primer inicijalizacije niza znakova char niz_znakova2[] = {'a', 'b', 'c', '3'}; • Primer inicijalizacije znakovnog niza String znakovni_niz1 = "abc3";
45
Operator + za znakovne nizove • Služi za nadovezivanje (konkatenaciju) znakovnih nizova, tj. objekata tipa String • Rezultat je novi objekat tipa String čiji je sadržaj dobija spajanjem sadržaja dva objekta tipa String • Primeri: String String String String String
str1 str2 str3 str4 str5
= = = = =
"prvi " + "drugi"; "prvi drugi"; "prvi "; "drugi"; str3 + str4;
46
23
Primer nadovezivanja znakovnih nizova class PrimerZaString1 { public static void main(String args[]) { String strObj1 = "Prvi znakovni niz"; String strObj2 = "Drugi znakovni niz"; String strObj3 = strObj1 + " i " + strObj2; System.out.println(strObj1); System.out.println(strObj2); System.out.println(strObj3); } }
Prvi znakovni niz Drugi znakovni niz Prvi znakovni niz i Drugi znakovni niz
47
Neki metodi klase String • Metod za proveru da li dva znakovna niza imaju isti sadržaj boolean equals(String objekat) • Metod koji vraća dužinu znakovnog niza int length() – Napomena: nizovi imaju polje length
• Metod koji vraća znak sa zadate pozicije char charAt(int indeks)
48
24
Primer za metode znakovnog niza class PrimerZaString4 { public static void main(String args[]) { String obj = "Prvi znakovni niz"; System.out.println("Dužina obj je " + obj.length()); System.out.println("Znak na poziciji 0 u obj je: " + obj.charAt(0)); System.out.println("Znak na poziciji 2 u obj je: " + obj.charAt(2)); System.out.println("Znak na poslednjoj poziciji " + (obj.length()-1) + " u obj je: " + obj.charAt(obj.length()-1)); } }
Znak na poziciji 0 u obj je: ? Znak na poziciji 2 u obj je: ? Znak na poslednjoj poziciji 16 u obj je: ?
49
Primer za metode znakovnog niza class PrimerZaString2 { public static void main(String args[]) { String obj1 = "Prvi znakovni niz"; String obj2 = "Drugi znakovni niz"; String obj3 = obj1; // obj1 i obj3 ukazuju na isti objekat if(obj1.equals(obj2)) System.out.println("obj1 i obj2 su jednaki"); else System.out.println("obj1 i obj2 su različiti"); if(obj1.equals(obj3)) System.out.println("obj1 i obj3 su jednaki"); else System.out.println("obj1 i obj3 su različiti"); } } obj1 i obj2 su različiti obj1 i obj3 su jednaki
50
25
Neki konstruktori klase String • Klasa String ima više konstruktora meñu kojima su i sledeći: – Podrazumevani konstuktor
String() – Konstruktor čiji je parametar objekat tipa String
String(String objekat) – Konstruktor čiji je parametar niz znakova
String(char niz_znakova[])
51
Primer: poreñenje objekata i referenci class PrimerZaString3 { public static void main(String args[]) { String obj1 = "Prvi znakovni niz"; String obj2 = obj1; // obj1 i obj2 ukazuju na isti objekat String obj3 = new String(obj1); System.out.println("Reference obj1 i obj2 ukazuju na isti objekat: " + (obj1 == obj2)); System.out.println("Reference obj1 i obj3 ukazuju na isti objekat: " + (obj1 == obj3)); 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 Objekti na koje ukazuju reference obj1 i obj3 su jednaki: true
52
26
Argumenti u komandnoj liniji class KomandnaLinija { public static void main(String args[]) { for(int i=0; i
27
Nasleñivanje
1
Nasleñivanje • Za grupu srodnih pojava može da se napravi klasa u kojoj su sve zajedničke karakteristike srodnih pojava • Primer: vozila • Specifičnije klase, za svaku od srodnih pojava, mogu da se izvedu iz opštije kase i da naslede sve njene 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 2
1
Primer izvoñenja (nasleñivanja) class A { int i, j; void prikaziIJ() { System.out.println("i, j: } }
" + i + "
" + j);
// potklasa B se izvodi iz klase A class B extends A { int k; void prikaziK() { System.out.println("k: " + k); } void PrikaziZbir() { System.out.println("i+j+k: " + (i+j+k)); } }
3
Pravljenje objekata klasa A i B A objA = new A(); objA
i j
Klasa A (objekat klase A) ima dva polja: i, j
B objB = new B(); objB
Klasa B (objekat klase B) ima tri polja: i, j, k (i, j su nasleñena iz klase A)
i j k
4
2
Primer za nasleñivanje class PrimerNasledjivanja { public static void main(String A objA = new A(); B objB = new B(); objA.i = 10; objA.j = 20; objB.i = 7; objB.j = 8; System.out.println("Sadržaj objA.prikaziIJ(); System.out.println(); System.out.println("Sadržaj objB.prikaziIJ(); objB.prikaziK(); System.out.println(); System.out.println("Zbir i, objB.prikaziZbir(); } }
args[]) {
objB.k = 9; objA: ");
objB: ");
j, k iz objB:");
5
Rezultat izvršavanja PrimerNasledjivanja Sadržaj objA: i, j: 10 20 Sadržaj objB: i, j: 7 8 k: 9 Zbir i, j, k iz objB: i+j+k: 24
6
3
Kontrola pristupa i nasleñivanje • Potklasa ne može pristupati privatnim članovima natklase
7
Primer class A { int i; private int j; void postaviIJ(int x, int y) { i = x; j = y; } } class B extends 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 8
4
Primer nasleñivanja sa klasom Kutija • Klasa Kutija će biti osnovna klasa (natklasa) • Iz klase Kuija će biti izvedene dve klase, KutijaSaTezinom i ObojenaKutija – Klasa KutijaSaTezinom će naslediti klasu Kutija, i imaće dodatno polje tezina – Klasa ObojenaKutija će naslediti klasu Kutija, i imaće dodatno polje boja
9
Klasa Kutija class Kutija { double sirina, visina, duzina; // Konstruktor čiji je parametar objekat, ovde služi za kopiranje objekta Kutija(Kutija obj) { sirina = obj.sirina; visina = obj.visina; duzina = obj.duzina; } // Konstruktor bez parametara Kutija() { } // Konstruktor sa parametrima za sve tri dimenzije Kutija(double s, double v, double d) { sirina = s; visina = v; duzina = d; } 10
5
Klasa Kutija – nastavak // Konstruktor sa jednim parametrom (kutija je kocka) Kutija(double stranica) { sirina = visina = duzina = stranica; } // Metod za postavljanje vrednosti polja (dimenzija kutije) void postaviDimenzije(double s, double v, double d){ sirina = s; visina = v; duzina = d; } // Metod za izračunavanje zapremune kutije double zapremina() { return sirina * visina * duzina; } } 11
Kutija sa težinom – potklasa klase Kutija class KutijaSaTezinom extends Kutija { double tezina; KutijaSaTezinom(double s, double v, double d, double t) { sirina = s; visina = v; duzina = d; tezina = t; } }
12
6
Primer za kutiju sa težinom class PrimerZaKutijuSaTezinom1 { public static void main(String args[]) { KutijaSaTezinom kt1 = new KutijaSaTezinom(1,2,5,3.3); KutijaSaTezinom kt2 = new KutijaSaTezinom(2,3,4,0.01); System.out.println("Zapremina kt1: " + kt1.zapremina()); System.out.println("Težina kt1: " + kt1.tezina); System.out.println(); System.out.println("Zapremina kt2: " + kt2.zapremina()); System.out.println("Težina kt2: " + kt2.tezina); } } Zapremina kt1: ? Težina kt1: ? Zapremina kt2: ? Težina kt2: ?
13
Konstruktor klase KutijaSaTezinom je loše napisan •
Konstruktor potklase KutijaSaTezinom je KutijaSaTezinom(double s, double v, double d, sirina = s; visina = v; duzina = d; tezina = t;
double t){
}
•
Konstruktor natklase Kutija je Kutija(double s, double v, double d) { sirina = s; visina = v; duzina = d; }
•
Bolje je da konstruktor podklase KutijaSaTezinom pozove konstruktor klase Kutija nego da ponavlja sve naredbe koje već postoje u konstruktor klase Kutija. 14
7
Rezervisana reč super • Konstruktor natklase se poziva pomoću rezervisane reči super • Pomoću rezervisane reči super može se pristupiti članu natklase koji je sakriven članom potklase
15
Popravljena klasa KutijaSaTezinom class KutijaSaTezinom extends Kutija { double tezina; KutijaSaTezinom(double s, double v, double d, double t) { super(s, v, d); tezina = t; } }
16
8
Pozivanje konstruktora natklase • Opšti oblik je super(lista_argumenata); • Ako se u konstruktoru potklase poziva konstruktor natklase, taj poziv mora biti prva naredba u konstruktoru potklase – Primer kad nijedan konstruktor nema parametre ImePotklase() { // konstruktor potklase super(); // pozivanje konstruktora natklase ... } • Pošto se konstruktori mogu preklapati, metoda super() se može pozvati na bilo koji način koji je definisan natklasom.
17
Referenciranje objekta potklase • Promenljivoj natklase može se dodeliti referenca na objekat bilo koje potklase izvedene iz te natklase
18
9
Primer referenciranja objekta potklase class A { int i, j; } class B extends A { int k; }
19
Primer referenciranja objekta potklase A refA = new A(); B refB = new B();
refA
i j
refB
i j k
refA = refB; • •
•
Referenca natklase A (refA) može ukazivati na objekat potklase B Preko refA može se pristupiti samo poljima i, j pošto refA zna samo za članove koji su definisani u klasi A Polju k se ne može pristupiti preko refA zato što je to polje definisano u klasi B
refA
i j
refB
i j k 20
10
Referenca potklase ne može ukazivati na objekat natklase A refA = new A(); B refB = new B();
refA
i j
refB
i j k
refB = refA; // Greška •
Referenca potklase B zna za polje k (može da pristupi polju k), a to polje ne postoji u objektu klase A, pa zato referenca potklase B ne može ukazivati na objekat natklase A
refA
i j
refB
i j k 21
Primer za referenciranje objekta potklase class PrimerReferenciranja { public static void main(String args[]) { Kutija refK = new Kutija(2, 4, 5); KutijaSaTezinom refKST = new KutijaSaTezinom(2,3,4,0.1); System.out.println("Zapremina kutije: " + refK.zapremina()); System.out.println(); System.out.println("Zapremina kutije sa težinom: " + refKST.zapremina()); System.out.println("Težina kutije sa težinom: " + refKST.tezina); System.out.println(); refK = refKST; //referenca natklase refK ukazuje na objekat potklase System.out.println("Zapremina: " + refK.zapremina()); // Greška: referenca natklase ne zna za članove definisane u potklasi //System.out.println("Težina: " + refK.tezina); } 22 }
11
Rezultat izvršavanja primera za referenciranje Zapremina kutije: 40.0 Zapremina kutije sa težinom: 24.0 Težina kutije sa težinom: 0.1 Zapremina: 24.0
23
Klasa KutijaSaTezinom sa više konstruktora class KutijaSaTezinom extends Kutija { double tezina; // Konstruktor čiji je parametar objekat KutijaSaTezinom(KutijaSaTezinom obj) { // Objekat klase KutijaSaTezinom može da se prosledi // konstruktoru klase Kutija čiji je parametar tipa Kutija super(obj); tezina = obj.tezina; } // Konstruktor bez parametara KutijaSaTezinom() { // Ako se ne navede, poziva se konstruktor bez parametara //super(); } 24
12
Klasa KutijaSaTezinom – nastavak // Konstruktor sa parametrima za sva polja natklase i potklase KutijaSaTezinom(double s, double v, double d, double t) { super(s, v, d); tezina = t; } // Konstruktor za kutiju u obliku kocke KutijaSaTezinom(double stranica, double t) { super(stranica); tezina = t; } }
25
Primer za kutiju sa težinom class PrimerZaKutijuSaTezinom2 { public static void main(String args[]) { KutijaSaTezinom kt1 = new KutijaSaTezinom(1,2,5,3.3); KutijaSaTezinom kt2 = new KutijaSaTezinom(); KutijaSaTezinom kt3 = new KutijaSaTezinom(2, 3); KutijaSaTezinom kt4 = new KutijaSaTezinom(kt1); System.out.println("Zapremina kt1: " + kt1.zapremina()); System.out.println("Težina kt1: " + kt1.tezina + "\n"); System.out.println("Zapremina kt2: " + kt2.zapremina()); System.out.println("Težina kt2: " + kt2.tezina+ "\n"); System.out.println("Zapremina kt3: " + kt3.zapremina()); System.out.println("Težina kt3: " + kt3.tezina+ "\n"); System.out.println("Zapremina kt4: " + kt4.zapremina()); System.out.println("Težina kt4: " + kt4.tezina+ "\n"); } } 26
13
Rezultat izvršavanja primera za kutiju sa težinom Zapremina kt1: 10.0 Težina kt1: 3.3 Zapremina kt2: 0.0 Težina kt2: 0.0 Zapremina kt3: 8.0 Težina kt1: 3.0 Zapremina kt4: 10.0 Težina kt4: 3.3
27
Primer pristupanja članu natklase class A { int i; } class B extends A { int i; // novo polje, ima isto ime kao i nasleñeno polje iz klase A B(int a, int b) { super.i = a; // polje i iz klase A i = b; // polje i iz klase B } void prikazi() { System.out.println("i iz natklase: " + super.i); System.out.println("i iz potklase: " + i); } } • Polje i u klasi B sakriva nasleñeno polje i iz klase A
28
14
Primer pristupanja članu natklase – nastavak class PrimerPristupanja { public static void main(String args[]) { B obj = new B(1, 2); obj.prikazi(); } }
i iz natklase: 1 i iz potklase: 2
29
Pristupanje članu natklase • Rezervisana reč super se koristiti za pristupanje članu, slično kao i rezervisana reč this, ali je razlika u tome što rezervisana reč super ukazuje na natklasu • Primer: super.član; // član je polje ili metod natklase • Članovima natklase se pristupa pomoću rezervisane reči super kad su članovi natklase sakriveni članovima potklase, tj. kad članovi natklase i potklase imaju ista imena
30
15
Višestepena hijerarhija class A { ... } class B extends A { ... } class C extends B { ... } • Klasa C je nasledila sve članove iz klase B, što znači da je nasledila i članove klase A • Referenca klase A može da ukazuje na objekte klasa A, B i C 31
Primer: klasa Isporuka • Iz klase KutijaSaTezinom može se dalje izvesti klasa Isporuka koja ima polje troskovi • Na dijagramu su prikazane klasa za ovaj primer sa svojim poljima
Kutija sirina visina duzina
KutijaSaTezinom tezina
Isporuka troskovi
32
16
Klasa Kutija public class Kutija { private double sirina, visina, duzina; public Kutija() {} public Kutija(Kutija obj) { sirina = obj.sirina; visina = obj.visina; duzina = obj.duzina; } public Kutija(double s, double v, double d) { sirina = s; visina = v; duzina = d; } public Kutija(double stranica) { sirina = visina = duzina = stranica; }
33
Klasa Kutija – nastavak public void postaviDimenzije(double s, double v, double d) { sirina = s; visina = v; duzina = d; } public double sirina() { return sirina; } public double visina() { return visina; } public double duzina() { return duzina; } public double zapremina() { return sirina * visina * duzina; } public String toString() { return "sirina " + sirina + ", visina " + visina + ", duzina " + duzina; } }
34
17
Klasa KutijaSaTezinom public class KutijaSaTezinom extends Kutija { private double tezina; public KutijaSaTezinom() { } public KutijaSaTezinom(KutijaSaTezinom obj) { super(obj); //samo sirina, visina, duzina iz nadklase 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; }
35
Klasa KutijaSaTezinom – nastavak public double tezina() { return tezina; } public void postaviTezinu(double t) { tezina = t; } public String toString() { return super.toString() + ", tezina " + tezina; }
}
36
18
Klasa Isporuka public class Isporuka extends KutijaSaTezinom { private double troskovi; public Isporuka() { } public Isporuka(Isporuka obj) { super(obj); troskovi = obj.troskovi; } public Isporuka(double s, double v, double d, double t, double tr) { super(s, v, d, t); troskovi = tr; } public Isporuka(double stranica, double t, double tr) { super(stranica, t); troskovi = tr; 37 }
Klasa Isporuka – nastavak public double troskovi() { return troskovi; } public void postaviTroskove(double tr) { troskovi = tr; } public String toString() { return super.toString() + ", troskovi " + troskovi; }
}
38
19
Primer za klasu Isporuka class PrimerZaIsporuku { public static void main(String args[]) { Isporuka is1 = new Isporuka(1, 2, 5, 3.3, 81.2); Isporuka is2 = new Isporuka(2, 1.1, 2.2); Isporuka is3 = new Isporuka(is1); System.out.println("Zapremina is1: " + is1.zapremina()); System.out.println("Težina is1: " + is1.tezina()); System.out.println("Troškovi is1: " + is1.troskovi()); System.out.println(); System.out.println("Zapremina is2: " + is2.zapremina()); System.out.println("Težina is2: " + is2.tezina()); System.out.println("Troškovi is2: " + is2.troskovi()); System.out.println(); System.out.println("Zapremina is3: " + is3.zapremina()); System.out.println("Težina is3: " + is3.tezina()); System.out.println("Troškovi is3: " + is3.troskovi()); } 39 }
Rezultat izvršavanja primera za isporuku Zapremina is1: 10.0 Težina is1: 3.3 Troškovi is1: 81.2 Zapremina is2: 8.0 Težina is2: 1.1 Troškovi is2: 2.2 Zapremina is3: 10.0 Težina is3: 3.3 Troškovi is3: 81.2
40
20
Redosled pozivanja konstruktora • Konstruktor natklase se izvršava pre konstruktora potklase • Ako se poziva konstruktor natklase, pozivanje metoda super mora biti prva naredba u konstruktoru potklase • Ako se u konstruktoru potklase ne poziva metod super tada će biti pozvan podrazumevani konstruktor natklase, ili odgovarajući konstruktor bez argumenata koji će se izvršiti prvi
41
Ilustracija redosleda pozivanja konstruktora class A { A() { System.out.println("Izvršen konstruktor klase A"); } } class B extends A { B() { System.out.println("Izvršen konstruktor klase B"); } } class C extends B { C() { System.out.println("Izvršen konstruktor klase C"); } } class RedosledIzvrsavanjaKonstruktora { public static void main(String args[]) { C c = new C(); } } Izvršen konstruktor klase A Izvršen konstruktor klase B Izvršen konstruktor klase C
42
21
Redefinisanje metoda • U potklasi može da se napiše metod koji ima isto ime i istu listu parametara (broj i tip parametara) kao i metod natklase, i to se naziva redefinisanje metoda natklase (overriding) • Kad se u potklasi pozove redefinisani metod izvršava se metod potklase tj. metod definisan u potklasi • Ako metod potklase ima isto ime kao i metod natklase, a razlikuje se lista parametara, to je preklapanje (overloading) metoda a ne redefinisanje
43
Primer redefinisanja metoda class A { int i, j; A(int x, int y) { i = x;
j = y; }
void prikazi() { System.out.println("i, j: " + i + " }
" + j);
} class B extends A { int k; B(int x, int y, int z) { super(x, y); k=z; } void prikazi() { System.out.println("k: " + k); } }
44
22
Primer redefinisanja metoda class PrimerRedefinisanja { public static void main(String args[]) { B obj = new B(1, 2, 3); obj.prikazi(); // poziva se metod prikazi iz klase B A objA = new A(5, 6); objA.prikazi(); // poziva se metod prikazi iz klase A } } k: 3 i, j: 5 6
45
Pristupanje redefinisanom metodu natklase • Redefinisani metod natklase je sakriven u potklasi, tj. ne može mu se pristupiti direktno preko imena • Redefinisanom metodu natklase se može pristupiti pomoću rezervisane reči super • Primer pozivanja redefinisanog metoda natklase: super.imeRedefinisanogMetoda(lista_argumenata)
46
23
Popravljena potklasa B iz primera za redefinisanje class A { int i, j; A(int x, int y) { i = x;
j = y; }
void prikazi() { System.out.println("i, j: " + i + " }
" + j);
} class B extends A { int k; B(int x, int y, int z) { super(x, y);
k = z; }
void prikazi() { super.prikazi(); System.out.println("k: " + k); } }
47
Primer redefinisanja sa popravljenom klasom B class PrimerRedefinisanja { public static void main(String args[]) { B obj = new B(1, 2, 3); obj.prikazi(); // poziva se metod prikazi iz klase B A objA = new A(5, 6); objA.prikazi(); // poziva se metod prikazi iz klase A } } i, j: 1 2 k: 3 i, j: 5 6
48
24
Primer za preklapanje metoda class A { int i, j; A(int x, int y) { i = x;
j = y; }
void prikazi() { System.out.println("i, j: " + i + " }
" + j);
} class B extends A { int k; B(int x, int y, int z) { super(x, y);
k = z; }
void prikazi(String tekst) { if(tekst.length() == 0) tekst = "k: "; System.out.println(tekst + k); } }
49
Primer preklapanja class PrimerPreklapanja { public static void main(String args[]) { B obj = new B(1, 2, 3); // Pozivanje metoda definisanog u klasi A obj.prikazi(); // Pozivanje preklopljenog metoda u klasi B obj.prikazi("Vrednost k je: "); obj.prikazi(""); } } i, j: 1 2 Vrednost k je: 3 k: 3 50
25
Dinamičko razrešavanje metoda pri izvršavanju • Referenca natklase može da ukazuje na objekat potklase • Ako se redefinisani metod poziva referenciranjem iz natklase, u trenutku pozivanja se odreñuje koji se metod poziva na osnovu tipa objekta na koji referenca trenutno ukazuje • Drugačije, tip referenciranog objekta odreñuje koji će metod biti pozvan, a ne tip reference koja ukazuje na objekat • Ovo ponašanje se naziva polimorfizam – postoji jedan način pristupa, a može se pozvati više različitih metoda 51
Ilustracija dinamičkog razrešavanja class A { void prikazi() { System.out.println("Izvršen metod klase A"); } } class B extends A { void prikazi() { System.out.println("Izvršen metod klase B"); } } class C extends B { void prikazi() { System.out.println("Izvršen metod klase C"); } }
52
26
Ilustracija dinamičkog razrešavanja class DinamickoRazresaanje { public static void main(String args[]) { A a = new A(); // objekat klase A B b = new B(); // objekat klase B C c = new C(); // objekat klase C A ref; // referenca na objekat klase A; // ovde je definisan tip reference! 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 } I}zvršen metod klase A Izvršen metod klase B Izvršen metod klase C
53
Redefinisanje metoda • Omogućava polimorfizam u trenutku izvršavanja (preklapanje metoda to čini u vreme kompajliranja!) • Omogućava da se u opštoj klasi definišu svi metodi koje treba da imaju objekti izvedenih klasa od kojih će neki biti redefinisani u izvedenim klasama
54
27
Primer sa redefinisanjem metoda public class GeometrijskaSlika { public double obim() { return 0; } // Loše napisan metod public double povrsina() { return 0; } // Takoñe i ovaj } public class Trougao extends GeometrijskaSlika { private double a, b, c; public Trougao(double a_, double b_, double c_) { a = a_; b = b_; c = c_; } public double obim() { return a + b + c; } public double povrsina() { double s = (a + b + c)/2; return Math.sqrt(s*(s-a)*(s-b)*(s-c)); } } 55
Primer sa redefinisanjem metoda - nastavak public class Kvadrat extends GeometrijskaSlika { private double a; public Kvadrat(double a_) { a = a_; } public double obim() { return 4 * a; } public double povrsina() { return a * a; } } public class Krug extends GeometrijskaSlika { private double r; public Krug(double r_) { r = r_; } public double obim() { return 2 * Math.PI * r; } public double povrsina() { return Math.PI * r*r; } } 56
28
Primer sa redefinisanjem metoda - nastavak public class PrimerGeometrijskeSlike { public static void main(String[] args) { Trougao tr = new Trougao(3, 4, 5); Krug kr = new Krug(1); Kvadrat kv = new Kvadrat(10); GeometrijskaSlika slike[] = new GeometrijskaSlika[3]; slike[0] = tr; slike[1] = kr; slike[2] = kv; 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()); } } } 57
Primer sa redefinisanjem metoda – rezultat i: 0, obim: 12.0 i: 0, površina: 6.0 i: 1, obim: 6.283185307179586 i: 1, površina: 3.141592653589793 i: 2, obim: 40.0 i: 2, površina: 100.0
58
29
Lepše napisan poslednji primer public class PrimerGeometrijskeSlike { public static void main(String[] args) { GeometrijskaSlika slike[] = new GeometrijskaSlika[3]; slike[0] = new Trougao(3, 4, 5); slike[1] = new Krug(1); slike[2] = new Kvadrat(10); 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()); } } } 59
Apstraktne klase • Č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 • Takoñe treba obezbediti da potklase moraju da redefinišu metod • Ovo se obezbeñuje pomoću apstraktnog metoda, tj. korišćenjem modifikatora abstract • Apstraktni metod nema telo • Opšti oblik deklaracije apstraktnog metoda je abstract tip imeMetoda(listaParametara);
60
30
Apstraktne klase • Klasa koja ima bar jedan apstraktan metod je apstraktna klasa • Deklaracija apstraktne klase mora imati modifikator abstract • • • •
Apstraktna klasa može imati metode koji nisu apstraktni Apstraktna klasa može imati članove podatke Ne može se napraviti objekat apstraktne klase U potklasi apstraktne klase za koju treba instancirati objekte moraju biti redefinisani svi apstraktni metodi • Može se koristiti referenca apstraktne klase i ona može referencirati objekte svih potklasa 61
Popravljanje primera sa geometrijskim slikama • U prethodnom primeru nije dobro napisana klasa GeometrijskaSlika, jer: – u njoj su definisani metodi za izračunavanje obima i površine iako ta klasa ne zna ništa o tome kako će se izračunavati obim i površina u potklasama – potklase ne moraju da redefinišu metode za izračunavanje obima i površine, a greška je ako se to ne uradi – može se napraviti objekat tipa GeometrijskaSlika iako nema smisla da postoji takav objekat
• Rešenje je da klasa GeometrijskaSlika bude apstraktna, i da oba metoda (obim i povrsina) budu apstraktni 62
31
Popravljanje primera sa geometrijskim slikama public abstract class GeometrijskaSlika { public abstract double obim(); public abstract double povrsina(); }
• Ostale klase iz prethodnog primera (Trougao, Kvadrat i Krug) ostaju nepromenjene
63
Popravljanje primera sa geometrijskim slikama public class PrimerGeometrijskeSlike { public static void main(String[] args) { // Može se deklarisati referenca apstraktne klase, // i može se napraviti niz referenci apstraktne klase GeometrijskaSlika slike[] = new GeometrijskaSlika[3]; slike[0] = new Trougao(3, 4, 5); slike[1] = new Krug(1); slike[2] = new Kvadrat(10); 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()); } } } 64
32
Rezervisana reč final • Ima tri namene: – služi za deklarisanje konstanti – sprečava redefinisanje metoda – sprečava izvoñenje iz klase
65
Sprečavanje redefinisanja metoda class A { final void prikazi() { System.out.println("Ne može se redefinisati."); } } class B extends A { void prikazi() { // Greška, metod se ne može redefinisati System.out.println("Pogrešno!"); } }
66
33
Sprečavanje redefinisanja metoda • Pošto se metodi označeni modifikatorom final ne mogu redefinisati prevodilac može umesto poziva metoda da doda ceo bajt kod metoda • Prevodilac ovo radi samo za kratke metode • Ovaj postupak se naziva inlining
67
Sprečavanje izvoñenja final class A { // ... }
// Klasa A ne može imati podklase
class B extends A { // ... }
// Greška! Ne može se izvoditi iz klase A
• Ako je klasa označena modifikatorom final, i svi njeni metodi postaju final
68
34
Primer sa redefinisanjem metoda public abstract class GeometrijskaSlika { public abstract double obim(); public abstract double povrsina(); } public class Krug extends GeometrijskaSlika { private double r; public Krug(double r_) { r = r_; } public double r() { return r; } public double obim() { return 2 * Math.PI * r; } public double povrsina() { return Math.PI * r*r; } public String toString() { return "Krug: poluprečnik=" + r + ", obim=" + obim() + ", površina=" + povrsina(); } } 69
Primer sa redefinisanjem metoda public class Trougao extends GeometrijskaSlika { private double a, b, c; public Trougao(double a_, double b_, double c_) { a = a_; b = b_; c = c_; } public double a() { return a; } public double b() { return b; } public double c() { return c; } public double obim() { return a + b + c; } public double povrsina() { double s = (a + b + c)/2; return Math.sqrt(s*(s-a)*(s-b)*(s-c)); } public String toString() { return "Trougao: stranice a=" + a + ", b=" + b + ", c=" + c + ", obim=" + obim() + ", površina=" + povrsina(); } 70 }
35
Primer sa redefinisanjem metoda - nastavak public class Kvadrat extends GeometrijskaSlika { private double a; public Kvadrat(double a_) { a = a_; } public double a() { return a; } public double obim() { return 4 * a; } public double povrsina() { return a * a; } public String toString() { return "Kvadrat: stranica a=" + a + ", obim=" + obim() + ", površina=" + povrsina(); } }
71
Primer sa geometrijskim slikama public class PrimerGeometrijskeSlike { public static void main(String[] args) { GeometrijskaSlika slike[] = new GeometrijskaSlika[3]; slike[0] = new Trougao(3, 4, 5); slike[1] = new Krug(1); slike[2] = new Kvadrat(10); for(int i=0; i<3; i++) System.out.println(slike[i]); } }
72
36
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
73
Klasa Object • Klasa Object je natklasa svih klasa u Javi • Referenca tipa Object može da referencira objekte svih ostalih klasa
74
37
Metodi klase Object protected native Object clone() public boolean equals(Object obj) protected void finalize() public final native Class getClass() protected native int hashCode() public final native void notify() 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 objekat prevodi u String 75
Primer korišćenja metoda toString class PrimerZaMetodToString { public static void main(String args[]) { Kutija kutija = new Kutija(1, 2, 5); KutijaSaTezinom kutija_sa_tezinom = new KutijaSaTezinom(2, 3, 4, 1.1); Isporuka isporuka = new Isporuka(2, 2, 3, 10.1, 5.2); Isporuka kopija = new Isporuka(isporuka); System.out.println("Kutija: " + kutija.toString()); System.out.println("Kutija sa težinom: " + kutija_sa_tezinom.toString()); System.out.println("Isporuka: " + isporuka.toString()); System.out.println("Kopija: " + kopija.toString()); } } Kutija: sirina 1.0, visina 2.0, duzina 5.0 Kutija sa težinom: sirina 2.0, visina 3.0, duzina 4.0, tezina 1.1 Isporuka: sirina 2.0, visina 2.0, duzina 3.0, tezina 10.1, troskovi 1.1 Kopija: sirina 2.0, visina 2.0, duzina 3.0, tezina 10.1, troskovi 1.1
76
38
Paketi
1
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 paketa, izvan je nevidljiva – u klasi mogu postojati članovi koji se vide samo unutar paketa
2
1
Sadržaj datoteke *.java • Datoteka *.java može da sadrži sledeća četiri dela – jedan iskaz za obrazovanje paketa (neobavezno) – proizvoljan broj naredbi za uvoz (neobavezno) – jednu definiciju javne klase, ime klase je jednako imenu datoteke (obavezno) – proizvoljan broj klasa bez specifikatora pristupa (neobavezno)
3
Definisanje paketa • Paket se definiše naredbom package koja treba da bude prva naredba u fajlu Javine izvorne datoteke package imePaketa; • Klase iz fajla u kojem je ova naredba pripadaju paketu imePaketa • Fajlovi koji pripadaju jednom paketu moraju biti u istom 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 4
2
Hijerarhija paketa • Paketi mogu da obrazuju hijerarhiju, i tada se piše npr. package paket1.paket2.paket3; • a direktorijum je: paket1\paket2\paket3
5
Sistemska promenljiva CLASSPATH • Program mora biti pokrenut iz direktorijuma neposredno iznad direktorijuma u kojem se nalazi, ili • Sistemska promenljiva CLASSPATH mora sadržati putanju dod direktorijuma MojPaket • Odreñuje osnovni direktorijum hijerarhije paketa
6
3
Starovanje programa iz komandne linije • Program se nalazi u nekom paketu • Radni direktorijum treba da bude onaj koji je odreñen sistemskom promenljivom CLASSPATH • Navodi se cela hijerarhija paketa (direktorijuma) počevši od direktorijuma odreñenog sa CLASSPATH, razdvojenih tačkom i na kraju je ime klase koja se staruje • Primer: C:\java imePaketa1.imePaketa2.imeKlase
7
Specifikatori pristupa za članove klase •
public za javni način pristupanja – javnim članovima mogu da pristupaju sve klase
•
protected za zaštićeni način pristupanja – zaštićenim članovima mogu da pristupaju sve klase iz istog paketa i podklase iz drugih paketa
•
private za privatni način pristupanja – privatnim članovima može da pristupa samo klasa u kojoj su definisani
•
bez specifikatora za podrazumevani način pristupanja – članovima bez specifikatora pristupa mogu da pristupaju sve klase iz istog paketa
8
4
Pristup članovima klase
Private
Bez specifikatora
Protected
Public
Ista klasa
Da
Da
Da
Da
Potklasa istog paketa
Ne
Da
Da
Da
Klase istog paketa koje nisu potklase
Ne
Da
Da
Da
Potklasa iz drugog paketa
Ne
Ne
Da
Da
Klase iz drugih paketa koje nisu potklase
Ne
Ne
Ne
Da
9
Pristupanje klasi iz drugog paketa • Klasi koja se nalazi u nekom drugom paketu može se pristupiti navoñenjem hijerarhije paketa razdvojenih tačkom i klase • Lakši način je da se klasa iz drugog paketa, ili ceo paket, importuje i tada se klasi pristupa preko imena • Za importovanje paketa služi naredba import
10
5
Importovanje • Za importovanje klase ili paketa služi naredba import koja se piše iza naredbe package a ispred definicije klase • Opšti oblik naredbe je import paket1[.paket2].(imeKlase | *) • Primeri: import java.util.Date; import java.util.*; import java.io.*; • Paket java.lang.* se uvozi po difoltu u sve programe
11
Primer: natklasa je u drugom paketu • Natklasa iz drugog paketa mora da bude javna • Primer sa importovanjem paketa: import java.util.*; class MojDatum extends Date { } • Primer bez importovanja paketa: class MojDatum extends java.util.Date { } 12
6
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
13
Interfejsi
14
7
Interfejsi • Interfejs sadrži potpise metoda, tj. definicija interfejsa je slična apstraktnoj klasi čiji su svi metodi apstraktni • Interfejs nema polja • Klasa može da implementira interfejs • Klasa koja implementira interfejs mora da sadrži sve metode iz interfejsa tj. da definiše tela svih metoda iz interfejsa • Klasa može da implementira više interfejsa • Potpuno različite klase mogu da implementiraju isti interfejs
15
Definisanje interfejsa • Opšti oblik je: pristup interface imeInterfejsa tip metod1 ( listaParametara tip metod2 ( listaParametara // ... tip metodN ( listaParametara
{ ); ); );
final tip promenljiva1 = vrednost; final tip promenljiva2 = vrednost; // ... final tip promenljivaN = vrednost; } 16
8
Specifikator pristupa za interfejs • Kao i klasa, i interfejs može imati samo javni i podrazumevani način pristupa • Značenje je isto kao i kod klase
17
Realizovanje interfejsa • Rezervisana reč implements služi za označavanje interfejsa koje implementira klasa • Opšti oblik definicije klase koja implementira interfejs je: pristup class imeKlase [extends imeNatklase] [implements interfejs1 [,interfejs2 ...]] { // telo klase }
18
9
Primer interface InterfejsTest { void test(int par); } class Klasa1 implements InterfejsTest { void test(int p) { // telo metoda iz interfejsa } double d; int metod() { // telo metoda koji nije iz interfejsa } } 19
Primer: geometrijska slika je natklasa public abstract class GeometrijskaSlika { public abstract double obim(); public abstract double povrsina(); } public class Trougao extends GeometrijskaSlika { private double a, b, c; public Trougao(double a, double b_, double c_) { a = a_; b = b_; c = c_; } public double obim() { return a + b + c; } public double povrsina() { double s = (a + b + c)/2; return Math.sqrt(s*(s-a)*(s-b)*(s-c)); } }
20
10
Primer: geometrijska slika je natklasa public class Kvadrat extends GeometrijskaSlika { private double a; public Kvadrat(double a_) { a = a_; } public double obim() { return 4 * a; } public double povrsina() { return a * a; } } public class Krug extends GeometrijskaSlika { private double r; public Krug(double r_) { r = r_; } public double obim() { return 2 * Math.PI * r; } public double povrsina() { return Math.PI * r*r; } } 21
Primer: geometrijska slika je natklasa public class PrimerGeometrijskeSlike1 { public static void main(String[] args) { Trougao tr = new Trougao(3, 4, 5); Krug kr = new Krug(1); Kvadrat kv = new Kvadrat(10); GeometrijskaSlika rn; rn = tr; // referenca natklase ukazuje na objekat trougla double o = rn.obim(); // obim trougla rn = kr; // referenca natklase ukazuje na objekat kruga double p = rn.povrsina(); // površina kruga rn = kv; // referenca natklase ukazuje na objekat kvadrata o = rn.obim(); // obim kvadrata } } 22
11
Primer: geometrijska slika je interfejs public interface GSInterface { public double obim(); public double povrsina(); } public class Trougao implements GSInterface { private double a, b, c; public Trougao(double a, double b_, double c_) { a = a_; b = b_; c = c_; } public double obim() { return a + b + c; } public double povrsina() { double s = (a + b + c)/2; return Math.sqrt(s*(s-a)*(s-b)*(s-c)); } }
23
Primer: geometrijska slika je interfejs public class Kvadrat implements GSInterface { private double a; public Kvadrat(double a_) { a = a_; } public double obim() { return 4 * a; } public double povrsina() { return a * a; } } public class Krug implements GSInterface { private double r; public Krug(double r_) { r = r_; } public double obim() { return 2 * Math.PI * r; } public double povrsina() { return Math.PI * r*r; } } 24
12
Primer: geometrijska slika je interfejs public class PrimerGeometrijskeSlike2 { public static void main(String[] args) { Trougao tr = new Trougao(3, 4, 5); Krug kr = new Krug(1); Kvadrat kv = new Kvadrat(10); GSInterface ri; ri = tr; // referenca tipa interfejsa ukazuje na objekat trougla double o = ri.obim(); // obim trougla 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 } } 25
Izvoñenje iz natklase ili implementiranje interfejsa? • Ako su klase srodne, kao što je slučaj sa geometrijskim slikama (trougao, krug, kvadrat, ...) treba definisati natklasu i iz nje izvesti potklase • Ako su klase potpuno različite i nije logično da imaju zajedničku natklasu, a imaju neke slične (zajedničke) metode, tada treba koristiti interfejse – u interfejs se stave zajednički metodi raznorodnih klasa koje sve klase treba da implementiraju
26
13
Referenciranje preko interfejsa • Može se definisati referenca tipa interfejsa • Referenca tipa interfejsa može ukazivati na objekte svih klasa koje implementiraju interfejs • 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
27
Dva interfejsa imaju isti metod • Klasa koja implementira dva interfejsa koji imaju isti metod realizuje taj metod samo jednom, tj. isti je metod za oba interfejsa
28
14
Delimična realizacija interfejsa • Klasa koja implementira interfejs, a ne definiše tela za sve metode iz interfejsa je apstraktna
29
Promenljive u interfejsu • Interfejs ne može imati promenljivem, može imati samo 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 30
15
Izvoñenje interfejsa • Jedan interfejs može da se izvede iz drugog i tada nasleñuje sve njegove metode
31
Nasleñivanje interfejsa interface A { void metod_A(); } interface B extends A { void metod_B(); } class Test implements 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 } } 32
16
Nasleñivanje interfejsa public class PrimerNasledjivanja { public static void main(String[] args) { 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 } } 33
17
Izuzeci
1
Izuzetak • Izuzetak je greška (vanredno stanje) pri izvršavanju programa • Java ima mehanizam za obradu izuzetaka • Izuzetak može da se: – izazove (baci) - rezervisana reč throw – uhvati radi obrade - rezervisana reč catch
• Izuzetak je objekat koji se pravi kad nastane vanredno 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 metodu 2
1
Rezervisane reči za obradu izuzetaka • • • • •
try catch throw throws finally
3
Obrada izuzetka • Unutar try bloka su naredbe koje mogu da izazovu izuzetak • Izuzetak se hvata pomoću rezervisane reči catch • Rezervisana reč throw služi za bacanje izuzetka • 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
4
2
Neuhvaćeni izuzeci • Ako se u kodu ne obradi izuzetak, obrañuje ga Javin izvršni sistem koji ispisuje tekst sa opisom izuzetka, stanje steka za metode od trenutka nastanka izuzetka i završava program • Primer: – Pri deljenju nulom Javin izvršni sistem pravi izuzetak tipa ArithmeticException i baca ga
5
Primer za izuzetak koji se ne obrañuje u kodu class Izuzetak0 { public static void main (String args[]) { int d = 0; int a = 7 / d; System.out.println(a); } } java.lang.ArithmeticException: / by zero 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 • Izuzetak je tipa ArithmeticException 6
3
Novi primer neobrañenog izuzetka class Izuzetak1 { static void izracunaj() { int d = 0; int a = 7 / d; System.out.println(a); } public static void main (String args[]) { Izuzetak1.izracunaj(); } }
Ista greška, ali ne u metodi main: java.lang.ArithmeticException: / by zero at Izuzetak1.izracunaj(Izuzetak1.java:4) at Izuzetak1.main(Izuzetak1.java:8) Exception in thread "main"
7
Opšti oblik bloka za obradu izuzetaka try { // blok u kojem može da se pojavi izuzetak } catch (TipIzuzetka1 excObj) { // kod za obradu izuzetka tipa TipIzuzetka1 } catch (TipIzuzetka2 excObj) { // kod za obradu izuzetka tipa TipIzuzetka2 } ... finally { // blok koda koji mora da se izvrši // pre kraja bloka try } 8
4
Primer obrañenog izuzetka class Izuzetak2 { public static void main(String args[]) { int d, a; try { d = 0; a = 7 / d; System.out.println("Ovo se ne prikazuje."); } catch (ArithmeticException e) { System.out.println("Deljenje nulom."); } System.out.println("Posle naredbe catch."); } } Deljenje nulom. Posle naredbe catch.
9
Korišćenje try i catch • try i catch su jedinstvena celina • catch se odnosi samo na prethodni try • Iza naredbi try uvek dolazi blok unutar vitičastih zagrada (vitičaste zagrade su obavezne), a isto važi i za catch • catch služi da uhvati izuzetak koji se obrañuje unutar tog catch bloka, posle čega se program nastavlja prvom naredbom ispod svih catch blokova jedne naredbe try
10
5
Tipovi izuzetaka • Throwable je nadklasa svih klasa za izuzetke • Error je klasa za izuzetke Javinog izvršnog sistema, npr. prekoračenje steka, i programi obično ne obrañuju ove izuzetke • Exception je nadklasa za izuzetke koje obrañuju programi • RuntimeException je nadklasa za neproveravane izuzetke npr. aritmetičke greške (ArithmeticException), indeksiranje niza izvan opsega (ArrayIndexOutOfBoundsEx ception)
Throwable
Exception
Error
RuntimeException
11
Prikazivanje opisa izuzetka • U klasi Throwable redefinisan je metod toString tako da vraća opis izuzetka
12
6
Primer prikazivanja opisa izuzetka class OpisIzuzetka { static void izracunaj() { int d = 0; int a = 7 / d; System.out.println(a); } public static void main (String args[]) { try { OpisIzuzetka.izracunaj(); } catch (ArithmeticException e) { System.out.println(e); } } }
java.lang.ArithmeticException: / by zero
13
Višestruki catch • Ako se unutar bloka try može pojaviti više različitih izuzetaka treba staviti više odredbi catch, po jedna za svaki tip izuzetka koji se obrañuje • Posle pojave izuzetka izvršava se prvi catch blok čiji tip izuzetka odgovara nastalom izuzetku, a svi ostali catch blokovi se preskaču
14
7
Primer višestrukog catch class DvaTipaIzuzetka { public static void main(String args[]) { try { int a = args.length; System.out.println("Broj argumenata = " + a); int b = 7 / a; int c[] = { 1 }; c[2] = 9; } catch(ArithmeticException e) { System.out.println("Deljenje nulom: " + e); } catch(ArrayIndexOutOfBoundsException e) { System.out.println("Nevažeći indeks niza: " + e); } System.out.println("Iza try/catch blokova."); } 15 }
Rezultat izvršavanja programa • Prvo izvršavanje programa, ne zadaju se argumenti C:\java DvaTipaIzuzetka Broj argumenata = 0 Deljenje nulom: java.lang.ArithmeticException: / by zero Iza try/catch blokova.
• Drugo izvršavanje programa, zadaju se dva argumenta C:\java DvaTipaIzuzetka dve reci Broj argumenata = 2 Nevažeći indeks niza: java.lang.ArrayIndexOutOfBoundsException Iza try/catch blokova.
16
8
Višestruki catch • Ako iza bloka try ima više blokova catch, potklase izuzetaka moraju da se pojave pre svojih natklasa jer catch sa tipom natklase hvata i izuzetke svih svojih potklasa
17
Primer višestrukog catch sa greškom class IzuzetakPotklasePreNatklase { public static void main(String args[]) { try { int a = 0; int b = 7 / a; } catch(Exception e) { System.out.println("catch tipa Exception."); } catch(ArithmeticException e) { // ArithmeticException je potklasa klase Exception i mora se // pojaviti u catch pre klase Exception (greška u prevoñenju) System.out.println("Nedostupan kod."); } } 18 }
9
Ugnježdene naredbe try • Naredba try može da bude unutar druge naredbe try • Ako se izuzetak ne uhvati u catch delovima untrašnje naredbe try, preuzima ga spoljašnja naredba try • Nastavlja se sve dok nek catch blok ne uhvati izuzetak, ili dok izuzetak ne doñe do Javinog izvršnog sistema
19
Primer ugnježdenog try class UgnjezdeniTry { public static void main(String args[]) { try { // Spoljašnji try blok int a = args.length; System.out.println("Broj argumenata = " + a); int b = 42 / a; // Deljenje nulom za a=0 try { // Unutrašnji try blok if(a==1) a = a/(a-a); // Deljenje nulom za a=1 if(a==2) { int c[] = { 1 }; c[42] = 99; // Greška u indeksiranju za a=2 } } catch(ArrayIndexOutOfBoundsException e) { System.out.println("Unutrašnji try: " + e); } } catch(ArithmeticException e) { System.out.println("Spoljašnji try: " + e); } } }
20
10
Rezultat izvršavanja programa • Prvo izvršavanje programa, ne zadaju se argumenti C:\java UgnjezdeniTry Broj argumenata = 0 Spoljašnji try: java.lang.ArithmeticException: / by zero
• Drugo izvršavanje programa, zadaje se jedan argument C:\java UgnjezdeniTry x Broj argumenata = 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 21
Ugnježdeni try u metodima •
try naredbe su ugnježdene i u sledećem slučaju: – metod A ima try blok – metod B ima try blok – metod A se poziva unutar try bloka metoda B
• U ovom primeru try blok metoda A je ugnježden unutar try bloka metoda B
22
11
Primer ugnježdenog try class UgnjezdeniTry1 { static void unutrasnjiTry(int a) { try { if(a==1) a = a/(a-a); // Deljenje nulom za a=1 if(a==2) { // Greška u indeksiranju za a=2 int c[] = { 1 }; c[2] = 99; } } catch(ArrayIndexOutOfBoundsException e) { System.out.println("Unutrašnji try: " + e); } } public static void main(String args[]) { try { int a = args.length; System.out.println("Broj argumenata = " + a); int b = 42 / a; // Deljenje nulom za a=0 UgnjezdeniTry1.unutrasnjiTry(a); } catch(ArithmeticException e) { System.out.println("Spoljašnji try: " + e); } } }
23
Rezervisana reč throw • Izuzetak se baca pomoću naredbe throw • Opšti oblik naredbe je throw objekatIzuzetka; • objekatIzuzetka je objekat klase Throwable ili neke potklase ove klase • objekatIzuzetka se može napraviti operatorom new ili može biti objekat uhvaćen u naredbi catch • Posle bacanja izuzetka prelazi se na hvatanje izuzetka u naredbi try bloka koji obuhvata naredbu throw
24
12
Primer za throw class PrimerZaThrow { static void bacanjeIzuzetka() { try { throw new NullPointerException("proba"); } catch(NullPointerException e) { System.out.println("Hvatanje unutar metoda."); throw e; // novo bacanje izuzetka } } public static void main(String args[]) { try { PrimerZaThrow.bacanjeIzuzetka(); } catch(NullPointerException e) { System.out.println("Ponovo uhvaćen: " + e); } } }
25
Rezultat izvršavanja programa C:\java PrimerZaThrow Hvatanje unutar metoda. Ponovo uhvaćen: java.lang.NullPointerException: proba
26
13
Konstruktori izuzetaka • 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() koji je definisan u klasi Throwable
27
Proveravani i neproveravani izuzeci • Metodi i konstruktori ne moraju ekspicitno da izjave da mogu da bace neproveravani izuzetak. Podrazumeva se da bilo koji metod može da ih baci. • Oni ne moraju eksplicitno da budu uhvaćeni (nije potreban catch). Kada se desi neproveravani izuzetak (NullPointerException, ClassCastException, OutOfMemoryError etc), Java će automatski “obraditi" izuzetak.
28
14
Proveravani i neproveravani izuzeci • Error je klasa za izuzetke Javinog izvršnog sistema, npr. prekoračenje steka, memorije itd. i programi obično ne obrañuju ove izuzetke • RuntimeException je nadklasa za neproveravane izuzetke npr. aritmetičke greške (ArithmeticException), indeksiranje niza izvan opsega (ArrayIndexOutOfBoundsExce ption), pokušaj da se dohvati objekat preko reference koja je null. • Runtime exceptions predstavljau probleme nastale pgreškom u programiranju i nije realno očekivati da bi program mogao da ih obradi na uspešan način.
Throwable
Exception
Error
RuntimeException
29
Rezervisana reč throws • Za metod koji baca izuzetke mora da se označi koje izuzetke baca • Moraju se navesti svi izuzeci koje baca metod izuzev izuzetaka tipa Error i RuntimeException ili njihovih potklasa • Izuzeci koji ne moraju da se navode nazivaju se neproveravani 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 • Opšti oblik deklaracije metoda je tip imeMetoda(listaParametara) throws listaIzuzetaka 30
15
Primer za throws sa greškom class PrimerZaThrows { static void bacanjeIzuzetka() { System.out.println("Unutar metoda."); throw new IllegalAccessException("proba"); } public static void main(String args[]) { PrimerZaThrows.bacanjeIzuzetka(); } }
• Izuzetak tipa IllegalAccessException je proveravani izuzetak i ako se ne pojavi u deklaraciji metoda koji ga baca javlja se greška u prevoñenju 31
Ispravan primer za throws class PrimerZaThrows { static void bacanjeIzuzetka() throws IllegalAccessException { System.out.println("Unutar metoda."); throw new IllegalAccessException("proba"); } public static void main(String args[]) { try { PrimerZaThrows.bacanjeIzuzetka(); } catch(IllegalAccessException e) { System.out.println("Uhvaćen: " + e); } } }
Unutar metoda. Uhvaćen: java.lang.IllegalAccessException: proba
32
16
Rezervisana reč finally • Prilikom pojavljivanja i obrade izuzetka dolazi do preskakanja pojedinih naredbi • Naredbe koje se ne smeju peskočiti, npr. zatvaranje fajla, stavljaju se u blok finally • Blok finally se izvršava uvek bez obzira da li se pojavljuje izuzetak ili ne • Ako se metod prekida iz bloka try/catch zbog pojave izuzetka ili zbog naredbe return, blok finally se izvršava neposredno pre izlaska iz metoda • Blok finally nije obavezan • Naredba try mora imati bar jednu od naredbi catch ili finally 33
Primer za finally class PrimerZaFinally { static void metodA() { try { // Izuzetak unutar try bloka System.out.println("Unutar metoda A"); throw new RuntimeException("proba"); } finally { System.out.println("Metod A: finally blok"); } } static void metodB() { try { System.out.println("Unutar metoda B"); return; // return unutar try bloka } finally { System.out.println("Metod B: finally blok"); } }
34
17
Primer za finally static void metodC() { try { // try bloka koji se ne prekida System.out.println("Unutar metoda C"); } finally { System.out.println("Metod C: finally blok"); } } public static void main(String args[]) { try { metodA(); } catch (Exception e) { System.out.println("Uhvaćen izuzetak"); } metodB(); metodC(); } }
35
Rezultat izvršavanja programa C:\java PrimerZaFinally Unutar metoda A Metod A: finally blok Uhvaćen izuzetak Unutar metoda B Metod B: finally blok Unutar metoda C Metod C: finally blok
36
18
Ugrañeni izuzeci • Nalaze se u standardnom paketu java.lang. • Neproveravani (potklase klase RuntimeException) • AritmeticException – aritmetička greška • ArrayIndexOutOfBoundException – prekoračenje indeksa niza • ArrayStoreException – dodela pogrešnog objekta nizu • ClassCastException – neispravna konverzija • IllegalArgumentException – metodu je prosleñen pogrešan argument • ... • Proveravani izuzeci • ClassNotFoundException – Klasa nije nañena • IllegalAccessException – odbijen zahtev za pristupanje klasi • NoSuchField Exception – Zahtevano poljene postoji • NoSuchMethodException – Zahtevana metoda ne postoji 37
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, ali se to može uraditi
38
19
Metode definisane u klasi Throwable • Throwable getCause() – Vraća razlog koji je prouzrokovao tekući izuzetak
• Throwable initCause(Throwable uzrokIzu) – Pridružuje uzrokIzu pozivajućem izuzetku kao uzrok
• String getMessage() – vraća opis izuzetka. • void printStackTrace() – Prikazuje stanje steka na standardnom izlazu.
• String toString() – Opis izuzetka, koji koristi metoda println().
39
Primer za pravljenje izuzetka class Izuzetak extends Exception { private int podatak; Izuzetak(int a) { podatak = a; } public String toString() { return "Izuzetak[" + podatak + "]"; } }
40
20
Primer za pravljenje izuzetka class PrimerZaIzuzetak { static void racunaj(int a) throws Izuzetak { System.out.println("racunaj(" + a + ")"); if(a > 10) throw new Izuzetak(a); System.out.println("Normalan izlaz"); } public static void main(String args[]) { try { PrimerZaIzuzetak.racunaj(1); PrimerZaIzuzetak.racunaj(20); } catch (Izuzetak e) { System.out.println("Uhvaćen " + e); } } }
41
Rezultat izvršavanja programa C:\java PrimerZaIzuzetak racunaj(1) Normalan izlaz racunaj(20) Uhvaćen Izuzetak[20]
42
21
Korišćenje izuzetaka • Za obradu grešaka i vanrednih situacija programa uvek treba koristiti izuzetke • Uvek kad metod ne može da obavi posao treba da baci izuzetak • Nikad ne treba koristiti vraćanje šifre greške kao način na koji metod prijavljuje da se pojavila greška • Ne smatrati izuzetke opštim mehanizmom nelokalnog grananja (tj. kao oblik naredbe go to).
43
22
Fuzija nizova Zadatak 3.6 (str. 33): Sastaviti program na jeziku Java za nalaženje fuzije dva niza celih brojeva koji su uređeni po neopadajućem redosledu u treći, na isti način uređeni niz. Program treba da obrađuje proizvoljan broj kompleta ulaznih podataka.
Rešenje:
2
4
5
7
7
1
3
5
9
9
8
ia:
ib:
1
2
3
4
5
5
7
7
8
9
9
ic:
// Fuzija.java - Fuzija dva uredjena niza celih brojeva. public class Fuzija { public static void main (String[] vpar) { while (true) { System.out.print ("na? "); int na = Citaj.Int (); if (na < 0) break; int[] a = new int [na]; System.out.print ("A ? "); for (int i=0; i
while (ib < nb) c[ic++] = b[ib++]; //ostatak niza b System.out.print ("C = "); for (int i=0; i
Rezultat izvršavanja: % java Fuzija na? 6 A ? 1 2 3 4 5 6 nb? 5 B ? 4 5 6 7 8 C = ... na? A ? nb? B ? C =
4 1 2 3 4 0
na? A ? nb? B ? C =
0
1 2 3 4
6 1 2 3 4 5 6 1 2 3 4 5 6
na? -1
2
Kompleksni brojevi Zadatak 4.2 (str. 41): Projektovati na jeziku Java klasu kompleksnih brojeva. Sastaviti glavni program za prikazivanje mogućnosti te klase.
, ,
,
Kompl1 - re, im + + + + + + + +
Kompl1() re(), im(), abs(), arg() postaviRe(), postaviIm(), postavi() konjg() zbir(), razlika(), proizvod(), kolicnik() citaj() toString() main()
// Kompl1.java - Klasa kompleksnih brojeva. public class Kompl1 { private double re, im;
// Realni i imaginarni deo.
public Kompl1 () {} // Stvaranje kompleksnog broja. public Kompl1 (double r) { re = r; } public Kompl1 (double r, double i) { re = r; im = i; } public double re () { return re; }
// Realni deo.
public double im () { return im; }
// Imaginarni deo.
public double abs () { return Math.sqrt (re*re + im*im); }
// Apsolutna vrednost.
public double arg
// Argument.
()
1
{ return (re!=0 || im!=0) ? Math.atan2(im,re) : 0; } public Kompl1 postavi (double r, double i) // Postavljanje delova. { re = r; im = i; return this; } public Kompl1 postaviRe (double r) { re = r; return this; } public Kompl1 postaviIm (double i) { im = i; return this; } public Kompl1 postavi (Kompl1 z) { re = z.re; im = z.im; return this; } public Kompl1 konjg () { return new Kompl1 (re, -im); }
// Konjugovan broj.
public Kompl1 zbir (Kompl1 b) // a += b { return new Kompl1 (re+b.re, im+b.im); } public Kompl1 razlika (Kompl1 b) // a -= b { return new Kompl1 (re-b.re, im-b.im); } public Kompl1 proizvod (Kompl1 b) // a *= b { return new Kompl1 (re*b.re-im*b.im, im*b.re+re*b.im); } public Kompl1 kolicnik (Kompl1 b) { // a /= b double c = b.re*b.re + b.im*b.im; return new Kompl1 ((re*b.re+im*b.im)/c, (im*b.re-re*b.im)/c); } public static Kompl1 citaj () // Citanje. { return new Kompl1 (Citaj.Double(), Citaj.Double()); } public String toString () { return "("+ re + "," + im +")"; }
// Tekstualni oblik.
// Glavna funkcija za ispitivanje klase Kompl1. ========================= public static void main (String[] vpar) { System.out.print ("Prvi broj (re,im)? "); Kompl1 x = new Kompl1 (Citaj.Double(), Citaj.Double()); System.out.print ("Drugi broj (re,im)? "); Kompl1 y = Kompl1.citaj (); System.out.println ("x = (" + x.re() + ',' + x.im() + ')'); System.out.println ("y = " + y); System.out.println ("x+y = " + x.zbir (y) ); System.out.println ("x-y = " + x.razlika (y) ); System.out.println ("x*y = " + x.proizvod (y) ); System.out.println ("x/y = " + x.kolicnik (y) ); } }
Rezultat izvršavanja: % javac Kompl1.java % java Kompl1
2
Prvi broj (re,im)? 1 2 Drugi broj (re,im)? 3 4 x = (1.0,2.0) y = (3.0,4.0) x+y = (4.0,6.0) x-y = (-2.0,-2.0) x*y = (-5.0,10.0) x/y = (0.44,0.08)
3
Skup uređenih realnih brojeva - klasa Zadatak 4.6 (str. 50): Projektovati na jeziku Java klasu uređenih skupova realnih brojeva. Predvideti: - stvaranje praznog skupa i skupa koji sadrži jedan broj, - stvaranje kopije skupa, - nalaženje unije, preseka i razlike dva skupa, - sastavljanje tekstualnog prikaza skupa, - čitanje skupa sa glavnog ulaza, - dohvatanje broja elemenata skupa Sastaviti glavni program za prikazivanje mogućnosti te klase. Skup - niz + + + + + + +
Skup() kopiraj() kopija() unija(), presek(), razlika() citaj() toString(), citaj() velicina()
// Skup.java - Klasa uredjenih skupova. class Skup { private double[] niz; public Skup () { niz = new double [0]; } public Skup (double b) { niz = new double [1]; niz[0] = b; }
// Elementi skupa. // Stvaranje skupa: // praznog, //
od jednog broja.
private void kopiraj (double[] a, int n) { // Kopiranje niza u skup. niz = new double [n]; for (int i=0; i
1
Dok još nismo izašli iz opsega nijednog skupa.
public void unija (Skup s1, Skup s2) { // Unija dva skupa. double[] a = new double [s1.niz.length+s2.niz.length]; int n = 0; for (int i=0, j=0; is2.niz[j] ? s2.niz[j++] : s1.niz[i++] ; //elementi su //jednaki if (j s2.niz[j]) j++; else { a[n++] = s1.niz[i++]; j++; } //elementi su jednaki kopiraj (a, n); } // Razlika dva skupa // Primer: A=1,2,3,4, B = 3,4,5,6,7 public void razlika (Skup s1, Skup s2) { // Razlika dva skupa. double[] a = new double [s1.niz.length]; int n = 0; for (int i=0, j=0; i s2.niz[j]) j++; // idi na sledeći j, i //ostaje isto else { i++; j++; } //elementi su jedn. kopiraj (a, n); } public String toString () { // Tekstualni oblik skupa. String s = "{"; for (int i=0; i
2
} public static Skup citaj () { // Citanje skupa. Skup s = new Skup (); int n = Citaj.Int (); for (int i=0; i
// SkupT.java - Ispitivanje klase uredjenih skupova. public class SkupT { public static void main (String[] vpar) { char jos; do { System.out.print ("niz1? "); Skup s1 = Skup.citaj (); System.out.print ("niz2? "); Skup s2 = Skup.citaj (); System.out.println ("s1 =" + s1); System.out.println ("s2 =" + s2); Skup s = new Skup (); s.unija (s1, s2); System.out.println ("s1+s2=" + s ); s.presek (s1, s2); System.out.println ("s1*s2=" + s ); s.razlika(s1, s2); System.out.println ("s1-s2=" + s ); System.out.print ("\nJos? "); jos = Citaj.Char (); } while (jos=='d' || jos=='D'); } }
Rezultat izvršavanja: % javac SkupT.java % java SkupT niz1? 4 1 2 3 4 niz2? 5 3 4 5 6 7 s1 ={1.0,2.0,3.0,4.0} s2 ={3.0,4.0,5.0,6.0,7.0} s1+s2={1.0,2.0,3.0,4.0,5.0,6.0,7.0} s1*s2={3.0,4.0} s1-s2={1.0,2.0} Jos? d niz1? 6 9 3 5 1 7 3 niz2? 4 6 2 8 8 s1 ={1.0,3.0,5.0,7.0,9.0} s2 ={2.0,6.0,8.0} s1+s2={1.0,2.0,3.0,5.0,6.0,7.0,8.0,9.0} s1*s2={}
3
s1-s2={1.0,3.0,5.0,7.0,9.0} Jos? n
4
Transponovanje matrice Zadatak 3.10 (str. 38): Sastaviti program na jeziku Java za transponovanje pravougaone matrice celih brojeva. Program treba da obrađuje proizvoljan broj kompleta podataka. Rešenje: // Transpon.java - Transponovanje matrice. public class Transpon { public static void main (String[] vpar) { while (true) { // Citanje dimenzija matrice: System.out.print ("\nBroj vrsta i kolona? "); int m = Citaj.Int (), n = Citaj.Int(); if (m<=0 || n<=0) break; // Citanje elemenata matrice: int[][] a = new int [m][n]; for (int i=0; i
1
Rezultat izvršavanja: % java Transpon Broj vrsta i kolona? 3 4 1. vrsta? 1 2 3 4 2. vrsta? 5 6 7 8 3. vrsta? 9 0 1 2 Transponovana matrica: 1 5 9 2 6 0 3 7 1 4 8 2 Broj vrsta i kolona? 0 0
2
Umetanje niza u niz Zadatak 3.8 (str. 36): Sastaviti program na jeziku Java za umetanje niza brojeva u drugi niz počev od zadate pozicije (ispred prvog elementa ako je pozicija manja od nule, odnosno iza poslednjeg elementa ako je pozicija veća od dužine odredišnog niza). Program treba da obrađuje proizvoljan broj kompleta podataka. Rešenje: Napomena za a=c: kopija reference (pokazivača) na niz c. Problem: ako dodelimo vrednost promenljivoj a[i], menja se i c[i]. Kako dodeliti vrednosti drugom nizu? - U petlji, prethodno new. // Umetni.java - Umetanje elemenata niza u drugi niz. public class Umetni { public static void main (String[] vpar) { while (true) { System.out.print ("m? "); int m = Citaj.Int (); if (m < 0) break; int[] a = new int [m]; System.out.print ("A? "); for (int i=0; i m) p = m; int[] c = new int [m+n]; int i = 0, j = 0, k = 0; while (j < p) c[k++] = a[j++]; while (i < n) c[k++] = b[i++]; while (j < m) c[k++] = a[j++]; a = c; c = null; m += n; System.out.print ("A= "); for (i=0; i
1
Rezultat izvršavanja: % java Umetni m? 5 A? 0 1 2 3 4 n? 3 B? 11 22 33 p? 2 A= 0 1 11 22 33 2 3 4 m? A? n? B? p? A=
5 0 1 2 3 4 3 11 22 33 -2 11 22 33 0 1 2 3 4
m? A? n? B? p? A=
5 0 1 2 3 4 3 11 22 33 8 0 1 2 3 4 11 22 33
m? -1
2
Uređivanje niza metodom izbora Zadatak 3.7 (str. 34): Sastaviti program na jeziku Java za uređivanje niza brojeva po neopadajućem redosledu metodom izbora. Program treba da obrađuje pročita dužinu niza, popuni niz slučajnim jednocifrenim decimalnim celim brojevima, ispiše dobijeni niz, uredi nit, ispiše dobijeni rezultat i ponavlja prethodne korake sve dok za dužinu niza ne pročita nedozvoljenu vrednost.
Rešenje:
2
4
5
7
7
1
3
5
9
9
8
ia:
ib:
1
2
3
4
5
5
7
7
8
9
9
ic:
// Fuzija.java - Fuzija dva uredjena niza celih brojeva. public class Fuzija { public static void main (String[] vpar) while (true) { System.out.print ("na? "); int na = if (na < 0) break; int[] a = new int [na]; System.out.print ("A ? "); for (int a[i++]=Citaj.Int()); if (na == 0) System.out.println (); System.out.print ("nb? "); int nb = if (nb < 0) break; int[] b = new int [nb]; System.out.print ("B ? "); for (int b[i++]=Citaj.Int()); if (nb == 0) System.out.println (); int nc = na + nb; int[] c = new int int ia = 0, ib = 0, ic = 0; 1
{ Citaj.Int ();
i=0; i
Citaj.Int ();
i=0; i
[nc];
Samo 1 indeks se inkrementira
while (ia
Rezultat izvršavanja: % java Fuzija na? 6 A ? 1 2 3 4 5 6 nb? 5 B ? 4 5 6 7 8 C = 1 2 3 4 4 5 5 6 6 7 8 na? A ? nb? B ? C =
4 1 2 3 4 0
na? A ? nb? B ? C =
0
1 2 3 4
6 1 2 3 4 5 6 1 2 3 4 5 6
na? -1
2
