The New Boston Java Programiranje (Begginer).pdf

JAVA

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

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

Uvod Java je objektno orjentisani programski jezik. Java program se sastoji od klasa tj. sav kod programa se nalzi u nekoj od klasa od koje pravimo objekte (instance klase). Klasa se sastoji od : 1. Atributa (promjenjive) 2. Ponasanje (metoda) Atributi su podatci na osnovu kojih se razlikuju objekti i definisani su pomocu promjenjivih. Imamo dve vrste promjenjivih : 1. Promjenjive instance: cuvaju atribute konkretnog objekta koji se razlikuje od objekata iz iste klase. 2. Promjenjive klase: cuvaju atribute koje su iste za sve objekte iste klase. Ponasanje je sve ono sto se moze izvrsiti nad objektima klase i drugih klasa definisano je pomocu metoda. Imamo dve vrste metoda: 1. Metode instance (ukoliko metod obavlja izmjenu pojedinacnog objekta on je metod instance) 2. Metode klase (metodi klase se primjenjuju na samu klasu) Metode i promjenjive klase imaju u zaglavlju rjec static sto oznacava da su instance tj. metode klase. U Javi moguce je nasljedjivanje klasa. Neka klasa moze nasljediti samo jednu klasu1, tj moze imati samo jednu superklasu. Takodje moze imati neograniceno podklasa ( klasa koje nasljedjuju nju). S obzirom da je cinjenica da se moze nasljediti samo jedna klasa veliko ogranicenje, postoje interfejsi koji to znatno ublazuju. Interfejs je kolekcija metoda koje ukazuju da klasa posjeduje neko ponasanje pored onoga sto nasljedjuje od nadklase. Klasa se definise tako sto ukucamo class pa zatim ime klase, 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 , klasa gdje se nalazi ta metoda se naziva glavna klasa. 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, 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. Pa bih u gore pomenutu klasu robot mogli staviti metodu main : Class public static void main(String args[]){ } }

Robot{

//zatvorena viticasta zagrada oznacava kraj tjela metode //zatvorena viticasta zagrada oznacava kraj tjela klase

1

ne racunajuci klasu Object koja je na vrhu hierarhije klasa i koju nasljedjuju sve klase , iako to nije nigdje eksplicitno navedeno.

~1~

Sada kada smo stvorili klasu Robot i u nju stavili glavnu metodu main. Mozemo napisati neki kod koji ce se izvrsiti. Npr: Class public static void main(String args[]){ System.out.println(„Pozdrav svjetu“); } }

Robot{

Kod koji smo mi napisali sastoji se od jedne instrucije tj: System.out.println(“Pozdrav svjetu”); . Kada pokrenemo ovj program dobicemo: Pozdrav svjetu System.out.println je ustvari ugradjena metoda i ona ce izbaciti ono sto navedemo unutar zagrada na standardom izlaznom uredjaju. Metoda je nešto poput recepta , unutar metode (recepta) su svi koraci koji su potrebni da bi se ispekala ta torta (instrukcije). Npr da imamo metodu „ispećitortu“, koja se nalazi unutar klaseApples: classApples void ispeći tortu (){ izmješaj margarin; koraci/instrukcije stavi u tavu; pojedi tortu; } }

//

// korak

su // //

Sve sve zajedno tjelo metode i zaglavlje metode je metoda.

~2~

zaglavlje 1 tjelo korak korak

{ metode svi ovi metode 2 3

Varijable (promjenjive) Kada napisemo x=73, pod x ce se podrazumjevati broj 73. Varijabli x je dodjeljena vrijednost 73 Prije nego sto krenemo raditi sa varijablom treba da definisemo vrstu varijable , to mogu biti brojevi cjeli brojevi ili int (1,2..),double brojevi sa decimalnim mjestima (3.14), lista karaktera (djordje)… Npr. Vrsta variable double (govori javi da ce raditi sa brojem koji moze imati i decimalni zarez) nakon toga joj moramo dati ime npr tuna , i dodjeliti joj vrijednost 5.28 , kao na primjeru: class apples { public static void main (String args[]) { double tuna = 5.28; System.out.print(tuna) } }

Kada pokrenemo ovaj program on ce umjesto u zagradi gdje pise tuna (System.out.println(tuna)) izbaciti vrijednost kojoj smo joj dodjelili (liniju koda ispod) tj. 5.28. System.out.print() - znaci prikazi ovo u zagradi pod i ostani u istoj liniji (redu), dok System.out.printl() -znaci prikazi ovo u zagradi i prebaci na sledeci red (liniju) , npr: public class apples { public static void main (String args[]){ double tuna; tuna = 5.28; System.out.print("I'd Like"); System.out.print(tuna); System.out.println(" kg of tuna"); System.out.print("for breakfast"); } }

Kada pokrenemo ovaj kod dobicemo: I'd Like5.28 kg of tuna for breakfast Imamo cetri naredbe koje prikazuju na ekranu cetri stvari : 1) I‟d Like 2)5.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.

~3~

Input from the user Jedan nacin za ulaz je da koristimo nesto sto je vec ugradjeno u javi , Scanner. Scanner uzima informacije koje korisnik kuca na tastaturi. Java program koristi samo ono sto je potrebno, pa da bismo koristili Scanner(tastaturu) moramo da ga „importujemo“ ili unesemo , tako sto upisemo: import java.util.Scanner; Importjava.util.Scanner; public class ai{ public static void main(String args[]){ Scanner djordje = new Scanner(System.in); //sada mozemo vrsiti operacije sa tastaturom System.out.println(djordje.nextLine()); } }

djordje je scanning varijabla i ona je jednaka bilo cemu sto unesemo tastaturom. Scanner djordje = new Scanner(System.in); -ova instrukcija znaci sta god unesemo tastaturom skladisti u djordje varijablu. Ova nam instrukcija omogucuje da koristimo tastaturu koju smo predhodno “inportovali” ( import java.util.Scanner; ) System.out.println(djordje.nextLine()); - ova insturkcija prikazuje na ekranu djordje varijblu. Dok next.Line() znaci da ce se na prikazivanje djordje promjenjive izvrsiti tek nakon sto je definisemo tj ukucamo nesto i pritisnemo enter .

Building a basic calculator

import java.util.Scanner; tastaturu*/

/*navodimo da cemo koristiti

class apples{ public static void main(String args[]){ Scanner broj = new Scanner(System.in); double broj1,broj2,rezultat; System.out.println("unesi broj 1"); broj1 = broj.nextDouble(); System.out.println("unesi broj 2"); broj2 = broj.nextDouble(); rezultat = broj1 + broj2; System.out.print(rezultat); } }

~4~

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,147,483,648 do 2,147,483,647 ) . Kada koristimo int u operacijama sa varijablama rezultat moze biti samo cjeli broj bez obzira sto je npr. 9/2=4.5 , on ce prikazati da je 9/2=4. import java.util.Scanner; public class lekcija8 { public static void main(String args[]) { Scanner input = new Scanner(System.in); int boys, girls, people; System.out.println("enter number of boys"); boys = input.nextInt(); System.out.println("enter number of girls"); girls = input.nextInt(); people = boys + girls; System.out.print("there is "); System.out.print(people); System.out.println(" people"); } }

Kada se izvrsi insturkcija people = boys + girls; , dobicemo tacan broj ljudi tj. People. Da je npr umjesto znaka + , znak “–“ (minus) dobili bi tacnu razliku ljudi tj. People. Da je umjesto znaka + , znak * (asteriks – znak za mnozenje) dobili bi smo tacan proizvod ljudi. Vec kod djeljenja je malo komplikovanije. Kada podjelimo npr 8 /4 dobicemo broj 2 , sto je i logicno . Ali ako npr. podjelimo 11/3 dobicemo broj 3 sto nije tacan rezutat( iz razloga sto int tip podataka ne podrzava decimalna mjesta). Sem operatora djeljenja(“/” ) postoji i modul operator (“%”) koji bi kada bih smo napisali insturkciju 11%3; , kao rezultat izbacio broj 2 (jer je broj 2 ostatak kod djeljenja ova dva broja).

~5~

Lekcija 9: Increment Operators(increment-“dopunsko punjenje) Uzmimo da imamo: 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13.

Import java.util.Scanner; public class l9increment { public static void main(String args[]);{ Scanner input = new Scanner(System.in); int tuna = 10; int swordfish = 20; System.out.println(tuna); ++tuna; } }

Kada pokrenemo ovaj program dobicemo broj 10, zbog toga sto smo naredili da nam prikaze na ekranu vrijednost promjenjive tuna (naredba System.out.println(tuna); ), a tuna je jednaka 10. Mi vrijednost varijable mozemo mjenjati naknadno tj nakon sto je definisemo kao sto smo uradili u liniji koda (10). tj. ++tuna; . 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). ++tuna; znaci da je sad tuna uvecana za jedan. Isto mozemo smanjiti vrijednost varijable ako ukucamo --tuna; , varijabla tuna ce imati vrijednost 9. Inkrementiranje i dekrementiranje mozemo raditi u letu. Npr. slobodno mozemo napisati System.out.println(++tuna); i na ekranu ce nam se prikazati vrijednost tuna povecana za 1. Kada stavimo ++ prije to se zove preincrementing. Npr System.out.println(++swordfish); to znaci da ce se prvo promjeni vrijednost promjenjive prije nego sto se prikaze na ekranu. Ali kada bi smo napisali System.out.println(swordfish++); prvo ce prikazati na ekranu staru vrijednost varijable tj 20 pa ce je tek onda povecati za jedan. To se zove post incrementing . npr: 1. public class Increment { 2. public static void main (String args[]){ 3. int tuna = 10; 4. int swordfish = 20; 5. 6. System.out.println(++tuna); 7. System.out.println(swordfish++); 8. System.out.println(swordfish); 9. } 10. }

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), dok je promjenjiva swordfish prvo prikazana na ekranu pa se tek onda povecla vrijednost ove promjenjive iz razloga sto je ++ poslije promjenjive. To da se promjenjiva swordfish povecala vidimo kada smo u 8 liniji koda pozvali da se vrijednost te promjenjive prikaze , i vidimo da vise nije 20 vec 21.

~6~

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. 18){ System.out.println("you can enter"); }else{ System.out.println("you can't enter"); }

//test 1

if(boy>18 || girl>18){ System.out.println("you can enter"); }else{ System.out.println("you can't enter"); }

//test 2

10. 11. 12. 13. 14. 15.

}

16. 17.

}

Kada pokrenemo ovaj program dobicemo: you can't enter

//posljedica testa 1

you can enter

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

Lekcija 12: switch naredba switch naredba testira jednu varijablu (promjenjivu) i zavisno od te promjenjive daje nam vise izbora. sintaksa izgleda ovako : switch(/*promjenjiva case 1: System.out.println(); break; case break; case n: break; default: break; }

koja

testira*/)

se

{

// case znaci slucaj, 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 nije zadovoljen

primjer: public class Switch{ public static void main(String args[]){ int age = 7; switch(age){ case 1: System.out.println("you are young"); break; case 2: System.out.println("you can crawl"); break; case 10: System.out.println("you are old motherfucker"); break; default: System.out.println("there isn't specified"); break; } } }

Kada pokrenemo ovaj program gore dobicemo: there isn‟t specified , iz razloga sto je vrijednost age promjenjive 7 pa se izvrsva default dio koda jer nemamo naznacenu opciju da je vrijednost 7. Imamo opcije da je vrijednost godina 1,2 ,10 i default (ono sto se izvrsava kada nijedno od ovih opcija nije). Da je vrijednost promjenjive age npr. 10 onda bih kao rezultat dobili : you are old motherfucker , iz razloga sto imamo definisano sta da se izvrsi kada je vrijednost promjenjive age jednako 10 (case 10: tj. System.out.println(“you are old motherfucker”); ). Kao sto mozemo primjetiti poslije svakog slucaja (ukljucujuci i default) smo stavili break , sto znaci da kada se nadje trazeni slucaj vise se nece dalje provjeravati vec ce se switch naredba zavrsiti. Npr: da je vrijednost promjenjive age jedanko 1 , i da nemamo break; unutar koda koji ce se izvrisiti u slucaju da je age jednako jedan , program bi provjeravao sve ostale slucaje.

~ 10 ~

Lekcija 13: While loop U prevodu loop znaci petlja. while nam omogucava da izvrsavamo dio koda vise puta , a da ga napisemo samo jednom. 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; while(counter 60) System.out.println("You else if(age >= 50) System.out.println("You else if(age >= 40) System.out.println("You else System.out.println("You

are a senior citizen"); are in your 50s"); are in your 40s"); are a young buck");

} }

else if se uvjek stavlja izmedju glavnog if( if(age > 60 ) i zadnjega else. Moze se izvrsiti samo jedna od ovih naredbi : 1. 2. 3. 4.

if(age > 60) , System.out.println(“you are a senior citizen”); else if(age >=50), System.out.println(“you are in your 50s”); else if(age>=40), System.out.println(“You are in your 40s”); else , System.our.println(“You are a young buck”);

To funkcionise ovako: promjenjiva age je 45, on pita pod (1) da li je age vece od 60, odgovor je ne. Zatim pita pod (2):da li je age vece ili jednako 50), odgovor je ne. Zatim pita pod (3): da li je age vece ili jednako 40 , odgovor je da i izvrsava se naredba pod(3) tj: System.out.println(“You are in your 40s”); . Zato cemo na ekranu imati ispisano “You are in your 40s”. Dakle kada naidje na pozitivan odgovor prestaje sa izvrsavanjem i nema portrbe da ide pod (4).

~ 17 ~

Lekcija 20: Conditional Operators Conditional operators su drugi nacin koriscenja if else naredbe ali su veoma kompaktni i veoma mali. Npr: public class Apples { public static void main(String args[]){ int age = 21; System.out.println(age > 50 ? "you are old" : "you are young"); } }

Treba obraditi paznju na System.out.println(age > 50 ? “you are old” : “you are young”); . 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. Nakon Upitnika moramo staviti sta da izbaci na ekranu ako je true (tj. ako je age > 50) i odvojeno “ : “ sta da izbaci na ekranu ako je false( tj ako age nije vece od 50 ). Rezultat izvrsavanja ovog programa je : you are young

~ 18 ~

Lekcija 21: Jednostavni program za izracunavanje prosjeka Napisali smo program za izracunavanje prosjeka 10 brojeva koje unesemo: import java.util.Scanner; public class Apples { public static void main(String args[]){ Scanner input = new Scanner(System.in); int ukupno = 0; int broj; int prosjek; int counter = 0; while(10>counter){ broj = input.nextInt(); ukupno = broj + ukupno; counter++; } prosjek = ukupno / counter; System.out.println("Your average is:" + prosjek); } }

Unijeli smo tastaturu, omogucili da je koristimo koristeci Scanner promjenjivu input. Zatim smo kreirali 4 promjenjive tipa int : 1. ukupno – koji ce izracunati ukupan zbir 10 brojeva koje unesemo. 2. broj-to ce biti svaki pojedinacni broj od 10 koje unesemo. 3. prosejek- on ce skladistiti srenju vrijednost. 4. counter ili brojac ce nam sluziti da izbroji koliko smo brojeva unijeli. Zatim imamo while petlju: while(10>counter){ broj = input.nextInt(); ukupno = broj + ukupno; counter++; } Sve dok je 10 vece od promjenjive counter ( 10 > counter) on radi sledece operacije: 1. broj = input.nextInt(); tj. sve sto ukucamo skladisti se u varijablu broj. Zatim 2. ukupno = broj + ukupno; 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. I na poslijetku imamo pod 3. counter++; sto znaci da ce se svaki put kad se ponovi while naredba promjenjiva counter povecati za jedan. Kada se zavrsi naredba while tj kad 10 ne bude vise vece od promjenjive counter program prelazi na sledecu liniju koda tj. prosjek =ukupno / counter; sto je nacin da izracunamo prosjek tako sto podijelimo ukupni zbir brojeva koje smo unijeli i counter (koliko smo brojeva unijeli ). Na kraju imamo naredbu System.out.println(“You average is : “ + prosjek) , koja govori izbaci na ekranu “Your average is “ i vrijednost promjenjive prosjek.Vidimo iznad kako smo to izveli.

~ 19 ~

Lekcija 22: for loop (petlja) For petlja zahtjeva 3 argumenta da bih radila, argumenti su razdvojeni sa “ ; ” . Konstrukcija for petlje je: for( argument1;argument2;argument3)   

argument 1: brojac argument 2: test (provjerava se npr. 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