JAVA

Sadrzaj:
Uvod ..........................................................................................................................................................1 Varijable (promjenjive) .............................................................................................................................3 Input from the user ....................................................................................................................................4 Building a basic calculator ........................................................................................................................4 Int tip podataka..........................................................................................................................................5 Lekcija 9: Increment Operators(increment-“dopunsko punjenje) ...........................................................6 Lekcija 10: if naredba ...............................................................................................................................8 Lekcija 11: Logicki operatori ....................................................................................................................9 Lekcija 12: switch naredba .....................................................................................................................10 Lekcija 13: While loop ............................................................................................................................11 Lekcija 14: Klase ....................................................................................................................................12 Lekcija 15: Koristenje metoda sa parametrima.......................................................................................13 Lekcija 16: Many Methods and Instances...............................................................................................14 Lekcija 17: Constructors .........................................................................................................................15 Lekcija 18: Nested If Naredbe ................................................................................................................16 Lekcija 19: else if naredba ......................................................................................................................17 Lekcija 20: Conditional Operators ..........................................................................................................18 Lekcija 21: Jednostavni program za izracunavanje prosjeka ..................................................................19 Lekcija 22: for loop (petlja) ....................................................................................................................20 Lekcija 23: Compound Interest(interkalarna kamata) Program ..............................................................21 Lekcija 24: do while petlja ......................................................................................................................22 Lekcija 27: Introduction to Arrays( array – mnostvo,poredak) ..............................................................25 Lekcija 28: Creating an Array Table .......................................................................................................26 Lekcija 29: Summing Elements of Array ...............................................................................................27 Lekcija 30: Array Elements as Counters.................................................................................................27 Lekcija 31: Enhanced for loop (Poboljsana for petlja) ...........................................................................29 Lekcija:32 Arrays in methods .................................................................................................................30 Lekcija 33: Multidimensional Arrays .....................................................................................................31 Lekcija 34: Prikazivanje Multidimenzionalnih Array-a u vidu tabele ....................................................32 Lekcija 35: Metode koje rade sa nepoznatim brojem argumenata ..........................................................33 Lekcija 36 : Time klasa ...........................................................................................................................34 Lekcija 38 : Public, Private i this ............................................................................................................36 Lekcije : 39,40 i 41 .................................................................................................................................38 Lekcija 42 : toString ................................................................................................................................40 Lekcija 43 : Composition ........................................................................................................................41 Lekcija 44 : Enumeration (nabrajanje)....................................................................................................42 Lekcija 45: EnumSet range .....................................................................................................................44 Lekcija 46: Static ....................................................................................................................................45 Lekcija 47: More on Static ......................................................................................................................46 Lekcija 48: final ......................................................................................................................................48 Lekcija 49: Inheritance(nasljedje) ...........................................................................................................49 Lekcija 50: GUI (Graphics User Interface) .............................................................................................51 Lekcija 51: GUI with Jframe ..................................................................................................................53 Lekcije:52,53,54 , Event Handling .........................................................................................................55

Lekcija 55: Intoduction to Polymorphism ..............................................................................................59 Lekcija: 56 Polymorphic Arguments ......................................................................................................61 Lekcije: 57 Overriding Rules (najvaznija pravila) i 58 Abstract and Concrete classes ..........................63 Lekcija: 59 Class to Hold Object ............................................................................................................65 Lekcija: 60 Array Holding Many Objects..............................................................................................66 Lekcija: 61 Simple Polymorphic Program ..............................................................................................67 Lekcija 62 i 63: Jbutton...........................................................................................................................68 Lekcije : 64 i 65 JCheckBox ...................................................................................................................71 Lekcija: 66 JRadioButton........................................................................................................................74 Lekcije: 68 i 69 JComboBox ..................................................................................................................78 Lekcije 70 i 71: JList ...............................................................................................................................80 Lekcije 72 i 73: Multiple Selection Lists ................................................................................................83 Lekcije 74,75 i 76 Mouse Events ............................................................................................................85 Lekcija 77: Adapter Class .......................................................................................................................88 Lekcija 78: File Class ..............................................................................................................................90 Lekcija 79: Creating Files .......................................................................................................................91 Lekcija:80 Writing to Files .....................................................................................................................92 Lekcija 81: Reading From Files ..............................................................................................................93 Lekcija 82: Exception Handling .............................................................................................................95 Lekcija 83: FlowLayout ..........................................................................................................................97 Lekcija 84: Drawing Grpahics ................................................................................................................99 Lekcija 85:JColorChooser.....................................................................................................................101 Lekcija 86: Drawing More Stuff ...........................................................................................................104 Lekcija 87: Series Finale .......................................................................................................................105

a tjelo klase je unuar viticastih zagrada kao na: classRobot{ } Kada pokrenemo Java program kod koji se izvrsava je kod koji se nalazi unutar metode main . Metode klase (metodi klase se primjenjuju na samu klasu) Metode i promjenjive klase imaju u zaglavlju rjec static sto oznacava da su instance tj. Klasa se definise tako sto ukucamo class pa zatim ime klase. metode klase. Tacan izgled zaglavlja metode main mora biti: Public static void main(String args[]) U tjelu metode main je kao sto smo rekli kod koji se izvrsava i nalazi se unutar viticastih zagrada. ~1~ . tj puni izgled metode main zaglavlje + tjelo bio bih: Public static void main(String args[]){ /*tjelo metode*/ } Naravno metoda (bez obzira sto je „glavana“) ne moze da postoji samostalno vec mora da se nalazi u nekoj klasi. iako to nije nigdje eksplicitno navedeno. U Javi moguce je nasljedjivanje klasa. Interfejs je kolekcija metoda koje ukazuju da klasa posjeduje neko ponasanje pored onoga sto nasljedjuje od nadklase. Ponasanje je sve ono sto se moze izvrsiti nad objektima klase i drugih klasa definisano je pomocu metoda. 2.Uvod Java je objektno orjentisani programski jezik. postoje interfejsi koji to znatno ublazuju. Metode instance (ukoliko metod obavlja izmjenu pojedinacnog objekta on je metod instance) 2. Ponasanje (metoda) Atributi su podatci na osnovu kojih se razlikuju objekti i definisani su pomocu promjenjivih. Pa bih u gore pomenutu klasu robot mogli staviti metodu main : Class public static void main(String args[]){ } } //zatvorena viticasta zagrada oznacava kraj tjela metode //zatvorena viticasta zagrada oznacava kraj tjela klase Robot{ 1 ne racunajuci klasu Object koja je na vrhu hierarhije klasa i koju nasljedjuju sve klase . S obzirom da je cinjenica da se moze nasljediti samo jedna klasa veliko ogranicenje. Neka klasa moze nasljediti samo jednu klasu1. Imamo dve vrste metoda: 1. klasa gdje se nalazi ta metoda se naziva glavna klasa. Promjenjive klase: cuvaju atribute koje su iste za sve objekte iste klase. Takodje moze imati neograniceno podklasa ( klasa koje nasljedjuju nju). Promjenjive instance: cuvaju atribute konkretnog objekta koji se razlikuje od objekata iz iste klase. tj moze imati samo jednu superklasu. Imamo dve vrste promjenjivih : 1. Klasa se sastoji od : 1. Atributa (promjenjive) 2. sav kod programa se nalzi u nekoj od klasa od koje pravimo objekte (instance klase). Java program se sastoji od klasa tj.

Sada kada smo stvorili klasu Robot i u nju stavili glavnu metodu main. Npr da imamo metodu „ispećitortu“. } } // korak zaglavlje 1 tjelo korak korak { metode svi ovi metode 2 3 // su // // Sve sve zajedno tjelo metode i zaglavlje metode je metoda. ~2~ . koja se nalazi unutar klaseApples: classApples void ispeći tortu (){ izmješaj margarin. pojedi tortu.out. koraci/instrukcije stavi u tavu. .println(„Pozdrav svjetu“). Npr: Class public static void main(String args[]){ System.out. Kada pokrenemo ovj program dobicemo: Pozdrav svjetu System. } } Robot{ Kod koji smo mi napisali sastoji se od jedne instrucije tj: System. unutar metode (recepta) su svi koraci koji su potrebni da bi se ispekala ta torta (instrukcije). Mozemo napisati neki kod koji ce se izvrsiti. Metoda je nešto poput recepta .println(“Pozdrav svjetu”).println je ustvari ugradjena metoda i ona ce izbaciti ono sto navedemo unutar zagrada na standardom izlaznom uredjaju.out.

out.28 kg of tuna for breakfast Imamo cetri naredbe koje prikazuju na ekranu cetri stvari : 1) I‟d Like 2)5.).out.out. lista karaktera (djordje)… Npr. System.out. System. Varijabli x je dodjeljena vrijednost 73 Prije nego sto krenemo raditi sa varijablom treba da definisemo vrstu varijable . i dodjeliti joj vrijednost 5.out.out. npr: public class apples { public static void main (String args[]){ double tuna.28.println(tuna)) izbaciti vrijednost kojoj smo joj dodjelili (liniju koda ispod) tj. pod x ce se podrazumjevati broj 73. } } Kada pokrenemo ovaj kod dobicemo: I'd Like5. System.14).28 .print("I'd Like"). ~3~ .28.2. Vrsta variable double (govori javi da ce raditi sa brojem koji moze imati i decimalni zarez) nakon toga joj moramo dati ime npr tuna . System.double brojevi sa decimalnim mjestima (3.out.print(tuna).println(" kg of tuna").28. kao na primjeru: class apples { public static void main (String args[]) { double tuna = 5.znaci prikazi ovo u zagradi pod i ostani u istoj liniji (redu). System. System.print("for breakfast").print() .out. dok System.printl() -znaci prikazi ovo u zagradi i prebaci na sledeci red (liniju) . tuna = 5. 5.print(tuna) } } Kada pokrenemo ovaj program on ce umjesto u zagradi gdje pise tuna (System..Varijable (promjenjive) Kada napisemo x=73. to mogu biti brojevi cjeli brojevi ili int (1.28 3)kg of tuna 4)for breakfast 4 nareda se nalazi u novom redu iz razloga sto naredba prije nje je ispisala nesto na ekranu (to nesto je kg of tuna) i presla u novi red.

System.println(djordje.nextLine()).println(djordje. ) System.Scanner.broj2. System.out.out. double broj1.nextDouble().nextDouble(). Java program koristi samo ono sto je potrebno. Scanner.Scanner. } } djordje je scanning varijabla i ona je jednaka bilo cemu sto unesemo tastaturom.Scanner.print(rezultat). public class ai{ public static void main(String args[]){ Scanner djordje = new Scanner(System.ova insturkcija prikazuje na ekranu djordje varijblu.util.Input from the user Jedan nacin za ulaz je da koristimo nesto sto je vec ugradjeno u javi .in).out.Line() znaci da ce se na prikazivanje djordje promjenjive izvrsiti tek nakon sto je definisemo tj ukucamo nesto i pritisnemo enter .in).util.out.out.println("unesi broj 1").util. broj1 = broj. Scanner djordje = new Scanner(System.util. } } /*navodimo da cemo koristiti ~4~ . broj2 = broj. tako sto upisemo: import java.in). System. Importjava. -ova instrukcija znaci sta god unesemo tastaturom skladisti u djordje varijablu. rezultat = broj1 + broj2. Dok next. Building a basic calculator import java. tastaturu*/ class apples{ public static void main(String args[]){ Scanner broj = new Scanner(System.Scanner. Ova nam instrukcija omogucuje da koristimo tastaturu koju smo predhodno “inportovali” ( import java. .rezultat.nextLine()). pa da bismo koristili Scanner(tastaturu) moramo da ga „importujemo“ ili unesemo . Scanner uzima informacije koje korisnik kuca na tastaturi. //sada mozemo vrsiti operacije sa tastaturom System.println("unesi broj 2").

Scanner. znak * (asteriks – znak za mnozenje) dobili bi smo tacan proizvod ljudi.483. Da je npr umjesto znaka + . people. podjelimo 11/3 dobicemo broj 3 sto nije tacan rezutat( iz razloga sto int tip podataka ne podrzava decimalna mjesta). int boys.print("there is ").out.println("enter number of girls"). } } Kada se izvrsi insturkcija people = boys + girls. System. Da je umjesto znaka + .println("enter number of boys"). People. System. import java. znak “–“ (minus) dobili bi tacnu razliku ljudi tj. People.out.647 ) .147.in). 9/2=4. people = boys + girls. Vec kod djeljenja je malo komplikovanije. dobicemo tacan broj ljudi tj.5 .nextInt(). ~5~ .483. . boys = input. Kada koristimo int u operacijama sa varijablama rezultat moze biti samo cjeli broj bez obzira sto je npr.out. girls = input. System. kao rezultat izbacio broj 2 (jer je broj 2 ostatak kod djeljenja ova dva broja).print(people).out. Ali ako npr. sto je i logicno . System.147. .util. on ce prikazati da je 9/2=4.println(" people"). System. girls.out. public class lekcija8 { public static void main(String args[]) { Scanner input = new Scanner(System.nextInt(). Sem operatora djeljenja(“/” ) postoji i modul operator (“%”) koji bi kada bih smo napisali insturkciju 11%3.648 do 2. Kada podjelimo npr 8 /4 dobicemo broj 2 .Int tip podataka Pored double tipa podataka koja govori da ce program raditi sa brojem koji moze imati decimalni zarez imamo i int tip podataka koji rade samo sa cijelim brojevima( od -2.

zbog toga sto smo naredili da nam prikaze na ekranu vrijednost promjenjive tuna (naredba System. ++tuna.println(++tuna). Npr System.out.{ Scanner input = new Scanner(System. 5.println(swordfish++).in). tj. 8. public static void main (String args[]){ 3. 7. Vrijednost promjenjive tuna je sada 11 iz razloga sto smo je povecali za jedan tako sto smo stavili ++ inkrement (sto znaci povecaj sledecu varijblu za jedan). System. public class l9increment { public static void main(String args[]). . int tuna = 10.out. System. Import java. . System.println(++swordfish).println(swordfish). to znaci da ce se prvo promjeni vrijednost promjenjive prije nego sto se prikaze na ekranu. prvo ce prikazati na ekranu staru vrijednost varijable tj 20 pa ce je tek onda povecati za jedan.out.println(swordfish++). 13. 11.out. 9. ++tuna. int tuna = 10. int swordfish = 20. varijabla tuna ce imati vrijednost 9.println(tuna).println(tuna). Ali kada bi smo napisali System. } } Kada pokrenemo ovaj program dobicemo broj 10.println(++tuna). i na ekranu ce nam se prikazati vrijednost tuna povecana za 1. 5. Mi vrijednost varijable mozemo mjenjati naknadno tj nakon sto je definisemo kao sto smo uradili u liniji koda (10). i vidimo da vise nije 20 vec 21. } Kada pokrenemo program izgledace ovako: 11 20 21 //posljedica 6 liniji koda //posljedica 7 linija koda //posljedica 8 linije koda Dakle promnjeniva tuna se prvo povecala pa prikazala na ekranu iz razloga sto je ++ prije nje (linija 6). 6.out. public class Increment { 2. System. int swordfish = 20. Isto mozemo smanjiti vrijednost varijable ako ukucamo --tuna.out. 2. 3.out.Lekcija 9: Increment Operators(increment-“dopunsko punjenje) Uzmimo da imamo: 1. 12. a tuna je jednaka 10. ). 4. 10. } 10.Scanner. Kada stavimo ++ prije to se zove preincrementing. ~6~ . Inkrementiranje i dekrementiranje mozemo raditi u letu. 9.out. Npr. znaci da je sad tuna uvecana za jedan. To da se promjenjiva swordfish povecala vidimo kada smo u 8 liniji koda pozvali da se vrijednost te promjenjive prikaze . 6. 4. 8. slobodno mozemo napisati System. 7. dok je promjenjiva swordfish prvo prikazana na ekranu pa se tek onda povecla vrijednost ove promjenjive iz razloga sto je ++ poslije promjenjive.util. ++tuna. npr: 1. To se zove post incrementing .

Mozemo takodje koristeci operator dodjeljivanja (=) povecati vrijednost neke varijable . npr:
public class Increment { public static void main(String args[]){ int tuna = 10; int swordfish = 20; tuna = tuna + 5; System.out.println(tuna); } }

Kada pokrenemo ovaj program dobili bih smo rezultat 15. To je iz razloga sto smo promjenjivoj tuna dodjelili vrijednost tuna + 5 (10+5). Ako zelimo mozemo vrijednost varijable povecati, smanjiti pomnoziti sa nekim drugim brojem (da nije jedan) mozemo koristi operatore:     += , kada bismo napisali tuna +=5; vrijednost bi se povecala za 5. -= , kada bismo napisali tuna -=5; vrijednost bi se smanjila za 5. *= , kada bismo napisali tuna *=5; vrijednost bi se pomnozila sa 5. /= , Kada bismo napisali tuna /=5; vrijednost bi se podjelila sa 5.

~7~

Lekcija 10: if naredba
Pomocu if naredbe komjuter donosi odluke. Sintaksa: If (/*uslov ili test, koji nam daje dva izbora*/) { /*prvi dio koda ako je uslov tacan*/} else {/*drugi dio koda ako je test netacan*/} , npr :
public class lekcija10ifstat { public static void main(String args[]){ int test = 6; if (test == 9){ System.out.println(“this is same”); }else { System.out.println(“this isn’t same”); } } }

Kada pokrenemo ovaj program ispisace se: „this isn't same“ zato sto promjenjiva test nije jednaka 9, pa se izvrsava dio koda pod else. Da je vrijednost promjenjive test 9 onda bih kao rezultat pokretanja programa dobili „this is same“, jer je test promjenjiva jedanka 9 i izvrsava se dio koda kada je test tacan. Kao sto vidimo u testu se odlucuje koji dio koda ce se izvrsiti. Ako je test tacan izvrsice se dio koda odmah poslije uslova u viticastoj zagradi (u ovom primjeru to je naredba System.out.println(„this is same“); . Ako test nije tacan izvrsice se dio koda koji se nalazi odmah poslije else u viticastim zagradama (U ovom primjeru to je System.out.println(„this isn't same“);). u zagradi u if (test == 9) kojoj se nalazi uslov ili test u ovom primjeru pise sledece:

ovo „ == “ je uslovni operator a ima ih 7: 1. == , da li je test promjenjiva tacno jednaka 9 (ne koristimo jedno =, zato sto je to operator dodjeljivanja). 2. != , da li test promjenjiva nije jednaka 9 if (test != 9) 3. > da li je test promjenjiva veca od 9 if (test > 9) 4. < da li je test promjenjiva manja od 9 if (test < 9 ) 5. >= da li je test promjenjiva veca ili jednaka 9 if (test >=9) 6. <= da li je test promjenjiva manja ili jedanka 9 if (test <= 9)

~8~

Lekcija 11: Logicki operatori
Postoje dva logicka operatora : 1) And ( sto znaci i ) u javi se pise && 2) Or (sto znaci ili ) u javi se pise || U if testu mozemo napraviti vise uslova pomocu „&&“ ili „ || “ logickih operatora. If( test1 && test2); ili if(test1 || test2); Npr:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17.

public class LogicOperator{ public static void main(String args[]){ int boy = 17, girl = 20; if(boy>18 && girl>18){ System.out.println("you can enter"); }else{ System.out.println("you can't enter"); } if(boy>18 || girl>18){ System.out.println("you can enter"); }else{ System.out.println("you can't enter"); } } } //test 1

//test 2

Kada pokrenemo ovaj program dobicemo: you can't enter you can enter //posljedica testa 1 // posljedica testa 2

Kao sto vidimo imamo dva testa : test1 tj. if( boy >18 && girl >18) i test2: if(boy>18 || girl>18). Ova dva testa na oko izgledaju isti ali se razlikuju u jednoj bitnoj stvari , tj. razlikuju se na nacin na koji su uslovi unutar testa povezani. Kod testa 1 uslovi su povezani sa operatorima && , sto znaci da oba uslova ( i boy > 18 i girl > 18 ) moraju biti ispunjena da bih se izvrsio dio koda kada je test tacan. Mi kao izvrsavanje prve if naredba imamo rezultat: you can‟t enter, iz razloga sto je 18 vece od promjenjive boy, pa se izvrsava dio koda pod else. Dok kao izvrsavanje druge if naredbe imamo rezultat: you can enter , iz razloga sto je girl>18 (a potrebno je da samo jedan uslov od dva bude tacan jer su povezani sa “||”), pa se izvrsava dio koda kada je test tacan.

~9~

break. switch(age){ case 1: System. iz razloga sto imamo definisano sta da se izvrsi kada je vrijednost promjenjive age jednako 10 (case 10: tj. break. Da je vrijednost promjenjive age npr.println("you are old motherfucker"). iz razloga sto je vrijednost age promjenjive 7 pa se izvrsva default dio koda jer nemamo naznacenu opciju da je vrijednost 7.2 . Kao sto mozemo primjetiti poslije svakog slucaja (ukljucujuci i default) smo stavili break . break. } primjer: public class Switch{ public static void main(String args[]){ int age = 7.println("you can crawl").10 i default (ono sto se izvrsava kada nijedno od ovih opcija nije).println(“you are old motherfucker”). 1 znaci: ako je vrijednost promjenjive kojda se testira 1 //ono sto ce se izvrsiti u slucaju da je vrijednost promjenjive koja se tesitira ==1 // break znaci ako je case 1 da stane sa izvrsenjem instrukcije switch 2: //n je bilo koji broj //default koji je rjesenje kada nijedan od slucajeva tj. case n: break. default: break.Lekcija 12: switch naredba switch naredba testira jednu varijablu (promjenjivu) i zavisno od te promjenjive daje nam vise izbora. case 10: System. System. i da nemamo break. program bi provjeravao sve ostale slucaje. break.println("you are young"). case nije zadovoljen Kada pokrenemo ovaj program gore dobicemo: there isn‟t specified . sintaksa izgleda ovako : switch(/*promjenjiva case 1: System.println(). sto znaci da kada se nadje trazeni slucaj vise se nece dalje provjeravati vec ce se switch naredba zavrsiti.out.println("there isn't specified"). 10 onda bih kao rezultat dobili : you are old motherfucker . } } } koja se testira*/) { // case znaci slucaj. Npr: da je vrijednost promjenjive age jedanko 1 . break. Imamo opcije da je vrijednost godina 1.out. ~ 10 ~ . default: System. case 2: System. case break.out.out.out. unutar koda koji ce se izvrisiti u slucaju da je age jednako jedan .out. ).

Sintaksa je sledeca: while ( /* u zagradi se nalazi test*/ ) { /* sve sto je unutar viticastih zagrada tj tjela petlje ce se izvrsavati iznova sve dok je zadovoljen test */} primjer: public class While{ public static void main(String args[]){ int counter = 0.println("ovo je " +counter+" iteracija ove petlje"). ~ 11 ~ . tj. 10 < 10 . while nam omogucava da izvrsavamo dio koda vise puta . Ona je ponovljena 10 puta iz razloga sto je trebalo deset puta da se izvrsi tjelo petlje i da se inkrementira promjenjiva counter (tj counter++) da bih na kraju kada je dostigla vrijednost 10 nije vise bio zadovoljen test (counter < 10 .out. a da ga napisemo samo jednom. counter++.println(“ovo je “+ counter + “ iteracija ove petlje”). je ponovljena 10 puta. ma kako se ona zvala. while(counter<10){ System. Promjenjiva koja kontrolise while petlju ne mora se zvati “counter” vec to moze biti bilo koja promjenjiva koja se moze upotrebiti da se dobije logicko true ili false . a koristili smo je unutar while petlje.Lekcija 13: While loop U prevodu loop znaci petlja.out. nije tacno) i petlja je zavrsena. Promjenjivu counter ( u prevodu brojac) smo definisali izvan same petlje . } } } Kada pokrenemo ovaj program dobicemo: ovo ovo ovo ovo ovo ovo ovo ovo ovo ovo je je je je je je je je je je 0 1 2 3 4 5 6 7 8 9 iteracija iteracija iteracija iteracija iteracija iteracija iteracija iteracija iteracija iteracija ove ove ove ove ove ove ove ove ove ove petlje petlje petlje petlje petlje petlje petlje petlje petlje petlje Kao sto vidimo instrukcija : System.

Imamo dve vrste promjenjivih:   Promjenjive instance koje cuvaju atribute konkretnog objekta koji se razlikuje u slucaju razlicitih objekata iste klase. void znaci da ce metoda raditi nesto (return je suprotno od void i znaci da kada se izvrsi metoda da ce se neka vrijednost vratiti tj. tj.SimpleMessage(). Npr klasa Tuna: public class Tuna { /*klasa*/ public void SimpleMessage(){ /*metoda*/ System. dok klasa koje nasljedjuju neku klasu moze biti neograniceno. } } Prvo sto moramo uraditi u main klasi jeste da kreiramo objekat za klasu koju zelimo ubaciti. Moguce je nasljedjivanje. mozemo vidjeti puno bicikala . t. to isto vazi i za metode.Svaki put kada vidimo public ispred imena klase to znaci da ce biti dostupna ostalim klasama za koristenje. Sada kada pokrenemo ovaj kod klasa Apples dobicemo : This is another class named Tuna . Medjutim instancu ove klase (tj. Sada kada imamo kreiranu instancu klase Tuna koju smo nazvali t¸ pomocu nje mozemo pozivati metode klase Tuna i pristupati promjenjivim klase Tuna. Promjenjive/ metode klase mozemo prepoznati po tome sto u zaglavlju imaju static. . Sve klase nasljeduju ovu klasu. “return”). Metodi pozivamo tako sto ukucamo: ImeObjektaKlase. tj u ovom slucaju Tuna t = new Tuna( ). Objekat se kreira tako sto ukucamo : ImeKlaseOdKojePravimoObjekat imeObjekta = new ImeKlaseOdKojePravimoObjekat ( ).imeMetode( ). Klasa koja nasljedjuje neku drugu klasu naziva se izvedena klasa (podklasa) dok klasa koja se nasljedjuje naziva se nadklasa (superklasa). Na vrhu hierarhije Java klasa je klasa Object. Klasa moze nasljediti samo jednu klasu .Lekcija 14: Klase U stvarnom svjetu mozemo vidjeti puno idividualnih objekata iste vrste. Npr. Klase se sastoje od promjenjivih i metoda. U objekto orjentisanom programiranju biciklo je instanca klase. } } Kao sto vidimo klasa tuna ima metodu kojoj je SimpleMessage. Klase su organizovane u hierarhijsku strukturu. u ovom slucaju t. objekat) mozemo kreirati u nekoj drugoj klasi koja sadrzi main metodu. ~ 12 ~ .SimpleMessage(). Promjenjive klase cuvaju atribute koji su jedinstveni za sve objekte iste klase ( definise se na nivou klase i cuva se samo jedna vrijednost koja kad se promjeni mjenja se za sve objekte te klase) Takodje imamo dve vrste metoda:   Metode instance : ukoliko metoda obavlja izmjenu pojedinacnog objekta. Kada pokrenemo ovaj program gore nista se nece desiti iz razloga kada pokrenemo Java program on trazi main metodu. Metoda klase : se primjenjuje na samu klasu..out.println("This is another class named Tuna"). ali svaki od njih je uradjen po istom nacrtu sto ga i cini biciklom. dok nacrt koji sluzi da se napravi biciklo predstavlja klasu. Kreiracemo instancu ove klase u klasi Apples : public class Apples { public static void main(String args[]){ Tuna t = new Tuna().

~ 13 ~ .nextLine() ) .in).println("Hello" + name) } } Kao sto vidimo ova klasa ne moze samostalno funkcionisat jer nema glavnu klasu i jer promjenjiva name nije definisana. Kada pokrenemo ovaj program dobicemo opciju da nesto upisemo. TunaObject. } } Prvo smo unijeli Scanner jer cemo koristiti tastaturu ( import java.nextLine().Scanner.out. System. mi cemo upisati npr.Lekcija 15: Koristenje metoda sa parametrima U ovom primjeru cemo imati dve klase glavnu klasu Apples i vanjsku Tuna. ustvari kaze .SimpleMessage (name).out. Iz klase Tuna pokreni metodu Simple. ) jer bez njega ne mozemo koristiti nista iz klase Tuna.SimpleMessage(name).println(" Enter your name "). TunaObject. u ovom slucaju : SimpleMessage) je argument (tj. kako bi smo ono sto napisemo koristeci tastaturu skladistili u input promjenjivu tipa Scanner. I zadnja linija koda tj.util. Ono sto se nalazi u zagradama poslije naziva metode (tj. Glavna klasa Apples: import java.u ovom slucaju : String name). Klasa Tuna : public class Tuna { public void SimpleMessage(String name){ System. String name = input. ). Kada bismo pokrenuli ovaj program dobili bih smo samo Hello bez name iz tog razloga nam je potreban argument tj (String name). Zatim smo napisali Scanner input = new Scanner (System. Djordje i program ce nam vratiti : Hello Djordje .nextLine(). imamo promjenjivu name i tu smo definisali da je ona jedanka bilo cemu sto ukucamo tastaturom(input. Onda smo kreirali objekat TunaObject ( Tuna TunaObject = new Tuna().in). Dalje kod String name = input.Scanner. A argument ili ekstra parametar je neka informacija koja je potrebna metodi da bih funkcionisala. Tuna TunaObject = new Tuna(). public class Apples { public static void main(String args[]){ Scanner input = new Scanner(System.util.Message i prosljedi kao trazeni argument promjenjivu name.

Lekcija 16: Many Methods and Instances
Koristicemo dve klase, Apples kao glavnu i Tuna kao sporednu. Klasa Tuna :
1. public class Tuna { 2. 3. private String girlname; 4. 5. public void setName(String name){ 6. girlname = name; 7. } 8. public String getName(){ 9. return girlname; 10. } 11. public void saying(){ 12. System.out.printf("My firs gf was $s", getname()); 13. } 14. }

Postoje dve vrste promjenjivih public i private. private promjenjive, oznacavaju da samo metode unutar te klase mogu je koriste. U (3) liniji koda smo kreirali promjenjiva girlname tipa String koja je private promjenjiva. Poslije nje u (5) liniji koda vidimo metodu Setname tj tacno: public void Setname(String name) , vidimo da ova metoda zahtjeva u zagradi String promjenjivu, i da tjelo metode zahtjevani String postavlja kao vrijednost girlname (koja je u (3) liniji koda kreirane). Kod druge metode (8 linija koda) getname nemamo parametara u zagradama ali pise: public String getname(), String znaci da ce ova metoda vratiti String pa posljedicno tome u tjelu imamo naredbu return girlname ( return znaci da vraca vrijednost promjenjive girlname). Kod trece metode tj: public void saying () imamo insrukciju System.out.printf(“My first gf was %s”, getname()) , gdje god imamo %s moramo poslije zareza odrediti koji “String” zelimo staviti na mjesto %s. Mi smo poslije zareza stavili getname(), sto znaci da ce umjesto %s ici vrijednost koju ima getname(). Glavna klasa ima sledeci izgled:
import java.util.Scanner; public class Apples{ public static void main(String args[]){ String temp; Tuna t = new Tuna(); Scanner input = new Scanner(System.in); System.out.println("Napisite ime djevojke"); temp = input.nextLine(); t.setName(temp); t.sayName(); } }

Kod String temp smo napravili privremenu promjenjivu ( temp nema nikakvog znacenja sa temporary (privremeno) mozemo je nazvati kako bilo) , dok = input.nextLine znaci da sta god ukucamo bice smjesteno u promjenjivu temp ( temp = input.nextLine(); ). Sledece trebamo uraditi nesto sa onim sto ukuca korisnik i smjesti se u temp. TunaObject.Setname(temp); ono sto radi ova instrukcija jeste da poziva metodu Setname iz klase Tuna i kao zaghtjevani String joj prosljedjuje temp. Zatim zadnja instrukcija TunaObject.saying(); poziva metodu saying iz klase Tuna koja u svom tjelu poziva metodu getname (takodje iz klase Tuna , koja vraca vrijednost promjenijive girlname) koja se prikazuje unutar instrukcije: System.out.printf(“My first gf was %s”, getname ());.

~ 14 ~

Lekcija 17: Constructors
Constructor nam dozvoljava da inicijaliziramo promjenjivu cim kreiramo objekat. Npr, kao u proslom primjeru imacemo dve klase Apples i Tuna. U Tuna klasi cemo napraviti Constructor. On se pravi isto kao i metoda samo sto ime constructora mora biti isto kao ime klase u kojoj se nalazi.
public class Tuna { private String girlname; public Tuna(String name){ girlname = name; } /*constructor*/ /*constructor*/ /*constructor*/

public void Setname(String name){ girlname = name; } public String getname(){ return girlname; } public void saying(){ System.out.printf("My firs gf was %s", getname()); } }

Dakle : public Tuna(String name) – je konstruktor, i on ima samo jednu funkciju tj. da inicijalizuje kreiranu instanuc klase. Tj da rukovodi sa onim sto stavimo u zagradi poslije new imeKlase ( u ovom primjeru “bla1” i “bla2”).
public class Apples { public static void main(String args[]){ Tuna t1 = new Tuna("bla1"); Tuna t2 = new Tuna("bla2"); t1.saying(); t2.saying(); } }

/*jedan objekat klase Tuna*/ /*drugi objekat klase Tuna*/

Sada imamo constructor u klasi Tuna koji radi sa kreiranim objektima koji imaju jedan String argument. U klasi Apples smo kreirali dva objekta i u zagradi stavili po jedan String argument (sto znaci da ce se ovi objekti cim se kreiraju obratiti konstruktoru klase Tuna koji zahtjeva jedan String argument). Razmortrimo kreiranje prvog objekta: Tuna t1 = new Tuna (“bla1”);, Dakle kreirali smo objekat t1 koji je instanca klase Tuna. “bla1” se automatski prosljedjuje konstruktoru klase Tuna , tj. prosljedjuje se : public Tuna (String name) , koji u svom tjelu ima naredbu girlname = name; sto znaci da ce “bla1” biti postavljeno za vrijednost girname promjenjive objekta t1. Isto je kod objekta t2 samo sto ce njegova vrijednost girlname biti “bla2”. t1.saying – je pozivanje metode saying klase Tuna koja prikazuje vrijednost atributa girlname za dati objekat ( to jest u ovom slucaju objekat t1 ).

~ 15 ~

Lekcija 18: Nested If Naredbe
Umjesto da imamo samo jednu akciju ako je test , tacan ili netacan mozemo imati vise njih, npr:
public class Apples { public static void main(String args[]){ int age = 60; if(age < 50){ System.out.println("you are young"); }else{ System.out.println("you are old"); if(age < 75){ System.out.println("you’re really old"); }else{ System.out.println("don't worry"); } } } }

Kada pokrenemo ovaj program dobicemo rezultat : you are old you are really old Sve ovo je ugnjezdjena if naredba: if(age < 50){ System.out.println("you are young"); }else{ System.out.println("you are old"); if(age < 75){ System.out.println("you’re really old"); }else{ System.out.println("don't worry"); } } Ovo sto je napisano plavim slovima je ono sto ce se dogoditi ako je test zadovoljen ( age < 50 ). Napisano crvenim slovima je ono sto ce se dogoditi ako test nije zadovoljen. Poslije prvog else koji je pocetak onog sto ce se dogoditi ako test nije zadovoljen nije zatvovrena viticasta zagrada vec je dodano novo if sa svojim else i tako se moze uraditi napisati dosta onoga sto ce se dogoditi ako test nije zadovoljen . Zagrada oznacena zelenom bojom je zagrada koja znaci zavrsetak onoga sto ce se dogoditi ako prvobitni test ( age <50 ) nije zadovoljen. U glavnome else svako if i svako else mora imati zatvorenu viticastu zagradu.

~ 16 ~

println(“You are a young buck”). else if se uvjek stavlja izmedju glavnog if( if(age > 60 ) i zadnjega else.} } } Dakle jednostavna if naredba nudi jednu opciju ako je test tacan i drugu else opciju ako test nije tacan.out.println(“you are a senior citizen”).println("You } } are a senior citizen").println("You else if(age >= 40) System. else if(age>=40).println(“You are in your 40s”). System.println(“You are in your 40s”).our.println("You else System. on pita pod (1) da li je age vece od 60. System. .out. 2. System. ~ 17 ~ . }else{ System.println("You else if(age >= 50) System. else if(age >=50). Dakle kada naidje na pozitivan odgovor prestaje sa izvrsavanjem i nema portrbe da ide pod (4). if(age > 60) . Zato cemo na ekranu imati ispisano “You are in your 40s”. odgovor je ne. I mozemo imati else if alternativa koliko hocemo. Primjer : public class Apples { public static void main(String args[]){ int age = 45.out.out. are in your 40s").println("You are a young buck"). Zatim pita pod (2):da li je age vece ili jednako 50). odgovor je ne.out.out.out.println("You are a senior citizen").out. odgovor je da i izvrsava se naredba pod(3) tj: System. To funkcionise ovako: promjenjiva age je 45. else . Jednostavna if naredba izgleda npr ovako: public class Apples { public static void main(String args[]){ int age = 55. are a young buck").Lekcija 19: else if naredba else if naredba je nacin da damo javi vise opcija. else if naredba je nesto poput dodatne opcije. 3.println(“you are in your 50s”).out. if(age > 60) System. Zatim pita pod (3): da li je age vece ili jednako 40 . are in your 50s"). System.out. if(age > 60){ System. Moze se izvrsiti samo jedna od ovih naredbi : 1. 4.

} } Treba obraditi paznju na System. Prvo sto trebamo uraditi jeste da zadamo test ( u ovom primjeru age > 50 ) nakon sto zadamo test stavljamo upitnik “?”I ono sto age > 50 ? radi jest da gleda da li je age vece od 50. Npr: public class Apples { public static void main(String args[]){ int age = 21.Lekcija 20: Conditional Operators Conditional operators su drugi nacin koriscenja if else naredbe ali su veoma kompaktni i veoma mali.out. Rezultat izvrsavanja ovog programa je : you are young ~ 18 ~ . ako je age > 50) i odvojeno “ : “ sta da izbaci na ekranu ako je false( tj ako age nije vece od 50 ).println(age > 50 ? "you are old" : "you are young"). Nakon Upitnika moramo staviti sta da izbaci na ekranu ako je true (tj. .println(age > 50 ? “you are old” : “you are young”). System.out.

Zatim smo kreirali 4 promjenjive tipa int : 1. I na poslijetku imamo pod 3.println("Your average is:" + prosjek). int prosjek. ukupno = broj + ukupno. counter ili brojac ce nam sluziti da izbroji koliko smo brojeva unijeli.Scanner. } prosjek = ukupno / counter.nextInt().Vidimo iznad kako smo to izveli. } Sve dok je 10 vece od promjenjive counter ( 10 > counter) on radi sledece operacije: 1.Lekcija 21: Jednostavni program za izracunavanje prosjeka Napisali smo program za izracunavanje prosjeka 10 brojeva koje unesemo: import java. int broj. Kada se zavrsi naredba while tj kad 10 ne bude vise vece od promjenjive counter program prelazi na sledecu liniju koda tj. 3. public class Apples { public static void main(String args[]){ Scanner input = new Scanner(System. int ukupno = 0. tj.in).out. omogucili da je koristimo koristeci Scanner promjenjivu input. tj izracunava ukupan zbir svih brojeva koje smo unijeli tako sto promjenjivoj ukupno dodjeli zbir prijasnje vrijednosti promjenjive ukupno i novi broj u vidu promjenjive broj. ~ 19 ~ . sto znaci da ce se svaki put kad se ponovi while naredba promjenjiva counter povecati za jedan. koja govori izbaci na ekranu “Your average is “ i vrijednost promjenjive prosjek.on ce skladistiti srenju vrijednost. System. while(10>counter){ broj = input. sve sto ukucamo skladisti se u varijablu broj. prosjek =ukupno / counter. ukupno – koji ce izracunati ukupan zbir 10 brojeva koje unesemo. Zatim imamo while petlju: while(10>counter){ broj = input.nextInt(). } } Unijeli smo tastaturu. sto je nacin da izracunamo prosjek tako sto podijelimo ukupni zbir brojeva koje smo unijeli i counter (koliko smo brojeva unijeli ). counter++. ukupno = broj + ukupno. broj = input.out. 4. Na kraju imamo naredbu System.nextInt(). 2. int counter = 0. broj-to ce biti svaki pojedinacni broj od 10 koje unesemo. counter++.println(“You average is : “ + prosjek) . prosejek. ukupno = broj + ukupno. Zatim 2.util. counter++.

argument3)    argument 1: brojac argument 2: test (provjerava se npr. } } } U ovom primjeru petlja for izgleda: for (int counter=1. tj dobicemo sledece: ovo je 1 iteracija petlje ovo je 2 iteracija petlje ovo je 3 iteracija petlje ovo je 4 iteracija petlje ovo je 5 iteracija petlje ovo je 6 iteracija petlje ovo je 7 iteracija petlje ovo je 8 iteracija petlje ovo je 9 iteracija petlje ovo je 10 iteracija petlje ~ 20 ~ . da li je argument1 veci od 10 argument3: odredjujemo za koliko da se mjenja argument 1 Primjer: public class Apples { public static void main(String args[]){ for (int counter=1. ” .counter++) otvaramo viticastu zagradu da definisemo sta ce ova petlja raditi(naravno moramo tu zagradu i zatvoriti kada to definisemo). sto znaci da ce se sve dok se vrti petlja na ekranu u svakoj sledecoj liniji prikazivati vrijednost promjenjive counter.counter++). Konstrukcija for petlje je: for( argument1.    Argument1 ili int counter=1 . znaci da ce se petlja izvrsavati sve dok je 10 vece ili jedanko promjenjivoj counter (argument 1). Argument2 ili counter<=10. .println(“ovo je “ +counter+ “iteracija petelje”). znaci da smo napravili promjenjivu counter (tipa int) cija je vrijednost 1 .counter<=10.println(counter). Argument3 ili counter++.argument2. Unutar viticaste zagrade mi smo stavili System. sto znaci da nam petlja pocinje od 1.out. argumenti su razdvojeni sa “ .out.counter<=10.Lekcija 22: for loop (petlja) For petlja zahtjeva 3 argumenta da bih radila.counter<=10.znaci da ce se promjenjiva counter uvecavati za 1 prilikom svake iteracije. Nakon svega toga tj: for (int counter=1.counter++){ System.

182686950395 10361. double trenutniiznos=7000.0816=7571. Dakle Math. for(int year=1.2 iz razloga sto je 7000*1.3) dobicemo rezultat 43 tj. Primjer: public class Apples { public static void main(String args[]){ double iznos.983352836918 9963.009920000001 8516. Iznos = trenutniiznos*Math.04 ili 4%) year puta.pow je vanjska metoda koja ima dva argumenta.pow( argument1. U drugoj godini imamo iznos=7571. } } } Kada pokrenemo ovaj program dobicemo koliki ce nam iznos biti za 10 godina .04 iz razloga sto je year=2) .233129472 9211. argument2).048000000001 8189.5703168 8857.year<=10.0 7571.pow(4.04 jednako 7280.64.pow(1+ kamata. npr Math.pow je nacin da dobijemo kvadrat nekog broja . System. tj: 1 2 3 4 5 6 7 8 9 10 7280.Lekcija 23: Compound Interest(interkalarna kamata) Program Napravicemo program koji ce izracunavati koliko ce se povecavati odredjeni broj(npr racun u banci) ako je kamata 4% . trenutniiznos se mnozi sa 1+kamata(sto je uvjek 1. funkcionise na sledeci nacin .200000000001 7874.println(year + " " + iznos). double kamata= 0. year).522454650882 9579. year).pow( 1+kamata. ~ 21 ~ . kroz 10 godina.out.04. Argument1 je u ovom slucaju 1+kamata a Argument2 je eksponent(je broj koji pokazuje koliko puta argument1 treba pomnoziti sam sa sobom) u ovom slucaju year puta.709994428411 Math.1 (imamo dva puta 1. U godini jedan iznos=7280 iz razloga sto je 7000(trenutniiznos)*1. Math.year++){ iznos= trenutniiznos*Math.

do while Izgleda ovako: do{ Instrukcija1.6.println(counter). counter++. }while(counter<=10).out.out.println(counter). Dobijeni rezultat nakon pokretanja programa izgleda ovako: 15 ~ 22 ~ . do{ System. counter++.println(counter). }while(counter<=10). } } Kada pokrenemo ovaj program dobicemo izlistane brojeve od 1 do 10 tj: 1.3.10 (jedan ispod drugog). U prvom primjeru je counter=1 dok je u drugom primjeru counter=15. ) pa tek onda se provjerava test (tj da li se treba dalje izvrsavati petlja) (counter <=10 ).) zatim se counter povecao za 1 (counter++) pa je tek onda pokrenut test ( counter <=10 ) gdje se utvrdilo da 10 vise nije vece ili jednako counter( koji je 15) pa se izvrsavanje petlje prekida.Lekcija 24: do while petlja Ono sto do while petlja radi jeste da izvrsi tjelo (body) petlje prije nego sto provjeri test . tako da nam je zagarantovano da ce se tjelo izvrsiti bar jednom.out. Kada pokrenemo drugi program( counter=15 ) na ekranu ce se ispisati samo broj 15 iz razloga sto se prvo izvrsava tijelo petlje (u ovom slucaju System.5.7.println(counter).out. do{ System. Izvrsilo se tjelo program je pokazao vrijednost 15 (System. } } Jedina razlika izmedju ova dva koda je u promjenjivoj counter. Tjelo se nalazi unutar viticastih zagrada .4.9.2. Instrukcija2. Tako da se cini da je do while petlja ne razlikuje od while petlje ali postoji razlika koju cemo ilustrovati na primjeru koji slijedi: public class Apples { public static void main(String args[]){ int counter=15.8. }while( test) Npr: public class Apples { public static void main(String args[]){ int counter=0. counter++.

max(broj1.sqrt(broj) .println("manji broj od broja1 i broja 2 je " + Math.367320587102 kvadratni korjen broja1 je 1.out.println("broj1 zaokruzen nanize je : "+ Math.out. System.out.min(broj1. System. 2) Math. Neki primjeri Math.println("broj1 na broj2 je : “ +Math.println("kvadratni korjen broja1 je "+Math.round(broj1)).sqrt(broj1)). System.out.broj2)).out.println("broj2 zaokruzen navise je : "+ Math.pow(broj.round(broj) .0 ~ 23 ~ .out.14. 5) Math.println(“najblizi cjeli broj na koji se Moze zaokruziti broj1 je: “ +Math.pow(broj1. System.Scanner.vadi kvadratni korjen Primjeri: import java. public class Apples{ public static void main(String args[]){ double broj1 = 3. System.772004514666935 kvadratni korjen broja2 je 3.println("apsolutna vrijednost broja1 je: " + Math.broj2.floor(broj) .out.broj2. broj2)).ceil(broj2)).14 veci broj izmedju broja 1 i broja 2 je: 9. broj2)). double broj2 = 9.floor(broj1)).brojn) – prikazuje broj koji ima najmanju vrijednost 7) Math.) i metoda.max(broj1.println("veci broj izmedju broja 1 i broja 2 je: " + Math. } } Rezultat izvrsavanja gornjeg programa je: apsolutna vrijednost broja1 je: 3.Lekcija 25: Ugradjene matematicke metode Sve metode iz matematicke klase pocinju sa Math zatim ide tacka (.bilo koji decimalni broj koji stavimo u zagradu bice zaokruzen nanize 4) Math.util. System.sqrt(broj2)).brojn) – prikazuje broj koji ima najvecu vrijednost 6) Math.metoda: 1) Math.bilo koji decimalni broj koji stavimo u zagradu bice zaokruzen navise 3) Math.min(broj1.absolute value bilo koji broj stavimo u zagradu bio on pozitivan ili negativan bice prikazan bez predznaka tj razlika tog broja do 0.ceil(broj) .14 broj1 zaokruzen nanize je : 3.0 broj2 zaokruzen navise je : 9. System.0 najblizi cjeli broj na koji se moze zaokruziti broj1 je : 3 broj1 na broj2 je 29673.abs(broj) .0 manji broj od broja1 i broja 2 je 3.abs(broj1)).out. System.bilo koji broj koji stavimo bice zaokruzen na najblizu vrijednost. System.out.println("kvadratni korjen broja2 je "+ Math. eksponent) – prikazuje broj pomnosen sam sa sobom eksponent puta 8) Math.

. int broj. } } } Dakle generator nasumicnih brojeva se kreira tako sto importujemo prvo java.nextInt(6).util. je 6 raspon sto znaci da ce ovaj generator generisati brojeve izmedju 0 i 5. sto ce nas dovesti do zeljenog rezultata na nacin: 1 + dice. .counter++){ broj = 1 + dice. .out. tj u nasem primjeru dice. for(int counter=1. U tjelu for petlje imamo number = 1 + dice. Jedino se slucajno moze desiti da se generisu dve iste kombinacije: bacanje br: 1 broj: 2 bacanje br: 2 broj: 3 bacanje br: 3 broj: 4 bacanje br: 4 broj: 4 bacanje br: 5 broj: 2 bacanje br: 6 broj: 2 ~ 24 ~ . S obzirom da kocka za bacanje ima brojeve od 1 do 6 .out.counter<=brojBacanja. kao i sako sledece izvrsavanje.nextInt(/*raspon*/). sto znaci da je promjenjiva number jedaka bilo kojem broju izmedju 0 I 5 . mi cemo svakom generisanom novom broju izmedju 0 i 5 dodati 1 . zatim ukucamo : Random dice = new Random().Random.nextInt(6). public class Apples{ public static void main(String args[]){ int brojBacanja = 6. Dalje imamo for petlju koja ce se izvrsavati 6 puta .nextInt(6). Rezultat jednog izvrsavanja je : bacanje br: 1 broj: 4 bacanje br: 2 broj: 3 bacanje br: 3 broj: 1 bacanje br: 4 broj: 2 bacanje br: 5 broj: 6 bacanje br: 6 broj: 1 Rezultat nekog drugog izvrsavanja je drugaciji. System.4.. uvecanom za 1. Random dice = new Random().println("bacanje br: "+counter+" broj: "+ broj).nextInt(6).util. sto simulira 6 bacanja kocke. Kada pokrenemo ovaj program prikazace nam se nasumicnih 6 brojeva izmedju 1 i 6.println(“bacanje br: “+counter+” broj: “+ broj ).Random.3. Nasumicni brojevi se generisu naredbom ImeRandomPromjenjive. I naposljetku imamo instrukciju da se tih sest bacanja prikaze na ekranu ( System.6) : import java. sto znaci da smo kreirali Random promjenjivu naziva Dice.5.2. .Lekcija 26: Random nuber Generator Napravicemo program koji ce simulirati bacanje kocke sest puta (ima sest izbora:1.

djordje[2]=12. Iz tog razloga kada smo napisali System. System. na ekranu smo dobili broj 2. Kada kreiramo Array prvo napisemo koje vrste ce biti podatci koje cemo skladistiti ( npr int) zatim ime array promjenjive i poslije toga kockaste zagrade [ ] te = new int[/*neki broj koji oznacava koliko ce vrijednosti ili promjenjivih biti skladisteno u ovom Array*/] Primjer: public class Appless { public static void main(String args[]){ int djordje[]= new int[10].println(djordje[4]).println(djordje[9]). br:7 ima indeks:1 . djordje[6]=32.5. element2. djordje[3]=123.6. djordje[0]=10. Prvo ukucamo vrstu podataka koje ce skladistiti ( u ovom primjeru int) zatim ime array-a sa ovim zagradama [] zatim = pa u otvorenoj viticastoj zagradi ukucamo vrijednosti kojima array sam pripise indeks iduci po redu od 0 pa nadalje. Samo Int ili String ili double.7. mi smo definisali prvu vrijednost tako sto smo napisali ime array-ja zatim u [] redni broj ili indeks vrijednost/promjenjive i nakon toga jednako kojoj vrijednosti. Postoji I malo brzi nacin da definisemo vrijednosti koje ce da sadrzi.2. ~ 25 ~ . Isto tako redom se dodjeljuju indeksi pocevsi od nule . djordje[9]=9.3.println(djordje[1]). } } Int djordje[]={1.2. } } Int djordje[] =new int[10]. br:3 ima ideks:3 . S obzirom da racunar uvjek pocinje da broji od 0 . br:6 ima indeks:2.3. Br: 1 ima indeks: 0. dobili smo broj sa indeksom 4 tj. djordje[1]=17. To izgleda ovako djordje[0]=10.7. djordje[5]=143. br:2 ima indeks:4 I naposljetku br:5 ima indeks:5.out. Konstrukcija je sledeca : tipPodatakaKojiseSkladisti ImeArraya [] = {element1.poredak) Array je promjenjiva koja moze da skladisti vise vrijednosti. element3. djordje[8]=8.3.6.Takodje moze da skladisti I objekte. Ona moze da skladisti samo vrijednosti iste vrste npr.6.2. djordje[7]=82. System.7. je Array koja moze imati deset vrijednosti.Lekcija 27: Introduction to Arrays( array – mnostvo. Kada kreiramo array moramo zadati koliko moze sadrzavati vrijednosti/promjenjivih. je isto array samo sto smo mi odmah upisali vrijednosti redom 1.out. djordje[4]=15. primjer: public class Appless { public static void main(String args[]){ int djordje[]={1.5}.5}.out. To se zove array initializator i kreira se na sledeci nacin . elementn} .

~ 26 ~ .Lekcija 28: Creating an Array Table Kreirati cemo “tabelu” koja ce nam prikazivati koju vrijednost indeks Array-a ima.println(“index\tValue”).length . Primjer: public class Apples { public static void main(String args[]){ System. da nismo napisali koliko puta treba da se izvrsi ova petlj vec smo napisali djordje. Da npr. treba primjetiti kada smo zadavali drugi argument tj counter < djordje.15.println("index\tValue"). Zatim smo napravili Array: int djordje[]={14. S obzirom da je pocetna vrijednost counter promjenjive 0.out.counter<djordje. na ekranu bi nam se ispisalo pet puta broj 15 . Djordje[counter] – counter je dakle indeks .length. Nakon toga smo napisali for petlju: for (int counter=0. gdje se counter poistovjecuje sa indeksom elementa a djordje[counter] sa vrijednoscu koji taj indeks ima.out.out.15.length. sto je u ovom slucaju 6. u prvom redu “tabele” bice pod Index prikazano 0 . U samoj for petlji smo definisal sledece: int counter=0 sto znaci da counter pocinje od 0 sto nama odgovara jer i indeki u Array-ju pocinju od nule. jer vrijednost u djordje Array sa indeksom 1 je 15.22.22.length.counter++){ System.16. sto nam daje broj elemenata unutar Array-a djordje . } } } Kada pokrenemo ovaj program dobicemo sledece: index 0 1 2 3 4 Value 14 15 16 22 10 //zaglavlje tabele //prvi red //drugi red Dakle na pocetku smo napravili zaglavlje tabele ukucali smo: System. koji ima 6 elemenata. for(int counter=0. pise djordje[1] . int djordje[]={14.10}.16.out. Naposljetku u tjelu for petlje imamo System.println(counter + "\t"+ djordje[counter]). pa ce nam djordje[counter] prikazati vrijednost elementa sa indeksom counter. a pod Value vrijednost koju ima element djordje Array-a sa indeksom 0 (u ovom slucaju 14). .10.counter<djordje.counter++) . .println( counter + “\t” + djordje[counter]). ovo “ \t “ je ustvari Tab tj razmak pa zato imamo razmak izmedju index i Value sto vidimo u zaglavlu “tabele”.17}..

face++){ System.4.counter<djordje.length.roll++){ ++freq[1+rand.6.out.nextInt(6)].println(face+"\t"+freq[face]).Random.length. int sum=0.10}. for(int face=1. Tacnije ono sto cemo uraditi jeste da cemo napraviti program koji ce simulirati bacanje kocke 1000 puta i prikazati koliko puta se pojavio koji broj u vidu tabele. koji ce skladistiti vrijednosti koliko se puta koji indeks ponovio ( indeks posistovjecujemo sa stranom kocke dok vrijednost indeksa ce prikazivati koliko je puta kocaka pala na tu stranu).println("ukupan zbir je: " + sum). } } } Kada pokrenemo ovaj program dobicemo sledece: Face 1 2 3 4 5 6 Frequency 179 176 148 163 169 164 Napravili smo Array freq [] = new int[7]. Lekcija 30: Array Elements as Counters Napravicemo program koji ce uzeti Array elemente i skladistiti ih kao countere. Da smo freq definisali da ce imati 6 elemenata.3. ~ 27 ~ . int freq[]=new int[7]. public class Apples{ public static void main(String args[]){ Random rand= new Random(). sto je tacno.9. } } Kada pokrenemo ovaj program ispisace se : “ Ukupan zbir je 55” .util.face<freq.5. Kocka ima 6 strana .out.counter++){ sum = sum + djordje[counter]. Primjer: public class Apples { public static void main(String args[]){ int djordje[]={1.println("Face\tFrequency").Lekcija 29: Summing Elements of Array Ono sto cemo uraditi jeste da cemo sabrati sve vrijednosti unutar jednog kreiranog Array-a.. zato smo Array freq definisali da ce imati 7 elemenata sa indeksima od od 0 do 6.2. Program izgleda: import java.8.} System. for(int roll=1.roll<1000. for (int counter=0.out.7. } System. indeksi bi isli od 0 do 5 pa ne bismo mogli koristiti indeks broj 6.

length je ustvari 1(face)<7(duzina array-a je 7 ) ali smo mi poceli brojati od 1. Dakle svaki put kada 1+ rand. pojednostavljeno bih izgledala ovako : ++freq[3] i vrijednost na koju pokazuje indeks 3 je sada uvecana za 1. sto nam daje 6.length.out.face++) – face=1 iz razloga zato sto je prvi broj na kocki 1. zato smo stavili 1+ sto ce nam dati iluziju da generise broj izmedju 1 i 6.nextInt(6) generise nasumican broj izmedju 1 i 6. Npr situacija da 1+rand. Taj generisani broj je indeks Array-a freq.Imamo for petlju koja simulira bacanje kocke 1000 puta : for(int roll=0.out.roll++) .println( face+ ”\t” + freq[face]).println(“Face\tFrequency”) . dok tijelo petlje ima sledeci izgeld : ++freq[ 1+rand. Rezultat jednog izvrsavanja: Face 1 2 3 4 5 6 Frequency 155 191 161 156 160 176 Drugo izvrsavanje daje drugacije rezultate: Face 1 2 3 4 5 6 Frequency 161 178 171 138 170 181 ~ 28 ~ . face<freq.nextInt(6) ce nam generisati broj izmedju 0 i 5.nextInt(6)]. Mozemo zakljuciti da Array-ju ne mozemo promejniti broj elemenata koji moze imati .face<freq. .nextInt(6) generise broj 3. ali zato mozemo mjenjati njihove vrijednosti. Sto ce nam prikazati rezultate na ekranu. zbog inkrementa ++ vrijednost elementa koji reprezentuje taj indeks ce se povecati za vrijednost 1.rand. da se generise 100 puta broj 3.roll<1000. znaci da ce se vrijednost elementa koji predstavlja generisani indeks povecati za 1. vrijednos na koju pokazuje indeks 3 bila bi 100. Dalje smo napravili zaglavlje tabele : System. Zatim smo napravili jos jednu for petlju koja ce prikazati nase podatke: for(int face=1.nextInt(6) ] . . Dok : ++freq[1+rand.U tijelu te petlje imamo System.

Nakon toga smo kreirali poboljsanu for petlju koja ima samo dva argumetna .int je vrsta podataka koje skaldisti Array.7}.5. dok je djordje ime array-a. Npr: for (int x: djordje) . int total=0. x – je indentifikator on ce da skladisti vrijednosti elementa Array-a dok se vrti petlja ( dakle prvi put kad se pokrene petlja on ce skladistiti 3. } } Kreirali smo Array : int djordje[]={3. Ona umjesto 3 argumenta treba samo dva . } System.7} .println(total). ~ 29 ~ . U tjelu for petlje smo stavili instrukciju total += x. Konstrukcija izgleda ovako: for(VrstaPodataka Idenrifikator : ime array-a){ instrukcije. zatim smo kreirali promjenjivu total i dali joj vrijednost 0.5.Lekcija 31: Enhanced for loop (Poboljsana for petlja) Java je napravila mnogo laksi nacin da se radi sa Array-jima i to pomocu enehanced (poboljsane) for petlje. koja izgleda: for (int x: djordje){ total+=x. x je identifikator koji u tjelu poboljsane for petlje predstavlja promjenjivu koja skladisti vrijednost elementa sa kojim se trenutno radi(u zavisnosti od iteracije petlje). for(int x: djordje){ total+=x. } – int (pripada prvom argumentu) i oznacava tip podataka. za razliku od obicne for petlje kojoj je potrebno tri argumenta.6.sto znaci da ce vrijednosti promjenjive total pri svakom obrtu petlje biti uvecane za x tj.4. drugi put 4.6. primjer: public class Apples { public static void main(String args[]){ int djordje[]={3. pa 5 zatim 6 zatim 7) zato nam kao drugi argument treba ime array-a od koji ce indentifikator x skladistiti vrijednosti.4.out. . } Argument 1 su vrsta podataka i indentifikator dok je argument2 ime array-a. vrijednos elementa array-a (koja zavisi od toga koji put se vrti petlja).

static znaci da je metoda klase. Programski kod izgleda ovako: public class Apples { public static void main(String args[]){ int djordje[]={1.} . Public static void change(int x[]) – public znaci da ce biti dostupna svima . void znamo sta znaci . elementi se nisu vracali povecani ??? ~ 30 ~ .println(y). koja uzima sve elemente iz pomocu indeksa (counter) i povecava ih za 5.length. Ova instrukcija Sada kada smo povecali elemente za 5 prikazacemo to na ekranu da se uvjerimo.5}. change(djordje). (int x[]) . Tjelo metode ima petlju: for (int counter=0<x.counter++) i unutar petlje instrukciju: x[counter]+=5.5}. dok je change ime metode. to jest: 6 7 8 9 10 Napomena: Iz nekog razloga kada sam u metodu change ubacio poboljsanu for petlju.3. Ono sto se nalazi u zagradi tj. int je vrsta dok x[] govori da cemo u ovoj metodi raditi sa Array-em koji ce u tjelu biti indeksiran sa x. } } } Napravili smo Array: int djordje[]={1. change-je ime metode koju smo kreirali dok je djordje parametar koji smo prosljedili za tu metodu tj. umjesto obicne. ime array-a. ). svaki od njih poveca za 5. Kreiranja metodu potrebno je pozvati. To smo uradili pomocu poboljsane for petlje: for(int y:djordje){System.Lekcija:32 Arrays in methods Stavicemo Array u neku metodu (koja ce svaki broj povecati za 5 ) pa cemo to prikazati na ekranu. To smo uradili u glavnoj metodi tako sto smo napisali change(djordje).2.counter<x. u suprotnom ona tu samo stoji.3.4. } public static void change(int x[]){ for(int counter=0.prikazace svaki element Array-a jedan ispod drugog.4.out. Zatim smo napravili metodu koja kada joj prosljedimo Array koji sadrzi int podatke .length.println(y).2.out. for(int y:djordje) System.counter++){ x[counter]+=5.

. Kreiranje multidimenzionalno Array-ja bi izgledalo ovako npr: int imeArray-a[] []={{PrviEl.Reda1. je multidimenzionalni Array . ili kada ne znamo sadrzaj ali znamo broj redova i kolona: int imeArray-ja [][] = new int [3][2].6}}. sto bi znacilo Array sa 3 reda koji sadrze po dve kolone.8.Reda1}.6} predstavlja drugi red. Ukucamo firstarray[1][1] . to znaci da je to red sa brojevima {9.DrugiEl.println(firstarray[1][1]).7. Multidimenzionalni Array pravimo tako sto ukucamo prvo vrstu podataka (npr: int) zatim ime Array-a (npr..4}. ~ 31 ~ . } } Kada pokrenemo ovaj program na ekranu ce se ispisati broj 8.4}.3.{9.N-tiEl. Unutar viticastie zagrade nove viticaste zagrade predstavljaju redove.Reda2.Reda2.2.8.out.8.…. firstarray je ime multidimenzionalnog array-a.3.{prviEl.{9.2.7. . Brojevi unutar {} viticastih zagrada predstavljaju kolone.NelementReda2} }. {1.3. Primjer: public class Apples { public static void main(String args[]){ int firstarray[][]={{1.2El.7. Objasnjenje: Dakle int firstarray[ ] [ ]={{1..6} jer znamo da racunar uvjek broji od nula) dok druga zagrada oznacava koji broj iz tog reda (s obzirom da je 1 u zagradi (a racunar broji od 0) dobijamo broj 8). dok elementi unutar tih zagrada predstavljaju kolone.Lekcija 33: Multidimensional Arrays Multidimenzionalni Array pravimo kada zelimo da napravimo tabelu u Javi ili da napravimo nesto sa koordinatama.Reda1. Broj u prvoj kockastoj zagradi oznacava red ( s obzirom da je u prvoj zagradi broj 1 . Kao sto vidimo i u primjeru. Ako npr zelimo pristupiti broju 8 u drugom redu. System.8.7.6}}.4} predstavlja prvi red dok {9.2. Firstarray) zatim dva para kockastih zagrada “ [] [] “ zatim znak = poslije kojeg otvorimo viticastu zagradu koja predstavlja sadrzaj Array-ja .

sto ce prikazati nase brojeve u zavisnosti koji put se koja petlja vrti sto ce odrediti indekse row i col i prikazati broj sa razmakom tj. display(secondarray).row++).32.10.length. System.sto zapravo znaci kad se jednom izvrsi druga petlja (koja je unutar prve.14.print().13.31.print(x[row][col]+ "\t").out.14.print(x[row][col]+ “\t”).{12.9. x.row<x. This is the second array ~ 32 ~ .11}.5. System.9. i koja prikazuje brojeve unutar tog reda(u zavisnosti da li se vrti 1 ili 2 put (koji put se vrti jeste red) ) prelazimo u sledeci red. .{4.out. } public static void display(int x [][]) { for(int row=0.Lekcija 34: Prikazivanje Multidimenzionalnih Array-a u vidu tabele Primjer: public class Apples { public static void main(String[] args){ int firstArray[][]={{8. int x [ ] [ ] – koji se nalazi unutar zagrada znaci da ce raditi sa multidimenzionalnim array-ima koji sadrze podatke tipa int.out. int secondArray[][]={{30.length.println().col<x[row].{43}. U Tjelu metode imamo dve petlje jednu za redove drugu za kolone.6}}. zaglavlje ove petlje izgleda : for(int col=0.length je broj kolona. display(firstarray).sto znaci da ce se ova petlja izvrsiti 2 puta i x. Izvan ove druge petlje i unutar prve poslije izvrsavanja druge petlje imamo System.row<x.11 a u drugom:12. Nakon toga smo napravili metodu koja ce prikazivati multidimenzionalne array-e kao tabele zaglavlje metode je: public static void display(int x[] []). row reda (u ovom primjeru kod firstarray s obzirom da ima 2 reda u prvom redu ce se prikazati 8.length.col++).10. } } } Kada pokrenemo ovaj program dobicemo: This is the first array 8 9 10 14 32 6 11 15 33 12 13 30 31 43 4 5 U Apples klasi smo napravili dva multidimenzionalna Array-a tj: firstArray i secondArray. Unutar petlje za redove se nalazi petlja koja ide kroz kolone.15}}.length ce prikazivati broj redova u Array( u ovom primjeru to je 2 za firstArray .row++){ for(int col=0.length.33}.col++){ System.println("This is the second array").13.out.println("This is the first array").col<x[row]. } System.out. tabom jer imamo +”\t”(sto u ovom slucaju znaci da ce izmedju svakog broja staviti tab) . x[row].15) ili (koliko ima brojeva unutar svakog reda). Zatim u tjeluimamo System.length je 3 za secondArray – sto znaci da ce se ova petlja izvrsiti 3 puta).out. Prva petlja za redove izgleda: for (int row=0.

20. prosjek brojeva koje smo prosljedili u metodu prosjek.sto ce prikazati vrijedost koja se dobije pozivanjem metode prosjek sa prosljedjenim argumentima: 2.12)) .brojevi){ int total=0.6 . Nako sto smo kreirali metodu prosjek. . tj. } } Kada pokrenemo ovaj program on ce nam izbaciti vrijednost 15. sto ce vratiti prosjek prosljedjenih brojeva tako sto ce uzeti zbir svih brojeva koji smo izracunali pomocu for petlje i podjeliti ga sa brojem elemenata brojevi.6. cjeli brojevi jer u zaglavlju imamo int. bice vraceni int tj. Parametri metode: (int…brojevi) . Tri tacke upravo znaci da neznamo koliko ce biti brojeva (dva . Prvo smo napravili metodu: public static int prosjek(int…brojevi) . pozvali smo tu metodu i prosljedili joj nasumican broj argumenata : System.6.length.u zaglavlju metode nema void sto znaci da ce neke vrijednost biti vracene.println(prosjek(2. Onda u zagradi stavimo vrstu podataka koja ce biti koristena pa poslije toga idu tri tacke onda stavimo ime promjenjive koju cemo koristiti tj: (int…imepromjenjive). return total/brojevi.length. i poboljsanu for petlju koja izgleda : for(int x:brojevi) I u tjelu ima: total+=x. tj.21.4.20. Unutar metode prosjek kreirali smo promjenjivu total=0.20)). ~ 33 ~ . for(int x:brojevi) total+=x. Primjer: public class Apples { public static void main(String args[]){ System.out.Lekcija 35: Metode koje rade sa nepoznatim brojem argumenata Nekada ne znamo koliko ili koje ce argumente metoda koristiti.int znacii da ce podatci biti cjeli brojevi tipa int. } public static int prosjek(int..println(prosjek(2.4.19..4..out.40.Takodje izvan for petlje unutar metode prosjek imamo : return total/brojevi. pet ili pet stotina cjelih brojeva) dok je brojevi Array koji ce skladistiti te brojevi unutar metode.

format(“%02d:%02d:%02d”.out. } public String toString(){ return String.setTime(13. second . Zaglavlje metode: public String toMillitary(). ((hour>12)? "PM":"AM")). && . drugi argument je : hour . ako ova dva uslova nisu zadovoljena onda se promjenjivoj minute dodjeljuje vrijednost 0. second). int s). minute. int s){ hour=((h>=0 && h<24) ? h : 0 ).toString()). public void setTime(int h.minute i sekunde i to ce biti konvertovano u “military” vrijeme i regularno vrijeme (sta god to znacilo). second.((hour<=12)?hour:hour-12). Glavna klasa Apples izgleda: Public class Apples { public static void main(String args[]){ Tuna tunaObject=new Tuna(). tunaObject.out. da sve izgleda fensi) i vraca tu vrijedost. hour. minte.out.toMilitary()). minute=((m>=0 && m<60) ? m :0).dakle imamo dva testa koji su spojeni operatorom “ i “ (tj. second=((s>=0 && s<60) ? s :0). int m. }} ~ 34 ~ . ne void). int m. } public String toMilitary(){ return String.String iz razloga sto ce vracati String ( metoda je return tipa. format zahtjeva dva argumenta prvi argument je : “%02d:%02d:%02d” .minute. Dalje smo napravili metodu toMillitary koja formatira ove brojeve u format vremena (dodace “ : “ . Primjer jednog dodjelivanja : minute=((m>=0 && m<60) ? m : 0). koja zahtjeva tri argumenta( tj. private int minute. minte. U tjelu metode ukucali smo : return String.Lekcija 36 : Time klasa Mi cemo dozvoliti korisniku da unese tri vrijednosti za sate . System. second).minute i second. tri broja (tipa int )) koja ce dodjeliti promjenjivima hour.je ime metode. “conditional operatorima” se provjerava da li je broj validan. prvi test “ m>0 ” provjerava da li je broj koji bih trebao prestavljati minutu ( m ) veci od 0. 6).println(tunaObject. }} U Tuna klasi smo kreirali tri private promjenjive hour.second tipa int kojima nismo dodjelili vrijedosti. System. sto znaci da oba testa moraju biti tacna). toMilitary . hour .println(tunaObject. 27. System. Ako su oba testa tacna uzima se vrijednost m i dodjeljuju se promjenjivoj minute. . minute. Znak % znaci da ce biti zamjenjen sa vrijednoscu iz argumeta2 dok 02d znaci da ce biti prikazano sa dva decimalna mjesta. Imacemo dve klase :Apples kao glavnu i Tuna kao time klasu koja izgleda: public class Tuna { private int hour.format("%02d:%02d:%02d". private int second. ako jeste postavalj se njegova vrijednost odgovarajucoj promjenjivoj i ako nije umjesto tog broja postavlja se vrijednost. Ovo dodjeljivanje ce biti malo komplikovanije jer ce prosljedjeni argumenti prvo morati da zadovolje odredjene kriterijume.println(tunaObject.format("%d:%02d:%02d %s".toMilitary()). dok drugi test ( m<60 ) provjerava da li broj koji bih trebao prestavljati minutu ( m ) manji od 60. Dalje imamo metodu setTime(int h.

nismo pozvali metodu setTime i prosljedili joj tri broja koji respektivno trebaju predstavljati sat. dok %d znaci da ce d biti zamjenjeno sa brojem . tunaObject.27.6) – Dakle poziva se metoda setTime i prosljedjuju joj se argumenti 13 .println(tunaObject.setTime i otvorili zagradu da prosljedimo argumente u njoj se samo pojavilo h . dok %02d znaci da ce d biti zamjenjeno sa brojem koji ima dve cifre (npr ako ima jednu tj. 3 bice mo dodana 0 pa ce biti : 03). Metoda toSting je slicna metodi toMillitary samo sto ona malo drugacije formatira %s u samom Stringu znaci da ce s biti zamjenjeno sa Stringom.println(tunaObject. 27. minute i second respektivno. minute. Kada pokrenemo ovaj kod dobicemo : 00:00:00 13:27:06 1:27:06 PM Dalje cemo napisati metodu koja formatira vrijeme u regularno tj. m . minute. vidimo na drugoj liniji rezultata. Zatim smo napisali :System.toMillitary prikazuje taj String na ekranu. second pomocu metode setTime. minute i sekunde) dobili smo formatirane nule tj. sadrzace am i pm i sati ce biti od 0 do 12.toMillitary( ) – vrijedosti koje smo postavili promjenjivima hour. preko kojeg cemo pozivati metode za postavljanje i formatiranje vremena. kada smo je kreirali ).toMilitary( )). . second (tj. I na posljetku imamo : System. s . ~ 35 ~ . Dok smo kucali tunaObject.s obzirom da nismo dodjelili vrijedosti promjenjivima hour. 6 koji ce u tjelu metode biti dodjeljeni promjenjivima hour.toMilitary()).out. Sto je posljedica toga da ova metoda zagtjeva tri argumenta (tako smo definisali u Tuna klasi . dok System.U glavnoj klasi Apples smo kreirali objekat t1 koji je instanca klase Tuna .out. metoda setTime . Tj.setTime(13. Dalje smo postavili vrijednosti : tunaObject.out. U klasu Apples ubacicemo metodu toString.println koji enkapsulira tunaObject. formatira da izgledaju kao vrijeme i vraca u obliku String-a.

hour is not visible”.out. dok promjnjive sa istim nazivima imao i u metodi setTime.toString()). private int minute = 2. } public String toMilitary(){ return String. } } Prvo cemo pricati o pristupu private promjenjivim (a to su promjenjive klase tuna: hour minute second.println(tunaObject. minute = 5. U ovom primjeru instant promjenjive su private promjenjive na pocetku klase Tuna tj : hour. System. Kao sto vidimo imena su im ista ali su vrijednosti drugacije.println(tunaObject. tunaObject. minute. private int second = 3.format("%d:%02d:%02d %s". second = 6.println(tunaObject. 27. Svaki put kada imamo promjenjive sa istim imenima: npr.setTime(15.toString()).Lekcija 38 : Public. Pokusamo pristupiti private promjenjivoj iz druge klase koristeci objekat npr: t1. Kada pokrenemo program dobicemo kao rezultat: 01:02:03 1:02:03 AM 01:02:03 1:02:03 AM ~ 36 ~ . Ono sto private znaci jeste da samo metode unutar te klase u kojoj se nalaze mogu koristiti te promjenjive.out.((hour<=12) ? hour: hour-12 ).toMilitary()).minute i second. tunaObject. ). System. }} Klasa Apples: public class Apples { public static void main(String args[]){ Tuna tunaObject=new Tuna(). second).((hour>12)? "PM":"AM")). Ako npr. 44). .2.hour=7. minute. int minute. } public String toString(){ return String.second. kada dodjemo strelicom misa do tog x pisace “The field Tuna.hour=7.format("%02d:%02d:%02d". imena promjenjivih u metodi ili konstruktoru su ista imenima instant promjenijve (valjda promjenjive koje se nalaze u samoj klasi) Java ce uvjek koristiti instant promjenjive. int second){ hour = 4.6. Private i this U ovo lekciji cemo uciti kako kontrolisati pristup ralicitim promjenjivim u drugim klasama. Instant promjenjive imaju vrijednost 1.out.5. public void setTime(int hour. hour. System. System. Klasa Tuna: public class Tuna { private int hour = 1. Medjutim ako promjenimo u Tuna klasi iz private u public onda nece biti x u toj liniji koda i bice moguce pristupiti toj promjenjivoj iz Apple klase(glavne).println(tunaObject.3 dok u setTime metodi imaju vrijednost 4. u toj liniji koda prikazace se x koje znaci da nesto nije u redu .toMilitary()).out.

this. modifikovacemo setTime metodu: public void setTime(int hour. this. int second){ this. Kada se pozove metoda .hour= 4.second= 6.Kao sto vidimo koristene su instant promjenjive na pocetku. Medjutim ako mi zelim da se prvo koriste promjenjive unutar metode ona ispred tih promjenjivih stavimo kljucnu rijec this. ~ 37 ~ . Ali ako unutar metode setTime prije imena hour. } Sada kada bi pokrenuli program dobili bih rezultat : 01:02:03 1:02:03 AM 04:05:06 4:05:06 AM Dakle kad god neka metoda ima promjenjive sa istim imenima kao sto su instant promjenjive . i zaobilazimo to pravilo. Vidimo na gornjem izvrsavanju koda kada smo modifikoali metodu.ime . int minute.minute i second stavimo this.minute= 5. ona ce uzimati vrijednosti koje su dodjeljene instant promjenjivima ( vidimo na rezultatu prvog izvrsavanja) .

} public void setHour(int h){ hour=((h>=0 && h<24)? h:0).s). tjelo : this(h.0).m.0) } – zahtjeva jedan parametar . this poziva cetvrti konstruktor koji zahtjeva 3 argumena i prosljedjuje mu 0.40 i 41 Konstruktor je ustvari metoda koja ima isto ime kao i klasa u kojoj se nalazi. Prvi konstrukor . Drugi konstruktor. } public int getMin(){ return minute. sa tri argumenta tj public Tuna (int h.getMinute(). int s){ setTime(h. } } U zavisnosti koliko argumenata objekat ima on ce uzeti taj konstruktor koji ima isto toliko argumenata.format("%02d:%02d:%02d". int m) .m. Tjelo: setTime (h.0) . setSec(s). Ono sto nismo rekli jeste da mozemo kreirati vise konstruktora ako svaki ima razlicite argumente.0). I kada god kreiramo objekat on automatski pozove tu metodu ili izvrsi tu metodu. private int minute. ne zahtjeva parametre. 4. int m.0. i prosljedjuje joj tri argumenta. Treci sa dva argumenta: public Tuna(int h. sto znaci da poziva metodu setTime. int s){ setHour(h). setMin(m).0. int m.0). Cetvrti konstruktor. Klasa Tuna: public class Tuna { private int hour. private int second.0. 1. } public void setTime(int h.s).zaglavlje public Tuna( ){ this(0. } public String toMilitary(){ return String. } public void setMinute(int m){ minute=((m>=0 && m<60)?m:0). int m){ this(h. public Tuna(){ this(0.this poziva cetvriti konstruktor koji zahtjeva 3 argumena i prosljedjuje mu h. } public int getSec(){ return second.m. 3. zaglavlje public Tuna(int h){ this(h.0).0).Lekcije : 39.0 i 0.0). tjelo: this(h.0 i 0. } public Tuna(int h){ this(h.m. 2. int s).0 i 0. } public int getHour(){ return hour.0. int m.this poziva cetvrti konstruktor koji zahtjeva 3 argumena i prosljedjuje mu h. U klasi Tuna Napravili smo 4 konstruktora .getHour().0. . ~ 38 ~ .0. } public Tuna(int h. } . } public Tuna(int h. tjelo: this(0.getSecond() ). } public void setSecond(int s){ second=((s>=0 && s<60)? s:0).

public String toMilitary() – koja formatira vrijeme. koji u tjelu ima : this (h. Tuna(5.u sklopu navodnika je nacin na koji ce biti formatirano. tunaObject3.out.printf(“%s\n”. int s) koja zahtjeva 3 parametra. To smo isto uradili za minute i sekunde samo sto smo se postarali da njihove vrijednosti budu izmedju 0 i 60. 0. second svakog kreiranog objekta : t1. s-vazi za string dok \n-vazi za predji u novi red. i treca instrukcija: setSec(s).m. druga setMin(m). dva i tri argumenta respektivno. jedan. radi jeste da kada se pozove metoda getMinute( ) . int s) i prosljedjuje mu : 5 . Takodje smo napisali kod da nam se prikazu vrijednosti promjenjivih hour. . .0).out. Tuna(5. tunaObject2. drugom. int m . Glavna klasa Apples: public class Apples { public static void main(String args[]){ Tuna Tuna Tuna Tuna t1 t2 t3 t4 = = = = new new new new Tuna(). Dalje napisali smo get metode samo da vratimo vrijednost npr: public int getMinute(){ return minute.. minute.printf("%s\n". 13 . System. tj public Tuna (int h. na mjestu gdje je pozvana metoda getMinute( ) isporucuje se vrijednost promjnjive minute. tunaObject4.toMilitary()). trecem odnosno cetvrtom konstruktoru u zavisnosti od broja argumenata: Za primjer t3 ima 2 argumenta(5 i 13). U tjelu metode imaamo 3 instrukcije u kojima se pozivaju nove tri metode i prosljedjuje po jedan argument: prva : setHour(h). Kada pokrenemo ovaj program dobicemo : 00:00:00 05:00:00 05:13:00 05:13:43 ~ 39 ~ .13).13.out. tunaObject1.out.printf("%s\n". Zadnja metoda koju trebamo je format metoda tj. System. System. } Izgradili smo 4 Tuna objekta u glavnoj klasi i prosljedili im nula.toMilitary()). sto znaci da ce se obracati prvom.out. – sto poziva konstruktor Tuna koji zahtjeva tri argumenta . t2. %-znamo sta je .43). Tako da u klasi Tuna trazi konstruktor koji ima takodje 2 argumenta i nalazi ga: public Tuna(int h.toMilitary()). i da ih formatira usput jedan od kodova izgleda : System.toMilitary()). Tuna(5).printf("%s\n".toMilitary( )).printf("%s\n". da li je izmedju 0 i 24 ako nije onda ce vrijednost biti 0 . int m. } – provjerava da li je sat u granicama tj. . int m) . System. t3 i t4 .Dalje imamo metodu setTime (int h.tunaObject3. } –ono sto return minute. Public void setHour(int h){ hour=((h>=0 && h<24)? h:0).

Dakle kreirali smo objekat sa parametrima 4. day= d . int y){ month = m. Svaki put kada treba String prikazivanje objekta . month.ono sto je novo je ovo zadnje this.5. year).day i year. this je upucivanje na objekat koji smo upravo izgradili koji koristimo svaki put kad pozovemo ovu klasu.sto ce formatirati brojeve 4. Taj konstrukotr ima takodje ima instrukciju System.5. System. this). day. year).format("%d/%d/%d".Lekcija 42 : toString U ovoj lekciji cemo pisati preko metode toString koja se nalazi u klasi Object koju nasljedjuju sve klase pa i ovo klase sa kojima mi radimo . . this) – koji izbacuje na ekranu ovaj string .day i year za novokreiranu instancu objekta klase Potpie biti jedanke onome sto napisemo u zagradi kada budemo kreirali objekat tj. day. poziva se toString metoda.int d. private int year. this) . day=5 . ona je vec nasljedjena zajedno sa klasom Object) . Dalje u tjelu imamo naredbu kojom provjeravamo da li nas konstruktor radi ili ne : System. Dakle zaglavlje metode : public String toString( ).printf(“The connstructor for this is %s\n”. month.6) . Glava Apples klasa izgleda: public class Apless { public static void main(String args[]){ Potpie potObject1 = new Potpie(4. int y). a umjesto %s imamo this koja prosljedjuje na metodu toString koja ima instrukciju return String.year).format(“%d/%d/%d” month.printf("The constructor for this is %s".5. year=6. day = d.6). Koristicemo dve klase Aples i Potpie klasu : public class Potpie { private int month. Ocigledno je da umjesto %s ide this. int y.out. U tjelu ovog konsturktora imamo : month =m. Sto znaci da ce private promjenjive month. Vecinom metode mozete nazvati kako zelite dok ovu morate striktno nazvati toString jer pisemo preko nje(tj. year = y. private int day. int d.day.printf(“the constructor for this is %s\n”.6 i prikazati ih kad pokrenemo ovaj program: The constructor for this is 4/5/6 ~ 40 ~ .out. int d. On je u klasi Potpie nasao konstruktor sa koji zahtjeva 3 argumenta i popunio ih tj month=4 . Zatim smo napravili Potpie konstruktor : public Potpie( int m. onome sto prosljedimo umjesto int m . year =y. } } Prvo sto smo napravili jesu tri private promjenjive month. Dok u tjelu imamo : return String.out. } public String toString(){ return String.format(“%d/%d/%d”.5. Ali this trebamo pretvoriti u String.6. } } Napravili smo potObject1 = new Potpie(4. public Potpie(int m.

birthday). my birthday is %s". da svaki put kada zelimo String od objekta . potObject1). Ali za birthday nema String koji se zove birthday . Tuna tunaObject = new Tuna("Djordje". Dok je : private Potpie birthday .5.6. Dalje smo napravili tunaObject (objekat klase Tuna) sa dva argumenta s obzirom da Tuna konstruktor trazi dva argumenta (String theName. } } Prvo smo kreirali objekat potObject1 klase Potpie ciji se kod nalazi u lekciji prije.referenca za Potpie Objekat. Potpie theDate). i Birthday = theDate. Svaki put kada prosljedimo objekat on gleda u klasu u kojoj se nalazi i trazi toString metodu i daje nam podatke. my birthday is %s” name. Drugi je referenca za Potpie.je promjenjiva koja ce skladistiti name tj ime. gdje pise %s nemoramo nuzno prosljediti string promjenjivu . Glavna klasa Apples izgleda: public class Apples { public static void main(String args[]){ Potpie potObject1 = new Potpie(4. .6). mozemo prosljediti umjesto toga objekat.birthday). private Potpie birthday. name. je composition.format("My name is %s. Izgled klase Tuna: public class Tuna { private String name. public Tuna(String theName. } public String toString(){ return String. Tuna i Potpie. prvi argument je String: Djordje a drugi je potObject1 koji smo malocas kreirali. Zatim smo napravili konstrukor: public Tuna(String theName. . birthday je referenca za theDate objekat.Lekcija 43 : Composition Imamo 3 klase : Apples kao glavnu .5.out. Dalje smo napravili toString metodu: public String toString( ) . otice u svoju klasu(u ovom slucaju u Potpie) u toStirng metodu i dace nam podatke koje zelimo. System. i prosljedili mu argumente 4. Ono sto ovo znaci .U tjelu metode imamo: name = theName.Kada pokrenemo ovaj program dobicemo: The constructor for this is 4/5/6 My name is Djordje. } } name . i u tjelu ove metode imamo : return String. ~ 41 ~ . birthday= theDate. Potpie the Date)dakle ovaj konstruktor ima dva argumenta prvi je String promjenjiva koju cemo nazvati theName.format(“My name is %s. theDate objekat. my birthday is 4/5/6 Composition se odnosi na objekte Iz drugih klasa kao clanovima npr u Tuna klasi private Potpie birthday.println("\n"+tunaObject). Dakle u ovoj metodi .kada bude trazio %s tj String za name uradice to jednostavno . Potpie theDate){ name= theName.Composition znaci da klasa umjesto da ima samo reference na promjenjive i metode moze imati i reference na objekte.

dok String “20” konstruktor postavlja kao vrijednost year promjenjive. Klasa Apples : public class Apples { public static void main(String args[]){ for(Tuna people:Tuna.. julia ) i svaki ima komplet od vlastitih promjenjivih jedan za description( desc) i jedan za godinu ( year ). private final String year. dobijamo ih tako sto napisemo Imenumerationa."20"). enum je nesto poput klase ali se koriste da “declare” proglase konstante (promjenjive koje se nikad ne mjenjaju). String birthday){ desc = description. i julia(“mistake”. } public String getDesc(){ return desc. String birthday) . U tijelu konstruktora imamo : desc = description . Tuna(String description. people.”10”). . ” i tako Java zna da smo prestali sa “nabrajanjem”."10"). public enum Tuna . Mi smo napravili tri : djordje(“nice”. Primjer: public enum Tuna { djordje("nice".values( ) – Svaki put kada napravimo numeration Java sama napravi Array koji sadrzi konstante iz tog numeration-a.people. Sada imamo 3 objekta/konstante (djordje."12"). Dakle Tuna. ” a tek poslije zadje ide “ . a people je promjenjiva(koja sluzi samo za ovu petlju) kako se zovu nasi objekti dok petlja ide kroz njih.printf("%s\t%s\t%s\n". Evo sta ce se desiti sa djordje : konstruktoru Tuna se prosljedjuju parametri objekta djordje “nice” i “20” .values( ) . private final String desc.values()) System.”20”) . } public String getYear(){ return year. Kao sto vidimo posli je svake ide “ .getYear()). Tuna. kelsey("cute".values ( ) – je broj elemenata koji se nalaze u Array-ju koji je java sama napravila . i private final String year.kelsey. Umjesto public class Tuna (sto je klasa) mi enumeration kreiramo tako sto umjesto class napisemo enum tj. i year = birthday. julia("mistake".final znaci da su ovo promjenjive kojima se ne mogu naknadno mjenjati vrijednost . Daklje ova for petlja ce proci kroz svaki od konstanti : djordje. ~ 42 ~ . Sada s obzirom da smo napravili konstante/objekte i imace svoj komplet promjenjivih u ovom enumeration.people. }} U glavnoj klasi napravili smo pobloljsanu for petlju : for(Tuna people: Tuna. }} Prvu stvar koja se radi kada napravimo enum jeste da se nabroje objekti enum vrste. Vidimo da u zagradi imaju par parametara (npr kod djordje imamo u zagradi (“nice” i “20”).Lekcija 44 : Enumeration (nabrajanje) U ovoj lekciji cemo graditi Enumeration (enum) . kelsey(“cute”.out. . Ove 3 konstante su u sustini objekti.getDesc().”12”).prvi argument Tuna people -Tuna je ime klase . String “nice” konstruktor postavlja kao vrijednost desc promjenjive. Stoga smo napravili dve promjenjive koje ce koristiti tj. year = birthday.values()) . Sada pravimo numeration konstruktor cije zaglavlje izgleda : Tuna (String description. private final String desc.

laura koji ce u tjelu petlje biti prestavljeni sa people.printf(“%s\t%s\t%s\n”.getDesc( ) – uzima people objekat i koristi metodu getDesc. ~ 43 ~ .kelsey . people. U tjelu poboljsane for petlje imamo : System.getDesc( ). people – ce samo prikazati imena. people. dok ce people. koja ce vratiti vrijednost desc.out.getYear( ) . Kada pokrenemo program dobicemo : djordje nice 20 kelsey julia cute 10 mistake 12 kljucna rijec final kod metoda znaci da se metode ne mogu redifinisati prilikom nasledjivanja klase. people.getYear( ) ).people. vratiti godine (tj year).

range(Tuna. Napravili smo novu poboljsanu for petlju for(Tuna people: EnumSet.to je metoda koja zahtjeva dva parametra (tj prvi parametar (od kojeg elementa) . Primjer je modifikovana Tuna enum iz prosle lekcije : public enum Tuna { djordje("nice"."20").range(od. kelsey("cute".candy i erin sa svojim atributima .candy)) .Lekcija 45: EnumSet range Kada u enum imamo duzu listu konstanti ne moramo ih prikazati sve pomocu Array-a koji Java automatski kreira vec mozemo importovati java. julia("mistake". String birthday){ desc=description.candy)) – Umjesto Tuna. Kada zelimo da prikazemo samo dio konstanti onda u glavnoj klasi Apples ukucao: import java. ~ 44 ~ . private final String desc. }} dodali smo jos 3 konstante tj: nicole.EnumSet.people. Tuna.EnumSet. Tuna."13").util.people.kelsey. nicole("italian"."14"). } public String getDesc(){ return desc.je ugradjena klasa koja nam omogucava da koristimo EnumSet.values kao u proslom primjeru mi smo napisali EnumSet."16").getDesc().EnumSet.range . public class Apples { public static void main(String args[]){ for(Tuna people:EnumSet. drugi do kojeg elementa).printf("%s\t\t%s\t\t%s\n".util. } } Java.range(Tuna."10"). pa izabrati od koje do koje konstante da nam prikaze pomocu imeklase.util.people.kelsey."12"). erin("wish".range(Tuna. . private final String year. candy("different". Tuna(String description.kelsey.candy)) System. year=birthday. } public String getYear(){ return year. Tuna.getYear().do). Kada pokrenemo ovaj program dobicemo : kelsey julia nicole candy cute mistake italian different 10 12 13 14 kao sto vidimo na ekranu su se ispisale konstante od kelsey do candy.out.

Lekcija 46: Static U ovoj lekciji cemo govoriti o static promjenjivima. Glavna klasa Aples izgleda: public class Apples { public static void main(String args[]){ Tuna member1 = new Tuna("Megan". zatim smo napravili jednu promjenjivu koju ce objekti djeliti tj.printf("Constructor for %s %s. ako promjenimo npr.last. i ako se ona promjeni mjenja se za sve objekte. dok ce se “Fox” poistovjetiti sa ln. member in the club 1 Construktor for Natalie Portman. Napravili smo dve klase. members++. member in the club 2 Construktor for Taylor Swift. } } Napravili smo dve private promjenjive ( first i last) . members++). U tjelu konstruktora takodje imamo static int member (zajednicka za sve promjenjiva ) koja se sa dodavanjem svakog novog Tuna objekta sa dva parametra inkrementira za 1 (tj. public Tuna(String fn.String ln){ first=fn. Kad god imamo klasu koja ima objekte svaki od objekata ima svoje promjenjive(koje su samo njegove). pa ce se “Megan” poistovjetiti sa fn . member2 i member3 sa svojim parametrima npr member1 sa parametrima (“Megan” i “Fox”).first. System."Swift"). } } Kao sto vidimo napravili smo 3 objekta : member1. Klasa Tuna izgleda: public class Tuna { private String first. Apples kao glavnu i Tuna. last=ln. Kada kreiramo instancu Tuna klase npr. Tuna member2 = new Tuna("Natalie". member in the club %s\n". atributi se salju konstruktoru . Kada pokrenemo ovaj program dobicemo : Construktor for Megan Fox. first mjenja se samo za taj objekat. Tuna member3 = new Tuna("Taylor".out.members). member in the club 3 ~ 45 ~ . private String last."Portman")."Fox"). public static int members=0. kod member1. ali nekada zelimo da svi objekti djele istu promjenjivu. public static int members=0. static -znaci da svaki objekat djeli istu promjenjivu . Dok bez static .

println("\n"+ member1. member of the Megan Fox 3 ~ 46 ~ .out. treca metoda je public static int getMemb( ) . private String last. member of the %s\n".println(member1. System.getLast()).static iz razloga sto ce raditi sa staticpromjenjivom. } public static int getMemb(){ return members. last=ln.Lekcija 47: More on Static U ovoj lekciji cemo dovrsiti pricu o static promjenjivim. System. System. } } for %s %s. Dve metode su public String (getFirst i getLast). U klasi iz prosle lekicje dodali smo 3 nove metode.out. member of the 1 2 3 Construktor for Natalie Portman.getFirst()).members).printf("Construktor first.out.String ln){ first=fn."Fox"). member of the Construktor for Taylor Swift. } public String getFirst(){ return first.println(member1.getMemb()). public static int members=0. public Tuna(String fn."Swift").last. members++.out. Tuna member3 = new Tuna("Taylor". Tuna member2 = new Tuna("Natalie". U glavnoj Apples klasi cemo demonstrirati kako svaki od objekata ima svoje jedinstvene parametre i kako postoje oni koji su zajednicki za sve zajedno: public class Apples { public static void main(String args[]){ Tuna member1 = new Tuna("Megan". Klasa Tuna: public class Tuna { private String first."Portman"). } public String getLast(){ return last. System. } } Kada pokrenemo ovaj program dobicemo: Construktor for Megan Fox.

odnosno System.getMemb( ) ) staviti member2 i pokrenuti program . Sada cemo u glavnoj klasi umjesto member1 staviti (u tri instrukcije : System. “Natalie” i “Portman” . System.getMembers()). “Fox” i “3”.getFirst( ).out.println(Tuna.out.getLast( ) i System.println(member2.println(member2.Vidmo da objekat member1 ima tri atributa: “Megan”.getMembers( ). ali vidimo broj 3 koji smo imali i kod objekta 1.getMembers()).metoda) . dobicemo rezultate: Natalie Portman 3 Kao sto vidimo i member2 ima svoje jedinstvene podatke tj.3. Kada pokrenemo ovaj kod dobicemo na kraju broj 3 sto je ta static promjenjiva pozvana na drugi nacin (tj imeklase. S obzirom da se static promjenjive ne mjenjaju izmedju objekata .out..2.out. Takodje da ovo sve uradimo i za member3 dobili bih smo: Taylor Swift 3 Ista prica dva jedinstvena i broj 3 koji je zajednicki za sve objekte.Tuna. Dakle uvjek kada imamo static metodu sa static promjenjivim ne moramo imati poseban objekat da je prikazemo vec to mozemo uraditi direktno preko klase tj.println(member2. ~ 47 ~ . } } Recimo da izbrisemo objekte member1. static informacije su dostupne cak i kada nemamo objekat npr: public class Apples { public static void main(String args[]){ System.println(Tuna.out.

}.i<5.kada god stavimo final . . Prva: private int sum i druga private final int NUMBER. U tjelu for petlje smo pozvali add metodu da se izvrsava ( na nacin da smo upisali TunaObject. Dalje smo napravili konstruktor : public Tuna(int x){ NUMBER=x.to znaci da ce NUMBER biti 2 dovjeka. Kreiracemo dve klase Apples u kojoj se nalazi glavna metoda i klasu Tuna. System.printf( “%s” .metoda) . public Tuna(int x){ NUMBER=x.koja izgleda public String toString( ){ return String. to znaci da kad je jednom odredimo vise je ne mozemo mjenjati. for(int i=0. sum). } } Napravili smo dve promjenjive. Zatim smo napisali da se vrijednost promjenjive sum prikaze na ekranu pri svakoj iteraciji petlje : System. Napravili smo zatim jos jednu metodu public void add( ){ sum+=NUMBER.ovo je klasicna metoda koja ce promjenjivoj sum dodati vrijednost koju sadrzi konstanta NUMBER. Klasa Apples izgleda: public class Apples { public static void main(String args[]){ Tuna TunaObject = new Tuna(10). }.add().printf("%s".out.Lekcija 48: final U ovoj lekciji cemo objasniti sta znaci final prije promjenjive. . tj imeobjekta. . } public void add(){ sum+=NUMBER. Klasa Tuna izgleda: public class Tuna { private int sum. }. Npr ako stavimo da je private final int NUMBER=2. TunaObject). } public String toString(){ return String.add( ) .format(“sum = %d\n. private final int NUMBER. } } } Napravili smo obicnu for petlju koja ce se vrtiti 5 puta. sum). Kada pokrenemo ovaj program dobijemo rezultat: sum = 10 sum = 20 sum = 30 sum = 40 sum = 50 ~ 48 ~ . TunaObject). Dalje smo napisali toString metodu( metoda koja pretvara objekat u String).i++){ TunaObject.out.format("sum = %d\n".

Potpie PotpieO = new Potpie(). Kada imamo klase koje se mogu svrstati u novu klasu koja ima neke zajednicke karakteristike (metode. Ali kao sto vidimo u klasama Tuna i Potpie se ne nalazi nista. } } Klase Tuna: public class Tuna extends Food { } Klasa Potpie: public class Potpie extends Food{ } Glavna Apples klasa: public class Apples { public static void main(String args[]){ Tuna tunaO = new Tuna(). logicki svu hranu(food) ).out. Klasa Food izgleda: public class Food { public void eat(){ System.. public class Tuna/Potpie extends Food) sto znaci da sve sto se nalazi u Food klasi . Kako se onda prikazuje eat metoda? U klasama Tuna i Potpie imamo extends Food (tj.). Klase koje nasljedjuju karakteristike su subclases a klasa od koje nasljedjuju je superclass. Dakle Klase Tuna i Potpie imaju istu metodu. }.out. tu karakteristiku napisemo u toj Superklasi i kasnije pomocu extends mozemo nasljediti te karakteristike.eat( ). tunaO.Recimo da svaka od ovih klasa (sem glavne) ima metodu pulic void eat( ){ System. Potpie i Food.eat( ). i pozvali smo eat metodu ( tunaO. kopiramo naziv) i promjenimo ~ 49 ~ . Tako iako eat metoda nije vidljiva u ovim klasama ona postoji pod uslovom da je public( ako je private onda nasljedjivanje nije moguce).eat(). imamo dosta klasa koje su subklase Food superklase .promjenjive. PotpieO. } } Kada pokrenemo ovaj program dobicemo: I am the eat method I am the eat method U glavnoj klasi smo napravili dva objekta . To radimo tako sto je prakticno kopiramo (tj.println("I am the eat method"). tj.println(“I am the eat method). PotpieO.Lekcija 49: Inheritance(nasljedje) Uzmimo da imamo 4 klase : Apples u kojoj se nalazi glavna metoda. Tuna. Tuna i Potpie to nasljedjuju. i zelimo da malo modifikujemo tu metodu sto se naljedjuje.eat(). ). Ako npr. jedan za klasu Tuna(tunaO) i drugi za klasu Potpie (PotpieO) . U ovom primjeru u klasi Food cemo napisati metodu koja je zajednicka za Tuna i Potpie (tj.

println. ~ 50 ~ .println("I am the new method of Tuna").out.out. Stoga u objekat tunaO prikazuje “I am the new method of Tuna” dok objekat PotpieO prikazuje nasljedjenu metodu od Food i stoga prikazuje ”I am the eat method”. tako stvaramo hijerarhiju. U klasi Tuna cemo modifikovati eat metodu dok cemo Potpie ostaviti nedirnutu. mi smo eat metodu nadjacali tako sto smo je napisali u Tuna klasi. } } Kao sto vidimo samo smo promjenili ovo u zagradi System.ono sto zelimo promjeniti. Klasa Tuna sada izgleda: public class Tuna extends Food { public void eat(){ System. nasljedjivanje od Food klase . Npr mozemo staviti da je klasa Tuna subklasa superklase Potpie dok je Potpie subklasa superklase Food. Tuna nasljedjuje sve i od Potpie i od Food . Sada kada pokrenemo program: I am the new method of Tuna I am the eat method Dakle iako imamo u nazivu klase Tuna .

swing.parseInt(sn). int num2 = Integer. String sn=JOptionPane.showInputDialog je ustvari klasa. Onda smo napisali kod da se saberu ova dva broja tj: int sum = num1 + num2 . Ta klasa se zove javax. . Joption. Treci parametar je naslov koji ce pisati na tom prozoru (tj. Java ima ugradjenu klasu koja skladisti sve komponente za Graficki Korisnici Interfejs(tj. public class Apples { public static void main(String args[]){ String fn=JOptionPane. Prva je fn tj. showMessageDialog – je metoda za prikazivanje koja zahtjeva cetri parametra.Lekcija 50: GUI (Graphics User Interface) U ovoj lekciji cemo uciti kako se pravi aplikacija sa kojom korisnik moze imati interakciju i koja je vidljiva korisniku.sto znaci da unosimo klasu koja sadrzi komponente za graficki prikaz(tj."the title".JOptionPane.PLAIN_MESSAGE). S obzirom da je showInputDialog metoda u mogucnosti samo da radi sa Stringom (slova. Prvi parametar odredjuje gdje ce se pokazati prozor (mi smo stavili null sto znaci da se pojavi na sredini ekrana).PLAIN_MESSAGE). Cetvrti parametar cemo objasniti kasnije (mi smo stavili JOptionPane. int num1 = Integer. Evo kako taj kod izgleda: import javax. javax. JOptionPane.JOptionPane).showMessageDialog (null.swing.PLAIN_MESSAGE).brojevi koji nemaju svojstvo brojeva).showInputDialog(“Enter first number”). int sum = num1+num2. a mi zelimo da sabiramo brojeve mi moramo da konvertujemo fn i sn u int promjenjive (da bih mogli vrsiti matematicke operacije nad njima).. dialog box. U ovom primjeru to smo uradili tako sto smo ukucali: int num1 = Integer.swing.JOptionPane. padajuci meni."The answer is " +sum. showInputDialog – je metoda za unos dok u zagradi je ono sto ce pisati u tom prozoru i sta ce govoriti korisniku sta da uradi/unese.ono sto ovo radi jeste da konvertuje ono sto je u zagradi tj.showMessageDialog(null.parseInt(fn). Isto smo uradili i sa String promjenjivom sn. ~ 51 ~ .Toolbar.JoptionPane. } } Na pocetku smo ukucali import javax. dok je metoda showInputDialog).metoda (klasa je JOptionPane . Title bar. Na kraju treba da se prikazu ti rezultati tako sto smo napisali: JOptionPane. “the title”. Isto je sa promjenivom sn . Primjer: napravicemo program u kojem cemo unijeti broj u jednom prozoru i kliknuti OK onda drugi broj u drugom “box”(prozoru) i na kraju ce se pojaviti prozor sa zbirom ta dva broja.showInputDialog("Enter first number"). JOptionPane. Meni. title bar).JOptionPane .swing. Drugi parametar je sta zelimo da se prikaze u tom prozoru ( mi smo stavili “The answer is “+ sum ).showInputDialog("Enter second number"). Dalje smo napravili dve String promjenjive.” answer is ”+ sum. scroll bar.parseInt(fn). String fn = JOption. fn i smjesta je u promjenivu num1 tipa int.).

3 . ~ 52 ~ . dobicemo prozor koji izgleda: prozor: 1 onda treba da ukucamo broj i stisnemo OK mi smo stavili broj 5 i kada kliknemo na OK dobijemo drugi prozor: prozor: 2 mi smo stavili broj 3 i kliknuli OK i dobili zadnji prozor koji izgleda: prozor: 3 Kao sto vidimo tacno su sabrana dva broja 5 i 3 i rezultat nam je prikazan u zadnjem prozoru br.Kada pokrenemo ovaj program . U formi “The answer is 8” .

kad izgradim novo stavi desno od toga .setToolTipText(“This is gonna show up on hover”). Sledeca stvar koju cemo uraditi jeste da cemo postaviti raspored tj. Moramo imati na umu da svaki item koji napravimo moramo dodati u prozor na ovaj nacin.Jframe. mi zelimo koristiti ono sto vec imamo . item1.JLabel je vrsta promjenjive .minimaze . . javax. close . setLayout(new FlowLayout()). .swing. Titlebar. . } } Kao sto vidimo na samom pocetku smo unijeli (inportovali) tri klase: 1) Java. maximaze.sada imamo tekst na ekranu koji kaze “this is a sentence”. Daje nam prosti prozor. Sada kad je Tuna nasljedila sve te karakteristike napravili smo promjenjivu na nacin: private JLabel item1. item1 je ime promjenjive.JLabel. x.. Koristicemo dve klase Apples (glavna) i Tuna.awt. kada izgradim novo stavi desno. zato inportujemo ovo. ovo je ustvari tlocrt ili raspored. add(item1).FlowLayout. Dakle omogucava nam da ubacimo tekst i slike u prozor. Na posljetku moramo dodati item1 u prozor: to je jednostavno ukucamo add(item1) tj add(/*ime promjenjive/stvari koju zelimo dodati u prozor*/).swing.setToolTipText("This is gonna show up on hover"). ~ 53 ~ . public Tuna(){ super("The title bar"). Dalje smo napravili konstruktor: public Tuna( ) . Sada cemo graditi stvar koju zelimo imati na ekranu (vec smo je nazvali item1): item1 = new JLabel(“this is a sentence”). Dace nam default raspored (stavi ovo ovde.FlowLayout – ovo ce unijeti kako su stvari postavljene . Klasa Tuna je nasljedila JFrame .JFrame.Lekcija 51: GUI with Jframe Za razliku od prosle lekcije gdje smo gradili graficki korisnicki interfejs koji bi izgledao isto bez obzira na kojem operativnom sistemu ga pokrenuli.daje nam osnovne karakteristike prozora kao npr. SetLayout( new FlowLayout( ) ) .ovo nam daje standardni “layout”. class Tuna extends JFrame{ private JLabel item1. sada klasa Tuna imamo sve karakteristike osnovnog prozora. 3) Javax.(Ovo ce ustvari biti item(“stvar”) koju dodajemo u prozor. tj. Tuna klasa izgleda: import import import public java. Label je ustvari samo linija teksta. Takodje nam omogucava da radimo jednostavne slike. Takodje kad ga pokrenemo na Mac OS on ce nasljediti sav izgled od Mac OS. Sada cemo napraviti interfejs koji kad pokrenemo na Windows OS on nasljedi sav izgled od Windows OS.awt. u tjelu konstruktora imamo: super(“The titel bar”) – sto je ustvari ono sto ce pisati u naslovnoj liniji.JLabel – ovo je ono sto cemo graditi . i kad ponestane prostora predji u sledeci red) 2) Javax. javax. To dakle radimo tako sto ukucamo super i u zagradi ono sto ce biti u naslovnoj liniji. item1 = new JLabel("this is a sentence").swing. Sada cemo dodati teks koji ce se prikazati kada predjemo preko svoga “item-a” na nacin sto smo ukucali : item1.swing.

Kada pokrenemo ovaj program dobijemo: Kada predjemo misem preko “this is a sentence “ dobijemo : ~ 54 ~ .180).Glavna klasa Apples izgleda: import javax.swing. TunaO. TunaO. napisali smo: TunaO. } } U glavnu klasu smo takodje inport-ovali javax.setDefaultCloseOperation(JFrame. Da nemamo ovo program bi bio zamrsen.swing. TunaO.JFrame ( objasnjenje ) – iz razloga sto nam daje osnovne karakteristike prozora. .u zagradi se nalazi nacin na koji zelimo da se nas program zatvara.setSize(275. .setVisible(true). Svaki put kada pritisnemo x dugme program prestaje . TunaO. TunaO.JFrame. Dalje smo napravili objekat TunaO bez argumenata. EXIT_ON_CLOSE). Sada cemo postaviti kako zelimo da se nas program zatvara .EXIT_ON_CLOSE). Ovaj objekat koji je prilicno prozor sa linijom teksta u njemu..180).znaci da je program vidljiv . public class Apples { public static void main(String args[]){ Tuna TunaO = new Tuna().setVisible(true).setDefaultCloseOperation(JFrame.odredili smo velicinu prozora.setSize(275.

event. private JTextField item2. event. Napravicemo dve klase.format("field 3: %s". add(item3).JOptionPane public class Tuna extends JFrame { private JTextField item1. Glavna:Apples i klasu Tuna koja izgleda: import java.ActionListener.JTextField. item2.setEditable(false). else if(event.format("pass field is : %s" . string). else if(event.53. import javax. item1. add(passwordField). add(item2).addActionListener(handler). item3=new JTextField("uneditable".getSource() == item1) string=String. else if(event.getSource() == passwordField) string=String.format("field 2: %s". private JTextField item3. thehandler handler = new thehandler().format("field 1 : %s". Cjeli ovaj proces se zove Event Handling.getActionCommand()).showMessageDialog(null. event handler ce izbaciti novi prozor.getActionCommand()). item3. pritisne neku tipku). U ovim lekcijama cemo izgraditi prozor i neke textbox-ove unutar njega . event). add(item1).awt.//JFrame. Event handler je kod koji reaguje na to sto korisnik moze da uradi (tj.getActionCommand()).addActionListener(handler).addActionListener(handler).getActionCommand()).54 .ActionEvent.Lekcije:52. item2= new JTextField("enter text here"). event.getSource() == item2) string=String. passwordField. i kad god korisnik unese nesto u taj text box i pritisne ENTER . } } } ~ 55 ~ .getSource() == item3) string=String. item1=new JTextField(10). passwordField = new JPasswordField("mypass"). Event Handling Event je bilo sta korisnik moze da uradi(pomjeri mis.*. item3.//FlowLayout. JOptionPane.20).JpasswordField.addActionListener(handler).*. private JPasswordField passwordField. } private class thehandler implements ActionListener{ public void actionPerformed(ActionEvent event){ String string = "". setLayout(new FlowLayout()).event. public Tuna(){ super("The title").swing. if(event.

add(passwordField). private JTextField item2.FlowLayout. . item1. Onda smo napravili promjenjive:     private JTextField item1. add(item2). passwordField = new JPasswordField("mypass"). to se ne odnosi na to koliko slova mozemo ukucati vec na to kolika ce polje biti prikazano u prozoru ). item3 je malo drugacije jer smo . Dodali smo:     item1 = new JTextField(10).swing.swing.setEditable(false) nam omogucava da zastitimo neki tekst unutar naseg prozora.setEditable(false).znaci da smo prilicno kreirali mjesto u prozoru koje takodje pokazuje tekst ali koji mi vidimo kao **** iil kao •••••• .swing. Sada cemo dodati malo funkcionalnosti ovom prozoru. u zagradi smo stavili da pise u polju “uneditable” . .swing. U tjelu konstruktora smo ukucali super(“The title”). add(/*ono sto zelimo dodati(ono sto zelimo staviti u prozor)*/). item3 = new JTextField("uneditable".setEditable(false). mjesto gdje mozemo kucati tekst u prozoru). private JTextField item3. . item3.ActionListener. Dalje smo nasljedili sve stvari od JFrame u Tuna klasu tj ukucali smo public class Tuna extends JFrame. . . Sada imamo prozor sa 4 polja . dakle promjenjiva.20).JPasswordField. Ustvari smo sada napravili prozor i mozemo stavljati “stvari” u njega. add(item1). .JOptionPane.daje nam raspored.event. . import java.JFrame. Sada kada imamo naslovnu liniju I raspored mozemo dodavati “stvari” u prozor. item2 = new JTextField("enter text here").uzeli smo jedan standarni iz “klasa” koje smo inportovali.tj: ~ 56 ~ .ovo su ti event-i. Item2 je isto sto i item1 samo sto cemo imati “default” tekst unutra .item2 i item3 su obcni “Text field” (tj.awt. Dalje smo napravili konstruktor(ustvari to je nas prozor): public Tuna(). import javax.slusa ili bolje receno ceka da korisnik uradi neki event.napravili smo naslovnu liniju i nazvali smo je “The title”.Prvo smo inportovali(unijeli) sledece klase :        import java. . import java.Text field je mjesto gdje mozemo ukucati tekst import javax. Pored toga u sledecoj liniji koda smo ukucali item3.PassworField je takodje mejsto gdje mozemo ukucati tekst samo sto je . import javax. Npr kada korisnik ukuca nesto i pritisne ENTER u ova polja da se pojavi prozor koji ce nam prikazati sta smo ukucali u njemu. private JpasswordField passwordField. passwordField = new JpasswordField(“mypass”). . “enter text here” . Dalje smo odredili raspored u prozoru tako sto smo ukucali setLayout( new FlowLayout()).awt.event. S tim da item1 je ima duzinu 10(iz razloga sto ima 10 u zagradi. samo sto ga sakrije (umjesto karaktera vidimo ***** ili ••••••••) import javax.JTextField. i stavili smo duzinu 20.awt. Moramo primjetiti da kada kreiramo tekst field ili password fied da ga moramo naknadno dodati u prozor tako sto upisemo add(item1) tj. add(item3).sto znaci da se ovo polje nemoze mjenjati .ActionEvent. tj. Prvu stvar koju cemo uraditi jeste da cemo napraviti objekat za klasu thehandler koju cemo naknadno napraviti.

Cjela ova izjava : if(event. Taj objekat smo dodali svakom od promjenjivih na nacin sto smo ukucali item1. item3 i passwordField . Dalje smo napravili veliku if izjavu.addActionListener(handler). dakle public void actionPerformed(Action Event event) –je ime te metode. getSource( ) – prilicno znaci gje se to dogodilo.getSource()==item1) string=String. else if(event.getActionCommand()).addActionListener(handler). polje3. Ono sto ova metoda(actionPerformed) ustvari radi jeste: Ako korisnik ukuca nesto u polju 1 i pritisne ENTER . ~ 57 ~ . Ovaj metod mora postojati i mora se zvati actionPerformed (ovo je ugradjena metoda koja ima veze sa ActionListener klasom).getSource( ) = item1) – event je ono sto ce korisnik uraditi( u ovom primjeru kad pritisne ENTER). else if(event.addActionListener(handler). a sada kada pritisnemo ENTER one rade nesto. i passwordField.format("field 2: %s". A to sto ce raditi nalazi se u public void actionPerformed(actionEvent event) metodi. passworField) dali malo funkcionalnosti . event. to je metod koji ce biti pozvan automatski kada se event javi.getSource()==item2) string=String. Zadnja stvar koju cemo ukucati u ovoj metodi je: JOptionPane. Mi mozemo unutar klase napraviti klasu . else if(event.format("field 3: %s". ako je false imamo novi else if test za item2 .getActionCommand( ) – getActionCommand( ) znaci uzmi tekst sa te lokacije. JOptionPane – je prazan prozor . event.format("field 1 : %s".item3. Dakle svaki put kada nesto koristi taj objekat upucuje se na klasu thehandler. . prije su samo postojale . s tim da klasa koja se nalazi unutar nasljedjuje sve od klase u kojoj se nalazi. If (event. to smo uradili sto smo ukucali: imepromjenjive. Metod: public void actionPerformed(ActionEvent event){ String string = "". – ovo ce biti klasa koja upravlja eventim-a.napravili smo objekat za klasu thehandler . event.getSource( )=item1 –znaci ako korisnik pritisne ENTER na tekst polju 1 . item3. kao sto je sposobnost da zovne specificne metode u ovom slucaju actionPerformed.addActionListener(handler). event.format(“ field1 : %s”.getSource()==item3) string=String. U metodi smo napravili promjenjivu string koja je jedanka praznom stringu. passwordField. promjenjiva string ce biti jednaka field1 : /*sta god da je korisnik ukucao*/.addActionListener(handler). string). event. i password polje .3. Sada smo svakom od ovih stvari(item1.getActionCommand( )). item2.showMessageDialog(null. tj:     item1. string). sta mi zelimo da se desi . Da bismo handle (rukovali) eventima definitivno je potrebno imati Event Handling klasu koja implementira ( ono sto implement ActionListener znaci jeste da ce klasa handle imati odredjene kvalitete . event. Dalje smo dodali ovaj objekat(handler) svakom “item-u” .addActionListener(/*objekat kojem zelimo dodati*/).showMessageDialog(null.getActionCommand()).item2. U ovoj klasi cemo napisati samo jedan metod . item2.format("password field is : %s".Thehandler handler = new thehandler( ). if(event. tj prikazacemo to na ekranu sta korisnik ukuca.getActionCommand()).getActionCommand()). JOptionPane. Ako je true izvrsice se : string=String.addActionListener(handler). Mi smo unutar Tuna klase napravili private class thehandler implement ActionListener{ . Isto tako je I za polje2. U zagradi imamo null i promjenjivu string koja ce biti prikazana u tom prozoru.addActionListener(handler).getSource()==passwordField) string=String. Kada imamo klasu mozemo i napraviti i objekat koji predstavlja tu klasu u ovom slucaju handler.

i ono sto pise uneditable ne mozemo promjeniti kada ukucamo nesto u polje 4 . Zatim smo definisali velicinu prozora: TunaO.setVisible(true). tj password polje . Kada pokrenemo ovaj program dobicemo: Kada ukucamo nesto u polje 1 npr. TunaO.setVisible(true). bla i pritisnemo ENTER dobicemo : S obzirom da je polje 3 zasticeno . npr bla izgledace: Tj umjesto bla ce biti prikazano ••• .JFrame.JFrame. string). i podesili da nam prozor bude vidljiv tj: TunaO. .swing.EXIT_ON_CLOSE ). Zatim smo napravili objekat TunaO.setDefaultCloseOperation(JFrame. u novom prozoru otkrice nam se to sto smo napisali u passwor field-u : ~ 58 ~ . } } Prvo smo inportovali (unijeli) javax. TunaO. TunaO.setSize(350. Prvo napravi promjenjivu string zatim testira kako zelimo da taj string izgleda i na kraju ga prikazuje : JOptionPane.swing.Dakle ova metoda se izvrsava automatski kada korisnik pritisne ENTER.100). da bi smo mogli koristiti prozore u nasoj glavnoj metodi.EXIT_ON_CLOSE ). a kada pritisnemo ENTER.setSize(350.showMessageDialog (null.setDefaultCloseOperation(JFrame. Sada mozemo preci u glavnu klasu Apples koja izgleda: import javax. Dalje smo mu definisali operaciju za izlazak na nacin sto smo ukucali: TunaO.100). public class Apples { public static void main(String args[]){ Tuna TunaO = new Tuna().

Klasa Food: public class Food { public void eat(){ System. pokazacemo na primjeru .println("this Tuna is great").println("this food is great"). Kako ovo moze biti korisno. Mi smo napravili 4 klase :glavna klasa Apples.Lekcija 55: Intoduction to Polymorphism Da bi smo demonstrirali polimorfizam moramo napraviti program koji koristi nasljeđivanje. Zasto nam to treba? Prvo Tuna i zadnje Tuna nisu isto.++x){ djordje[x]. djordje[1]=new Potpie(). } } Klasa Potpie: public class Potpie extends Food{ public void eat(){ System. for(int x=0. djordje[0]=new Tuna(). } } Klasa Tuna: public class Tuna extends Food{ public void eat(){ System.vidimo da na dva mjesta imamo Tuna. } } Kao sto vidimo mi smo overwrite (pisali preko) u klasama Tuna i Potpie na nacin da smo ime nasljedene metode kopirali i izmjenili joj tjelo. to znaci da kad god uputimo na promjenjivu tunaO mi upucujemo da kontrolise stvari u klasi Tuna( ) (tj zadnje Tuna ). Prvo Tuna je “data type” (vrsta podataka) . Ono sto sad mozemo uraditi . Kada kreiramo objekte npr za Tuna klasu mi bi smo ukucali: Tuna tunaO = new Tuna( ). ~ 59 ~ .out..a tunaO je objekat vrste Tuna (iz razloga sto tunaO= new Tuna( ). Food-a) moze biti assigned (dodjeljen) objektu tunaO. bilo sta sto nasljedjuje od superklase (tj. glavna klasa Apples izgleda : public class Apples { public static void main(String args[]){ Food djordje[]=new Food[2].out. tako da moze kontrolisati Tuna vrstu podataka . Ne samo da je TunaO od Tuna vrste podataka vec je TunaO takodje i Food vrsta podataka. preporuka. klasa Tuna i Potpie koje su subklase klase Food (superklasa).eat()..x<2. ).I ovo je poprilicno uvod u polimorfizam. .) .out. Npr ako napisemo ovako Food tunaO = new Tuna( ). tunaO je refernce variable (reference znaci upucivanje. . } } } Najbrzi primjer kojim mozemo objasniti jeste da napravimo polymorphic Array i on skladisti objekte od razlicitih klasa u prilicno superklasa vrsti. Tuna( ) s obzirom da nasljedjuje od Food moze biti dodjeljeno tunaO.println("this Potpie is great").

Zatim ide kroz drugi objekat djordje[1] kome je dodjeljena Potpie klasa i zove eat metodu. s obzirom da imamo nesto Food vrste on moze “hold” (drzati.++x){ bucky[x}. Jedan od razloga koriscena polimorfizma su polymorphics arrays . Prvo ide kroz prvi objekat djordje[0] kome je dodjeljenja Tuna klasa i zove tu metodu (eat). Kad pokrenemo ovaj program dobicemo : this Tuna is great this Potpie is great ~ 60 ~ .djordje[ ] – je Array objekat . . Ono sto ovo radi jeste da ide kroz svaki od objekata i zove eat metodu za svaki.x<2. } – ono sto ovo radi jeste da ide kroz svaki od ovih objekata i zove eat metodu.Napravili smo : Food djordje[ ] = new Food[2]. i ovaj objekat je Food vrste (iz razloga sto se ispred djordje [] nalazi Food ) . i to bi bilo nesto poput ovoga: For(int x=0.eat( ).posjedovati) objekte Tuna i Potpie (iz razloga sto su Tuna i Potpie subklase superklase Food ).

~ 61 ~ .eat( ). } . Zatim smo napravili Food objekat i nazvali ga fo. I Glavna klasa Apples: public class Apllses { public static void main(String args[]){ Fatty djordje = new Fatty().println("This food is great").digest(po).out. Osim sto metoda digest moze prihvatiti Food objekat. Takodje smo napravili Potpie objekat koji se zove po( kao sto vidimo za razliku od objekata djordje i fo kod kojih imamo na dva mjesta ime klase . Sada mozemo uraditi nesto sa tim objektom. Kao sto vidimo u zagradi imamo(parametar) Food x sto znaci da ce uzimati Food objekat. djordje.println("This Tuna is great"). U tjelu digest metode imamo x. ona takodje moze prihvatiti i svaki objekat subklase ( u ovom primeru subklase superklase Food su Tuna i Potpie. x samo znaci da ce se u toj metodi x odositi na taj objekat.digest(fo). Food fo = new Food(). sto znaci da na Food objekat koji prosljedimo bice primjenjena metoda eat( ) . } } Klasa Tuna: public class Tuna extends Food{ void eat(){ System. } } Prvo smo napravili Fatty objekat i nazvali ga djordje.println("This Potpie is great"). djordje.Lekcija: 56 Polymorphic Arguments Imamo 5 klasa: Klasa Fatty: public class Fatty { public void digest(Food x){ x. } } Za razliku od prosle lekcije u ovoj imamo jos jednu klasu Fatyy.out.out. u kojoj imao digest metodu tj:public void diges (Food x) { x. Food po = new Potpie(). } } Klasa Potpie: public class Potpie extends Food{ void eat(){ System. kod objekta po imao Food na pocetku i Potpie( ) na kraju) .eat().eat( ). } } Klasa Food: public class Food { void eat(){ System.

2) Kada odemo u klasu Fatty do metode digest vidimo da ona zahtjeva jedan Food objekat . sto je demonstracija da umjesto Food objekta kao parametar mozemo prosljediti bilo koji objekat koji predstavlja subklasu Food superklase. digest je Fatty meteoda . . Kada pokrenemo ovaj program dobijemo: This food is great This Potpie is great Dakle “This Food is great” se prikazalo na sledeci nacin: 1) imamo instrukciju u glavnoj klasi djordje. 4) Metoda eat u klasi Food ima instrukciju(System.digest(fo) . ) koja se izvrsava i na ekranu se prikazuje “This food is great” “This Potpie is great” se pokazalo na slican naci .eat ( sto u stvari znaci fo. dakle ide dalje do eat metode u klasi Food ( jer je fo objekat klase Food ).eat). koji smo mi dali (fo).iz klase Fatty (pomocu objekta djordje) smo pozvali metodu digest koja zahtjeva jedan argument tj. djordje. Takodje mozemo kao argument uzeti bilo koji objekat cija je klasa subklasa superklase Food . djordje je Fatty objekat. 3) Unutar digest metode imamo instrukciju x. u ovom slucaju fo ( objekat klase Food).digest(fo). dok je ovo u zagradi argument tj.out.Zasto smo uopste napravili Food objekat? Zato sto u klasi Fatty metoda digest uzima argument koji je Food objekat. fo je upravo taj Food objekat. Metoda digest tom Food objektu dodjeljuje ime x koje koristi unutar te metode( bilo koji Food objekat bi dobio to ime) . Food objekat .println(“This food is great”). ~ 62 ~ .

eat(). } } Klasa Tuna: public class Tuna extends Food{ void eat(){ System. Npr ako vracamo int u super klasi moramo vratiti int i u subklasama. ~ 63 ~ . Kod klase Fatty gdje digest metoda zahtjeva jedan Food objekat. U subklasama Tuna i Apples smo “overwrite” metodu eat( ) koja se nalazi takodje u superklasi Food . garantuje nam da mozemo koristiti i subklasu takodje( npr. subklase klase Food: Tuna i Potpie .println("This food is great").out. Ova pravila postoje da bih smo imali consistency (dosljednost tj. U prosloj lekciji smo imali 5 klasa : glavnu Apples.println("This Tuna is great").out. konzistencija) a to nam osigurava da bilo kad pozovemo metodu . Svaki put kada zelimo u subklasi “overvrite” pisati preko neke metode iz superklase moramo sem istog imena metode staviti i iste argumente u zagradi (dakle ako je u superklasi void eat( ) . } } Klasa Potpie: public class Potpie extends Food{ void eat(){ System. To je potpuno nova metoda. } } Klasa Food: public class Food { void eat(){ System. ako zelimo “overvrite” u subklasi mora pisati void eat( ) ) da pise void eat( int i) ) to vise nije “overvrite” vec overloading a to je potpuno druga stvar ).Lekcije: 57 Overriding Rules (najvaznija pravila) i 58 Abstract and Concrete classes Klasa Fatty: public class Fatty { public void digest(Food x){ x. } } I Glavna klasa Apples: public class Apllses { public static void main(String args[]){ } } U ovj lekciji cemo pokusati rasvljetiti neke stvari koje smo obradili u proslim lekcijama. superklasu Food. ako sve overvrite metode u subklasama vracaju iste stvari i imaju iste argumente onda umjesto objekta Food mozemo staviti bilo koji objekat koji predstavlja njegovu subklasu). Isto tako moramo i vratiti “return” istu stvar.out. “Overloded” (preklopljena) metoda je metoda sa istim imenom ali koja ima drugacije argumente. Isto takodje kad god overvrite metodu ne mozemo mjenjati iz public u private.println("This Potpie is great"). i klasa Fatty.

Klase koje nemaju abstract zaglavlju klase .. suprotno: apstraktan). Samo u apstraktnim klasama mozemo imati apstraktne metode(Dok concrete metode mozemo imati i u apstraktnim klasama s tim da moraju imati tjelo). Apstract metoda je metoda koja mora biti “overvriten”. okus… . Implement znaci prilicno da moramo “overvrite” apstracktne metode. Apstraktna klasa Food. dok njihovoj superklasi Food ne mozemo odrediti takve argumente . Ako subklase nemaju tu metodu pojavice se error u liniji gdje se nalazi glava klase ili header(zaglavlje). oblik. Kada napravimo apstract metodu potrebno je da u superklasi da napisemo metodu bez tjela tj samo glavu metode.println("This Tuna is great"). } } I klasa Potpie: public class Potpie extends Food{ void eat(){ System. eat metoda u Food klasi) .out.out. zato sto je Food(hrana) sirok pojam . koji se moze opaziti culima . se zovu concrete (konkretan – stvaran. Kada god vidimo error u kome se nalazi rjec visibility vjerovatno morate promjeniti iz private u public ili obrnuto ili dodati ili jedno ili drugo. Postoje neke klase (npr Food) koje su previse opste i za koje ne zelimo praviti objekte. okus. miris. Klasa Tuna: public class Tuna extends Food{ void eat(){ System. Ako neku klasu zelimo koristiti za “inheritance” nasljedje ili polimorfizam a ne zelimo da se mogu praviti objekti prije klase stavimo abstract ( npr za Food : abstract public class Food { ) i sada kada bih smo pokusali napraviti Food objekat dobili bih smo error. ~ 64 ~ . miris. } } Dakle kada god imamo apstraktnu metodu u superklasi(npr. sve subklase (u ovom primjeru Tuna i Potpie ) moraju imati tu metodu ili drugim rjecimo sve subklase moraju da “implement” ili “overvrite” tu metodu. Npr. neznamo joj boju.println("This Potpie is great").Klase Tuna i Potpie mogu imati neke svoje argumente tipa : boja oblik. sa apstraktnom metodom eat : apstract public class Food { public abstract void eat() } S obzirom da subklase Tuna i Potpie moraju da “overvrite” ovu metodu one moraju da imaju tjelo.

out. nam prikazuje sta se ustvari desava.length) i ako je ovaj uslov u zagradi ispunjen (tj. private int i=0. DLO.length){ thelist[i]=d.println(“Dog added at index “ +i). Klasa Dog: public class Dog } { Klasa Animals: public class Animal { } Klasa DogList: public class DogList { private Dog[] thelist = new Dog[5].u parametrima smo definisali da ce primati Dog objekte i da ce oni u ovoj metodi biti prestavljeni sa d. } } Napravili smo Doglist objekat i nazvali ga DLO i Dog objekat koji smo nazvali d. . i++. i++. Scenario je ovakav : Imamo 4 klase: Glavna Apples. U tjelu metode smo napravili if statement: if(i < thelist. I treba da napravimo novu klasu DogList u kojoj cemo napraviti array koji ce skladistiti objekte klase Dog. Dallje smo napravili promjenjivu i koju cemo koristiti kao brojac(counter).add(d). Dog d = new Dog(). Zatim smo pomocu DLO objekta iz DogList klase pozvali metodu add i stavili u parametrima objekat d koji predstavlja klasu Dog.println("Dog added at index "+i). superklasu Animals.out. Zatim smo napravili metodu pomocu koje cemo dodavati Dog objekte cije zaglavlje izgleda: public void add(Dog d) . public void add(Dog d){ if(i<thelist. System. Glavna klasa Apples: public class Apples { public static void main(String args[]){ DogList DLO = new DogList(). se povecava da ne bih pripisali/dodali istom indeksu novi objekat.Lekcija: 59 Class to Hold Object U ovoj lekciji cemo napraviti program koji uzima klasu i stavlja objekte u array. njene subklase Dog i Fish . System. thelist je ime array-ja dok Dog[5] znaci da ovaj array skladisti 5 Dog objekata. } } } Prvo smo napravili array: private Dog[ ] the list = new Dog[5] – Dog[ ] znaci da cemo u ovom array skladistiti Dog objekte . Kada pokrenemo ovaj program dobicemo: Dog added at index 0 ~ 65 ~ . provjerava da li je array pun ili ne) ako nije dodaje taj objekat i pripisuje mu indeks i (cija je pocetna vrijednost postavljena na nula) tj: thelist[i]=d ili imearray-a[indeks]=d.

length){ TheList[i]=a. public void add(Animal a){ if(i<TheList. ALO.println("Animal added at index "+ i). i univerzalnu AnimalList klasu koja ce imati Array koji ce biti u mogucnosti da skladisti bilo koji objekat koji je predstavnik klase koja nasljeđuje klasu Animals (po logici tu spadaju sve zivotinje). System. Klasa Fish: public class Fish extends Animal{ } Klasa Dog: public class Dog extends Animal{ } Klasa Animal: public class Animal { } Klasa AnimalList: public class AnimalList { public Animal[] TheList = new Animal[5].add(f). Fish f = new Fish(). i++.add(d). Imamo 5 klasa: glavnu Apples. Whale i koliko vec postoji zivotinja. } } } Glavna Klasa Apples: public class Apples { public static void main(String args[]){ AnimalList ALO = new AnimalList(). superklasu Animals njene subklase Fish i Tuna. } } Kada pokrenemo ovaj program dobicemo: Animal added at index 0 Animal added at index 1 Ovaj kod je identican onom iz prosle lekcije samo sto smo sada umjesto da pravimo za svaku novu klasu Array .Lekcija: 60 Array Holding Many Objects U prosloj lekciji smo napravili Array koji skladisti Dog objekte. Mozemo predpostaviti posto ima mnogo zivotinja da bih smo mogli dobiti zahtjev da napravimo Array koji ce sadrzavati objekte od : Cat. za bilo koju zivotinju) nam zatreba taj Array imamo ga vec kreiranog. Dolphin. izgradili jedan univerzalni u klasi AnimalList i za koju god subklasu superklase Animal (tj. ali sada je potrebno da napravimo Array koji ce da sadrzava Fish objekte. Dog d = new Dog(). ~ 66 ~ .out. public int i=0. Zato umjesto da za svaku ponaosob klasu pravimo poseban Array mi cemo napraviti Array koji ce biti univerzalan za sve zivotinje. ALO.

thenoiselist[0]=d.out. moze sadrzavati objekte svih njenih subklasa).noise(). }} Klasa Dog: public class Dog extends Animal{ public void noise(){ System. zatim smo istu tu metodu “overvrite” u klasama Dog i Fish. koji ce sadrzavati objekte tipa Animal (tj. Onda smo napravljenom Array-u dodjelili te objekte . objekat) dodjeli mu indetifikator x i pokrene metodu noise. povezali smo indekse i objekte( thenoiselist[0]=d i thenoiselist[1]=f.Lekcija: 61 Simple Polymorphic Program Napravicemo primjer na kome cemo prikazati kako polimorfizam moze biti koristan.out.println("Dog: Ruff"). }} Klasa Fish: public class Fish extends Animal{ public void noise(){ System. Glavna klasa Apples: public class Apples { public static void main(String args[]){ Animal[] thenoiselist = new Animal[2].noise( ) sto u stvari znaci da kada petlja prodje kroz Array uzmima tekući element(tj. ) . Napravili smo 4 klase: Glavna Apples. Klasa Animal: public class Animal { public void noise(){ System. Zatim smo napravili objekte d i f koji predstavljaju klase Dog odnosno Fish. Kada pokrenemo ovaj program dobicemo: Dog: Ruff Fish: Glurp Slurp ~ 67 ~ . U tjelu petlje imamo : x. Dog d = new Dog().println("Animals don't make noise"). thenoiselist[1]=f. Dalje smo napravili pobloljsanu for petlju( to je prilicno specijalna petlja koja prolazi kroz Array): for(Animal x: thenoiselist) – Animal je vrsta podataka. x je indentifikator kojim ce se nazivati objekti u ovoj petlji dok je thenoiselist Array kroz koji ce ova petlja ici. tj. subklase Dog i Fish.println("Fish: Glurp Slurp "). superklasa Animal. }} Dakle napravili smo noise metodu u klasi Animal . for(Animal x:thenoiselist) x. Fish f = new Fish().out. } } Prvo smo napravili Array thenoiselist .

b). HandlerClass handler = new HandlerClass().ImageIcon.png")).addActionListener(handler).awt.kada napravimo “button” moramo ga i manuelno dodati.getResource("aia.Lekcija 62 i 63: Jbutton U ovoj lekciji cemo praviti prozor na kojem cemo mi sami napraviti “buttons” . } } } Provo smo inportovali sve sto nam treba da bih smo napravili ovaj program.”reg Button” je ono sto ce pisati unutar tog “buttona”.swing.png")). jedan ce biti obicni a drugi ce biti sa slikom koja ce se mjenjati kada predjemo misem preko nje. .format("%s". java. reg = new JButton("reg Button"). javax. Icon x = new ImageIcon(getClass().event. java.awt.String. Zatim cemo dodati “button” koji ima izgled slike . reg. Zatim smo odredili kakav ce biti raspored unutar prozora tj. custom. U tjelu konstruktora smo ukucali super(„The title”) – dali smo ime prozoru (naslovna linija). custom. javax. ~ 68 ~ . Icon b = new ImageIcon(getClass().sto je default raspored. private JButton custom. add(reg).swing.showMessageDialog(null. reg = new JButton(“reg Button”). Napravili smo dve klase: glavnu Apples i klasu Gui. setLayout(new FlowLayout()). public Gui(){ super("The title"). .Icon.swing. add(custom). javax. add(reg) . javax. public class Gui extends JFrame{ private JButton reg.setRolloverIcon(x). U klasi Gui smo napravili dve private promjenjive reg i custom tipa JButton.addActionListener(handler). javax. Zatim smo klasu Gui “extend” klasom JFrame( sto znaci da klasa Gui nasljedjuje sve od klase JFrame). Sada kada smo podesili naslov prozora i raspored mozemo dodati nase “buttons”.swing. i kada predjemo preko njega dobice izgled druge slike.ActionEvent.awt.getResource("bib. } private class HandlerClass implements ActionListener{ public void actionPerformed(ActionEvent event){ JOptionPane.ActionListener.FlowLayout.JButton.JOptionPane. custom = new JButton("Custom". Klasa Gui : import import import import import import import import java.event. Onda smo napravili konstruktor za klasu Gui .getActionCommand())).swing. Kada sve to uradimo mozemo nastaviti sa programiranjem. setLayout(new FlowLayout( )). Takodje te slike moraju imati png ekstenziju (?) .JFrame. Prvo sto moramo jeste da te slike stavimo u Workspace/mjesto gdje se nalaze nase kalse. event.

} } U glavnoj klasi smo prvo importovali javax.swing.png”)) –getClass( ) sto oznacava ovu klasu.png”)) . HandlerClass smo napravili izvan konstrukora ali unutar klase Gui . Tjelo HandlerClass ima metodu public void actionPerformed(ActionEvent event).200). setRolloverIcon(/*u zagradu stavljamo objekat koji sadrzava sliku koju zelimo da se pojavi*/) tj. Zatim smo dodali ActionListener tipkama reg i custom i kao parametar smo dodali objekat handler tj.ono sto ova cjelokupna instrukcija kaze jeste da uzima tu sliku i snima ga u objekat koji smo nazvali b.setRolloverIcon(x). .addActionListener(handler).Icon b = new ImageIcon(getClass(). Zatim smo napravili objekat GO koji predstavlja Gui klasu.EXIT_ON_CLOSE).getResource(“aia. event. I namjestili smo da je prozor vidljiv tako sto smo ukucali GO.setVisible(true) .png”). .Ono sto upisemo u tjelu ove metode je ono sto ce se desiti kada kliknemo tipku reg ili custom . Ukucali smo u zaglavlju klase : private class HandlerClass implements ActionListener . String.png. Sada s obzirom da imamo objekat handler a nemamo klasu HandlerClass . Dalje smo napravili HandlerClass objekat handler tako sto smo ukucali HandlerClass handler = new HandlerClass( ).setDefaultCloseOperation(JFrame. objekat koji sadrzava sliku aia.ono sto implements znaci jeste: da cemo koristiti ono sto se nalazi u klasi ActionListener ali pod uslovom da u klasi HandlerClass “overvrite” sve metode. To smo isto uradili za sliku bib. getResource(“b. I na kraju smo dodali to “button” prozoru instrukcijom add(custom). tako da smo kucajuci Icon b = new ImageIcon( ) kreirali klasicni objekat koji u zagradi ima getClass( ).je slika koju smo ubacili ranije u radniprostor.setSize . Onda smo namjestili velicinu prozora tako sto smo ukucali imeobjekta.showMessageDialog( null. dok je b drugi parametar tj.JFrame. sto nam prilicno omogucava da koristimo prozore. Icon je klasa . GO. Ono sto ovo jeste jeste pocetak dodavanja dinmike nasim “buttonim-a”. GO.Custom je ime .getResource(“aia.setSize(300. Kad god zelimo da napravimo da kada na neku sliku/ikonu predjemo misem da se pojavi druga slika ukucamo ime tog “buttona”. Srecom po nas ActionListener ima samo jednu metodu (sto znaci da moramo “overvrite samo jednu metodu). u ovom primjeru custom.png .addActionListener(handler) i custom. moramo je kreirati. ~ 69 ~ . Zatim smo ukucali custom = new JButton(“Custom”.b). GO. Tjelo metode izgleda : JOptionPane.swing.setVisible(true).format( “%s” .JFrame. reg. .getActionCommand( ) ) ) Glavna klasa Apples izgleda: import javax. public class Apples { public static void main(String args[]){ Gui GO = new Gui().

Kada pokrenemo ovaj program dobicemo: Kada kliknemo “reg Button” dobicemo: Kada predjemo preko Custom . promjenice se slika i izgledace: I na kraju kad kliknemo na Custom: ~ 70 ~ .

italicbox = new JCheckBox("italic").* i javax.isSelected()) font = new Font("Serif". italicbox. Imamo dve klase glavna klasa Main i klasa Gui.awt.isSelected()) font = new Font("Serif".ITALIC. ~ 71 ~ .addItemListener(handler).isSelected() && italicbox. 14).event. 14).20). tf. U tjelu konstruktora imamo : Super(“The title”) – sto je nacin da podesimo naslovnu liniju naseg prozora i setLayout(new FlowLayout( )) – sto je standardni raspored u prozoru. tj. Font. Nakon toga smo napravili tri promjenjive: prva promjenjiva tf (tipa JTextField).* . } } } Prvo smo inportovali : java.14)). druge dve boldbox i italicbox (tipa JCheckBox).PLAIN.Font. brojkojioznacavavelicinutekstpolja ) . import java.PLAIN.*. else if(italicbox. else font = new Font("Serif". add(boldbox).BOLD. setLayout(new FlowLayout()). boldbox = new JCheckBox("bold").Lekcije : 64 i 65 JCheckBox U ovom programu cemo napraviti prozor koji ce imati jedno polje gdje ce biti tekst i dva druga koja ce taj tekst napraviti itailc ili bold u zavisnosti od toga koji “box” oznacimo.ITALIC. HandlerClass handler = new HandlerClass(). add(italicbox). Nakon toga smo napravili konstruktor public Gui( ) . imepromjenjive = new vrstapromjenjive(“/*ono sto ce pisati unutar tog polja*/”. tf = new JTextField("This is a sentence".isSelected()) font = new Font("Serif". boldbox. import javax.swing. Font. public Gui(){ super("The title"). private JCheckBox boldbox.*.awt.swing. Klasa Gui: import java.awt. } private class HandlerClass implements ItemListener{ public void itemStateChanged(ItemEvent event){ Font font = null.event. if(boldbox.setFont(new Font("Serif". private JCheckBox italicbox.setFont(font).Font.*. Dalje smo promjenjivoj tf tipa JTextField odredili sta ce pisati u tom tekst polju i koja ce biti velicina tog polja na nacin: tf = new JTextField(“This is a sentence” . Font.14). else if(boldbox. add(tf).addItemListener(handler). 20) . java.*.14).awt. tf.BOLD + Font. public class Gui extends JFrame { private JTextField tf.

Dakle prozor izgleda onako kako bih i trebao izgledati ali pogledamo sta se desava kada kliknemo nesto na njemu . Sada cemo kreirati novi objekat handler koji ce predstavljati klasu HandlerClass. Ono sto ukucamo u tjelu ove metode ce se desiti kada cekiramo boldbox ili italicbox. HandlerClass. brojkojiodredjujevelicinufonta ).addItemListener(handler) Dakle sada kada smo dodali ItemListener promjenive boldbox i italicbox cekaju da se nesto desi (a jedino sto se moze desiti promjenjivim tipa JCheckBox jeste da ih cekiramo) i kada se to desi izvrsava se ono sto se nalazi u HandlerClass (iz razloga sto u zagradi imamo objekat koji predstavlja tu klasu). kada cekiramo italic da tekst bude nakrivljen i kada su cekirana oba da tekst bude i podebljan i nakrivljen.PlAIN. 14)) ili imepromjenjive. Sada mozemo nastaviti.addItemListener(“/*objekat koji predstavlja HandlerClass*/).setFont(new Font(“/*imefonta*/”. To smo uradili sluzeci se if izjavom . FONT. ItemListener ima samo jednu metodu pa samo nju moramo “overvrite”. samo jedan od njih ili nijedan. Prije nego sto nastavimo moramo razjasniti jednu stvar: kada god stavimo jednu klasu unutar druge klase onda ta klasa koja je unutra moze da pristupi svim metodama i promjenjivim koje se nalaze u vanjskoj klasi.implements ItemListener znaci da u ovoj klasi ( HandlerClass) moramo koristiti sve metode ItemListener-a i “overvrite” ih . Font. Ta metoda je ItemStateChanged i zaglavlje izgleda: Public void ItemStateChanged(ItemEvent event). To izgleda : boldbox. ~ 72 ~ . Ukucali smo : Private class HandlerClass implements ItemListener .setFont(new Font(“Serif”. Nakon toga smo ove dve promjenjive dodali prozoru. BOLD . Kada bih smo sada pokrenuli ovaj program ne bih imao nikakve funkiconalnosti. ITALIC ili obicni tj. Ali prije toga smo kreirali promjenjivu font tipa Font i dodjelili joj vrijednost null tj: Font font = null. PLAIN*/. Posto smo napravili objekat handler unutar Gui klase (izvan konstruktora) moramo napraviti klasu koju on predstavlja tj. Na kraju smo dodali tf nasem prozoru ukucavsi add(tf). to znaci da moramo sada isprogramirati ove checkbox-ove da kada cekiramo bold da ovaj tekst postane podebljan.Nakon toga tf promjenjivo smo podesili font tako sto smo ukucali: tf. Onda smo promjenjivima boldbox i italicbox tipa JCheckBox odredili sta ce da pise pored “checkbox-a” na nacin : imepromjenjive = new JCheckBox(„‟/*sta zelimo da pise pored tog checkbox-a*/). Dakle ukucali smo : HandlerClass handler = new HandlerClass( ).addItemListener(handler) italicbox./*efekat tj. Zatim cemo promjenjim boldbox i italicbox tipa CheckBox dodati ItemListener tako sto cemo ukucati : imepromjenjive. npr cekiracemo bold: Kao sto vidimo nije se nista promjenilo .

Isto tako imamo 4 stvari koje ce se dogoditi zavisno koja od opcija je tacna: 1.setFont(font) ili imePromjenjiveKojojZelimoPostavitiOdredjeniFont. To smo uradili ukucavsi : tf.ITALIC.ITALIC. tj imePromjenjiveTipaJCheckBox. 4.BOLD. Font.isSelected( ) ) Kada je cekiran samo boldbox. moramo taj font primjeniti na promjenjivu tf (tj. Kada su cekirane i boldbox i italicbox .isSelected( ) oznacava da je taj check box cekiran. Font. else if ( italicbox.setFont(/*promjenjiva vrste Font*/). font = new Font(“Serif”. 2.Imamo 4 opcije : 1.BOLD + Font. Ali takodje u sva cetri primjera 2 argument je razlicit jer zelimo kada je cekiran odredjeni “checkbox” da slova postanu bolditalic. tekst u polju). bold. Dakle font namjestamo tako sto ukucamo imePromjenjiveTipaFont = new Font(“/*vrsta fonta*/”. 4. /*velicina slova izrazena brojevima*/). 14) font = new Font(“Serif. italic ili obicna. Na kraju izvan if izjave kada se odredi vrijednost promjenjive font . 3. Kada pokrenemo ovaj program dobicemo: prozor 1: Kada cekiramo samo bold prozor 2: kada cekiramo samo italic prozor 3: cekirano bold i italic Kao sto vidimo onaj effeka koji cekiramo . on se i primjeni na tekst u tekst polju ~ 73 ~ . Font.isSelected( ) && italicbox. 14) font = new Font(“Serif . Font.isSelected( ) znaci da je boldbox cekiran. /*effekat*/. 3. else if (boldbox. if( boldbox.isSelected( ) ) Kada je cekiran samo italicbox.PLAIN. 14) font = new Font(“Serif.14) Kao sto mozemo primjetiti u sva 4 slucaja prvi i treci argumenti su nam isti jer ne zelimo mjenjati font odnosno velicinu slova.isSelected( ) ) Kada nije nista cekirano ( else kada nije ispunjen nijedan od ova prva 3 uslova) boldbox. 2.

bif = new Font("Serif". public Gui(){ super("the title"). private JRadioButton bib. bib = new JRadioButton("bold and italic". pf = new Font("Serif".addItemListener( new bib. public class Gui extends JFrame{ private JTextField tf.25). add(ib). add(pb).awt. HandlerClass(itf)).addItemListener( new ib. private JRadioButton bb.event.ITALIC. private Font bif. bb = new JRadioButton("bold". 14).swing.add(pb).ITALIC. false).addItemListener(new } HandlerClass(pf)).false).setFont(pf). group. import java.BOLD. 14). group.PLAIN.add(bib). HandlerClass(bif)). private Font bf. private Font pf. private class HandlerClass implements ItemListener{ ~ 74 ~ . import javax.*.BOLD + Font. private ButtonGroup group. pb.addItemListener( new bb. private JRadioButton pb.*.awt. Font. private Font itf. add(bib). 14). U ovom programu cemo napraviti prozor u kome cemo imati jedno polje za tekst i 4 Radio tipke koje ce mjenjati Font u zavisnosti od toga koji RadioButton pritisnemo. 14).*. ib = new JRadioButton("italic". To cemo demonstirati na programu slicnom proslom. tf = new JTextField("djordje is awsome and hot". Font. bf = new Font("Serif". group. true). false).add(ib). add(bb). private JRadioButton ib.add(bb).Lekcija: 66 JRadioButton RadioButton je nesto poput CheckBox-a samo sto mozemo imati samo jedan RadioButton selektovan u isto vrijeme. HandlerClass(bf)). Kada selektujemo jedno dugme sva druga se “iskljuce”. itf = new Font("Serif". group. Napravili smo dve klase Glavnu Main i klasu Gui. add(tf). setLayout(new FlowLayout()). Font. group = new ButtonGroup(). pb = new JRadioButton("plain". Font. Klasa Gui: import java. tf.

event.add(bb) . Ukucali smo :     pb.addItemListener(new HandlerClass(bif)). Font. Font. add(ib). izmedju “buttona” (izmedju kojih dugmadi .addItemListener(new HandlerClass(pf)). addItemListener – znaci da taj “buton” ceka da se dogodi dogadjaj.14) bf = new Font(“Serif”.addItemListener(new HandlerClass(itf)). false) ib = new JRadioButton(“italic”. ButtonGroup je promjenjiva koja uspostavlja vezu . 4 tipa Font .awt.add(/*promjenjiva*/).BOLD. bb. cemo definisati kasnije). na nacin group.14) itf = new Font(“Serif”. Zatim smo napravili deset promjenjivih od kojih su 4 tipa JRadioButton. } public void itemStateChanged(ItemEvent event) { tf.swing. imepromjenjivetipaButtonGrup.* . } } } Na pocetku smo importovali : java. false) dakle prvi parametar u zagradi jeste ono sto ce pisati desno od “butona”.14) bif = new Font(“Serif”.addItemListener(new HandlerClass(bf)).ITALIC. U prozor smo ih dodali na standardan nacin tako sto smo ukucali add(pb). a kada se ~ 75 ~ . Definisali naslov i raspored. Nakon toga smo definisali promjenjive tipa Font :     pf = new Font(“Serif”. public HandlerClass(Font f){ font = f. true) bb= new JRadioButton(“bold”.addItemListener( new HandlerClass(/* ime fonta koji zelimo da se prosljedi HandlerClass */).* . Sada cemo dodati itemListener svakom od nasih JRadioButtona da bih im dali neku funkcionalnost jer u suprotnom imamo samo prozor sa jednim tekst poljem u kojem pise “djordje is awsome and hot” i 4 JRadioButton koji samo stoje tu u prozoru.PLAIN. Nakon toga smo dodali nase tekst polje . jedna tipa JTextField i jedna tipa ButtonGroup. java. ib.private Font font.* . group tipa ButtonGroup tako sto smo ukucali group=new ButtonGroup( ) onda smo dodali nase JradioButtone toj grupi . Zatim smo definisali i dodali nasa 4 RadioButtona:     pb = new JRadioButton(“plain”.awt. tj. 14) i stavili smo da nam tekst polje tf ima po defaultu plain font (obicni font. add(bb). bez ikakvih efekata) .BOLD + Font. to je karakteristika JRadioButton). javax.setFont(font).setFont(pf). drugi parametar (true ili false) je ono dugme koje ce biti ukljuceno(samo jedno moze biti ukljuceno. bib. imeJRadioButtona. false) bib = new JRadioButton(“bold and italic”. add(bib). Font. Font. Zatim smo definisali pro. tj. tako sto smo ukucali tf.add(pb). Klasa Gui je nasljedila JFrame. group.ITALIC. Dalje smo napravili konstruktor.

sto je odprilike metoda u cijem tjelu je ono sto ce se dogoditi kada se dogodi dogadjaj . Sada izvan naseg Gui konstruktora ali unutar Gui klase pravimo HandlerClass koja implements ItemListener. tj kada se klikne na pb.setDefaultCloseOperation(JFrame.swing. S obzirom da smo u klasu HandlerClass “implementirali” interfejs ItemListener . koji ima u zagradi pf tj PlainFont koji ce prosljediti konstruktoru.dogodi izvrsava se ono sto je u zagradama poslije.Font je vrsta podataka sa kojom ce konstruktor raditi dok je f ime koje ce Font vrsta podataka imati unutar ovog konstruktora. public class Main { public static void main(String args[]){ Gui go = new Gui(). ( new HandlerClass(pf)) – je objekat ustvari . go.200).setFont(font) tj.setSize(300. go. U tjelu imamo font= f.ib ili bib. Sada cemo u HandlerClass napraviti konstruktor koji prihvata jedanu promjenjivu/objekat tipa Font: Dakle napisali smo: public HandlerClass( Font f) .EXIT_ON_CLOSE).JFrame. font je promjenjiva koju smo napravili u klasi HandlerClass (izvan) konstruktora.bb.setVisible(true).setFont(/*font koji smo prosljedili u konstruktor i dodjelili ga promjenjivoj font(koju smo napravili izvan konstruktora unutar HandlerClass)*/) Klasa Main: import javax. } } Ovu istu klasu imamo u prosloj lekciji tako da je netreba dodatno objesnjavati. dok je f font koji je prosljedjen u konstruktor. a ima samo jednu : public void ItemStateChanged(ItemEvent event) . Unutar ove klase cemo napraviti promjenjivu font tipa Font. tekstpolje. Kada pokrenemo ovaj program dobicemo: ~ 76 ~ . U tjelu te metode smo ukucali tf. znaci da moramo “overvrte” sve metode koje ItemListener ima. go.

Takodje ono sto je najvaznije tekst u tekst polju ce postati podebljan: Isto ce se desiti kada pritisnemo “italic” . tekst ce postati i podebljan i nakrivljen : ~ 77 ~ . iskljucice se plain i ostace cekirano samo “bold”.Kada pritisnemo krug( tj. samo sto ce tekst postati nakrivljen: I naposljetku kada pritisnemo “bold and italic”. JRadioButton ) pored kojeg pise “bold” .

Dalje smo napravili konstruktor za klasu Gui.*. private Icon[] pics = {new ImageIcon(getClass().getSelectedIndex()]). padajuca lista) a druga je picture tipa JLabel (tj. tj.png”} –skladistiti ce put a put je vrste String. Klasa Gui: import java. Ono sto ce padajuca lista raditi jeste da cemo u prozoru imati ime dve slike i kada selektujemo ime jedne od dva imena u padajucoj listi promjeniti ce se slika. box.*.addItemListener( new ItemListener(){ public void itemStateChanged(ItemEvent event){ if(event.* .swing.setIcon(pics[box. picture=new JLabel(pics[0]). public class Gui extends JFrame { private JComboBox box. Zatim je klasa Gui nasljedila JFrame. new ImageIcon( getClass().filename je array koji sadrzi imena silka .getStateChange() == ItemEvent. } } Importovali smo java. private JLabel picture. public Gui(){ super("the title"). U package gdje se nalaze nase klase smo stavili dve slike: x.event.* i javax. Unutar Gui klase smo kreirali dve promjenjive od kojih je jedna box tipa JcomboBox (tj. setLayout(new FlowLayout()).awt. Definisali smo naslov prozora i raspored unutar njega. ~ 78 ~ .png i b.*. i on ce skladistiti slike.getResource( filename[1] ) ) – ovaj Array skladisti podatke vrste Icon . Dalje smo napravili dva Array-a:   private static String[ ] filename = {“b. slika).png”."x.png". JcomboBox je ustvari dropdown list tj. import javax. u nasem slucaju da se promjeni slika koja se nalazi u sklopu naseg prozora).png. SELECTED) picture. b.awt.Lekcije: 68 i 69 JComboBox U ovoj lekciji cemo napraviti prozor koji sadrzi JComboBox. private static String[] filename = {"b. box = new JComboBox(filename). tj.*. Sada cemo promjenjivoj box dodati Item listener (koji sluzi da kada kliknemo na jednu od opcija. Nakon toga smo promjenjivoj box (tj padajucoj listi ) dodjelili opcije koje ce imati. new ImageIcon(getClass().getResource( filename[1]))}. add(picture). add(box).png koje cemo imati kao izbor kada kliknemo na strelicu padajuce liste. private Icon[ ] pics = (new ImageIcon (getClass(). import java. padajuca lista. java.getResource( filename[0] ) ).png i x. Imamo dve klase glavnu Main i klasu Gui . } } ).awt.swing.png"}.event. ukucali smo : box = new JcomboBox (filename) . “x.awt. da se nesto desi .getResource( filename[0])).

sada cemo napraviti unutar tih zagrada(obicne zagrade su oblast vazenja ove klase) . Onda smo dodali u prozor box i picture .getStateChange( ) == ItemEvent. Ukucali smo box. Vec cemo napraviti anonimnu unutrasnju klasu na mjestu gdje nam je potrebna. pics je Array koji sadrzi dve slike .png kao default sliku u prozoru. Glavna klasa Main je standardnog izgleda kao iz proslog primjera. New Item Listener je klasa .addItemListener kao i inace .png ili x. setIcon( ) metoda mjenja sliku .SELECTED) picture. koji cemo dodjeliti promjenjivoj box tj. i postavili sliku b. itemStateChanged metodu sa parametrima u zagradi (ItemEvent event).Ovaj put necemo praviti objekat za HandlerClass (niti cemo posebno definisati HandlerClass kao u proslim primjerima) . (pics[box. box.png)). koja ima samo jednu metodu koju treba “overvrite” tj. U tjelu metode smo napisali if izjavu pomocu koje cemo razabrati koja od opcija je selektovana : if ( event.setIcon(pics[box. To izgleda: box.getSelectedIndex()]).getSelectedIndex( ) ] ) picture je promjenjiva tipa JLabel . U tjelu metode cemo napisati ono sto zelimo da se desi u kada se dogadjaj dogodi (u ovom primjeru dogadjaj je .png dobicemo: ~ 79 ~ . zatim smo otvorili obicnu zagradu u kojoj cemo staviti anonimnu unutrasnju klasu a ono sto ona radi jeste da implementira ItemListener interfejs . tj. b. prozor 1: Kada pokrenemo program dobicemo Prozor 2: Kada kliknemo na strelicu dobicemo: Prozor 3:Kada izaberemo x.klasu koju smo prije posebno pravili. kada u padajucoj listi selektujemo jednu od imena od dve slike (tj. }}).setIcon(pics[box.SELECTED ).addItemListener( new ItemListener( ){ public void itemStateChanged(ItemEvent event){ if(event.ova if izjava nam govori sta je selektovano .addItemListener(/* HandlerClass objekat*/).getStateChange() == ItemEvent. koja od dve slike ce biti izabrana zavisi od onoga sto je selektovano . koja je navedena kao argument tj. Ako je uslov tacan izvrsava se picture.getSelectedIndex) .

add(new JScrollPane(list)).u u kojoj ce biti ponudjena imena 4 boje ( tj.event. Color. U tjelu konstruktora smo promjenjivoj tipa Jlist dodjelili vrijednosti koje ce prikazivati odnosno dodjelili smo joj array colornames tako sto smo ukucali list = new Jlist(colornames). } } ).* .addListSelectionListener( new ListSelectionListener(){ public void valueChanged(ListSelectionEvent event){ getContentPane().”white”} – ovaj array ce nam sluziti da skladisti imena boja koje cemo staviti u nasu list(tj JList-u ). Color. private static String[] colornames={"black".* . mi smo stavili da se moze selektovati samo jedana: list.setSelectionMode(ListSelectionModel.swing. Color.Black. podesili naslov i raspored. public Gui(){ super("title"). Nakon toga smo klasu Gui extends za JFrame. ne bih se prikazivale 2 opcije vec sve 4 bez scroll bara. Klasa Gui: import import import import java. Color.BLUE.swing.BLACK.getSelectedIndex()]). Unutar Gui klase smo napravili jednu promjenjivu list tipa Jlist .awt. list. “blue”. Color.setBackground( colors[list.BLUE. Na kraju smo dodali tu listu u prozor. Onda smo kreirali konstruktor. Color. Imamo dve klase : Glavna Main i Gui. private static Color[ ] colors = {Color. u slucaju da smo stavili da prikazuje samo dvije opcije ( a mi imamo 4.swing. private static Color[] colors = {Color. javax.*. black.RED.White} – dok ce ovaj array skladistiti stvarne boje za nasu pozadinu. ~ 80 ~ . Nakon toga smo definisali koliko se opcija moze selektovati .INGLE_INTERVAL_SELECTION). "white"}.*. javax. list = new JList (colornames). Takodje smo definisali koliko ce nasa Jlist prikazivati vidljivih opcija(za one koje ne mogu stati pojavi se scrollbar) .awt.awt. i dva array-a :   private static String[ ] colornames = {“black”. white) i kada kliknemo na jednu od boja promjenice se pozadina naseg prozora u tu boju.event.event. Mi cemo napraviti program koji ce sadrzavati Jlist."blue". public class Gui extends JFrame{ private JList list. blue. list.Lekcije 70 i 71: JList Jlist je lista za nas graficki korisnicki interfejs.* .setVisibleRowCount(4).awt. } } Dakle na pocetku smo importovali : java. list. “red”. "red".*. javax. Da smo napisali samo add(list) .WHITE}.swing.setSelectionMode(ListSelectionModel. setLayout(new FlowLayout()).RED.*. java. red. Zato smo ukucali : add(new JScrollPane(list)).* i java. SINGLE_INTERVAL_SELECTION ). Vrijednost smo stavili na 4 ukucavsi: list. java.setVisibleRowCount(4).event.

getSelectedIndex()]).getSelectedIndex( )]). Ukucali smo: list. zato moramo dati malo funkcionalnosti nasoj listi. u zagradi smo stavili colors[list. .addListSelectionListener( new ListSelectionListener(){ public void valueChanged(ListSelectionEvent event){ getContentPane().setBackground( /*Color.getSelectedIndex( ) ce nam dati broj (indeks) koji string iz array-a list je selektovan. boja koja je selektovana ce se pojaviti kao boja pozadine prozora. Buduci da indeks list odgovara indeksu boje u colors.setBackground(colors[list. kada pokrenemo program dobicemo: Kada pritisnemo red : kada pritisnemo black dobicemo crnu pozadinu : Kada pritisnemo blue : ~ 81 ~ .Sada imamo prozor koji ima listu ali kada bih smo kliknuli na neku od boja nista se ne bih promjenilo . Jedino sto cemo objasnavati iz ovog prozora jeste getContentPane().colors je Array koji sadrzi boje. list. Glavna klasa Main je ista kao u proslom primjeru pa je necemo prikazivati ovde. } } ).jeste nacin na koji definisemo nasu pozadinu .imeBojeUkojuZelimoPromejnitiPozadinu*/) .

~ 82 ~ .

addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent event){ rightlist.*. movebutton. leftlist.awt. leftlist i rightlist. javax. I jedan Array food. tako sto smo ukucali sledecece movebutton = new JButton (“Move ”). . rightlist. Jednu tipa JButton . Sada kada imamo leftlist dodanu u prozor. public Gui(){ super("the title"). Dalje smo ukucali leftlist. javax.*. } } ). rightlist = new JList(). setLayout(new FlowLayout()).setFixedCellHeight(15).*.awt.setVisibleRowCount(3). add(new JScrollPane(rightlist)). } } Napravili smo 4 promjenjive."ham". podesili naslov prozora.setVisibleRowCount(3) – sto prakticno znaci koliko stvari u listi zelimo da vidimo(tj.setSelectionMode(ListSelectionModel. java. koja ce biti visina liste).Lekcije 72 i 73: Multiple Selection Lists U ovoj lekciji cemo praviti prozor u kome cemo imati listu sa ljeve i desne strane . definisali smo movebutton . i izmedju njih dugme koje kada pritisnemo sve sto smo selektovali sa ljeve strane predje u desnu stranu (listu). add(movebutton).event.MULTIPLE_INTERVAL_SELECTION). Imamo dve klase: Glavna Main i klasa Gui.swing. rightlist.getSelectedValues()). rightlist. Nakon toga unutar konstruktora smo promjenjivoj leftlist dodjelili Array food.setVisibleRowCount(3).setSelectionMode(ListSelectionModel. Zatim smo napravili konstruktor. JList rightlist."eggs". koju smo nazvali movebutton. MULTIPLE_INTERVAL_SELECTION ).event.setSelectionMode(ListSelectionModel.setListData(leftlist. Dve tipa JList .swing. leftlist. Nakon toga smo definisali da mozemo selektovati vise opcija tako sto smo ukucali: leftlist. leftlist = new JList(food). Klasa Gui: import import import import java. rasored.*. rightlist. movebutton = new JButton("Move -->"). JButton movebutton."milk"."beef"}.setFixedCellWidth(100). I dodali smo ga u prozor add(new JScrollPane(movebutton)). MULTIPLE_INTERVAL_SELECTION ). static String[] food ={"bacon".sto znaci da ce na movebutton pisati “Move ”) . public class Gui extends JFrame { private private private private JList leftlist. Na posljetku smo leftlist stavili u prozor: add(new JScrollPane(leftlist). add(new JScrollPane(leftlist)). ~ 83 ~ .

a mi to ne zelimo. egg i milkpritisnemo Move . rightlist. moramo ga isprogramiirati da kada oznacimo nesto sa ljeve strane . dok ce bacon i ham nestati sa desne liste: ~ 84 ~ . i pritisnemo movebutton da se to prebaci na desnu listu. rightlist. Sada cemo rightlist dodati u program : add(new JScrollPane(rightlist). S obzirom na to nece se prikazati na ekranu. bacon i ham ce preci u desnu listu: Akosada selektujemo iz ljeve liste npr.setFixedCellHeight(15) . mozemo primjetiti da nismo nista stavili u zagradi i da ona nema nikavu vrijednost.setListData ( leftlist. Stoga moramo cemo podesiti height i width (osim sto cemo podesiti nacin selektovanja.setFixedCellWidth(100) . Sada smo sigurni da ce se prikazati u prozor (naravnno u slucaju da ga dodamo sa add). To smo uradili na nacin da smo dodali ActionListener. i koliko stvari moze da prikaze ). Sada smo definisali rightlist: rightlist = new Jlist ( ) . Glavna klasa Main nam je ista kao u proslim lekcijama. ham. Dakle rightlist.getSelectedValues ( ) ) . kada pokrenemo program dobicemo Kada selektujemo bacon i ham izgledace: Kada pritisnemo Dugme “Move ” . u desnoj listi ce se naci ove tri stvari .sto znaci sve one stvari koje smo selektovali u leftlist. U zagradi imamo leftlist.Nakon sto smo definisali i dodali movebutton prozoru .setListData( ) – ce uzeti podatke koji se nalaze u zagradi i staviti ih u rightlist.rightlist.getSelectedValues( )) .

setText("mouse is pressed").WHITE). Imao glavnu klasu Main i klasu Gui : import java. mousepanel. Zatim smo napravili dve promjenjive :   mousepanel tipa JPanel statusbar tipa JLabel Zatim smo napravili konstruktor . mousepanel.%d". event.getY())). java.setText("the mouse is released").*.Lekcije 74. Onda smo promjenjivoj mousepanel dodjelili vrijednost : mousepanel = new JPanel() .setText("the mouse entered"). import javax.setBackground(Color.* .swing. mousepanel.CENTER).awt. add(mousepanel. }}} prvo smo importovali klase: java. BorderLayout. } private class HandlerClass implements MouseListener.* . } public void mouseDragged(MouseEvent event){ statusbar.setText(String.setBackground(Color. BorderLayout.getX().event.awt. public JLabel statusbar.setBackground(Color. HandlerClass handler = new HandlerClass(). public class Gui extends JFrame{ public JPanel mousepanel. event.setText("the mouse exited").setText("the mouse is dragging"). public Gui(){ super("the title"). mousepanel. } public void mouseEntered(MouseEvent event){ statusbar.addMouseMotionListener(handler). } public void mouseMoved(MouseEvent event){ statusbar. statusbar = new JLabel("default").SOUTH). } public void mousePressed(MouseEvent event){ statusbar. mousepanel.75 i 76 Mouse Events U ovoj lekciji cemo praviti program koji ce reagovati na mis. MouseMotionListener{ public void mouseClicked(MouseEvent event){ statusbar. Nakon toga smo klasu Gui extends za JFrame (da mozemo koristiti prozore) .addMouseListener(handler).setText("the mouse is moved"). add(statusbar.event.*. Napravicemo prozor koji ce imati bjelu pozadiu i status bar koji ce nam govoriti sta smo uradli sa misem.BLUE).* i javax. mousepanel = new JPanel(). podesili naslov ali nismo podesavali raspored.stavili smo da je ova promjenjiva jednaka necemu pa je mozemo koristiti.awt.swing.*. } public void mouseReleased(MouseEvent event){ statusbar. } public void mouseExited(MouseEvent event){ statusbar.WHITE). import java. ~ 85 ~ .awt.format("mouse is clicked at %d.

Tu klasu cemo implementirati sa MouseListener i MouseMotionListener .CENTER). mouseDragged 2. MouseListener interfejs ima 5 metoda koje moramo “overvrite” a to su : 1.setBackground (Color.Dalje smo mouspanel podesili boju pozadine u bjelu boju: mousepanel. BorderLayout. S obzirom da smo u zagradama stavili objekat handler.addMouseListener(handler) i mousepanel. 2. Kreiracemo Objekat za klasu HandlerClass .Center znaci da ce se ova “ploca”(JPanel) nalaziti na sredini prozora i ako budemo povecavali prozor ona ce ga popunjavati.addMouseMotionListener(handler). BorderLayout. Kada pokrenemo dobicemo: Kada kursor stavimo u prozor boja ce se promjeniti u plavu i u status baru ce pisati “you moved mouse” ~ 86 ~ . . Promjenjivoj mousepanel cemo dati malo funkcionalnosti tako sto cemo mu dodati MouseListener i MouseMotionListener . Definisali smo vrijednos promjenjive statusbar : statusbar = new JLabel(“default”). mouseClicked mousePressed mouseReleased mouseEntered mouseExited dok MouseMotionListener ima dve metode koje moramo “overvrite” a to su: 1. 3. BorderLayout. Nakon sto smo definisali i dodali ove dve promjenjive u prozor. 5.SOUTH). I dodali smo statusbar u prozor i podesili ga da bude na dnu prozora: add(statusbar . Nakon toga smo mousepanel dodali u prozor i usput definisali gdje ce se nalaziti: add(mousepanel. tj: mousepanel. mozemo pokrenuti ovaj program (Klasa Main je ista kao u prosloj lekciji). koji se zove handler.. 4. mouseMoved Kada smo “overvrite” ove metode i odredili sta ce se desavati u zavisnosti koja od ovih sedam se desi. Unutar klase Gui cemo kreirati unutrasnju HandlerClass koja ce rukovoditi dogadjajima.WHITE) .

drzimo.Kada kliknemo negdje: Kada pritisnemo tipku misa: Kada pritisnemo . drzimo i povlacimo mis po prozoru : Kada pritisnemo. povucemo mis po prozoru I naposljetku ga pustimo na nekoj drugoj lokaciji: Kada izadjemo sa kursorom iz prozora: ~ 87 ~ .

java.Lekcija 77: Adapter Class U ovoj lekciji cemo uciti o Adapter klasama. Na kraju smo dodali MouseLIstener : addMouseListener(new Mouseclass( ) ) . Zatim smo dodjelili statusbar vrijednos “the default text” sto ce pisati cim pokrenemo program.awt. kada pritisnemo mis. i dok ne kliknemo nista. Zatimo smo nasljedili klasu JFrame. } } } prvo smo importovali java. else details +="with left mouse button". svih sedam metoda(za svaki slucaj kada: kliknemo .getClickCount()). kada pustimo mis. add(statusbar. new Mouseclass( ) je objekat klase Mouseclass koju cemo sada napraviti izvan konstruktora ali unutar klase Gui. statusbar tipa JLabel Zatim smo napravili konstruktor unutar kojeg smo definisali naslovnu liniju.awt. ~ 88 ~ . kada se pomjeramo unutar prozora . } class Mouseclass extends MouseAdapter{ public void mouseClicked(MouseEvent event){ details = String. pa da ne bih smo morali “overvrite” ostale metode i gubiti vrijeme .SOUTH). Nakon toga smo statusbar dodali u prozor i postavili ja na juznu granicu (tj. U prosloj lekcij kada smo implementirali MouseListener i MouseMotionListener . public Gui(){ super("the title"). event. statusbar = new JLabel("the default text"). Unutar Gui klase smo napravili dve promjenjive : 1. BorderLayout. u ovom slucaju mouseClicked . statusbar. BorderLayout.*.event. kada udjemo u prostor. else if(event.setText(details).*. kada prevlacimo) smo morali “overvrite”. public class Gui extends JFrame{ private String details.South) ili u donji dio prozora.isMetaDown()) details +="with right mouse button". korisnik klikne u prozor. Imao dve klase glavnu Main i klasu Gui.awt.swing.* . Klasa Gui: import java. kada izadjemo . Nekada zelimo da nas program reaguje samo na to kada npr. if(event. addMouseListener(new Mouseclass()). import javax. private JLabel statusbar.isAltDown()) details +="whit center mouse button".* .awt.* i javax.swing. Napravicemo program koji ce u status baru govoriti koliko smo puta kliknuli desni klik a koliko puta ljevi klik.format("you clicked %d".event. details tipa String 2. import java.*. Java je smislila rjesenje tj Adapter klasu( ono sto adapter klasa radi jeste da ona vec implementirala interfejs i “overvrite” sve metode koje su prazne i nerade nista) tako da samo moramo “overvrite” one metode koje cemo koristiti tj.

event. Dalje smo napravili if izjavu koja ce nam govoriti koje smo dugme kliknuli.Ukucali smo private class Mouseclass extends MouseAdapter.getCLickCount( ) ). MouseAdapter je ugradjena klasa u Javi i ona ce nam dozvoliti da “overvrite” samo one metode koje nam trebaju. unutar Mousecalss cemo samo kreirati tu metodu. Posto mi samo trebamo metodu koja definise klik misa. Event. Event. Dok se smo pod elese (tj. Kao prvo dodjelili smo neku vrijednost promjenjivoj details.getClickCount( ) broji koliko smo puta kliknuli bilo koje dugme misa.format (“you clicked %d. U tjelu metode mouseClicked(MouseEvent event) smo napisali :details = String. korak: 1 Kada pokrenemo program korak: 2 Kada kliknemo 7 puta ljevim klikom misa korak: 4 Kada kliknemo 9 puta sa desnim klikom misa onih 7 ce se ponistiti korak: 3 Kada kliknemo 1 ljevi sada ce se onih 9 desnim klikom ponistiti ~ 89 ~ . ako nijedan od ovih if i elseif nije zadovoljen broji kao ljevi klik misa. Klasa Main je ista kao u proslim lekcijama.isAltDown( ) se odnosi na kada kliknemo na scrollbutton . event.isMetaDown( ) se odnosi na desni klik misa.

Kada pokrenemo ovaj program . Ali kada jednom izadjemo iz programa sve ove stvari nestanu.out.Lekcija 78: File Class U ovoj lekciji cemo pricati o fajlovima. s obzirom da djordje. if(x.exists()) System. else System. velicina.getName() + " file does exist"). tako kada pokrenemo program ponovo sve stvari koje smo urdili prosli put nestanu. } } Importovali smo java.println(x.txt koja se nalazi na E disku. put… Unutar Main klase smo napravili objekat za klasu File koji smo nazvali x. ili promjenimo ime fajla u samoj datoteci dobicemo: This file doesn't exist ~ 90 ~ .txt "). public class Main { public static void main(String args[]){ File x = new File("E://Users//Djordje//Workspace//Djordje//src//lekcija78//djordje. Dakle ako metoda: x.getName( ) + “ file does exist”. \n odnosno t\ .txt postoji upravo na adresi koju smo naveli dobicemo: djordje.txt file does exist Medjutim ako preimenujemo fajl bilo u Windows Exproreru.txt jer smo u zagradi objekta x upisali cjeli put do te datoteke.out. na ekranu cemo dobiti “This file doesn‟t exist”.println("This file doesn't exist"). kao sto vidimo umjesto da smo ukucali File x = new File( ).io. Moramo primjetiti da u putu do datoteke djordje. promjenimo putanju.File.exists( ).getName( ) uzima ime djordje.txt nismo koristili jedan backslash \ vec dva \ iz razloga sto se jedan backslash odnosi na novi red ili tab tj. Dalje smo napravili if instrukciju da testiramo da li ovaj fajl postoji na nacin sto smo unutar testa za if instrukciju ukucali x. Do sada smo kreirali kompjuterske programe koji su koristili promjenjive i slicno(npr skladisti broj 5 u promjenjivoj broj). Ako fajl ne postoji izvrsava se ono pod else tj. Imacemo samo jednu klasu Main koja izgleda: import java.exists( ) vraca true znaci da djordje fajl postoji(x je objekat koji predstavlja File klasu. Mi smo odmah popunili zagradu sa putanjom tekstualne datoteke djordje. i ono sto file klasa radi jeste da nam daje informacije o fajlovima da li postoje. Za sada cemo samo napraviti program koji ce nam govoriti da li neki fajl postoji ili ne na nasem racunaru. x. Ako postoji ispisuje se x. U javi mozemo kreirati i modifikovati fajlove.io.exists( ) ili imepromjenjive.File sto je fajl klasa.

catch(Exception e){ . Imacemo jednu klasu Main: import java. tj ono u zagradama .println(“you got an error”) .txt”). mi smo stavili firstfile.txt"). System.out. To je prilicno kao printf osim sto ne pokazuje na ekranu vec u fajl. ono sto se pokusava izvrsiti je ono unutar viticastih zagrada.txt”) – dodjelili smo vrijednost promjenjivoj x tipa Formatter . try{ x = new Formatter("firstfile.Lekcija 79: Creating Files U ovoj lekciji cemo nauciti kako kreirati fajl pomocu Jave.println("you created file successfuly").out. Foramtter promjenjiva sluzi da “outputs” String u fajl. Mi unutar try viticastih zagrada imamo: x = new Formatter(“firstfile. a ono sto se nalazi u zagradi kod ove vrste promjenjive je put fajla koji zelimo “output” . Dalje smo napisali: try{ x = new Formatter(“firstfile. x = new Formatter(“fistfile.println(“you got an error”).* .println(“you created file successfully”). public class Main { public static void main(String args[]){ final Formatter x.println("you got an error").println(“you created file successfully”). } } } Prvo smo inportovali java. vjerovatno u folderu u kojem je nasa klasa).util. } catch(Exception e){ System. i System.txt je kreiran i nalazi se na racunaru.*.out.out.txt”).} try – znaci pokusaj .sto znaci ako try ne uspije na ekranu ce nam se prikazati “you got an error” i fajl nece biti kreiran. U tjelu catch smo upisali System. ~ 91 ~ . System. } catch(Exception e){ System.util.out.out. Zatim smo napravili promjenjivu x koja je vrste Formatter.Exception je ustvari error u Javi ( tako je nazvan) . Takodje u zagradi mozemo upisati cjeli put (path) do fajla i ako takav fajl ne postoji na toj adresi Java ga kreira na toj adresi.txt ali posto takav fajl ne postoji Java ga kreira (i firstfile.

close(). } } Dakle kreirali smo objekat za klasu CreateFile koji smo nazvali cf.lang.format(“argument1”.io. java. }} Importovali smo java. Glavna klasa Main izgleda: public class Main { public static void main(String args[]){ CreateFile cf = new CreateFile(). ~ 92 ~ .*.close( ) ) . Zatim smo u 3 metode:    otvorili/kreirali fajl tj. cf.io.lang.WriteonFile().* . public void createF( ) . jer ako fajl slucajno ostane otvoren moze doci do error-a tj. ) zatvorili fajl (obavezno zatvoriti fajl. public void WriteonFile ( u fajlu pisemo tako sto napisemo imeforamterpromjenjive. Zatim smo pozvali metodu koja kreira fajl na nacin cf. Nakon toga smo napisali cf. Unutar klase CreateFile smo napravili jednu promjenjivu tipa Formatter koju smo nazvali x.* . import java.*.util. }} public void WriteonFile(){ x. } catch(Exception e){ System.createF( ) koja je kreirala fajl “info." Djordje ". " 17-11/RPI").*. public void createF(){ try{ x = new Formatter("info.close( ).createF(). i glavnu klasu Main. public void close( ) (fajl zatvaramo tako sto napisemo imeformatterpromjenjive.txt”.txt").util. " Trbovic ". public class CreateFile { private Formatter x.close( ) odnosno cf.close( ) je ugradjena metoda koju smo inportovali.WriteonFile( ) cime smo pozvali metodu koja upisuje u fajl .println("Error"). pisali u fajlu tj. i upisali smo “ Trbovic Djordje 17-11/RPI”. “argument2”). Nakon toga smo zatvorili fajl da ne bih doslo do errora( to moramo raditi obvezno) pozvavsi metodu close iz klase CreateFile .Lekcija:80 Writing to Files U ovoj lekciji cemo nauciti kako se dodaju podatci u nas fajl. cf. tako sto smo ukucali imeobjektakojipredstavljaklasuCreateFile.format("%s%s%s". cf. Imamo dve klase CreateFile.close(). Klasa Createfile izgeda: import java.* . } public void close(){ x. import java.out. Dobili smo novi fajl koji se naziva info i koji sadrzi “Trbovic Djordje 17-11/RPI” . java.

b. public class ReadFile { private Scanner x.hasNext) – znaci sve dok promjenjiva x ima nesto da se petlja izvrsava.hasNext( ). ~ 93 ~ . import java.next().close().next( ).hasNext( ) – jeste ono sto promjenjiva x ima ( a ima tekst koji se nalazi u fajlu “UEFAChampionsLeagueWinners.next( ) .println("you have an error"). String b = x.out.next(). Zatim smo napravili tri metode:    OpenFIle ReadFiles CloseFiles U prvoj metodi(OpenFile) u sklopu try smo promjenjivoj x dodjelili vrijednost (new File(/*ime fajla ili putanja*/).next( ) . String c = x.next( ).*.io.Tj ukucali smo : x = new Scanner(new File(E:\Users\Djordje\workspace\Djordje \src\lekcija81\UEFAChampionsLeagueWinners. } } Prvo smo inportovali java. Moramo primjetiti da kada smo koristili Scanner da bih smo upisivali nesto da smo u zagradi stavljali (System. public void openFile(){ try{ x = new Scanner(new File("UEFAChampionsLeagueWinners. }catch(Exception e){ System. x dodjelili taj fajl). x.printf("%s %s %s \n".* jer se tu nalazi alat za citanje iz fajlova.c).a.Lekcija 81: Reading From Files U ovoj lekciji cemo uciti kako se cita iz fajla.*. Napravicemo Program koji ce citati podatke sa tekstualnog fajla “UEFAChampionsLeagueWinners.* jer se tu nalazi Scanner i inportovali smo java.io.in) a sada smo u zagradi stavili (new File(/*ime fajla ili putanja pa ime fajla*/). Kreirali smo while petlju u cijim smo zagradama ukucali x. String b = x.next(). To se radi pomocu Scanner-a koji smo koristili za unos teksta od strane korisnika. Napravili smo promjenjivu x tipa Scanner.txt")).util. Druga metoda nam sluzi da program cita iz fajlova i da procitano ispisuje na ekran. String c = x. Imamo dve klase.oznacava svaki sledeci string. }} public void closeFiles(){ x. a/b/c.hasNext()){ String a = x.out. System.txt” i prikazati ih na ekranu.txt”)).txt” jer smo u metodi OpenFile . } } public void readFiles(){ while(x. Glavana klasa Main i klasa ReadFile koja izgleda: import java. Unutar while petlje imamo naredbe: String a = x. While(x.hasNext( ) ili imepromjenjiveScanner.util.

next broj 9 koji nema svojsto broja vec Stringa). broj 9 se dodjeljuje promjenjivoj c (odnosno String c = x. Zadnja metoda ili CloseFile nam sluzi da zatvorimo fajl da ne bih doslo do nekih error-a.CloseFiles(). Dalje imamo broj 9(tj. gdje je sad x.ReadFiles().next Real). R.txt imamo tekst koji izgleda: Real AC CF Madrid Milan Liverpool 9 7 5 4 4 Bayern Munich FC Barcelona Dakle kada while petlja prodje kroz ovu Scanner promjenjivu prvo na sto ce naici jeste Real i dodjelice ga a (tj.next Madrid). Glavana metoda Main izgleda: public class Main { public static void main(String args[]){ ReadFile R = new ReadFile(). Ovo je samo jedno prolazenje kroz while petlju . String a = x.b.OpenFile(). String b = x. R. ~ 94 ~ .U fajlu UEFAChampionsLeagueWinners. dalje se Madrid dodjeljuje promjenjivoj b (tj. ono isto sto se nalazi unutar tekstualnog fajla UEFAChampionsLeagueWinners. sada je x.c).b.printf(“%s%s%s \n”.next. } } Kada pokrenemo ovaj program dobicemo: Real Madrid 9 AC Milan 7 CF Liverpool 5 Bayern Munich 4 FC Barcelona 4 Tj. R. gdje je x. Sada se a.next .c prikazuju na ekranu i usput formatiraju pomocu naredbe System.hasNext( ) true.next. petlja ce se vrtiti sve dok u fajlu ima teksta odnosno sve dok je uslov x.out. a.

out. int n1 = input.println("enter the second number").lang. Napravicemo program za djeljenje. System.println("the result is: "+sum).Main.ArithmeticException: / by zero at lekcija82. System.out. public class Main { public static void main(String args[]){ try{ Scanner input = new Scanner(System. int n2 = input.nextInt(). System. To radimo pomocu try i catch. int n2 = input.nextInt(). }catch(Exception e){ System.Scanner. public class Main { public static void main(String args[]){ Scanner input = new Scanner(System. } } Kada pokrenemo ovaj program prikazace se ”Enter the first number” kada unesemo prvi broj prikazace se “enter the second number”.nextInt().in).util. zato je bitno rukovoditi “error-ima”.out.out.java:11) Dakle cjeli program ce se srusiti samo zato sto smo podjelili sa nulom.println("enter the second number").Scanner. } } } ~ 95 ~ . int n1 = input. System.nextInt().println("the result is: "+sum).in).main(Main. Kada korisnik uradi nesto sto ne bih trebao uraditi . Kada unesemo ta dva broja prvi broj ce biti podjeljen sa drugim i dobicemo neki rezultat npr: enter the first number 32 enter the second number 4 the result is: 8 ali ako broj 32 ili neki drugi podjelimo sa nulom dobicemo error koji npr izgleda: Exception in thread "main" java. Mi ovo mozemo spreciti tako sto cjeli kod stavimo unutar viticastih zagrada koje se nalaze poslije komande try i poslije tih viticastih zagrada napisemo catch(Exception e) i otvorimo viticaste zagrade da napisemo sta ce se izvrsiti ako se desi neki error.println("you can't do that").out. x=2.println("enter the first number"). Imao jednu klasu Main koja izgleda: import java. int sum = n1/n2. Kada zapakujemo kod u try i catch izgledace ovako: import java.util.Lekcija 82: Exception Handling Exception je u Javi ustvari naziv za Error. System.out. koji ce djeliti dva int broja. int sum = n1/n2. try{kod koji treba da se izvrsi}catch(Exception e){ono sto ce se desiti ako se pojavi error}. pojavi se error i cjeli se prorgram zaustavlja . System.println("enter the first number").out.

ako se izvrsi catch promjenjiva x ce idalje ostati ista (tj x ==1) i uslov pod while ce biti ispunjen tako da ce se dio koda pod do izvrsavati iznova i iznova dok se ne izvrsi try odnosno dok vrijednos vise ne bude jednaka 1.println("enter the first number").println("you can't do that"). System. opet se djeljenje nece moci izvrstiti ali ce se zato izvrstiti dio koda koji se nalazi unutar viticastih zagrada poslije catch. System. Sada klasa Main izgleda ovako: import java. input.util. int sum = n1/n2. tj. Ili bolje receno izvrsavace se sve dok je promjenjiva x (koju smo kreirali specijalno da nam posluzi kao test u obicnim zagradama poslije while) jednaka broju 1. pisace “you can‟t do that” i program ce zavrsiti sa radom a da nije izracunao ono sto je trebao. System.out. }catch(Exception e){ System.println("enter the second number"). dok catch ako se pojavi error u djelu koda kod try izvrsi dio koda unutar catch. } } Dakle ova petlja ce se izvrsiti bar jednom.nextInt(). Postoje razlicite vrste errora : aritmeticki. public class Main { public static void main(String args[]){ int x = 1.out.println("the result is: "+sum). } }while(x==1). do{ try{ Scanner input = new Scanner(System. Mozemo primjetiti da u obicnim zagradama poslije catch imamo argumente kojima definisemo sta zelimo da “catch” ili “uhvatimo” mi smo napisali : Exception e (sto znaci da “hvata” errore sve vrste( tj ako bilo sta podje po zlu) . Kada pokrenemo ovaj kod iznad i ako sada podjelimo prvi broj sa nulom. sto znaci da se ova petlja nece nastaviti izvrsavati vise. Ako zelimo da se program radi sve dok ne dobijemo kolicnik dva broja mozemo sve ovo umetnuti u do while petlju.nextInt(). int n2 = input. math error …) Ako sada pokrenemo program i podjelimo sa nulom . x=2. Ako se ono pod try izvrsi vidimo da ce se vrijednost promjenjive x promjeniti na 2 . opet se nece izvrsiti djeljenje vec ce nam pisati “You can‟t do that” i program ce se pokrenuti ponovo (zahvaljujuci do while petlji) sve dok se ne podjele dva broja bez error-a/Exception-1. Tj.in). Ali ako se ono pod try ne izvrsi . int n1 = input.Poslije try i viticastih zagrada uvjek mora biti catch sa viticastim zagradama.out.out.Scanner. ~ 96 ~ . try – ustvari kaze pokusaj izvrsiti ovaj dio koda. Mi sa time dobijamo da ce se nas program iznova i iznova pokretati sve dok ne podjelimo ova dva broja kako treba.

ustvari smo podesili da objekat layout tipa FlowLayout sadrzi podesavanja koja poravnavaju u ljevo (layout = new FlowLayout .swing. layout.event. CENTER).*.layoutContainer(container).addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent event){ layout.awt.*.Lekcija 83: FlowLayout U ovoj lekciji cemo napraviti prozor sa par “button-a” na ekranu i u zavisnosi od toga koji “button” pritisnemo poravnanje tih dugmadi ce se mjenjati.awt. public class Layout extends JFrame{ private JButton lb. }}). rb = new JButton("right")..awt.layoutContainer(container). setLayout(layout). ~ 97 ~ . lb = new JButton("left"). import java. private Container container.swing. cb.* i java.setAlignment(FlowLayout.setAlignment(FlowLayout. private JButton rb. Nakon toga smo upisali: layout = new FlowLayout( ) . private JButton cb. add(cb). LEFT). layout = new FlowLayout().awt.addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent event){ layout. import javax. }}).addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent event){ layout. private FlowLayout layout.*. public Layout(){ super("the title"). java. rb. container = getContentPane(). } Prvo smo inportovali : javax. layout. layout. }}).setAlignment(FlowLayout. cb = new JButton("center").FlowLayout ima default podesavanje koje poravnava u centar). container tipa Container Dalje smo napravili konstruktor i podesili naslovnu liniju. Zatim smo napravili 3 promjenjive:    Private JButton lb ( lb – znaci left button) Private JButton cb (cb – znaci center button) Private JButton rb (rb – znaci right button) Dalje smo kreirali dva “objekta” : 1. add(rb).event. Iamo glavnu klasu Main i klasu Layout: import java.*. RIGHT). layout tipa FlowLayout 2.layoutContainer(container). add(lb).*. lb.

l. ovo sluzi samo da zna gdje da smjesti stvari. buttoni ce se poravnati centralno ~ 98 ~ . Dakle kada zelimo da promjenimo kako ce nesto biti poravnato ukucamo : imepromjenjiveFlowLayout.setDefaultCloseOperation(JFrame. Naravno za cb smo stavili da pise “center” i da je Raspored podesen na layout.Left) . Nakon toga smo ovo isto uradili za cb i za rb. layout.layoutContainer(container). ovo prilicno znaci preuredi sve u zavisnosti od toga koji je nas Layout ili “raspored”.*.addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent event){ layout.setAlignment(FlowLayot. l.layoutContainer(container). public class Main { public static void main(String args[]){ Layout l = new Layout(). l.Center) i za rb smo stavili da pise “right” (unutar “button-a” ) Ii podesil poravnanje na desno tj layout.RIGHT) . pomocu ove naredbe mjenjamo poravnanje .setSize(300. Glavna klasa Main izgleda: import javax. } } ).setVisible(true).setAlignment(FlowLayout. layout. lb = new JButton(“left”). Sve ce biti poravnato na ljevo. dugmad ce se poravnati na ljevo kor: 4 Kada pritisnemo dugme "center" .setAlignment(FlowLayout. Sada cemo postaviti vazeci raspored tako sto smo ukucali setLayout(layout) ili setLayout(imeobjektaFlowLayout). Komentarisacemo samo layout. EXIT_ON_CLOSE).container = getContentPane( ) . "buttoni" ce se poravnati u desno kor: 3 Kada pritisnemo dugme "left" .LEFT).swing.setAlignment(FlowLayout.setAlignment(FlowLayout. } } Kada pokrenemo ovaj program dobicemo: kor: 1 default podesavanja gdje su "buttoni" poravnati centralno kor: 2 Kada pritisnemo dugme "right" . Zatim smo dodjelili funkcionalnost lb ukucavsi: lb.LEFT). Definisali smo lb i dodjelili mu tekst left tj.100). Zatim smo lb dodali u prozor tako sto smo ukucali add(lb). Umjesto LEFT moze biti CENTER (koji poravnava centralno) i RIGHT koji poravnava na desno.

Da bih smo crtali u Javi moramo imati metodu paintComponent.25.awt.Lekcija 84: Drawing Grpahics U ovoj lekciji cemo obradjivati grafiku. g. Da bih smo crtali objekte u Javi prvo moramo podesiti boju koju zelimo koristiti .swing.30) .*i javax. this. Ukucali smo super. ili imeGraphicsobjekta.100.25.drawString("this is some text". Unutar paintComponent metode mozemo sada stvarati “grafiku”. java.setBackground(Color.120). mi cemo nacrtati pravougaonik. Pomocu super. 100.setColor(Color. ili npr.*. g je objekat klase Graphics.BLUE).168.setColor(new Color(192.bojakujuzelimo). . import javax.100.swing.paintComponent(g). polozaj po y osi gdje ce se pojaviti tekst ). Moramo naznaciti da smo kod svakog crtanja mjenjali boju tj. – sto znaci ovaj objekat(tj. public class Bla extends JPanel{ public void paintComponent(Graphics g){ super. Kao sto vidimo klasu Bla smo extend za Jpanel klasu. g.awt.25. Poslije toga smo nacrtali jos jedan pravougaonik ukucavsi: g.drawString(“this is some text”. g.fillRect(25. Pozivamo metode iz superklase. 65.*.fillRect( 25. 30).event.drawString(“stringKojiCeSePojavitiNaEkranu”. g.*.65. this.120) ili objekatGraphics.30) . sirina. ~ 99 ~ . Nakon toga smo nacrtali “String” ukucavsi: g. Kao sto mozemo primjetiti boju smo podesili na drugaciji nacin .awt. to cinimo tako sto ukucamo imeobjektaGraphics.event.25.168. sto ne moramo raditi .1)) i g. Zatim smo ukucali : this. objekat koji se nalazi u parametrima unutar metode). visina). g.30). Cjela ova naredba postavlja bjelu boju kao pozadinu objekta g). Kada odredimo boju mozemo poceti sa crtanjem . Podesili smo “Custom” boju tj boju sa RGB vrijednostima gdje je 192 broj koji oznacava koliko crvene boje zelimo. koja u parametrima ima objekat koji predstavlja Graphics klasu. objekta klase Graphics). Imamo dve klase glavnu Main i klasu Bla koja izgleda: import java. Pozvali smo metodu paintComponent I prosljedili parametar g (tj. polozaj po x osi gdje ce se pojaviti tekst .paintComponent(g).setColor(Color. g. } } Importovali smo java.fillRect(polozajodakle pocinje po x osi.100. I 1 oznacava koliko plave boje zelimo. g.RED) i g. 168 koliko zelene zelimo .setColor(/*boja*/). g. polozaj od kojeg pocinje po y osi.setColor(new Color(192. import java.White) . . mogli smo jednom postaviti boju i onda crtati ove pravougaonike i string.* .Blue).fillRect(25.* .1)).RED). Ukucacemo : g.fillRect(25.setColor(Color.WHITE).setColor(Color. Prvu stvar koju moramo uraditi je ustvari “houskeeping” ili odrzavanje.setBackground(Color.awt. To smo uradili tako sto smo ukucali: public void paintComponent(Graphics g) .setColor(Color.

Glavna klasa Main ima izgled: import javax. Kada pokrenemo ovaj program dobicemo: operaciju za zatvaranje tj.setDefaultCloseOperation(JFrame. jedan neke znj boje i jedan String “this is some text”… ~ 100 ~ . f. Zatim smo prozoru f definisali “default” f. f.swing.setSize(400.setDefaultCloseOperation(JFrame. Napravili smo novi objekat klase JFrame(Okvir/mozda cak i prozor ? )koji smo nazvali f i prosljedili mu parametar “title” sto ce pisati na naslovnoj liniji prozora. Dakle imamo dva pravougaonika jedan plave boje .swing.setVisible(true). Bla b = new Bla().add(b). public class Main { public static void main(String args[]){ JFrame f = new JFrame("Title").*. Nakon toga smo kreirali objekat b koji predstavlja klasu Bla. sto prilicno znaci da smo u prozor f dodali objekat b koji predstavlja klasu Bla .EXIT_ON_CLOSE).250). Ukucali smo f.EXIT_ON_CLOSE). } } Importovali smo javax. Podesili smo velicinu f prozora na sirina 400 i visina 250 i postavili ga vidljivim.*. f.add(b). f.

swing. new ActionListener( ) ) koja zahtjeva da se overvrite metoda actionPerformed unutar koje ce se prosljediti argumenti (ActionEvent event) .setBackground(color) ili imePromjenjiveJPanel. stavili smo da ce na dugmetu pisati “Choose a color” tj ukucali smo: b = new JButton(“Chose a color”).awt. } panel. ~ 101 ~ . add(panel.event. b = new JButton("Choose a color").* i javax.awt.* . Unutar klase Bla smo napravili 3 promjenjive:    JButton promjenjivu koju smo nazvali b Color promjenjivu koju smo nazvali color i podesili na bijelu boju tj:private Color color = (Color.*.WHITE) JPanel promjenjivu koju smo nazvali panel Nakon toga smo napravili konstruktor. private Color color = (Color. Nakon toga smo klasu Bla extends za klasu JFrame.setBackground(color).*.Lekcija 85:JColorChooser U ovoj lekciji cemo uciti o JColorChooser.SOUTH). Nakon toga smo definisali promjenjivu b . Napravicemo prozor koji ce imait dugme koje kada pritisnemo izace nam dijaloski okvir da biramo boju koja ce se implementirati na prozor. b.WHITE).swing. panel = new JPanel().CENTER).setBackground(color). } } Prvo smo importovali : java.*. import javax. public Bla(){ super("the title"). public class Bla extends JFrame{ private JButton b. Kada smo to uradili onda smo dodali funkcionalnost promjenjivoj b tako sto smo dodali ActionListener tj: b. "Pick a color".addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent event){ color = JColorChooser. add(b. BorderLayout. panel.addActionListener(/*unutar zagrada smo kreirali anonimnu unutrasnju klasu ActionListener (tj.awt. if(color==null){ color = (color.WHITE). }}). color).showDialog(null. podesili naslov. Imamo dve klase glavnu klasu Main i klasu Bla koja izgleda: import java. Nakon toga smo podesili boju pozadine promjenjivoj panel koja uzima boju od Color promjenjive koju smo nazvali color tako sto smo ukucali: panel.*. private JPanel panel. BorderLayout.setBackground( imePromjenjiveColor). Unutar konstruktora smo promjenjivoj panel dodjelili bilo kakvu vrijednost da bih je mogli koristiti tj: panel = new JPanel() . java. import java.awt.event.

dok je treci argument promjenjiva color . pojavice se na centru ekrana). to smo ucinili tako sto smo ukucali: add(b. Dakle imaju tri parametra prvi je null i on oznacava poziciju (tj.EXIT_ON_CLOSE). BorderLayout. dok BorderLayout. tj boja koju smo izabrali iz dijaloskog okvira se skladistila u promjenjivu color i tu promjenjivu smo prosljedili da bude boja pozadine promjenjive panel. To smo izveli tako sto smo ukucali : Color = JColorChooser. da ce boja prozora biti bjela.SOUTH) – samo add(b) znaci da je “button” b dodan u prozor . Glavna kalsa Main ima izgled: import javax.White} – sto znaci ako korisnik pokrene dijaloski okvir i ne izabere nista ( tj. Napravili smo objekat b koji predstavlja klasu Bla i pomocu tog objekta definisali neke stvari sto vidimo iznad.CENTER) – isti slucaj samo sto ce se “panel” nalaziti na centralnom djelu ekrana i sirice se kako se siri prozor I popunjavati sav prozor. Ispod toga imao napisano: if(color == null) { color = Color. “Pick a color”.* da bih smo mogli koristiti prozore. ili na prozoru na dugme “Chose a color” */} Dakle ono sto ce se desavati kada kliknemo na promjenjivu b jeste ono sto pise unutar actionPerformed metode tj: Promjenjiva Color ce biti jedanaka boji koju izaberemo iz dijaloskog okvira JColorChooser koji ce se pojaviti kada klikemo na button “Chose a color”. Da za treci argument stavimo Color. sto znaci da je pritisnuo “X” ili “Cancel”) .swing. tj.showDialog(null. BorderLayout. pocetna boja koja je odabrana( u nasem slucaju bjela boja).*. b. } } Dakle inportovali smo javax.Ovu metodu smo overvrite tako sto smo unutar klase ActionListener ukucali : public void actionPerformed(ActionEvent event){ /*ono sto se nalazi unutar ove metode je ono sto ce se desavati kada kliknemo na promjenjivu b.setDefaultCloseOperation(JFrame. zatim “Pick a color” je ono sto ce pisati na naslovnoj liniji dijaloskog okvira koji ce se pojaviti. Sada izvan metode actionPerformed i klase ActionListener unutar samog konstruktora moramo dodati ove promjenijve u prozor .SOTH znaci da ce se nalaziti na donjem djelu prozora. null .200).setSize(425. b.setBackground(color) .setVisible(true). I ako bih odmah kliknuli OK nas prozor bih postao plav). Kada pokrenemo ovaj program dobicemo: ~ 102 ~ . b.Blue kada se pokrene dijaloski okvir da izaberemo boju . Da nemamo ovo if i ovo sto slijedi ispod kada ne bih izabrali nista boja bih se promjenila u neku default sivu boju. boja koju smo stavili kao treci argument ce biti automatski postavljena kao izabrana boja (to je u nasem slucaju “BLUE” . public class Main { public static void main(String args[]){ Bla b = new Bla(). Na kraju unutar metode actionPerformed imamo panel.swing. color). add(panel.

Kada kliknemo na “Choose a color” pojavice se dijaloski okvir Dijaloski okvir ima 5 tabova za biranje boje . ~ 103 ~ . ako npr kliknemo na RGB : Ako iz taba Swatches izaberemo npr crvenu boju i kliknemo OK : Ako sada idemo na “Choose a color” i pritisnemo samo “OK” a da ne izaberemo boju . boja ce se vratiit na Bijelu kao na prvoj slici.

* i javax. import javax. import java.swing. g.awt. true) tj.drawLine(10. pozicija po y osi.awt.YELLOW). sirina . } } ~ 104 ~ . moramo to raditi u metodi paintComponent. g. 30) ili g. 100. 40.GREEN). Unutar paint Component metode smo nacrtali :     Liniju odnostno : g.bojaKojuZelimo). pozicija po y osi.Lekcija 86: Drawing More Stuff U ovoj lekciji cemo uciti kako se crtaju . g.drawLine(10.setColor(Color.fill3DRect (pozicija po x osi.drawRect(10 . g.*. public class Main { public static void main(String args[]){ JFrame f = new JFrame("title").drawRect(10.awt.fillOval(10. 250. g.10.setSize(500.drawLine(pozicija po x osi.event. 100. java. 50.*.event.setColor(Color. true). pa smo je shodno tome kreirali i u parametrima stavili Graphics g. f. b. sirina .swing. g. 30). draw samo nacrta oblik dok fill nacrta oblik i popuni ga bojom koju smo odredili pomocu g. Klasu smo extend za JPanel. 30). import java.fill3DRect(10. 40.500). 100.setColor(Color. visina) Pravougaonik g. 100.EXIT_ON_CLOSE). 30). 130.swing.100.100 .setColor(Color.*. Imacemo dve klase glavnu Main i klasu Bla: import java. visina. f.30) “3D” Pravougaonik tj.BLUE).setBackground(Color. Kao sto znamo da bih smo crtali oblike . Bla b = new Bla(). g.setDefaultCloseOperation(JFrame. da li da dobije “3D odlike” (mozemo staviti true ili false) ). 90.*. 10. 250. g. public class Bla extends JPanel { public void paintComponent(Graphics g){ g.setVisible(true).add(b). g.awt.fill3DRect(10. jos neki oblici. f.* .fillOval(10. 130.setColor(Color. 50 .awt. Glavna klasa Main Izgleda: import javax.WHITE).*. 30) “Oval” g.90. Moramo naglasiti razliku izmedju draw i fill . f.RED). } } Dakle prvo smo importovali java.

println("string b nije isti kao string c"). da su ova dva stringa ista ako zanemarimo da li su pisani velikim ili malim slovimaj. ili imePromjenjiveTipaString. Zatim smo ukucali a. if(b.equals(c ) .} }}} Kreirali smo tri promjenjive tipa String tj:    String a =”apples” String b =”djordje” String c =”DJORDJE” Svakom stringu smo dodjelili neku vrijednost. sto znaci da string b nije isti kao string c.println( ).Kada program pokrenemo dobijemo: Lekcija 87: Series Finale U ovoj lekciji cemo malo obradjivati “String-ove” .equalsIgnoreCase(ImePromjenjiveSaKojomUporedjujemo). Medjutim sem uporedjivanja Stringova pomocu b.println("b je isti kao c.out.equalsIgnoreCase(c)){ System.length . To smo prikazali na ekranu pomocu naredbe System.println("duzin stringa a je: "+a. ako ignorisemo velika/mala slova"). System.equals(c) ili imePromjenjiveKojuZelimoUporediti.length sto nam prikazuje koliko karaktera ima dati string. Imacemo jednu glavnu klasu Main.equals(ImePromjenjiveSaKomZelimoUporediti).out. Dalje smo uporedjivali promjenijivu b sa promjenivom c(obe su tipa String). Kao rezultat tog uporedjivanja bih smo dobili logicku vrijednost false. }else{ System. Kada pokrenemo kod dobijemo: ~ 105 ~ .equals(c)){ System.out.length()). u ovom slucaju ukucali smo: b. Kao rezultat bih smo dobili logicku vrijednost true tj.println("string b je isti kao string c"). stringove mozemo uporedjivati tako da zanemarimo velika/mala slova. koja izgleda: public class Main { public static void main(String args[]){ String a ="apples".} else{ if(b. na nacin da samo ukucali : b. String b ="djordje".out.out.equalsIgnoreCase(c) ili : imePromjenjivekojuZelimoUporediti. String c ="DJORDJE".

duzin stringa a je: 6 string b je isti kao string c. ako ignorisemo velika/mala slova ~ 106 ~ .