# JAVA

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.

~ 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"); } } } }

~ 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.

~ 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.

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.

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 .

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” .

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.

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.

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 .

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.

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” .

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.

~ 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 ~ .

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 ~ .

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.

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.