the new boston java programiranje (begginer).pdf

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

~ 1 ~

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 Robot{ public static void main(String args[]){ } //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.

~ 2 ~

Sada kada smo stvorili klasu Robot i u nju stavili glavnu metodu main. Mozemo napisati neki kod

koji ce se izvrsiti. Npr:

Class Robot{ public static void main(String args[]){ System.out.println(„Pozdrav svjetu“); } }

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 (){ // zaglavlje metode izmješaj margarin; // korak 1 svi ovi koraci/instrukcije su tjelo metode stavi u tavu; // korak 2 pojedi tortu; // korak 3 } }

Sve sve zajedno tjelo metode i zaglavlje metode je metoda.

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

~ 4 ~

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; /*navodimo da cemo koristiti tastaturu*/ 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); } }

~ 5 ~

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

~ 6 ~

Lekcija 9: Increment Operators(increment-“dopunsko punjenje)

Uzmimo da imamo:

1. Import java.util.Scanner; 2. 3. public class l9increment { 4. public static void main(String args[]);{ 5. Scanner input = new Scanner(System.in); 6. 7. int tuna = 10; 8. int swordfish = 20; 9. System.out.println(tuna); 10. 11. ++tuna; 12. } 13. }

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 //posljedica 6 liniji koda 20 //posljedica 7 linija koda 21 //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.

~ 7 ~

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.

~ 8 ~

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 kojoj se nalazi uslov ili test u ovom primjeru pise sledece:

if (test == 9)

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)

~ 9 ~

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. public class LogicOperator{

2. public static void main(String args[]){

3. int boy = 17, girl = 20;

4.

5. if(boy>18 && girl>18){ //test 1

6. System.out.println("you can enter");

7. }else{

8. System.out.println("you can't enter");

9. }

10.

11. if(boy>18 || girl>18){ //test 2

12. System.out.println("you can enter");

13. }else{

14. System.out.println("you can't enter");

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.

~ 10 ~

Lekcija 12: switch naredba

switch naredba testira jednu varijablu (promjenjivu) i zavisno od te promjenjive daje nam vise izbora.

sintaksa izgleda ovako :

switch(/*promjenjiva koja se testira*/) {

case 1: // case znaci slucaj, 1 znaci: ako je vrijednost promjenjive kojda se testira 1

System.out.println(); //ono sto ce se izvrsiti u slucaju da je vrijednost promjenjive koja se tesitira ==1

break; // break znaci ako je case 1 da stane sa izvrsenjem instrukcije switch

case 2:

break;

case n: //n je bilo koji broj

break;

default: //default koji je rjesenje kada nijedan od slucajeva tj. case nije zadovoljen

break;

}

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.

~ 11 ~

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<10){

System.out.println("ovo je " +counter+" iteracija ove petlje");

counter++;

}

}

}


ovo je 0 iteracija ove petlje










Kao sto vidimo instrukcija : System.out.println(“ovo je “+ counter + “ iteracija ove petlje”); je

ponovljena 10 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 , tj. 10 < 10 , nije tacno) i petlja je zavrsena.

Promjenjivu counter ( u prevodu brojac) smo definisali izvan same petlje , a koristili smo je unutar

while petlje. 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 , ma kako se ona zvala.

~ 12 ~

Lekcija 14: Klase

U stvarnom svjetu mozemo vidjeti puno idividualnih objekata iste vrste. Npr. mozemo vidjeti puno

bicikala , ali svaki od njih je uradjen po istom nacrtu sto ga i cini biciklom. U objekto orjentisanom

programiranju biciklo je instanca klase, dok nacrt koji sluzi da se napravi biciklo predstavlja klasu.

Klase se sastoje od promjenjivih i metoda.

Imamo dve vrste promjenjivih:

Promjenjive instance koje cuvaju atribute konkretnog objekta koji se razlikuje u slucaju

razlicitih objekata iste klase.

Promjenjive klase cuvaju atribute koji su jedinstveni za sve objekte iste klase ( definise se na

nivou klase i cuva se samo jedna vrijednost koja kad se promjeni mjenja se za sve objekte te

klase)

Takodje imamo dve vrste metoda:

Metode instance : ukoliko metoda obavlja izmjenu pojedinacnog objekta.

Metoda klase : se primjenjuje na samu klasu.

Promjenjive/ metode klase mozemo prepoznati po tome sto u zaglavlju imaju static.

Klase su organizovane u hierarhijsku strukturu. Moguce je nasljedjivanje. Klasa moze nasljediti samo

jednu klasu , dok klasa koje nasljedjuju neku klasu moze biti neograniceno.

Klasa koja nasljedjuje neku drugu klasu naziva se izvedena klasa (podklasa) dok klasa koja se

nasljedjuje naziva se nadklasa (superklasa). Na vrhu hierarhije Java klasa je klasa Object. Sve klase

nasljeduju ovu klasu. void znaci da ce metoda raditi nesto (return je suprotno od void i znaci da kada

se izvrsi metoda da ce se neka vrijednost vratiti tj. “return”).Svaki put kada vidimo public ispred

imena klase to znaci da ce biti dostupna ostalim klasama za koristenje, to isto vazi i za metode. Npr

klasa Tuna:

public class Tuna { /*klasa*/ public void SimpleMessage(){ /*metoda*/ System.out.println("This is another class named Tuna"); } }

Kao sto vidimo klasa tuna ima metodu kojoj je SimpleMessage. Kada pokrenemo ovaj program gore

nista se nece desiti iz razloga kada pokrenemo Java program on trazi main metodu. Medjutim instancu

ove klase (tj. objekat) mozemo kreirati u nekoj drugoj klasi koja sadrzi main metodu. Kreiracemo

instancu ove klase u klasi Apples :

public class Apples { public static void main(String args[]){ Tuna t = new Tuna(); t.SimpleMessage(); } }

Prvo sto moramo uraditi u main klasi jeste da kreiramo objekat za klasu koju zelimo ubaciti. Objekat

se kreira tako sto ukucamo :

ImeKlaseOdKojePravimoObjekat imeObjekta = new ImeKlaseOdKojePravimoObjekat ( ); tj u ovom

slucaju Tuna t = new Tuna( );. Sada kada imamo kreiranu instancu klase Tuna koju smo nazvali t¸

pomocu nje mozemo pozivati metode klase Tuna i pristupati promjenjivim klase Tuna. Metodi

pozivamo tako sto ukucamo: ImeObjektaKlase.imeMetode( ); , tj. u ovom slucaju t.SimpleMessage();

Sada kada pokrenemo ovaj kod klasa Apples dobicemo : This is another class named Tuna .

~ 13 ~

Lekcija 15: Koristenje metoda sa parametrima

U ovom primjeru cemo imati dve klase glavnu klasu Apples i vanjsku Tuna. Klasa Tuna :

public class Tuna { public void SimpleMessage(String name){ System.out.println("Hello" + name) } }

Kao sto vidimo ova klasa ne moze samostalno funkcionisat jer nema glavnu klasu i jer promjenjiva

name nije definisana. Ono sto se nalazi u zagradama poslije naziva metode (tj. u ovom slucaju :

SimpleMessage) je argument (tj.u ovom slucaju : String name). A argument ili ekstra parametar je

neka informacija koja je potrebna metodi da bih funkcionisala. Kada bismo pokrenuli ovaj program

dobili bih smo samo Hello bez name iz tog razloga nam je potreban argument tj (String name).

Glavna klasa Apples:

import java.util.Scanner; public class Apples { public static void main(String args[]){ Scanner input = new Scanner(System.in); Tuna TunaObject = new Tuna(); System.out.println(" Enter your name "); String name = input.nextLine(); TunaObject.SimpleMessage(name); } }

Prvo smo unijeli Scanner jer cemo koristiti tastaturu ( import java.util.Scanner; ). Zatim smo napisali

Scanner input = new Scanner (System.in); kako bi smo ono sto napisemo koristeci tastaturu

skladistili u input promjenjivu tipa Scanner. Onda smo kreirali objekat TunaObject ( Tuna

TunaObject = new Tuna(); ) jer bez njega ne mozemo koristiti nista iz klase Tuna. Dalje kod String

name = input.nextLine(); imamo promjenjivu name i tu smo definisali da je ona jedanka bilo cemu

sto ukucamo tastaturom(input.nextLine() ) . I zadnja linija koda tj. TunaObject.SimpleMessage

(name); ustvari kaze , Iz klase Tuna pokreni metodu Simple.Message i prosljedi kao trazeni argument

promjenjivu name.

Kada pokrenemo ovaj program dobicemo opciju da nesto upisemo, mi cemo upisati npr. Djordje i

program ce nam vratiti : Hello Djordje .

~ 14 ~

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 ());.

~ 15 ~

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){ /*constructor*/ girlname = name; /*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"); /*jedan objekat klase Tuna*/ Tuna t2 = new Tuna("bla2"); /*drugi objekat klase Tuna*/ t1.saying(); t2.saying(); } }

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

~ 16 ~

Lekcija 18: Nested If Naredbe

Umjesto da imamo samo jednu akciju ako je test , tacan ili netacan mozemo imati vise njih, npr:

public class Apples { public static void main(String args[]){ int age = 60; if(age < 50){ System.out.println("you are young"); }else{ System.out.println("you are old"); if(age < 75){ System.out.println("you’re really old"); }else{ System.out.println("don't worry"); } } } }

Kada pokrenemo ovaj program dobicemo rezultat :

you are old

you are really old

Sve ovo je ugnjezdjena if naredba:

if(age < 50){ System.out.println("you are young"); }else{ System.out.println("you are old"); if(age < 75){ System.out.println("you’re really old"); }else{ System.out.println("don't worry"); } }

Ovo sto je napisano plavim slovima je ono sto ce se dogoditi ako je test zadovoljen ( age < 50 ).

Napisano crvenim slovima je ono sto ce se dogoditi ako test nije zadovoljen. Poslije prvog else koji je

pocetak onog sto ce se dogoditi ako test nije zadovoljen nije zatvovrena viticasta zagrada vec je

dodano novo if sa svojim else i tako se moze uraditi napisati dosta onoga sto ce se dogoditi ako test

nije zadovoljen . Zagrada oznacena zelenom bojom je zagrada koja znaci zavrsetak onoga sto ce se

dogoditi ako prvobitni test ( age <50 ) nije zadovoljen. U glavnome else svako if i svako else mora

imati zatvorenu viticastu zagradu.

~ 17 ~

Lekcija 19: else if naredba

else if naredba je nacin da damo javi vise opcija. Jednostavna if naredba izgleda npr ovako:

public class Apples { public static void main(String args[]){ int age = 55; if(age > 60){ System.out.println("You are a senior citizen"); }else{ System.out.println("You are a young buck");} } }

Dakle jednostavna if naredba nudi jednu opciju ako je test tacan i drugu else opciju ako test nije tacan.

else if naredba je nesto poput dodatne opcije. I mozemo imati else if alternativa koliko hocemo.

Primjer :

public class Apples { public static void main(String args[]){ int age = 45; 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.out.println("You 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. if(age > 60) , System.out.println(“you are a senior citizen”);

2. else if(age >=50), System.out.println(“you are in your 50s”);

3. else if(age>=40), System.out.println(“You are in your 40s”);

4. 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).

~ 18 ~

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

~ 19 ~

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.

~ 20 ~

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<=10;counter++){ System.out.println(“ovo je “ +counter+ “iteracija petelje”); } } }

U ovom primjeru petlja for izgleda: for (int counter=1;counter<=10;counter++).

Argument1 ili int counter=1 , znaci da smo napravili promjenjivu counter (tipa int) cija je

vrijednost 1 , sto znaci da nam petlja pocinje od 1.

Argument2 ili counter<=10; znaci da ce se petlja izvrsavati sve dok je 10 vece ili jedanko

promjenjivoj counter (argument 1).

Argument3 ili counter++; ,znaci da ce se promjenjiva counter uvecavati za 1 prilikom svake

iteracije.

Nakon svega toga tj: for (int counter=1;counter<=10;counter++) otvaramo viticastu zagradu da

definisemo sta ce ova petlja raditi(naravno moramo tu zagradu i zatvoriti kada to definisemo). Unutar

viticaste zagrade mi smo stavili System.out.println(counter); sto znaci da ce se sve dok se vrti petlja

na ekranu u svakoj sledecoj liniji prikazivati vrijednost promjenjive counter. tj dobicemo sledece:

ovo je 1 iteracija petlje










~ 21 ~

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% , kroz 10 godina. Primjer:

public class Apples { public static void main(String args[]){ double iznos; double trenutniiznos=7000; double kamata= 0.04; for(int year=1;year<=10;year++){ iznos= trenutniiznos*Math.pow(1+ kamata, year); System.out.println(year + " " + iznos); } } }

Kada pokrenemo ovaj program dobicemo koliki ce nam iznos biti za 10 godina , tj:

1 7280.0

2 7571.200000000001

3 7874.048000000001

4 8189.009920000001

5 8516.5703168

6 8857.233129472

7 9211.522454650882

8 9579.983352836918

9 9963.182686950395

10 10361.709994428411

Math.pow je vanjska metoda koja ima dva argumenta. Math.pow( argument1, argument2).

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.

Iznos = trenutniiznos*Math.pow( 1+kamata, year), funkcionise na sledeci nacin , trenutniiznos se

mnozi sa 1+kamata(sto je uvjek 1.04 ili 4%) year puta. U godini jedan iznos=7280 iz razloga sto je

7000(trenutniiznos)*1.04 jednako 7280. U drugoj godini imamo iznos=7571.2 iz razloga sto je

7000*1.0816=7571.1 (imamo dva puta 1.04 iz razloga sto je year=2) . Dakle Math.pow je nacin da

dobijemo kvadrat nekog broja . npr Math.pow(4,3) dobicemo rezultat 43

tj.64.

~ 22 ~

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. Tjelo se nalazi unutar viticastih zagrada . do while

Izgleda ovako:

do{

Instrukcija1;

Instrukcija2;

}while( test)

Npr:

public class Apples { public static void main(String args[]){ int counter=0; do{ System.out.println(counter); counter++; }while(counter<=10); } }

Kada pokrenemo ovaj program dobicemo izlistane brojeve od 1 do 10 tj: 1,2,3,4,5,6,7,8,9,10 (jedan

ispod drugog). 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; do{ System.out.println(counter); counter++; }while(counter<=10); } }

Jedina razlika izmedju ova dva koda je u promjenjivoj counter. U prvom primjeru je counter=1 dok je

u drugom primjeru counter=15. 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.out.println(counter); counter++; ) pa tek onda se provjerava test (tj da li se treba dalje

izvrsavati petlja) (counter <=10 ). Izvrsilo se tjelo program je pokazao vrijednost 15

(System.out.println(counter);) 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. Dobijeni rezultat nakon pokretanja programa izgleda ovako:

15

~ 23 ~

Lekcija 25: Ugradjene matematicke metode

Sve metode iz matematicke klase pocinju sa Math zatim ide tacka (.) i metoda. Neki primjeri

Math.metoda:

1) Math.abs(broj) - absolute value bilo koji broj stavimo u zagradu bio on pozitivan ili negativan

bice prikazan bez predznaka tj razlika tog broja do 0.

2) Math.ceil(broj) - bilo koji decimalni broj koji stavimo u zagradu bice zaokruzen navise

3) Math.floor(broj) - bilo koji decimalni broj koji stavimo u zagradu bice zaokruzen nanize

4) Math.round(broj) - bilo koji broj koji stavimo bice zaokruzen na najblizu vrijednost.

5) Math.max(broj1,broj2,brojn) – prikazuje broj koji ima najvecu vrijednost

6) Math.min(broj1,broj2,brojn) – prikazuje broj koji ima najmanju vrijednost

7) Math.pow(broj, eksponent) – prikazuje broj pomnosen sam sa sobom eksponent puta

8) Math.sqrt(broj) - vadi kvadratni korjen

Primjeri:

import java.util.Scanner; public class Apples{ public static void main(String args[]){ double broj1 = 3.14; double broj2 = 9; System.out.println("apsolutna vrijednost broja1 je: " + Math.abs(broj1)); System.out.println("broj1 zaokruzen nanize je : "+ Math.floor(broj1)); System.out.println("broj2 zaokruzen navise je : "+ Math.ceil(broj2)); System.out.println("manji broj od broja1 i broja 2 je " + Math.min(broj1, broj2)); System.out.println("veci broj izmedju broja 1 i broja 2 je: " + Math.max(broj1, broj2)); System.out.println(“najblizi cjeli broj na koji se Moze zaokruziti broj1 je: “ +Math.round(broj1)); System.out.println("broj1 na broj2 je : “ +Math.pow(broj1,broj2)); System.out.println("kvadratni korjen broja1 je "+Math.sqrt(broj1)); System.out.println("kvadratni korjen broja2 je "+ Math.sqrt(broj2)); } }

Rezultat izvrsavanja gornjeg programa je:

apsolutna vrijednost broja1 je: 3.14

broj1 zaokruzen nanize je : 3.0

broj2 zaokruzen navise je : 9.0

manji broj od broja1 i broja 2 je 3.14

veci broj izmedju broja 1 i broja 2 je: 9.0

najblizi cjeli broj na koji se moze zaokruziti broj1 je : 3

broj1 na broj2 je 29673.367320587102

kvadratni korjen broja1 je 1.772004514666935

kvadratni korjen broja2 je 3.0

~ 24 ~

Lekcija 26: Random nuber Generator

Napravicemo program koji ce simulirati bacanje kocke sest puta (ima sest izbora:1,2,3,4,5,6) :

import java.util.Random; public class Apples{ public static void main(String args[]){ int brojBacanja = 6; int broj; Random dice = new Random(); for(int counter=1;counter<=brojBacanja;counter++){ broj = 1 + dice.nextInt(6); System.out.println("bacanje br: "+counter+" broj: "+ broj); } } }

Dakle generator nasumicnih brojeva se kreira tako sto importujemo prvo java.util.Random; , zatim

ukucamo : Random dice = new Random();, sto znaci da smo kreirali Random promjenjivu naziva

Dice.

Nasumicni brojevi se generisu naredbom ImeRandomPromjenjive.nextInt(/*raspon*/); , tj u nasem

primjeru dice.nextInt(6); , je 6 raspon sto znaci da ce ovaj generator generisati brojeve izmedju 0 i 5.

S obzirom da kocka za bacanje ima brojeve od 1 do 6 , mi cemo svakom generisanom novom broju

izmedju 0 i 5 dodati 1 , sto ce nas dovesti do zeljenog rezultata na nacin: 1 + dice.nextInt(6); .

Dalje imamo for petlju koja ce se izvrsavati 6 puta , sto simulira 6 bacanja kocke. U tjelu for petlje

imamo number = 1 + dice.nextInt(6); sto znaci da je promjenjiva number jedaka bilo kojem broju

izmedju 0 I 5 , uvecanom za 1. I naposljetku imamo instrukciju da se tih sest bacanja prikaze na ekranu

( System.out.println(“bacanje br: “+counter+” broj: “+ broj ). Kada pokrenemo ovaj program

prikazace nam se nasumicnih 6 brojeva izmedju 1 i 6.

Rezultat jednog izvrsavanja je :

bacanje br: 1 broj: 4






Rezultat nekog drugog izvrsavanja je drugaciji, kao i sako sledece izvrsavanje. Jedino se slucajno

moze desiti da se generisu dve iste kombinacije:







~ 25 ~

Lekcija 27: Introduction to Arrays( array – mnostvo,poredak)

Array je promjenjiva koja moze da skladisti vise vrijednosti. Ona moze da skladisti samo vrijednosti

iste vrste npr. Samo Int ili String ili double.Takodje moze da skladisti I objekte. Kada kreiramo Array

prvo napisemo koje vrste ce biti podatci koje cemo skladistiti ( npr int) zatim ime array promjenjive

i poslije toga kockaste zagrade [ ] te = new int[/*neki broj koji oznacava koliko ce vrijednosti ili promjenjivih biti

skladisteno u ovom Array*/] Primjer:

public class Appless { public static void main(String args[]){ int djordje[]= new int[10]; djordje[0]=10; djordje[1]=17; djordje[2]=12; djordje[3]=123; djordje[4]=15; djordje[5]=143; djordje[6]=32; djordje[7]=82; djordje[8]=8; djordje[9]=9; System.out.println(djordje[9]); } }

Int djordje[] =new int[10]; je Array koja moze imati deset vrijednosti. Kada kreiramo array moramo

zadati koliko moze sadrzavati vrijednosti/promjenjivih. S obzirom da racunar uvjek pocinje da broji od

0 , mi smo definisali prvu vrijednost tako sto smo napisali ime array-ja zatim u [] redni broj ili indeks

vrijednost/promjenjive i nakon toga jednako kojoj vrijednosti. To izgleda ovako djordje[0]=10;

Postoji I malo brzi nacin da definisemo vrijednosti koje ce da sadrzi. To se zove array initializator i

kreira se na sledeci nacin . Prvo ukucamo vrstu podataka koje ce skladistiti ( u ovom primjeru int)

zatim ime array-a sa ovim zagradama [] zatim = pa u otvorenoj viticastoj zagradi ukucamo vrijednosti

kojima array sam pripise indeks iduci po redu od 0 pa nadalje. Konstrukcija je sledeca :

tipPodatakaKojiseSkladisti ImeArraya [] = {element1, element2, element3, elementn} . primjer:

public class Appless { public static void main(String args[]){ int djordje[]={1,7,6,3,2,5}; System.out.println(djordje[1]); } }

Int djordje[]={1,7,6,3,2,5}; je isto array samo sto smo mi odmah upisali vrijednosti redom 1,7,6,3,2,5.

Isto tako redom se dodjeljuju indeksi pocevsi od nule . Br: 1 ima indeks: 0, br:7 ima indeks:1 , br:6

ima indeks:2, br:3 ima ideks:3 , br:2 ima indeks:4 I naposljetku br:5 ima indeks:5.

Iz tog razloga kada smo napisali System.out.println(djordje[4]); dobili smo broj sa indeksom 4 tj. na

ekranu smo dobili broj 2.

~ 26 ~

Lekcija 28: Creating an Array Table

Kreirati cemo “tabelu” koja ce nam prikazivati koju vrijednost indeks Array-a ima. Primjer:

public class Apples { public static void main(String args[]){ System.out.println("index\tValue"); int djordje[]={14,15,16,22,10}; for(int counter=0;counter<djordje.length;counter++){ System.out.println(counter + "\t"+ djordje[counter]); } } }

Kada pokrenemo ovaj program dobicemo sledece:

index Value //zaglavlje tabele

0 14 //prvi red

1 15 //drugi red

2 16

3 22

4 10

Dakle na pocetku smo napravili zaglavlje tabele ukucali smo: System.out.println(“index\tValue”);,

ovo “ \t “ je ustvari Tab tj razmak pa zato imamo razmak izmedju index i Value sto vidimo u zaglavlu

“tabele”.

Zatim smo napravili Array: int djordje[]={14,15,16,22,10,17}; , koji ima 6 elemenata. Nakon toga

smo napisali for petlju: for (int counter=0;counter<djordje.length;counter++) , treba primjetiti kada

smo zadavali drugi argument tj counter < djordje.length , da nismo napisali koliko puta treba da se

izvrsi ova petlj vec smo napisali djordje.length, sto nam daje broj elemenata unutar Array-a djordje ,

sto je u ovom slucaju 6.

Naposljetku u tjelu for petlje imamo System.out.println( counter + “\t” + djordje[counter]); , gdje

se counter poistovjecuje sa indeksom elementa a djordje[counter] sa vrijednoscu koji taj indeks

ima.

S obzirom da je pocetna vrijednost counter promjenjive 0, u prvom redu “tabele” bice pod Index

prikazano 0 , a pod Value vrijednost koju ima element djordje Array-a sa indeksom 0 (u ovom slucaju

14).

Djordje[counter] – counter je dakle indeks , pa ce nam djordje[counter] prikazati vrijednost

elementa sa indeksom counter. Da npr. pise djordje[1] , na ekranu bi nam se ispisalo pet puta broj 15

, jer vrijednost u djordje Array sa indeksom 1 je 15.

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.

~ 27 ~

Lekcija 29: Summing Elements of Array

Ono sto cemo uraditi jeste da cemo sabrati sve vrijednosti unutar jednog kreiranog Array-a. Primjer:

public class Apples { public static void main(String args[]){ int djordje[]={1,2,3,4,5,6,7,8,9,10}; int sum=0; for (int counter=0;counter<djordje.length;counter++){ sum = sum + djordje[counter];} System.out.println("ukupan zbir je: " + sum); } }

Kada pokrenemo ovaj program ispisace se : “ Ukupan zbir je 55” , sto je tacno.

Lekcija 30: Array Elements as Counters

Napravicemo program koji ce uzeti Array elemente i skladistiti ih kao countere. 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. Program izgleda:

import java.util.Random; public class Apples{ public static void main(String args[]){ Random rand= new Random(); int freq[]=new int[7]; for(int roll=1;roll<1000;roll++){ ++freq[1+rand.nextInt(6)]; } System.out.println("Face\tFrequency"); for(int face=1;face<freq.length;face++){ System.out.println(face+"\t"+freq[face]); } } }

Kada pokrenemo ovaj program dobicemo sledece:

Face Frequency

1 179

2 176

3 148

4 163

5 169

6 164

Napravili smo Array freq [] = new int[7];, 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). Kocka ima 6 strana , zato smo Array freq definisali da ce imati 7

elemenata sa indeksima od od 0 do 6. Da smo freq definisali da ce imati 6 elemenata, indeksi bi isli

od 0 do 5 pa ne bismo mogli koristiti indeks broj 6.

~ 28 ~

Imamo for petlju koja simulira bacanje kocke 1000 puta : for(int roll=0;roll<1000;roll++) , dok tijelo

petlje ima sledeci izgeld : ++freq[ 1+rand.nextInt(6) ] ; - rand.nextInt(6) ce nam generisati broj

izmedju 0 i 5, zato smo stavili 1+ sto ce nam dati iluziju da generise broj izmedju 1 i 6. Taj generisani

broj je indeks Array-a freq. Dok : ++freq[1+rand.nextInt(6)], znaci da ce se vrijednost elementa koji

predstavlja generisani indeks povecati za 1. Dakle svaki put kada 1+ rand.nextInt(6) generise

nasumican broj izmedju 1 i 6, zbog inkrementa ++ vrijednost elementa koji reprezentuje taj indeks ce

se povecati za vrijednost 1. Npr situacija da 1+rand.nextInt(6) generise broj 3, pojednostavljeno bih

izgledala ovako : ++freq[3] i vrijednost na koju pokazuje indeks 3 je sada uvecana za 1, da se

generise 100 puta broj 3, vrijednos na koju pokazuje indeks 3 bila bi 100.

Mozemo zakljuciti da Array-ju ne mozemo promejniti broj elemenata koji moze imati , ali zato

mozemo mjenjati njihove vrijednosti.

Dalje smo napravili zaglavlje tabele : System.out.println(“Face\tFrequency”) . Zatim smo napravili

jos jednu for petlju koja ce prikazati nase podatke: for(int face=1;face<freq.length;face++) – face=1

iz razloga zato sto je prvi broj na kocki 1. face<freq.length je ustvari 1(face)<7(duzina array-a je 7 )

ali smo mi poceli brojati od 1, sto nam daje 6. .U tijelu te petlje imamo System.out.println( face+ ”\t”

+ freq[face]). Sto ce nam prikazati rezultate na ekranu. Rezultat jednog izvrsavanja:

Face Frequency

1 155

2 191

3 161

4 156

5 160

6 176

Drugo izvrsavanje daje drugacije rezultate:

Face Frequency

1 161

2 178

3 171

4 138

5 170

6 181

~ 29 ~

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. Ona umjesto 3 argumenta treba samo dva , za razliku od obicne for petlje kojoj je potrebno tri

argumenta. Konstrukcija izgleda ovako:

for(VrstaPodataka Idenrifikator : ime array-a){

instrukcije; }

Argument 1 su vrsta podataka i indentifikator dok je argument2 ime array-a. Npr: for (int x: djordje)

- int je vrsta podataka koje skaldisti Array, 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), dok je djordje ime array-a. primjer:

public class Apples { public static void main(String args[]){ int djordje[]={3,4,5,6,7}; int total=0; for(int x: djordje){ total+=x; } System.out.println(total); } }

Kreirali smo Array : int djordje[]={3,4,5,6,7} , zatim smo kreirali promjenjivu total i dali joj

vrijednost 0. Nakon toga smo kreirali poboljsanu for petlju koja ima samo dva argumetna , koja

izgleda: for (int x: djordje){ total+=x; } – int (pripada prvom argumentu) i oznacava tip podataka. 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, drugi put 4, pa 5 zatim 6 zatim 7) zato nam kao drugi argument

treba ime array-a od koji ce indentifikator x skladistiti vrijednosti. U tjelu for petlje smo stavili

instrukciju total += x; - sto znaci da ce vrijednosti promjenjive total pri svakom obrtu petlje biti

uvecane za x tj. vrijednos elementa array-a (koja zavisi od toga koji put se vrti petlja).

~ 30 ~

Lekcija:32 Arrays in methods

Stavicemo Array u neku metodu (koja ce svaki broj povecati za 5 ) pa cemo to prikazati na ekranu.

Programski kod izgleda ovako:

public class Apples { public static void main(String args[]){ int djordje[]={1,2,3,4,5}; change(djordje); for(int y:djordje) System.out.println(y); } public static void change(int x[]){ for(int counter=0;counter<x.length;counter++){ x[counter]+=5; } } }

Napravili smo Array: int djordje[]={1,2,3,4,5}; ). Zatim smo napravili metodu koja kada joj

prosljedimo Array koji sadrzi int podatke , svaki od njih poveca za 5.

Public static void change(int x[]) – public znaci da ce biti dostupna svima , static znaci da je metoda

klase. void znamo sta znaci , dok je change ime metode. Ono sto se nalazi u zagradi tj. (int x[]) , int je

vrsta dok x[] govori da cemo u ovoj metodi raditi sa Array-em koji ce u tjelu biti indeksiran sa x.

Tjelo metode ima petlju: for (int counter=0<x.length;counter++) i unutar petlje instrukciju:

x[counter]+=5; koja uzima sve elemente iz pomocu indeksa (counter) i povecava ih za 5.

Kreiranja metodu potrebno je pozvati, u suprotnom ona tu samo stoji. To smo uradili u glavnoj metodi

tako sto smo napisali change(djordje); change-je ime metode koju smo kreirali dok je djordje

parametar koji smo prosljedili za tu metodu tj. ime array-a. Ova instrukcija

Sada kada smo povecali elemente za 5 prikazacemo to na ekranu da se uvjerimo. To smo uradili

pomocu poboljsane for petlje: for(int y:djordje){System.out.println(y);} - prikazace svaki element

Array-a jedan ispod drugog, to jest:

6

7

8

9

10

Napomena: Iz nekog razloga kada sam u metodu change ubacio poboljsanu for petlju, umjesto obicne,

elementi se nisu vracali povecani ???

~ 31 ~

Lekcija 33: Multidimensional Arrays

Multidimenzionalni Array pravimo kada zelimo da napravimo tabelu u Javi ili da napravimo nesto sa

koordinatama. Multidimenzionalni Array pravimo tako sto ukucamo prvo vrstu podataka (npr: int)

zatim ime Array-a (npr. Firstarray) zatim dva para kockastih zagrada “ [] [] “ zatim znak = poslije

kojeg otvorimo viticastu zagradu koja predstavlja sadrzaj Array-ja . Unutar viticastie zagrade nove

viticaste zagrade predstavljaju redove, dok elementi unutar tih zagrada predstavljaju kolone.

Kreiranje multidimenzionalno Array-ja bi izgledalo ovako npr:

int imeArray-a[] []={{PrviEl.Reda1,2El.Reda1,…,N-tiEl.Reda1},{prviEl.Reda2,DrugiEl.Reda2,..,NelementReda2} }.

ili kada ne znamo sadrzaj ali znamo broj redova i kolona: int imeArray-ja [][] = new int [3][2]; , sto bi

znacilo Array sa 3 reda koji sadrze po dve kolone.

Primjer:

public class Apples { public static void main(String args[]){ int firstarray[][]={{1,2,3,4},{9,8,7,6}}; System.out.println(firstarray[1][1]); } }

Kada pokrenemo ovaj program na ekranu ce se ispisati broj 8.

Objasnjenje:

Dakle int firstarray[ ] [ ]={{1,2,3,4},{9,8,7,6}}; je multidimenzionalni Array . {1,2,3,4} predstavlja

prvi red dok {9,8,7,6} predstavlja drugi red. Brojevi unutar {} viticastih zagrada predstavljaju kolone.

Ako npr zelimo pristupiti broju 8 u drugom redu. Ukucamo firstarray[1][1] , firstarray je ime

multidimenzionalnog array-a. Broj u prvoj kockastoj zagradi oznacava red ( s obzirom da je u prvoj

zagradi broj 1 , to znaci da je to red sa brojevima {9,8,7,6} jer znamo da racunar uvjek broji od nula)

dok druga zagrada oznacava koji broj iz tog reda (s obzirom da je 1 u zagradi (a racunar broji od 0)

dobijamo broj 8). Kao sto vidimo i u primjeru.

~ 32 ~

Lekcija 34: Prikazivanje Multidimenzionalnih Array-a u vidu tabele

Primjer:

public class Apples { public static void main(String[] args){ int firstArray[][]={{8,9,10,11},{12,13,14,15}}; int secondArray[][]={{30,31,32,33},{43},{4,5,6}}; System.out.println("This is the first array"); display(firstarray); System.out.println("This is the second array"); display(secondarray);

} public static void display(int x [][]) { for(int row=0;row<x.length;row++){ for(int col=0;col<x[row].length;col++){ System.out.print(x[row][col]+ "\t"); } System.out.println(); } } }


This is the first array

8 9 10 11

12 13 14 15

This is the second array

30 31 32 33

43

4 5 6

U Apples klasi smo napravili dva multidimenzionalna Array-a tj: firstArray i secondArray. Nakon

toga smo napravili metodu koja ce prikazivati multidimenzionalne array-e kao tabele zaglavlje metode

je: public static void display(int x[] []). int x [ ] [ ] – koji se nalazi unutar zagrada znaci da ce raditi

sa multidimenzionalnim array-ima koji sadrze podatke tipa int.

U Tjelu metode imamo dve petlje jednu za redove drugu za kolone. Prva petlja za redove izgleda:

for (int row=0;row<x.length;row++). x.length ce prikazivati broj redova u Array( u ovom primjeru

to je 2 za firstArray - sto znaci da ce se ova petlja izvrsiti 2 puta i x.length je 3 za secondArray – sto

znaci da ce se ova petlja izvrsiti 3 puta).

Unutar petlje za redove se nalazi petlja koja ide kroz kolone, zaglavlje ove petlje izgleda :

for(int col=0;col<x[row].length;col++). x[row].length je broj kolona, row reda (u ovom primjeru

kod firstarray s obzirom da ima 2 reda u prvom redu ce se prikazati 8,9,10,11 a u

drugom:12,13,14,15) ili (koliko ima brojeva unutar svakog reda). Zatim u tjeluimamo

System.out.print(x[row][col]+ “\t”); - 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. tabom jer imamo +”\t”(sto u

ovom slucaju znaci da ce izmedju svakog broja staviti tab) . Izvan ove druge petlje i unutar prve

poslije izvrsavanja druge petlje imamo System.out.print()- sto zapravo znaci kad se jednom izvrsi

druga petlja (koja je unutar prve, 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.

~ 33 ~

Lekcija 35: Metode koje rade sa nepoznatim brojem argumenata

Nekada ne znamo koliko ili koje ce argumente metoda koristiti. 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). Primjer:

public class Apples { public static void main(String args[]){ System.out.println(prosjek(2,4,6,20)); } public static int prosjek(int...brojevi){ int total=0; for(int x:brojevi) total+=x; return total/brojevi.length; } }

Kada pokrenemo ovaj program on ce nam izbaciti vrijednost 15, tj. prosjek brojeva koje smo

prosljedili u metodu prosjek. Prvo smo napravili metodu: public static int prosjek(int…brojevi) - u

zaglavlju metode nema void sto znaci da ce neke vrijednost biti vracene, tj. bice vraceni int tj. cjeli

brojevi jer u zaglavlju imamo int. Parametri metode: (int…brojevi) - int znacii da ce podatci biti cjeli

brojevi tipa int. Tri tacke upravo znaci da neznamo koliko ce biti brojeva (dva , pet ili pet stotina cjelih

brojeva) dok je brojevi Array koji ce skladistiti te brojevi unutar metode. Unutar metode prosjek

kreirali smo promjenjivu total=0; i poboljsanu for petlju koja izgleda : for(int x:brojevi) I u tjelu

ima: total+=x; .Takodje izvan for petlje unutar metode prosjek imamo : return total/brojevi.length;,

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.

Nako sto smo kreirali metodu prosjek, pozvali smo tu metodu i prosljedili joj nasumican broj

argumenata : System.out.println(prosjek(2,4,6,19,20,21,40,12)) - sto ce prikazati vrijedost koja se

dobije pozivanjem metode prosjek sa prosljedjenim argumentima: 2,4,6 ,20.

~ 34 ~

Lekcija 36 : Time klasa

Mi cemo dozvoliti korisniku da unese tri vrijednosti za sate ,minute i sekunde i to ce biti konvertovano

u “military” vrijeme i regularno vrijeme (sta god to znacilo). Imacemo dve klase :Apples kao glavnu i

Tuna kao time klasu koja izgleda:

public class Tuna { private int hour; private int minute; private int second; public void setTime(int h, int m, int s){ hour=((h>=0 && h<24) ? h : 0 ); minute=((m>=0 && m<60) ? m :0); second=((s>=0 && s<60) ? s :0); } public String toMilitary(){ return String.format("%02d:%02d:%02d", hour, minute, second); } public String toString(){ return String.format("%d:%02d:%02d %s",((hour<=12)?hour:hour-12), minute, second, ((hour>12)? "PM":"AM")); }}

U Tuna klasi smo kreirali tri private promjenjive hour,minute,second tipa int kojima nismo dodjelili

vrijedosti.

Dalje imamo metodu setTime(int h, int m, int s), koja zahtjeva tri argumenta( tj. tri broja (tipa int ))

koja ce dodjeliti promjenjivima hour,minute i second. Ovo dodjeljivanje ce biti malo komplikovanije

jer ce prosljedjeni argumenti prvo morati da zadovolje odredjene kriterijume, “conditional

operatorima” se provjerava da li je broj validan, ako jeste postavalj se njegova vrijednost

odgovarajucoj promjenjivoj i ako nije umjesto tog broja postavlja se vrijednost. Primjer jednog

dodjelivanja : minute=((m>=0 && m<60) ? m : 0); - dakle imamo dva testa koji su spojeni

operatorom “ i “ (tj. && , sto znaci da oba testa moraju biti tacna), prvi test “ m>0 ” provjerava da li je

broj koji bih trebao prestavljati minutu ( m ) veci od 0, dok drugi test ( m<60 ) provjerava da li broj

koji bih trebao prestavljati minutu ( m ) manji od 60. Ako su oba testa tacna uzima se vrijednost m i

dodjeljuju se promjenjivoj minute, ako ova dva uslova nisu zadovoljena onda se promjenjivoj minute

dodjeljuje vrijednost 0.

Dalje smo napravili metodu toMillitary koja formatira ove brojeve u format vremena (dodace “ : “ , da

sve izgleda fensi) i vraca tu vrijedost. Zaglavlje metode: public String toMillitary()- String iz razloga

sto ce vracati String ( metoda je return tipa, ne void). toMilitary - je ime metode. U tjelu metode

ukucali smo : return String.format(“%02d:%02d:%02d”, hour , minte, second). format zahtjeva

dva argumenta prvi argument je : “%02d:%02d:%02d” , drugi argument je : hour , minte, second .

Znak % znaci da ce biti zamjenjen sa vrijednoscu iz argumeta2 dok 02d znaci da ce biti prikazano sa

dva decimalna mjesta.

Glavna klasa Apples izgleda:

Public class Apples { public static void main(String args[]){ Tuna tunaObject=new Tuna(); System.out.println(tunaObject.toMilitary()); tunaObject.setTime(13, 27, 6); System.out.println(tunaObject.toMilitary()); System.out.println(tunaObject.toString()); }}

~ 35 ~

U glavnoj klasi Apples smo kreirali objekat t1 koji je instanca klase Tuna , preko kojeg cemo pozivati

metode za postavljanje i formatiranje vremena.

Zatim smo napisali :System.out.println(tunaObject.toMilitary()); - s obzirom da nismo dodjelili

vrijedosti promjenjivima hour, minute, second (tj. nismo pozvali metodu setTime i prosljedili joj tri

broja koji respektivno trebaju predstavljati sat, minute i sekunde) dobili smo formatirane nule tj.

vidimo na drugoj liniji rezultata.

Dalje smo postavili vrijednosti : tunaObject.setTime(13,27,6) – Dakle poziva se metoda setTime i

prosljedjuju joj se argumenti 13 , 27, 6 koji ce u tjelu metode biti dodjeljeni promjenjivima hour,

minute i second respektivno.

Dok smo kucali tunaObject.setTime i otvorili zagradu da prosljedimo argumente u njoj se samo

pojavilo h , m , s . Sto je posljedica toga da ova metoda zagtjeva tri argumenta (tako smo definisali u

Tuna klasi , metoda setTime , kada smo je kreirali ).

I na posljetku imamo : System.out.println(tunaObject.toMilitary( )). tunaObject.toMillitary( ) –

vrijedosti koje smo postavili promjenjivima hour, minute, second pomocu metode setTime, formatira

da izgledaju kao vrijeme i vraca u obliku String-a, dok System.out.println koji enkapsulira

tunaObject.toMillitary prikazuje taj String na ekranu. Tj, 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. sadrzace am i pm i sati ce biti od 0

do 12. U klasu Apples ubacicemo metodu toString.

Metoda toSting je slicna metodi toMillitary samo sto ona malo drugacije formatira

%s u samom Stringu znaci da ce s biti zamjenjeno sa Stringom, dok %d znaci da ce d biti zamjenjeno

sa brojem , 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).

~ 36 ~

Lekcija 38 : Public, Private i this

U ovo lekciji cemo uciti kako kontrolisati pristup ralicitim promjenjivim u drugim klasama. Klasa

Tuna:

public class Tuna { private int hour = 1; private int minute = 2; private int second = 3; public void setTime(int hour, int minute, int second){ hour = 4; minute = 5; second = 6; } public String toMilitary(){ return String.format("%02d:%02d:%02d", hour, minute, second); } public String toString(){ return String.format("%d:%02d:%02d %s",((hour<=12) ? hour: hour-12 ), minute,second,((hour>12)? "PM":"AM")); }}

Klasa Apples:

public class Apples { public static void main(String args[]){ Tuna tunaObject=new Tuna(); System.out.println(tunaObject.toMilitary()); System.out.println(tunaObject.toString()); tunaObject.setTime(15, 27, 44); System.out.println(tunaObject.toMilitary()); System.out.println(tunaObject.toString()); tunaObject.hour=7; } }

Prvo cemo pricati o pristupu private promjenjivim (a to su promjenjive klase tuna: hour minute

second; ). Ono sto private znaci jeste da samo metode unutar te klase u kojoj se nalaze mogu koristiti

te promjenjive. Ako npr. Pokusamo pristupiti private promjenjivoj iz druge klase koristeci objekat

npr: t1.hour=7; , u toj liniji koda prikazace se x koje znaci da nesto nije u redu , kada dodjemo

strelicom misa do tog x pisace “The field Tuna.hour is not visible”. 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).

Svaki put kada imamo promjenjive sa istim imenima: npr. 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. U ovom primjeru instant promjenjive su private

promjenjive na pocetku klase Tuna tj : hour,minute i second, dok promjnjive sa istim nazivima imao i

u metodi setTime. Kao sto vidimo imena su im ista ali su vrijednosti drugacije. Instant promjenjive

imaju vrijednost 1,2,3 dok u setTime metodi imaju vrijednost 4,5,6. Kada pokrenemo program

dobicemo kao rezultat:

01:02:03

1:02:03 AM

01:02:03

1:02:03 AM

~ 37 ~

Kao sto vidimo koristene su instant promjenjive na pocetku. Ali ako unutar metode setTime prije

imena hour,minute i second stavimo this.ime , modifikovacemo setTime metodu:

public void setTime(int hour, int minute, int second){

this.hour= 4;

this.minute= 5;

this.second= 6;

}

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 . Kada se

pozove metoda , ona ce uzimati vrijednosti koje su dodjeljene instant promjenjivima ( vidimo na

rezultatu prvog izvrsavanja) . Medjutim ako mi zelim da se prvo koriste promjenjive unutar metode

ona ispred tih promjenjivih stavimo kljucnu rijec this. i zaobilazimo to pravilo. Vidimo na gornjem

izvrsavanju koda kada smo modifikoali metodu.

~ 38 ~

Lekcije : 39,40 i 41

Konstruktor je ustvari metoda koja ima isto ime kao i klasa u kojoj se nalazi. I kada god kreiramo

objekat on automatski pozove tu metodu ili izvrsi tu metodu. Ono sto nismo rekli jeste da mozemo

kreirati vise konstruktora ako svaki ima razlicite argumente. Klasa Tuna:

public class Tuna { private int hour; private int minute; private int second; public Tuna(){ this(0,0,0); } public Tuna(int h){ this(h,0,0); } public Tuna(int h, int m){ this(h,m,0); } public Tuna(int h, int m, int s){ setTime(h,m,s); } public void setTime(int h, int m, int s){ setHour(h); setMin(m); setSec(s); } public void setHour(int h){ hour=((h>=0 && h<24)? h:0); } public void setMinute(int m){ minute=((m>=0 && m<60)?m:0); } public void setSecond(int s){ second=((s>=0 && s<60)? s:0); } public int getHour(){ return hour; } public int getMin(){ return minute; } public int getSec(){ return second; } public String toMilitary(){ return String.format("%02d:%02d:%02d",getHour(),getMinute(),getSecond() ); } }

U zavisnosti koliko argumenata objekat ima on ce uzeti taj konstruktor koji ima isto toliko argumenata.

U klasi Tuna Napravili smo 4 konstruktora ,

1. Prvi konstrukor ,zaglavlje public Tuna( ){ this(0,0,0); } , ne zahtjeva parametre, tjelo: this(0,0,0); -

this poziva cetvrti konstruktor koji zahtjeva 3 argumena i prosljedjuje mu 0,0 i 0.

2. Drugi konstruktor, zaglavlje public Tuna(int h){ this(h,0,0) } – zahtjeva jedan parametar , tjelo :

this(h,0,0); - this poziva cetvrti konstruktor koji zahtjeva 3 argumena i prosljedjuje mu h,0 i 0.

3. Treci sa dva argumenta: public Tuna(int h, int m) , tjelo: this(h,m,0) - this poziva cetvriti

konstruktor koji zahtjeva 3 argumena i prosljedjuje mu h,0 i 0.

4. Cetvrti konstruktor, sa tri argumenta tj public Tuna (int h, int m, int s). Tjelo: setTime (h,m,s); -

sto znaci da poziva metodu setTime, i prosljedjuje joj tri argumenta.

~ 39 ~

Dalje imamo metodu setTime (int h, int m, int s) koja zahtjeva 3 parametra. U tjelu metode imaamo

3 instrukcije u kojima se pozivaju nove tri metode i prosljedjuje po jedan argument: prva : setHour(h);

, druga setMin(m); , i treca instrukcija: setSec(s); .

Public void setHour(int h){ hour=((h>=0 && h<24)? h:0); } – provjerava da li je sat u granicama tj.

da li je izmedju 0 i 24 ako nije onda ce vrijednost biti 0 . To smo isto uradili za minute i sekunde samo

sto smo se postarali da njihove vrijednosti budu izmedju 0 i 60.

Dalje napisali smo get metode samo da vratimo vrijednost npr:

public int getMinute(){ return minute; } –ono sto return minute; radi jeste da kada se pozove

metoda getMinute( ) , na mjestu gdje je pozvana metoda getMinute( ) isporucuje se vrijednost

promjnjive minute.

Zadnja metoda koju trebamo je format metoda tj. public String toMilitary() – koja formatira vrijeme.


public class Apples { public static void main(String args[]){ Tuna t1 = new Tuna(); Tuna t2 = new Tuna(5); Tuna t3 = new Tuna(5,13); Tuna t4 = new Tuna(5,13,43); System.out.printf("%s\n", tunaObject1.toMilitary()); System.out.printf("%s\n", tunaObject2.toMilitary()); System.out.printf("%s\n", tunaObject3.toMilitary()); System.out.printf("%s\n", tunaObject4.toMilitary()); }

Izgradili smo 4 Tuna objekta u glavnoj klasi i prosljedili im nula, jedan, dva i tri argumenta

respektivno, sto znaci da ce se obracati prvom, drugom, trecem odnosno cetvrtom konstruktoru u

zavisnosti od broja argumenata:

Za primjer t3 ima 2 argumenta(5 i 13). Tako da u klasi Tuna trazi konstruktor koji ima takodje 2

argumenta i nalazi ga: public Tuna(int h, int m) , koji u tjelu ima : this (h,m,0); – sto poziva

konstruktor Tuna koji zahtjeva tri argumenta , tj public Tuna (int h, int m , int s) i prosljedjuje mu :

5 , 13 , 0.

Takodje smo napisali kod da nam se prikazu vrijednosti promjenjivih hour, minute, second svakog

kreiranog objekta : t1, t2, t3 i t4 , i da ih formatira usput jedan od kodova izgleda :

System.out.printf(“%s\n”,tunaObject3.toMilitary( ));- u sklopu navodnika je nacin na koji ce biti

formatirano. %-znamo sta je , s-vazi za string dok \n-vazi za predji u novi red. Kada pokrenemo ovaj

program dobicemo :

00:00:00

05:00:00

05:13:00

05:13:43

~ 40 ~

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 . Koristicemo dve klase Aples i Potpie klasu :

public class Potpie { private int month; private int day; private int year; public Potpie(int m, int d, int y){ month = m; day = d; year = y; System.out.printf("The constructor for this is %s", this); } public String toString(){ return String.format("%d/%d/%d", month,day,year); } }

Prvo sto smo napravili jesu tri private promjenjive month,day i year. Zatim smo napravili Potpie

konstruktor : public Potpie( int m, int d, int y). U tjelu ovog konsturktora imamo : month =m; day=

d ; year =y; Sto znaci da ce private promjenjive month,day i year za novokreiranu instancu objekta

klase Potpie biti jedanke onome sto napisemo u zagradi kada budemo kreirali objekat tj. onome sto

prosljedimo umjesto int m ,int d, int y.

Dalje u tjelu imamo naredbu kojom provjeravamo da li nas konstruktor radi ili ne :

System.out.printf(“The connstructor for this is %s\n”, this) - ono sto je novo je ovo zadnje this.

this je upucivanje na objekat koji smo upravo izgradili koji koristimo svaki put kad pozovemo ovu

klasu. Ocigledno je da umjesto %s ide this. Ali this trebamo pretvoriti u String.

Svaki put kada treba String prikazivanje objekta , poziva se toString metoda. Vecinom metode

mozete nazvati kako zelite dok ovu morate striktno nazvati toString jer pisemo preko nje(tj. ona je vec

nasljedjena zajedno sa klasom Object) .

Dakle zaglavlje metode : public String toString( ). Dok u tjelu imamo :

return String.format(“%d/%d/%d”, month, day, year);

Glava Apples klasa izgleda:

public class Apless { public static void main(String args[]){ Potpie potObject1 = new Potpie(4,5,6); } }

Napravili smo potObject1 = new Potpie(4,5,6) - Dakle kreirali smo objekat sa parametrima 4,5,6. On

je u klasi Potpie nasao konstruktor sa koji zahtjeva 3 argumenta i popunio ih tj month=4 , day=5 ,

year=6. Taj konstrukotr ima takodje ima instrukciju System.out.printf(“the constructor for this is

%s\n”, this) – koji izbacuje na ekranu ovaj string , a umjesto %s imamo this koja prosljedjuje na

metodu toString koja ima instrukciju return String.format(“%d/%d/%d” month, day, year); - sto

ce formatirati brojeve 4,5,6 i prikazati ih kad pokrenemo ovaj program:

The constructor for this is 4/5/6

~ 41 ~

Lekcija 43 : Composition

Imamo 3 klase : Apples kao glavnu , Tuna i Potpie.Composition znaci da klasa umjesto da ima samo

reference na promjenjive i metode moze imati i reference na objekte. Izgled klase Tuna:

public class Tuna { private String name; private Potpie birthday; public Tuna(String theName, Potpie theDate){ name= theName; birthday= theDate; } public String toString(){ return String.format("My name is %s, my birthday is %s", name,birthday); } }

name - je promjenjiva koja ce skladistiti name tj ime. Dok je : private Potpie birthday - referenca za

Potpie Objekat. Zatim smo napravili konstrukor: public Tuna(String theName, Potpie the Date)-

dakle ovaj konstruktor ima dva argumenta prvi je String promjenjiva koju cemo nazvati theName,

Drugi je referenca za Potpie, theDate objekat.U tjelu metode imamo: name = theName; i Birthday

= theDate; .

Dalje smo napravili toString metodu: public String toString( ) , i u tjelu ove metode imamo :

return String.format(“My name is %s, my birthday is %s” name, birthday); - kada bude trazio

%s tj String za name uradice to jednostavno . Ali za birthday nema String koji se zove birthday .

birthday je referenca za theDate objekat. Ono sto ovo znaci , da svaki put kada zelimo String od

objekta , otice u svoju klasu(u ovom slucaju u Potpie) u toStirng metodu i dace nam podatke koje

zelimo. Dakle u ovoj metodi , gdje pise %s nemoramo nuzno prosljediti string promjenjivu , mozemo

prosljediti umjesto toga objekat. Svaki put kada prosljedimo objekat on gleda u klasu u kojoj se nalazi

i trazi toString metodu i daje nam podatke.


public class Apples { public static void main(String args[]){ Potpie potObject1 = new Potpie(4,5,6); Tuna tunaObject = new Tuna("Djordje", potObject1); System.out.println("\n"+tunaObject); } }

Prvo smo kreirali objekat potObject1 klase Potpie ciji se kod nalazi u lekciji prije, i prosljedili mu

argumente 4,5,6. Dalje smo napravili tunaObject (objekat klase Tuna) sa dva argumenta s obzirom da

Tuna konstruktor trazi dva argumenta (String theName, Potpie theDate), prvi argument je String:

Djordje a drugi je potObject1 koji smo malocas kreirali.Kada pokrenemo ovaj program dobicemo:

The constructor for this is 4/5/6

My name is Djordje, my birthday is 4/5/6

Composition se odnosi na objekte Iz drugih klasa kao clanovima npr u Tuna klasi private Potpie

birthday; je composition.

~ 42 ~

Lekcija 44 : Enumeration (nabrajanje)

U ovoj lekciji cemo graditi Enumeration (enum) . enum je nesto poput klase ali se koriste da “declare”

proglase konstante (promjenjive koje se nikad ne mjenjaju). Umjesto public class Tuna (sto je klasa)

mi enumeration kreiramo tako sto umjesto class napisemo enum tj. public enum Tuna . Primjer:

public enum Tuna { djordje("nice","20"), kelsey("cute","10"), julia("mistake","12"); private final String desc; private final String year; Tuna(String description, String birthday){ desc = description; year = birthday; } public String getDesc(){ return desc; } public String getYear(){ return year; }}

Prvu stvar koja se radi kada napravimo enum jeste da se nabroje objekti enum vrste. Mi smo napravili

tri : djordje(“nice”,”20”) , kelsey(“cute”,”10”), i julia(“mistake”,”12”);. Kao sto vidimo posli je

svake ide “ , ” a tek poslije zadje ide “ ; ” i tako Java zna da smo prestali sa “nabrajanjem”. Ove 3

konstante su u sustini objekti. Vidimo da u zagradi imaju par parametara (npr kod djordje imamo u

zagradi (“nice” i “20”). Sada s obzirom da smo napravili konstante/objekte i imace svoj komplet

promjenjivih u ovom enumeration. Stoga smo napravili dve promjenjive koje ce koristiti tj. private

final String desc; i private final String year; - final znaci da su ovo promjenjive kojima se ne mogu

naknadno mjenjati vrijednost .

Sada imamo 3 objekta/konstante (djordje,kelsey, julia ) i svaki ima komplet od vlastitih promjenjivih

jedan za description( desc) i jedan za godinu ( year ). Sada pravimo numeration konstruktor cije

zaglavlje izgleda : Tuna (String description, String birthday) . U tijelu konstruktora imamo :

desc = description ; i year = birthday; . Evo sta ce se desiti sa djordje : konstruktoru Tuna se

prosljedjuju parametri objekta djordje “nice” i “20” , String “nice” konstruktor postavlja kao

vrijednost desc promjenjive, dok String “20” konstruktor postavlja kao vrijednost year promjenjive.

Klasa Apples :

public class Apples { public static void main(String args[]){ for(Tuna people:Tuna.values()) System.out.printf("%s\t%s\t%s\n", people,people.getDesc(),people.getYear()); }}

U glavnoj klasi napravili smo pobloljsanu for petlju : for(Tuna people: Tuna.values()) - prvi

argument Tuna people -Tuna je ime klase , a people je promjenjiva(koja sluzi samo za ovu petlju)

kako se zovu nasi objekti dok petlja ide kroz njih. Tuna.values( ) – Svaki put kada napravimo

numeration Java sama napravi Array koji sadrzi konstante iz tog numeration-a. Dakle Tuna.values ( )

– je broj elemenata koji se nalaze u Array-ju koji je java sama napravila , dobijamo ih tako sto

napisemo Imenumerationa.values( ) . Daklje ova for petlja ce proci kroz svaki od konstanti : djordje,

~ 43 ~

kelsey , laura koji ce u tjelu petlje biti prestavljeni sa people. U tjelu poboljsane for petlje imamo :

System.out.printf(“%s\t%s\t%s\n”, people, people.getDesc( ),people.getYear( ) );

people – ce samo prikazati imena, people.getDesc( ) – uzima people objekat i koristi metodu getDesc,

koja ce vratiti vrijednost desc, dok ce people.getYear( ) , vratiti godine (tj year).

Kada pokrenemo program dobicemo :

djordje nice 20

kelsey cute 10

julia mistake 12

kljucna rijec final kod metoda znaci da se metode ne mogu redifinisati prilikom nasledjivanja klase.

~ 44 ~

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.util.EnumSet; pa izabrati od koje do koje konstante

da nam prikaze pomocu imeklase.range(od,do). Primjer je modifikovana Tuna enum iz prosle lekcije :

public enum Tuna { djordje("nice","20"), kelsey("cute","10"), julia("mistake","12"), nicole("italian","13"), candy("different","14"), erin("wish","16"); private final String desc; private final String year; Tuna(String description, String birthday){ desc=description; year=birthday; } public String getDesc(){ return desc; } public String getYear(){ return year; }}

dodali smo jos 3 konstante tj: nicole,candy i erin sa svojim atributima . Kada zelimo da prikazemo

samo dio konstanti onda u glavnoj klasi Apples ukucao:

import java.util.EnumSet; public class Apples { public static void main(String args[]){

for(Tuna people:EnumSet.range(Tuna.kelsey, Tuna.candy)) System.out.printf("%s\t\t%s\t\t%s\n",people,people.getDesc(),people.getYear(); } }

Java.util.EnumSet; - je ugradjena klasa koja nam omogucava da koristimo EnumSet.range .

Napravili smo novu poboljsanu for petlju for(Tuna people: EnumSet.range(Tuna.kelsey,

Tuna.candy)) – Umjesto Tuna.values kao u proslom primjeru mi smo napisali

EnumSet.range(Tuna.kelsey, Tuna.candy)) - to je metoda koja zahtjeva dva parametra (tj prvi

parametar (od kojeg elementa) , drugi do kojeg elementa). Kada pokrenemo ovaj program dobicemo :

kelsey cute 10

julia mistake 12

nicole italian 13

candy different 14

kao sto vidimo na ekranu su se ispisale konstante od kelsey do candy.

~ 45 ~

Lekcija 46: Static

U ovoj lekciji cemo govoriti o static promjenjivima. Kad god imamo klasu koja ima objekte svaki od

objekata ima svoje promjenjive(koje su samo njegove), ali nekada zelimo da svi objekti djele istu

promjenjivu. Napravili smo dve klase, Apples kao glavnu i Tuna. Klasa Tuna izgleda:

public class Tuna { private String first; private String last; public static int members=0; public Tuna(String fn,String ln){ first=fn; last=ln; members++; System.out.printf("Constructor for %s %s, member in the club %s\n",first,last,members); } }

Napravili smo dve private promjenjive ( first i last) , zatim smo napravili jednu promjenjivu koju ce

objekti djeliti tj. public static int members=0; static -znaci da svaki objekat djeli istu promjenjivu , i

ako se ona promjeni mjenja se za sve objekte. Dok bez static , ako promjenimo npr. first mjenja se

samo za taj objekat.

Glavna klasa Aples izgleda:

public class Apples { public static void main(String args[]){ Tuna member1 = new Tuna("Megan","Fox"); Tuna member2 = new Tuna("Natalie","Portman"); Tuna member3 = new Tuna("Taylor","Swift"); } }

Kao sto vidimo napravili smo 3 objekta : member1, member2 i member3 sa svojim parametrima npr

member1 sa parametrima (“Megan” i “Fox”). Kada kreiramo instancu Tuna klase npr. kod

member1, atributi se salju konstruktoru , pa ce se “Megan” poistovjetiti sa fn , dok ce se “Fox”

poistovjetiti sa ln. 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. members++).

Kada pokrenemo ovaj program dobicemo :

Construktor for Megan Fox, member in the club 1

Construktor for Natalie Portman, member in the club 2

Construktor for Taylor Swift, member in the club 3

~ 46 ~

Lekcija 47: More on Static

U ovoj lekciji cemo dovrsiti pricu o static promjenjivim. Klasa Tuna:

public class Tuna { private String first; private String last; public static int members=0; public Tuna(String fn,String ln){ first=fn; last=ln; members++; System.out.printf("Construktor for %s %s, member of the %s\n", first,last,members); } public String getFirst(){ return first; } public String getLast(){ return last; } public static int getMemb(){ return members; } }

U klasi iz prosle lekicje dodali smo 3 nove metode. Dve metode su public String (getFirst i getLast),

treca metoda je public static int getMemb( ) - static iz razloga sto ce raditi sa staticpromjenjivom.

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","Fox"); Tuna member2 = new Tuna("Natalie","Portman"); Tuna member3 = new Tuna("Taylor","Swift"); System.out.println("\n"+ member1.getFirst()); System.out.println(member1.getLast()); System.out.println(member1.getMemb()); } }


Construktor for Megan Fox, member of the 1

Construktor for Natalie Portman, member of the 2

Construktor for Taylor Swift, member of the 3

Megan

Fox

3

~ 47 ~

Vidmo da objekat member1 ima tri atributa: “Megan”, “Fox” i “3”. Sada cemo u glavnoj klasi

umjesto member1 staviti (u tri instrukcije : System.out.println(member2.getFirst( ),

System.out.println(member2.getLast( ) i System.out.println(member2.getMemb( ) ) staviti

member2 i pokrenuti program , dobicemo rezultate:

Natalie

Portman

3

Kao sto vidimo i member2 ima svoje jedinstvene podatke tj. “Natalie” i “Portman” , ali vidimo broj 3

koji smo imali i kod objekta 1. 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.

S obzirom da se static promjenjive ne mjenjaju izmedju objekata , static informacije su dostupne cak

i kada nemamo objekat npr:

public class Apples { public static void main(String args[]){ System.out.println(Tuna.getMembers()); } }

Recimo da izbrisemo objekte member1,2,3. 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.Tuna.getMembers( ); odnosno System.out.println(Tuna.getMembers());. Kada

pokrenemo ovaj kod dobicemo na kraju broj 3 sto je ta static promjenjiva pozvana na drugi nacin (tj

imeklase.metoda) .

~ 48 ~

Lekcija 48: final

U ovoj lekciji cemo objasniti sta znaci final prije promjenjive. Kreiracemo dve klase Apples u kojoj se

nalazi glavna metoda i klasu Tuna. Klasa Tuna izgleda:

public class Tuna { private int sum; private final int NUMBER; public Tuna(int x){ NUMBER=x; } public void add(){ sum+=NUMBER; } public String toString(){ return String.format("sum = %d\n", sum); } }

Napravili smo dve promjenjive. Prva: private int sum i druga private final int NUMBER; - kada god

stavimo final , to znaci da kad je jednom odredimo vise je ne mozemo mjenjati. Npr ako stavimo da je

private final int NUMBER=2; - to znaci da ce NUMBER biti 2 dovjeka. Dalje smo napravili

konstruktor : public Tuna(int x){ NUMBER=x; }. 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. Dalje smo napisali toString metodu( metoda koja pretvara objekat u

String),koja izgleda public String toString( ){ return String.format(“sum = %d\n, sum); }.

Klasa Apples izgleda:

public class Apples { public static void main(String args[]){ Tuna TunaObject = new Tuna(10); for(int i=0;i<5;i++){ TunaObject.add(); System.out.printf("%s", TunaObject); } } }

Napravili smo obicnu for petlju koja ce se vrtiti 5 puta. U tjelu for petlje smo pozvali add metodu da

se izvrsava ( na nacin da smo upisali TunaObject.add( ) , tj imeobjekta.metoda) . Zatim smo napisali

da se vrijednost promjenjive sum prikaze na ekranu pri svakoj iteraciji petlje : System.out.printf(

“%s” , TunaObject); . Kada pokrenemo ovaj program dobijemo rezultat:

sum = 10

sum = 20

sum = 30

sum = 40

sum = 50

~ 49 ~

Lekcija 49: Inheritance(nasljedje)

Uzmimo da imamo 4 klase : Apples u kojoj se nalazi glavna metoda, Tuna, Potpie i Food.Recimo da

svaka od ovih klasa (sem glavne) ima metodu pulic void eat( ){ System.out.println(“I am the eat

method); }. Dakle Klase Tuna i Potpie imaju istu metodu. Kada imamo klase koje se mogu svrstati u

novu klasu koja ima neke zajednicke karakteristike (metode,promjenjive..), tu karakteristiku napisemo

u toj Superklasi i kasnije pomocu extends mozemo nasljediti te karakteristike. Klase koje nasljedjuju

karakteristike su subclases a klasa od koje nasljedjuju je superclass. U ovom primjeru u klasi Food

cemo napisati metodu koja je zajednicka za Tuna i Potpie (tj. logicki svu hranu(food) ). Klasa Food

izgleda:

public class Food { public void eat(){ System.out.println("I am the eat method"); } }

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(); Potpie PotpieO = new Potpie(); tunaO.eat(); PotpieO.eat(); } }


I am the eat method

I am the eat method

U glavnoj klasi smo napravili dva objekta , jedan za klasu Tuna(tunaO) i drugi za klasu Potpie

(PotpieO) , i pozvali smo eat metodu ( tunaO.eat( ); tj. PotpieO.eat( ); ). Ali kao sto vidimo u

klasama Tuna i Potpie se ne nalazi nista, Kako se onda prikazuje eat metoda? U klasama Tuna i Potpie

imamo extends Food (tj. public class Tuna/Potpie extends Food) sto znaci da sve sto se nalazi u

Food klasi , Tuna i Potpie to nasljedjuju. Tako iako eat metoda nije vidljiva u ovim klasama ona

postoji pod uslovom da je public( ako je private onda nasljedjivanje nije moguce).

Ako npr. imamo dosta klasa koje su subklase Food superklase , i zelimo da malo modifikujemo tu

metodu sto se naljedjuje. To radimo tako sto je prakticno kopiramo (tj. kopiramo naziv) i promjenimo

~ 50 ~

ono sto zelimo promjeniti. U klasi Tuna cemo modifikovati eat metodu dok cemo Potpie ostaviti

nedirnutu. Klasa Tuna sada izgleda:

public class Tuna extends Food { public void eat(){ System.out.println("I am the new method of Tuna"); } }

Kao sto vidimo samo smo promjenili ovo u zagradi System.out.println. Sada kada pokrenemo

program:

I am the new method of Tuna

I am the eat method

Dakle iako imamo u nazivu klase Tuna , nasljedjivanje od Food klase , mi smo eat metodu nadjacali

tako sto smo je napisali u Tuna klasi. 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”.

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 , tako stvaramo hijerarhiju.

~ 51 ~

Lekcija 50: GUI (Graphics User Interface)

U ovoj lekciji cemo uciti kako se pravi aplikacija sa kojom korisnik moze imati interakciju i koja je

vidljiva korisniku. Java ima ugradjenu klasu koja skladisti sve komponente za Graficki Korisnici

Interfejs(tj. Meni, dialog box, scroll bar,Toolbar, padajuci meni, Title bar..). Ta klasa se zove

javax.swing.JoptionPane.

Primjer: napravicemo program u kojem cemo unijeti broj u jednom prozoru i kliknuti OK onda drugi

broj u drugom “box”(prozoru) i na kraju ce se pojaviti prozor sa zbirom ta dva broja. Evo kako taj kod

izgleda:

import javax.swing.JOptionPane; public class Apples { public static void main(String args[]){ String fn=JOptionPane.showInputDialog("Enter first number"); String sn=JOptionPane.showInputDialog("Enter second number"); int num1 = Integer.parseInt(fn); int num2 = Integer.parseInt(sn); int sum = num1+num2; JOptionPane.showMessageDialog(null,"The answer is " +sum,"the title",JOptionPane.PLAIN_MESSAGE); } }

Na pocetku smo ukucali import javax.swing.JOptionPane - sto znaci da unosimo klasu koja sadrzi

komponente za graficki prikaz(tj. javax.swing.JOptionPane). Dalje smo napravili dve String

promjenjive. Prva je fn tj. String fn = JOption.showInputDialog(“Enter first number”).

JOptionPane.showInputDialog je ustvari klasa.metoda (klasa je JOptionPane , dok je metoda

showInputDialog). showInputDialog – je metoda za unos dok u zagradi je ono sto ce pisati u tom

prozoru i sta ce govoriti korisniku sta da uradi/unese. Isto je sa promjenivom sn .

S obzirom da je showInputDialog metoda u mogucnosti samo da radi sa Stringom (slova,brojevi koji

nemaju svojstvo brojeva), a mi zelimo da sabiramo brojeve mi moramo da konvertujemo fn i sn u int

promjenjive (da bih mogli vrsiti matematicke operacije nad njima). U ovom primjeru to smo uradili

tako sto smo ukucali: int num1 = Integer.parseInt(fn); - ono sto ovo radi jeste da konvertuje ono sto

je u zagradi tj. fn i smjesta je u promjenivu num1 tipa int. Isto smo uradili i sa String promjenjivom

sn. Onda smo napisali kod da se saberu ova dva broja tj: int sum = num1 + num2 .

Na kraju treba da se prikazu ti rezultati tako sto smo napisali: JOptionPane.showMessageDialog

(null,” answer is ”+ sum, “the title”, Joption.PLAIN_MESSAGE); showMessageDialog – je

metoda za prikazivanje koja zahtjeva cetri parametra. Prvi parametar odredjuje gdje ce se pokazati

prozor (mi smo stavili null sto znaci da se pojavi na sredini ekrana). Drugi parametar je sta zelimo da

se prikaze u tom prozoru ( mi smo stavili “The answer is “+ sum ). Treci parametar je naslov koji ce

pisati na tom prozoru (tj. title bar). Cetvrti parametar cemo objasniti kasnije (mi smo stavili

JOptionPane.PLAIN_MESSAGE).

~ 52 ~

prozor: 3

Kada pokrenemo ovaj program , dobicemo prozor koji izgleda:

onda treba da ukucamo broj i stisnemo OK

mi smo stavili broj 5 i kada kliknemo na OK dobijemo drugi prozor:

mi smo stavili broj 3 i kliknuli OK i dobili zadnji prozor koji izgleda:

Kao sto vidimo tacno su sabrana dva broja 5 i 3 i rezultat nam je prikazan u zadnjem prozoru br. 3 . U

formi “The answer is 8” .

prozor: 1

prozor: 2

~ 53 ~

Lekcija 51: GUI with Jframe

Za razliku od prosle lekcije gdje smo gradili graficki korisnicki interfejs koji bi izgledao isto bez

obzira na kojem operativnom sistemu ga pokrenuli. Sada cemo napraviti interfejs koji kad pokrenemo

na Windows OS on nasljedi sav izgled od Windows OS. Takodje kad ga pokrenemo na Mac OS on ce

nasljediti sav izgled od Mac OS. Koristicemo dve klase Apples (glavna) i Tuna. Tuna klasa izgleda:

import java.awt.FlowLayout; import javax.swing.JFrame; import javax.swing.JLabel; public class Tuna extends JFrame{ private JLabel item1; public Tuna(){ super("The title bar"); setLayout(new FlowLayout()); item1 = new JLabel("this is a sentence"); item1.setToolTipText("This is gonna show up on hover"); add(item1); } }

Kao sto vidimo na samom pocetku smo unijeli (inportovali) tri klase:

1) Java.awt.FlowLayout – ovo ce unijeti kako su stvari postavljene , ovo je ustvari tlocrt ili

raspored. Dace nam default raspored (stavi ovo ovde, kad izgradim novo stavi desno od toga ,

kada izgradim novo stavi desno, i kad ponestane prostora predji u sledeci red)

2) Javax.swing.Jframe; - daje nam osnovne karakteristike prozora kao npr. Titlebar, x, close

,minimaze , maximaze. Daje nam prosti prozor, mi zelimo koristiti ono sto vec imamo , zato

inportujemo ovo.

3) Javax.swing.JLabel – ovo je ono sto cemo graditi , Label je ustvari samo linija teksta. Takodje

nam omogucava da radimo jednostavne slike. Dakle omogucava nam da ubacimo tekst i slike u

prozor.

Klasa Tuna je nasljedila JFrame , tj. sada klasa Tuna imamo sve karakteristike osnovnog prozora.

Sada kad je Tuna nasljedila sve te karakteristike napravili smo promjenjivu na nacin: private JLabel

item1;- JLabel je vrsta promjenjive , item1 je ime promjenjive.(Ovo ce ustvari biti item(“stvar”) koju

dodajemo u prozor.

Dalje smo napravili konstruktor: public Tuna( ) , u tjelu konstruktora imamo: super(“The titel bar”)

– sto je ustvari ono sto ce pisati u naslovnoj liniji. To dakle radimo tako sto ukucamo super i u zagradi

ono sto ce biti u naslovnoj liniji. Sledeca stvar koju cemo uraditi jeste da cemo postaviti raspored tj.

SetLayout( new FlowLayout( ) ) - ovo nam daje standardni “layout”. Sada cemo graditi stvar koju

zelimo imati na ekranu (vec smo je nazvali item1): item1 = new JLabel(“this is a sentence”); - sada

imamo tekst na ekranu koji kaze “this is a sentence”. Sada cemo dodati teks koji ce se prikazati kada

predjemo preko svoga “item-a” na nacin sto smo ukucali : item1.setToolTipText(“This is gonna

show up on hover”); . Na posljetku moramo dodati item1 u prozor: to je jednostavno ukucamo

add(item1) tj add(/*ime promjenjive/stvari koju zelimo dodati u prozor*/). Moramo imati na umu da

svaki item koji napravimo moramo dodati u prozor na ovaj nacin.

~ 54 ~


import javax.swing.JFrame; public class Apples { public static void main(String args[]){ Tuna TunaO = new Tuna(); TunaO.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); TunaO.setSize(275,180); TunaO.setVisible(true); } }

U glavnu klasu smo takodje inport-ovali javax.swing.JFrame ( objasnjenje ) – iz razloga sto nam

daje osnovne karakteristike prozora.

Dalje smo napravili objekat TunaO bez argumenata. Ovaj objekat koji je prilicno prozor sa linijom

teksta u njemu. Sada cemo postaviti kako zelimo da se nas program zatvara , napisali smo:

TunaO.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); - u zagradi se nalazi nacin na koji

zelimo da se nas program zatvara. Svaki put kada pritisnemo x dugme program prestaje . Da nemamo

ovo program bi bio zamrsen. TunaO.setSize(275,180); - odredili smo velicinu prozora.

TunaO.setVisible(true);- znaci da je program vidljiv .

Kada pokrenemo ovaj program dobijemo:

Kada predjemo misem preko “this is a sentence “ dobijemo :

~ 55 ~

Lekcije:52,53,54 , Event Handling

Event je bilo sta korisnik moze da uradi(pomjeri mis, pritisne neku tipku). Event handler je kod koji

reaguje na to sto korisnik moze da uradi (tj. event). Cjeli ovaj proces se zove Event Handling.

U ovim lekcijama cemo izgraditi prozor i neke textbox-ove unutar njega , i kad god korisnik unese

nesto u taj text box i pritisne ENTER , event handler ce izbaciti novi prozor.

Napravicemo dve klase. Glavna:Apples i klasu Tuna koja izgleda:

import java.awt.*;//FlowLayout,ActionListener,ActionEvent. import javax.swing.*;//JFrame,JTextField,JpasswordField,JOptionPane public class Tuna extends JFrame { private JTextField item1; private JTextField item2; private JTextField item3; private JPasswordField passwordField; public Tuna(){ super("The title"); setLayout(new FlowLayout()); item1=new JTextField(10); add(item1); item2= new JTextField("enter text here"); add(item2); item3=new JTextField("uneditable",20); item3.setEditable(false); add(item3); passwordField = new JPasswordField("mypass"); add(passwordField); thehandler handler = new thehandler(); item1.addActionListener(handler); item2.addActionListener(handler); item3.addActionListener(handler); passwordField.addActionListener(handler); } private class thehandler implements ActionListener{ public void actionPerformed(ActionEvent event){ String string = ""; if(event.getSource() == item1) string=String.format("field 1 : %s", event.getActionCommand()); else if(event.getSource() == item2) string=String.format("field 2: %s", event.getActionCommand()); else if(event.getSource() == item3) string=String.format("field 3: %s", event.getActionCommand()); else if(event.getSource() == passwordField) string=String.format("pass field is : %s" ,event.getActionCommand()); JOptionPane.showMessageDialog(null, string);

} } }

~ 56 ~

Prvo smo inportovali(unijeli) sledece klase :

import java.awt.FlowLayout; - daje nam raspored.

import java.awt.event.ActionListener; - slusa ili bolje receno ceka da korisnik uradi neki

event.

import java.awt.event.ActionEvent; - ovo su ti event-i.

import javax.swing.JFrame; -

import javax.swing.JTextField; - Text field je mjesto gdje mozemo ukucati tekst

import javax.swing.JPasswordField; - PassworField je takodje mejsto gdje mozemo ukucati

tekst samo sto je , samo sto ga sakrije (umjesto karaktera vidimo ***** ili ••••••••)

import javax.swing.JOptionPane;

Dalje smo nasljedili sve stvari od JFrame u Tuna klasu tj ukucali smo public class Tuna extends

JFrame, Ustvari smo sada napravili prozor i mozemo stavljati “stvari” u njega.

Onda smo napravili promjenjive:

private JTextField item1;



private JpasswordField passwordField;

Dalje smo napravili konstruktor(ustvari to je nas prozor): public Tuna(). U tjelu konstruktora smo

ukucali super(“The title”); - napravili smo naslovnu liniju i nazvali smo je “The title”. Dalje smo

odredili raspored u prozoru tako sto smo ukucali setLayout( new FlowLayout()); - uzeli smo jedan

standarni iz “klasa” koje smo inportovali. Sada kada imamo naslovnu liniju I raspored mozemo

dodavati “stvari” u prozor. Dodali smo:

item1 = new JTextField(10);

add(item1);

item2 = new JTextField("enter text here");

add(item2);

item3 = new JTextField("uneditable",20);

item3.setEditable(false);

add(item3);

passwordField = new JPasswordField("mypass");

add(passwordField);

item1,item2 i item3 su obcni “Text field” (tj. mjesto gdje mozemo kucati tekst u prozoru). S tim da

item1 je ima duzinu 10(iz razloga sto ima 10 u zagradi, to se ne odnosi na to koliko slova mozemo

ukucati vec na to kolika ce polje biti prikazano u prozoru ). Item2 je isto sto i item1 samo sto cemo

imati “default” tekst unutra , tj. “enter text here” . item3 je malo drugacije jer smo , u zagradi smo

stavili da pise u polju “uneditable” , i stavili smo duzinu 20. Pored toga u sledecoj liniji koda smo

ukucali item3.setEditable(false); - sto znaci da se ovo polje nemoze mjenjati , dakle

promjenjiva.setEditable(false) nam omogucava da zastitimo neki tekst unutar naseg prozora.

passwordField = new JpasswordField(“mypass”); - znaci da smo prilicno kreirali mjesto u prozoru

koje takodje pokazuje tekst ali koji mi vidimo kao **** iil kao •••••• . Moramo primjetiti da kada

kreiramo tekst field ili password fied da ga moramo naknadno dodati u prozor tako sto upisemo

add(item1) tj. add(/*ono sto zelimo dodati(ono sto zelimo staviti u prozor)*/). Sada imamo prozor sa

4 polja .

Sada cemo dodati malo funkcionalnosti ovom prozoru. Npr kada korisnik ukuca nesto i pritisne

ENTER u ova polja da se pojavi prozor koji ce nam prikazati sta smo ukucali u njemu.

Prvu stvar koju cemo uraditi jeste da cemo napraviti objekat za klasu thehandler koju cemo naknadno

napraviti.tj:

~ 57 ~

Thehandler handler = new thehandler( ); - napravili smo objekat za klasu thehandler . Dalje smo

dodali ovaj objekat(handler) svakom “item-u” , tj:

item1.addActionListener(handler);



passwordField.addActionListener(handler);

to smo uradili sto smo ukucali: imepromjenjive.addActionListener(/*objekat kojem zelimo dodati*/).

Mi mozemo unutar klase napraviti klasu , s tim da klasa koja se nalazi unutar nasljedjuje sve od klase u

kojoj se nalazi. Mi smo unutar Tuna klase napravili private class thehandler implement

ActionListener{ . – ovo ce biti klasa koja upravlja eventim-a. U ovoj klasi cemo napisati samo jedan

metod , to je metod koji ce biti pozvan automatski kada se event javi. Metod:

public void actionPerformed(ActionEvent event){ String string = ""; if(event.getSource()==item1) string=String.format("field 1 : %s", event.getActionCommand());

else if(event.getSource()==item2) string=String.format("field 2: %s", event.getActionCommand()); else if(event.getSource()==item3) string=String.format("field 3: %s", event.getActionCommand());

else if(event.getSource()==passwordField) string=String.format("password field is : %s", event.getActionCommand());

JOptionPane.showMessageDialog(null, string);

dakle public void actionPerformed(Action Event event) –je ime te metode. U metodi smo napravili

promjenjivu string koja je jedanka praznom stringu. Dalje smo napravili veliku if izjavu.

If (event.getSource( ) = item1) – event je ono sto ce korisnik uraditi( u ovom primjeru kad pritisne

ENTER), getSource( ) – prilicno znaci gje se to dogodilo. Cjela ova izjava : if(event.getSource(

)=item1 –znaci ako korisnik pritisne ENTER na tekst polju 1 , sta mi zelimo da se desi . Ako je true

izvrsice se : string=String.format(“ field1 : %s”, event.getActionCommand( )); ako je false imamo

novi else if test za item2 , item3 i passwordField .

event.getActionCommand( ) – getActionCommand( ) znaci uzmi tekst sa te lokacije.

Ono sto ova metoda(actionPerformed) ustvari radi jeste: Ako korisnik ukuca nesto u polju 1 i pritisne

ENTER , promjenjiva string ce biti jednaka field1 : /*sta god da je korisnik ukucao*/. Isto tako je I za

polje2, polje3, i password polje .

Zadnja stvar koju cemo ukucati u ovoj metodi je: JOptionPane.showMessageDialog(null, string); -

tj prikazacemo to na ekranu sta korisnik ukuca. JOptionPane – je prazan prozor . U zagradi imamo

null i promjenjivu string koja ce biti prikazana u tom prozoru.

Da bismo handle (rukovali) eventima definitivno je potrebno imati Event Handling klasu koja

implementira ( ono sto implement ActionListener znaci jeste da ce klasa handle imati odredjene

kvalitete , kao sto je sposobnost da zovne specificne metode u ovom slucaju actionPerformed. Kada

imamo klasu mozemo i napraviti i objekat koji predstavlja tu klasu u ovom slucaju handler. Dakle

svaki put kada nesto koristi taj objekat upucuje se na klasu thehandler. Taj objekat smo dodali

svakom od promjenjivih na nacin sto smo ukucali item1.addActionListener(handler),

item2,3.addActionListener(handler); i passwordField.addActionListener(handler). Sada smo

svakom od ovih stvari(item1,item2,item3, passworField) dali malo funkcionalnosti , prije su samo

postojale , a sada kada pritisnemo ENTER one rade nesto. A to sto ce raditi nalazi se u public void

actionPerformed(actionEvent event) metodi. Ovaj metod mora postojati i mora se zvati

actionPerformed (ovo je ugradjena metoda koja ima veze sa ActionListener klasom).

~ 58 ~

Dakle ova metoda se izvrsava automatski kada korisnik pritisne ENTER. Prvo napravi promjenjivu

string zatim testira kako zelimo da taj string izgleda i na kraju ga prikazuje :

JOptionPane.showMessageDialog (null, string);

Sada mozemo preci u glavnu klasu Apples koja izgleda:

import javax.swing.JFrame; public class Apples { public static void main(String args[]){ Tuna TunaO = new Tuna(); TunaO.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE ); TunaO.setSize(350,100); TunaO.setVisible(true); } }

Prvo smo inportovali (unijeli) javax.swing.JFrame; da bi smo mogli koristiti prozore u nasoj glavnoj

metodi. Zatim smo napravili objekat TunaO. Dalje smo mu definisali operaciju za izlazak na nacin sto

smo ukucali: TunaO.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE ); . Zatim smo

definisali velicinu prozora: TunaO.setSize(350,100); i podesili da nam prozor bude vidljiv tj:

TunaO.setVisible(true);


Kada ukucamo nesto u polje 1 npr. bla i pritisnemo ENTER dobicemo :

S obzirom da je polje 3 zasticeno , i ono sto pise uneditable ne mozemo promjeniti kada ukucamo

nesto u polje 4 , tj password polje , npr bla izgledace:

Tj umjesto bla ce biti prikazano ••• , a kada pritisnemo ENTER, u novom prozoru otkrice nam se to sto

smo napisali u passwor field-u :

~ 59 ~

Lekcija 55: Intoduction to Polymorphism

Da bi smo demonstrirali polimorfizam moramo napraviti program koji koristi nasljeđivanje. Mi smo

napravili 4 klase :glavna klasa Apples, klasa Tuna i Potpie koje su subklase klase Food (superklasa).

Klasa Food:

public class Food { public void eat(){ System.out.println("this food is great"); } }

Klasa Tuna:

public class Tuna extends Food{ public void eat(){ System.out.println("this Tuna is great"); } }

Klasa Potpie:

public class Potpie extends Food{ public void eat(){ System.out.println("this Potpie is great"); } }

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.

Kada kreiramo objekte npr za Tuna klasu mi bi smo ukucali: Tuna tunaO = new Tuna( ); - vidimo da

na dva mjesta imamo Tuna. Zasto nam to treba? Prvo Tuna i zadnje Tuna nisu isto. tunaO je

refernce variable (reference znaci upucivanje, preporuka,..) , 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) , tako da moze kontrolisati Tuna vrstu podataka ,a tunaO je objekat vrste

Tuna (iz razloga sto tunaO= new Tuna( ); ).

Npr ako napisemo ovako Food tunaO = new Tuna( ); - I ovo je poprilicno uvod u polimorfizam. Ne

samo da je TunaO od Tuna vrste podataka vec je TunaO takodje i Food vrsta podataka. Ono sto sad

mozemo uraditi , bilo sta sto nasljedjuje od superklase (tj. Food-a) moze biti assigned (dodjeljen)

objektu tunaO. Tuna( ) s obzirom da nasljedjuje od Food moze biti dodjeljeno tunaO.

Kako ovo moze biti korisno, pokazacemo na primjeru , glavna klasa Apples izgleda :

public class Apples { public static void main(String args[]){ Food djordje[]=new Food[2]; djordje[0]=new Tuna(); djordje[1]=new Potpie(); for(int x=0;x<2;++x){ djordje[x].eat(); } } }

Najbrzi primjer kojim mozemo objasniti jeste da napravimo polymorphic Array i on skladisti objekte

od razlicitih klasa u prilicno superklasa vrsti.

~ 60 ~

Napravili smo : Food djordje[ ] = new Food[2]; - djordje[ ] – je Array objekat , i ovaj objekat je

Food vrste (iz razloga sto se ispred djordje [] nalazi Food ) , s obzirom da imamo nesto Food vrste on

moze “hold” (drzati,posjedovati) objekte Tuna i Potpie (iz razloga sto su Tuna i Potpie subklase

superklase Food ).

Jedan od razloga koriscena polimorfizma su polymorphics arrays , i to bi bilo nesto poput ovoga:

For(int x=0;x<2;++x){ bucky[x}.eat( ); } – ono sto ovo radi jeste da ide kroz svaki od ovih objekata i

zove eat metodu. Prvo ide kroz prvi objekat djordje[0] kome je dodjeljenja Tuna klasa i zove tu

metodu (eat). Zatim ide kroz drugi objekat djordje[1] kome je dodjeljena Potpie klasa i zove eat

metodu. Ono sto ovo radi jeste da ide kroz svaki od objekata i zove eat metodu za svaki. Kad

pokrenemo ovaj program dobicemo :

this Tuna is great

this Potpie is great

~ 61 ~

Lekcija: 56 Polymorphic Arguments

Imamo 5 klasa:

Klasa Fatty:

public class Fatty { public void digest(Food x){ x.eat(); } }

Klasa Food:

public class Food { void eat(){ System.out.println("This food is great"); } }

Klasa Potpie:

public class Potpie extends Food{ void eat(){ System.out.println("This Potpie is great"); } }

Klasa Tuna:

public class Tuna extends Food{ void eat(){ System.out.println("This Tuna is great"); } }

Za razliku od prosle lekcije u ovoj imamo jos jednu klasu Fatyy, u kojoj imao digest metodu tj:public

void diges (Food x) { x.eat( ); } , Kao sto vidimo u zagradi imamo(parametar) Food x sto znaci da ce

uzimati Food objekat. Sada mozemo uraditi nesto sa tim objektom. x samo znaci da ce se u toj metodi

x odositi na taj objekat. U tjelu digest metode imamo x.eat( ); sto znaci da na Food objekat koji

prosljedimo bice primjenjena metoda eat( ) .

Osim sto metoda digest moze prihvatiti Food objekat, ona takodje moze prihvatiti i svaki objekat

subklase ( u ovom primeru subklase superklase Food su Tuna i Potpie.

I Glavna klasa Apples:

public class Apllses { public static void main(String args[]){ Fatty djordje = new Fatty(); Food fo = new Food(); Food po = new Potpie(); djordje.digest(fo); djordje.digest(po); } }

Prvo smo napravili Fatty objekat i nazvali ga djordje. Zatim smo napravili Food objekat i nazvali ga

fo. 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 , kod objekta po imao Food na pocetku i

Potpie( ) na kraju) .

~ 62 ~

Zasto smo uopste napravili Food objekat? Zato sto u klasi Fatty metoda digest uzima argument koji je

Food objekat.

djordje.digest(fo); - iz klase Fatty (pomocu objekta djordje) smo pozvali metodu digest koja zahtjeva

jedan argument tj. Food objekat , fo je upravo taj Food objekat. Takodje mozemo kao argument uzeti

bilo koji objekat cija je klasa subklasa superklase Food .

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.digest(fo) , djordje je Fatty objekat, digest je Fatty

meteoda , dok je ovo u zagradi argument tj. u ovom slucaju fo ( objekat klase Food).

2) Kada odemo u klasu Fatty do metode digest vidimo da ona zahtjeva jedan Food objekat , koji

smo mi dali (fo). Metoda digest tom Food objektu dodjeljuje ime x koje koristi unutar te

metode( bilo koji Food objekat bi dobio to ime) .

3) Unutar digest metode imamo instrukciju x.eat ( sto u stvari znaci fo.eat), dakle ide dalje do eat

metode u klasi Food ( jer je fo objekat klase Food ).

4) Metoda eat u klasi Food ima instrukciju(System.out.println(“This food is great”); ) koja se

izvrsava i na ekranu se prikazuje “This food is great”

“This Potpie is great” se pokazalo na slican naci , sto je demonstracija da umjesto Food objekta kao

parametar mozemo prosljediti bilo koji objekat koji predstavlja subklasu Food superklase.

~ 63 ~

Lekcije: 57 Overriding Rules (najvaznija pravila) i 58 Abstract and Concrete

classes

Klasa Fatty:

public class Fatty { public void digest(Food x){ x.eat(); } }

Klasa Food:

public class Food { void eat(){ System.out.println("This food is great"); } }

Klasa Potpie:


Klasa Tuna:


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. U prosloj

lekciji smo imali 5 klasa : glavnu Apples, superklasu Food, subklase klase Food: Tuna i Potpie , i

klasa Fatty. U subklasama Tuna i Apples smo “overwrite” metodu eat( ) koja se nalazi takodje u

superklasi Food . 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(

) , 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 ). Isto tako moramo i vratiti “return” istu

stvar. Npr ako vracamo int u super klasi moramo vratiti int i u subklasama. Ova pravila postoje da bih

smo imali consistency (dosljednost tj. konzistencija) a to nam osigurava da bilo kad pozovemo metodu

, garantuje nam da mozemo koristiti i subklasu takodje( npr. Kod klase Fatty gdje digest metoda

zahtjeva jedan Food objekat, 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 takodje kad god overvrite metodu ne mozemo mjenjati iz public u private.

“Overloded” (preklopljena) metoda je metoda sa istim imenom ali koja ima drugacije argumente. To

je potpuno nova metoda.

~ 64 ~

Klase Tuna i Potpie mogu imati neke svoje argumente tipa : boja oblik, miris, okus… , dok njihovoj

superklasi Food ne mozemo odrediti takve argumente , zato sto je Food(hrana) sirok pojam , neznamo

joj boju, oblik, miris, okus.. Postoje neke klase (npr Food) koje su previse opste i za koje ne zelimo

praviti objekte. 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.

Klase koje nemaju abstract zaglavlju klase , se zovu concrete (konkretan – stvaran, koji se moze

opaziti culima ; 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”. Kada napravimo apstract metodu potrebno je da u superklasi da napisemo metodu bez

tjela tj samo glavu metode. Npr. Apstraktna klasa Food, 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.

Klasa Tuna:


I klasa Potpie:


Dakle kada god imamo apstraktnu metodu u superklasi(npr. eat metoda u Food klasi) , sve subklase (u

ovom primjeru Tuna i Potpie ) moraju imati tu metodu ili drugim rjecimo sve subklase moraju da

“implement” ili “overvrite” tu metodu. Ako subklase nemaju tu metodu pojavice se error u liniji gdje

se nalazi glava klase ili header(zaglavlje). Implement znaci prilicno da moramo “overvrite”

apstracktne metode.

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.

~ 65 ~

Lekcija: 59 Class to Hold Object

U ovoj lekciji cemo napraviti program koji uzima klasu i stavlja objekte u array. Scenario je ovakav :

Imamo 4 klase: Glavna Apples, superklasu Animals, njene subklase Dog i Fish . I treba da napravimo

novu klasu DogList u kojoj cemo napraviti array koji ce skladistiti objekte klase Dog.

Klasa Dog:

public class Dog { }

Klasa Animals:

public class Animal { }

Klasa DogList:

public class DogList { private Dog[] thelist = new Dog[5]; private int i=0; public void add(Dog d){ if(i<thelist.length){ thelist[i]=d; System.out.println("Dog added at index "+i); i++; } } }

Prvo smo napravili array: private Dog[ ] the list = new Dog[5] – Dog[ ] znaci da cemo u ovom array

skladistiti Dog objekte , thelist je ime array-ja dok Dog[5] znaci da ovaj array skladisti 5 Dog

objekata. Dallje smo napravili promjenjivu i koju cemo koristiti kao brojac(counter). Zatim smo

napravili metodu pomocu koje cemo dodavati Dog objekte cije zaglavlje izgleda: public void

add(Dog d) - u parametrima smo definisali da ce primati Dog objekte i da ce oni u ovoj metodi biti

prestavljeni sa d. U tjelu metode smo napravili if statement: if(i < thelist.length) i ako je ovaj uslov u

zagradi ispunjen (tj. provjerava da li je array pun ili ne) ako nije dodaje taj objekat i pripisuje mu

indeks i (cija je pocetna vrijednost postavljena na nula) tj: thelist[i]=d ili imearray-a[indeks]=d; .

System.out.println(“Dog added at index “ +i); nam prikazuje sta se ustvari desava. i++; se povecava

da ne bih pripisali/dodali istom indeksu novi objekat.


public class Apples { public static void main(String args[]){ DogList DLO = new DogList(); Dog d = new Dog(); DLO.add(d); } }

Napravili smo Doglist objekat i nazvali ga DLO i Dog objekat koji smo nazvali d. Zatim smo pomocu

DLO objekta iz DogList klase pozvali metodu add i stavili u parametrima objekat d koji predstavlja

klasu Dog.


Dog added at index 0

~ 66 ~

Lekcija: 60 Array Holding Many Objects

U prosloj lekciji smo napravili Array koji skladisti Dog objekte, ali sada je potrebno da napravimo

Array koji ce da sadrzava Fish objekte. Mozemo predpostaviti posto ima mnogo zivotinja da bih smo

mogli dobiti zahtjev da napravimo Array koji ce sadrzavati objekte od : Cat, Dolphin, Whale i koliko

vec postoji zivotinja. Zato umjesto da za svaku ponaosob klasu pravimo poseban Array mi cemo

napraviti Array koji ce biti univerzalan za sve zivotinje. Imamo 5 klasa: glavnu Apples, superklasu

Animals njene subklase Fish i Tuna, i univerzalnu AnimalList klasu koja ce imati Array koji ce biti u

mogucnosti da skladisti bilo koji objekat koji je predstavnik klase koja nasljeđuje klasu Animals (po

logici tu spadaju sve zivotinje). Klasa Fish:

public class Fish extends Animal{ }

Klasa Dog:

public class Dog extends Animal{ }

Klasa Animal:

public class Animal { }

Klasa AnimalList:

public class AnimalList { public Animal[] TheList = new Animal[5]; public int i=0; public void add(Animal a){ if(i<TheList.length){ TheList[i]=a; System.out.println("Animal added at index "+ i); i++; } } }

Glavna Klasa Apples:

public class Apples { public static void main(String args[]){ AnimalList ALO = new AnimalList(); Dog d = new Dog(); Fish f = new Fish(); ALO.add(d); ALO.add(f); } }


Animal added at index 0

Animal added at index 1

Ovaj kod je identican onom iz prosle lekcije samo sto smo sada umjesto da pravimo za svaku novu

klasu Array , izgradili jedan univerzalni u klasi AnimalList i za koju god subklasu superklase Animal

(tj. za bilo koju zivotinju) nam zatreba taj Array imamo ga vec kreiranog.

~ 67 ~

Lekcija: 61 Simple Polymorphic Program

Napravicemo primjer na kome cemo prikazati kako polimorfizam moze biti koristan. Napravili smo 4

klase: Glavna Apples, superklasa Animal, subklase Dog i Fish.

Klasa Animal:

public class Animal { public void noise(){ System.out.println("Animals don't make noise"); }}

Klasa Dog:

public class Dog extends Animal{ public void noise(){ System.out.println("Dog: Ruff"); }}

Klasa Fish:

public class Fish extends Animal{ public void noise(){ System.out.println("Fish: Glurp Slurp "); }}

Dakle napravili smo noise metodu u klasi Animal , zatim smo istu tu metodu “overvrite” u klasama

Dog i Fish.


public class Apples { public static void main(String args[]){ Animal[] thenoiselist = new Animal[2]; Dog d = new Dog(); Fish f = new Fish(); thenoiselist[0]=d; thenoiselist[1]=f; for(Animal x:thenoiselist) x.noise(); } }

Prvo smo napravili Array thenoiselist , koji ce sadrzavati objekte tipa Animal (tj. moze sadrzavati

objekte svih njenih subklasa). Zatim smo napravili objekte d i f koji predstavljaju klase Dog odnosno

Fish. Onda smo napravljenom Array-u dodjelili te objekte , tj. povezali smo indekse i objekte(

thenoiselist[0]=d i 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. U tjelu petlje imamo : x.noise( ) sto u

stvari znaci da kada petlja prodje kroz Array uzmima tekući element(tj. objekat) dodjeli mu

indetifikator x i pokrene metodu noise.


Dog: Ruff

Fish: Glurp Slurp

~ 68 ~

Lekcija 62 i 63: Jbutton

U ovoj lekciji cemo praviti prozor na kojem cemo mi sami napraviti “buttons” , jedan ce biti obicni a

drugi ce biti sa slikom koja ce se mjenjati kada predjemo misem preko nje. Napravili smo dve klase:

glavnu Apples i klasu Gui. Klasa Gui :

import java.awt.FlowLayout; import java.awt.event.ActionListener; import java.awt.event.ActionEvent; import javax.swing.JFrame; import javax.swing.JButton; import javax.swing.Icon; import javax.swing.ImageIcon; import javax.swing.JOptionPane; public class Gui extends JFrame{ private JButton reg; private JButton custom; public Gui(){ super("The title"); setLayout(new FlowLayout()); reg = new JButton("reg Button"); add(reg); Icon b = new ImageIcon(getClass().getResource("aia.png")); Icon x = new ImageIcon(getClass().getResource("bib.png")); custom = new JButton("Custom", b); custom.setRolloverIcon(x); add(custom); HandlerClass handler = new HandlerClass(); reg.addActionListener(handler); custom.addActionListener(handler); } private class HandlerClass implements ActionListener{ public void actionPerformed(ActionEvent event){ JOptionPane.showMessageDialog(null,String.format("%s", event.getActionCommand())); } } }

Provo smo inportovali sve sto nam treba da bih smo napravili ovaj program. Zatim smo klasu Gui

“extend” klasom JFrame( sto znaci da klasa Gui nasljedjuje sve od klase JFrame). U klasi Gui smo

napravili dve private promjenjive reg i custom tipa JButton. Onda smo napravili konstruktor za klasu

Gui . U tjelu konstruktora smo ukucali super(„The title”) – dali smo ime prozoru (naslovna linija).

Zatim smo odredili kakav ce biti raspored unutar prozora tj. setLayout(new FlowLayout( )); - sto je

default raspored.

Sada kada smo podesili naslov prozora i raspored mozemo dodati nase “buttons”. reg = new

JButton(“reg Button”); - ”reg Button” je ono sto ce pisati unutar tog “buttona”. add(reg) - kada

napravimo “button” moramo ga i manuelno dodati.

Zatim cemo dodati “button” koji ima izgled slike , i kada predjemo preko njega dobice izgled druge

slike. Prvo sto moramo jeste da te slike stavimo u Workspace/mjesto gdje se nalaze nase kalse.

Takodje te slike moraju imati png ekstenziju (?) . Kada sve to uradimo mozemo nastaviti sa

programiranjem.

~ 69 ~

Icon b = new ImageIcon(getClass().getResource(“aia.png”)) - ono sto ova cjelokupna instrukcija

kaze jeste da uzima tu sliku i snima ga u objekat koji smo nazvali b. Icon je klasa . tako da smo

kucajuci Icon b = new ImageIcon( ) kreirali klasicni objekat koji u zagradi ima getClass(

).getResource(“aia.png”)) –getClass( ) sto oznacava ovu klasu, getResource(“b.png”)- je slika koju

smo ubacili ranije u radniprostor. To smo isto uradili za sliku bib.png . Zatim smo ukucali

custom = new JButton(“Custom”,b); - Custom je ime , dok je b drugi parametar tj. objekat koji

sadrzava sliku aia.png. Kad god zelimo da napravimo da kada na neku sliku/ikonu predjemo misem da

se pojavi druga slika ukucamo ime tog “buttona”. setRolloverIcon(/*u zagradu stavljamo objekat koji

sadrzava sliku koju zelimo da se pojavi*/) tj. u ovom primjeru custom.setRolloverIcon(x); . I na

kraju smo dodali to “button” prozoru instrukcijom add(custom).

Dalje smo napravili HandlerClass objekat handler tako sto smo ukucali HandlerClass handler =

new HandlerClass( ); . Zatim smo dodali ActionListener tipkama reg i custom i kao parametar smo

dodali objekat handler tj. reg.addActionListener(handler) i custom.addActionListener(handler).

Ono sto ovo jeste jeste pocetak dodavanja dinmike nasim “buttonim-a”.

Sada s obzirom da imamo objekat handler a nemamo klasu HandlerClass , moramo je kreirati.

HandlerClass smo napravili izvan konstrukora ali unutar klase Gui . Ukucali smo u zaglavlju klase :

private class HandlerClass implements ActionListener - ono sto implements znaci jeste: da cemo

koristiti ono sto se nalazi u klasi ActionListener ali pod uslovom da u klasi HandlerClass “overvrite”

sve metode. Srecom po nas ActionListener ima samo jednu metodu (sto znaci da moramo “overvrite

samo jednu metodu). Tjelo HandlerClass ima metodu public void actionPerformed(ActionEvent

event).Ono sto upisemo u tjelu ove metode je ono sto ce se desiti kada kliknemo tipku reg ili custom .

Tjelo metode izgleda :

JOptionPane.showMessageDialog( null, String.format( “%s” , event.getActionCommand( ) ) )


import javax.swing.JFrame; public class Apples { public static void main(String args[]){ Gui GO = new Gui(); GO.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); GO.setSize(300,200); GO.setVisible(true); } }

U glavnoj klasi smo prvo importovali javax.swing.JFrame; sto nam prilicno omogucava da koristimo

prozore. Zatim smo napravili objekat GO koji predstavlja Gui klasu. Onda smo namjestili velicinu

prozora tako sto smo ukucali imeobjekta.setSize . I namjestili smo da je prozor vidljiv tako sto smo

ukucali GO.setVisible(true) .

~ 70 ~


Kada kliknemo “reg Button” dobicemo:

Kada predjemo preko Custom , promjenice se slika i izgledace:

I na kraju kad kliknemo na Custom:

~ 71 ~

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. Imamo dve klase glavna

klasa Main i klasa Gui.

Klasa Gui:

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Gui extends JFrame { private JTextField tf; private JCheckBox boldbox; private JCheckBox italicbox; public Gui(){ super("The title"); setLayout(new FlowLayout()); tf = new JTextField("This is a sentence",20); tf.setFont(new Font("Serif",Font.PLAIN,14)); add(tf); boldbox = new JCheckBox("bold"); italicbox = new JCheckBox("italic"); add(boldbox); add(italicbox); HandlerClass handler = new HandlerClass(); boldbox.addItemListener(handler); italicbox.addItemListener(handler); } private class HandlerClass implements ItemListener{ public void itemStateChanged(ItemEvent event){ Font font = null; if(boldbox.isSelected() && italicbox.isSelected()) font = new Font("Serif",Font.BOLD + Font.ITALIC, 14); else if(boldbox.isSelected()) font = new Font("Serif", Font.BOLD,14); else if(italicbox.isSelected()) font = new Font("Serif", Font.ITALIC,14); else font = new Font("Serif", Font.PLAIN, 14); tf.setFont(font); } } }

Prvo smo inportovali : java.awt.* , java.awt.event.* i javax.swing.*. Nakon toga smo napravili tri

promjenjive: prva promjenjiva tf (tipa JTextField), druge dve boldbox i italicbox (tipa JCheckBox).

Nakon toga smo napravili konstruktor public Gui( ) . 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.

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” , 20) , tj. imepromjenjive = new

vrstapromjenjive(“/*ono sto ce pisati unutar tog polja*/”, brojkojioznacavavelicinutekstpolja ) .

~ 72 ~

Nakon toga tf promjenjivo smo podesili font tako sto smo ukucali: tf.setFont(new Font(“Serif”,

Font.PlAIN, 14)) ili imepromjenjive.setFont(new Font(“/*imefonta*/”, FONT./*efekat tj. BOLD ,

ITALIC ili obicni tj. PLAIN*/, brojkojiodredjujevelicinufonta ). Na kraju smo dodali tf nasem prozoru

ukucavsi add(tf).

Onda smo promjenjivima boldbox i italicbox tipa JCheckBox odredili sta ce da pise pored

“checkbox-a” na nacin : imepromjenjive = new JCheckBox(„‟/*sta zelimo da pise pored tog

checkbox-a*/). Nakon toga smo ove dve promjenjive dodali prozoru.

Kada bih smo sada pokrenuli ovaj program ne bih imao nikakve funkiconalnosti. Dakle prozor izgleda

onako kako bih i trebao izgledati ali pogledamo sta se desava kada kliknemo nesto na njemu , npr

cekiracemo bold:

Kao sto vidimo nije se nista promjenilo , to znaci da moramo sada isprogramirati ove checkbox-ove da

kada cekiramo bold da ovaj tekst postane podebljan, kada cekiramo italic da tekst bude nakrivljen i

kada su cekirana oba da tekst bude i podebljan i nakrivljen.

Sada cemo kreirati novi objekat handler koji ce predstavljati klasu HandlerClass. Dakle ukucali smo

: HandlerClass handler = new HandlerClass( ). Zatim cemo promjenjim boldbox i italicbox tipa

CheckBox dodati ItemListener tako sto cemo ukucati : imepromjenjive.addItemListener(“/*objekat

koji predstavlja HandlerClass*/). To izgleda :

boldbox.addItemListener(handler) italicbox.addItemListener(handler)

Dakle sada kada smo dodali ItemListener promjenive boldbox i italicbox cekaju da se nesto desi (a

jedino sto se moze desiti promjenjivim tipa JCheckBox jeste da ih cekiramo) i kada se to desi izvrsava

se ono sto se nalazi u HandlerClass (iz razloga sto u zagradi imamo objekat koji predstavlja tu klasu).

Prije nego sto nastavimo moramo razjasniti jednu stvar: kada god stavimo jednu klasu unutar druge

klase onda ta klasa koja je unutra moze da pristupi svim metodama i promjenjivim koje se nalaze u

vanjskoj klasi.

Sada mozemo nastaviti. Posto smo napravili objekat handler unutar Gui klase (izvan konstruktora)

moramo napraviti klasu koju on predstavlja tj. HandlerClass. Ukucali smo :

Private class HandlerClass implements ItemListener - implements ItemListener znaci da u ovoj

klasi ( HandlerClass) moramo koristiti sve metode ItemListener-a i “overvrite” ih . ItemListener

ima samo jednu metodu pa samo nju moramo “overvrite”. Ta metoda je ItemStateChanged i

zaglavlje izgleda: Public void ItemStateChanged(ItemEvent event).

Ono sto ukucamo u tjelu ove metode ce se desiti kada cekiramo boldbox ili italicbox, samo jedan od

njih ili nijedan. To smo uradili sluzeci se if izjavom . Ali prije toga smo kreirali promjenjivu font tipa

Font i dodjelili joj vrijednost null tj: Font font = null.

~ 73 ~

Imamo 4 opcije :

1. Kada su cekirane i boldbox i italicbox , if( boldbox.isSelected( ) && italicbox.isSelected( ) )

2. Kada je cekiran samo boldbox, else if (boldbox.isSelected( ) )

3. Kada je cekiran samo italicbox, else if ( italicbox.isSelected( ) )

4. Kada nije nista cekirano ( else kada nije ispunjen nijedan od ova prva 3 uslova)

boldbox.isSelected( ) znaci da je boldbox cekiran, tj imePromjenjiveTipaJCheckBox.isSelected( )

oznacava da je taj check box cekiran.

Isto tako imamo 4 stvari koje ce se dogoditi zavisno koja od opcija je tacna:

1. font = new Font(“Serif”, Font.BOLD + Font.ITALIC, 14)

2. font = new Font(“Serif , Font.BOLD, 14)

3. font = new Font(“Serif, Font.ITALIC, 14)

4. font = new Font(“Serif, Font.PLAIN,14)

Kao sto mozemo primjetiti u sva 4 slucaja prvi i treci argumenti su nam isti jer ne zelimo mjenjati font

odnosno velicinu slova. Ali takodje u sva cetri primjera 2 argument je razlicit jer zelimo kada je

cekiran odredjeni “checkbox” da slova postanu bolditalic, bold, italic ili obicna. Dakle font

namjestamo tako sto ukucamo imePromjenjiveTipaFont = new Font(“/*vrsta fonta*/”, /*effekat*/,

/*velicina slova izrazena brojevima*/);

Na kraju izvan if izjave kada se odredi vrijednost promjenjive font , moramo taj font primjeniti na

promjenjivu tf (tj. tekst u polju). To smo uradili ukucavsi : tf.setFont(font) ili

imePromjenjiveKojojZelimoPostavitiOdredjeniFont.setFont(/*promjenjiva vrste Font*/).


Kao sto vidimo onaj effeka koji cekiramo , on se i primjeni na tekst u tekst polju

prozor 1: Kada cekiramo samo bold prozor 2: kada cekiramo samo italic prozor 3: cekirano bold i italic

~ 74 ~

Lekcija: 66 JRadioButton

RadioButton je nesto poput CheckBox-a samo sto mozemo imati samo jedan RadioButton selektovan

u isto vrijeme. Kada selektujemo jedno dugme sva druga se “iskljuce”. To cemo demonstirati na

programu slicnom proslom. U ovom programu cemo napraviti prozor u kome cemo imati jedno polje

za tekst i 4 Radio tipke koje ce mjenjati Font u zavisnosti od toga koji RadioButton pritisnemo.

Napravili smo dve klase Glavnu Main i klasu Gui. Klasa Gui:

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Gui extends JFrame{ private JTextField tf; private Font pf; private Font bf; private Font itf; private Font bif; private JRadioButton pb; private JRadioButton bb; private JRadioButton ib; private JRadioButton bib; private ButtonGroup group; public Gui(){ super("the title"); setLayout(new FlowLayout()); tf = new JTextField("djordje is awsome and hot",25); add(tf); pb = new JRadioButton("plain", true); bb = new JRadioButton("bold", false); ib = new JRadioButton("italic", false); bib = new JRadioButton("bold and italic",false); add(pb); add(bb); add(ib); add(bib); group = new ButtonGroup(); group.add(pb); group.add(bb); group.add(ib); group.add(bib); pf = new Font("Serif", Font.PLAIN, 14); bf = new Font("Serif", Font.BOLD, 14); itf = new Font("Serif", Font.ITALIC, 14); bif = new Font("Serif", Font.BOLD + Font.ITALIC, 14); tf.setFont(pf); pb.addItemListener( new HandlerClass(pf)); bb.addItemListener( new HandlerClass(bf)); ib.addItemListener( new HandlerClass(itf)); bib.addItemListener(new HandlerClass(bif)); } private class HandlerClass implements ItemListener{

~ 75 ~

private Font font; public HandlerClass(Font f){ font = f; } public void itemStateChanged(ItemEvent event) { tf.setFont(font); } } }

Na pocetku smo importovali : java.awt.* , java.awt.event.* , javax.swing.* . Klasa Gui je nasljedila

JFrame. Zatim smo napravili deset promjenjivih od kojih su 4 tipa JRadioButton, 4 tipa Font , jedna

tipa JTextField i jedna tipa ButtonGroup. ButtonGroup je promjenjiva koja uspostavlja vezu , izmedju

“buttona” (izmedju kojih dugmadi , cemo definisati kasnije).

Dalje smo napravili konstruktor. Definisali naslov i raspored. Nakon toga smo dodali nase tekst polje .

Zatim smo definisali i dodali nasa 4 RadioButtona:

pb = new JRadioButton(“plain”, true)

bb= new JRadioButton(“bold”, false)

ib = new JRadioButton(“italic”, false)

bib = new JRadioButton(“bold and italic”, false)

dakle prvi parametar u zagradi jeste ono sto ce pisati desno od “butona”, drugi parametar (true ili false)

je ono dugme koje ce biti ukljuceno(samo jedno moze biti ukljuceno, to je karakteristika

JRadioButton). U prozor smo ih dodali na standardan nacin tako sto smo ukucali add(pb), add(bb),

add(ib), add(bib).

Zatim smo definisali pro. group tipa ButtonGroup tako sto smo ukucali group=new ButtonGroup( )

onda smo dodali nase JradioButtone toj grupi , na nacin group.add(pb), group.add(bb) , tj.

imepromjenjivetipaButtonGrup.add(/*promjenjiva*/).

Nakon toga smo definisali promjenjive tipa Font :

pf = new Font(“Serif”, Font.PLAIN,14)

bf = new Font(“Serif”, Font.BOLD,14)

itf = new Font(“Serif”, Font.ITALIC,14)

bif = new Font(“Serif”, Font.BOLD + Font.ITALIC, 14)

i stavili smo da nam tekst polje tf ima po defaultu plain font (obicni font, bez ikakvih efekata) , tako

sto smo ukucali tf.setFont(pf).

Sada cemo dodati itemListener svakom od nasih JRadioButtona da bih im dali neku funkcionalnost

jer u suprotnom imamo samo prozor sa jednim tekst poljem u kojem pise “djordje is awsome and hot”

i 4 JRadioButton koji samo stoje tu u prozoru.

Ukucali smo :

pb.addItemListener(new HandlerClass(pf));

bb.addItemListener(new HandlerClass(bf));

ib.addItemListener(new HandlerClass(itf));

bib.addItemListener(new HandlerClass(bif));

tj. imeJRadioButtona.addItemListener( new HandlerClass(/* ime fonta koji zelimo da se prosljedi

HandlerClass */). addItemListener – znaci da taj “buton” ceka da se dogodi dogadjaj, a kada se

~ 76 ~

dogodi izvrsava se ono sto je u zagradama poslije. ( new HandlerClass(pf)) – je objekat ustvari , koji

ima u zagradi pf tj PlainFont koji ce prosljediti konstruktoru. Sada izvan naseg Gui konstruktora ali

unutar Gui klase pravimo HandlerClass koja implements ItemListener. Unutar ove klase cemo

napraviti promjenjivu font tipa Font. Sada cemo u HandlerClass napraviti konstruktor koji prihvata

jedanu promjenjivu/objekat tipa Font:

Dakle napisali smo: public HandlerClass( Font f) - Font je vrsta podataka sa kojom ce konstruktor

raditi dok je f ime koje ce Font vrsta podataka imati unutar ovog konstruktora. U tjelu imamo font= f,

font je promjenjiva koju smo napravili u klasi HandlerClass (izvan) konstruktora, dok je f font koji je

prosljedjen u konstruktor.

S obzirom da smo u klasu HandlerClass “implementirali” interfejs ItemListener , znaci da moramo

“overvrte” sve metode koje ItemListener ima, a ima samo jednu :

public void ItemStateChanged(ItemEvent event) - sto je odprilike metoda u cijem tjelu je ono sto ce

se dogoditi kada se dogodi dogadjaj , tj kada se klikne na pb,bb,ib ili bib. U tjelu te metode smo

ukucali tf.setFont(font) tj. tekstpolje.setFont(/*font koji smo prosljedili u konstruktor i dodjelili ga

promjenjivoj font(koju smo napravili izvan konstruktora unutar HandlerClass)*/)

Klasa Main:

import javax.swing.JFrame; public class Main { public static void main(String args[]){ Gui go = new Gui(); go.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); go.setSize(300,200); go.setVisible(true); } }

Ovu istu klasu imamo u prosloj lekciji tako da je netreba dodatno objesnjavati. Kada pokrenemo ovaj

program dobicemo:

~ 77 ~

Kada pritisnemo krug( tj. JRadioButton ) pored kojeg pise “bold” , iskljucice se plain i ostace

cekirano samo “bold”. Takodje ono sto je najvaznije tekst u tekst polju ce postati podebljan:

Isto ce se desiti kada pritisnemo “italic” , samo sto ce tekst postati nakrivljen:

I naposljetku kada pritisnemo “bold and italic”, tekst ce postati i podebljan i nakrivljen :

~ 78 ~

Lekcije: 68 i 69 JComboBox

U ovoj lekciji cemo napraviti prozor koji sadrzi JComboBox. JcomboBox je ustvari dropdown list tj.

padajuca lista. Ono sto ce padajuca lista raditi jeste da cemo u prozoru imati ime dve slike i kada

selektujemo ime jedne od dva imena u padajucoj listi promjeniti ce se slika. Imamo dve klase glavnu

Main i klasu Gui . Klasa Gui:

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Gui extends JFrame { private JComboBox box; private JLabel picture; private static String[] filename = {"b.png","x.png"}; private Icon[] pics = {new ImageIcon(getClass().getResource(filename[0])), new ImageIcon(getClass().getResource(filename[1]))}; public Gui(){ super("the title"); setLayout(new FlowLayout()); box = new JComboBox(filename); box.addItemListener( new ItemListener(){ public void itemStateChanged(ItemEvent event){ if(event.getStateChange() == ItemEvent.SELECTED) picture.setIcon(pics[box.getSelectedIndex()]); } } ); add(box); picture=new JLabel(pics[0]); add(picture); } }

Importovali smo java.awt.* , java.awt.event.* i javax.swing.*. Zatim je klasa Gui nasljedila

JFrame. Unutar Gui klase smo kreirali dve promjenjive od kojih je jedna box tipa JcomboBox (tj.

padajuca lista) a druga je picture tipa JLabel (tj. slika). U package gdje se nalaze nase klase smo

stavili dve slike: x.png i b.png.

Dalje smo napravili dva Array-a:

private static String[ ] filename = {“b.png”, “x.png”} –skladistiti ce put a put je vrste String.

private Icon[ ] pics = (new ImageIcon (getClass().getResource( filename[0] ) ), new

ImageIcon( getClass().getResource( filename[1] ) ) – ovaj Array skladisti podatke vrste Icon

, i on ce skladistiti slike.

Dalje smo napravili konstruktor za klasu Gui. Definisali smo naslov prozora i raspored unutar njega.

Nakon toga smo promjenjivoj box (tj padajucoj listi ) dodjelili opcije koje ce imati, ukucali smo : box

= new JcomboBox (filename) - filename je array koji sadrzi imena silka , tj. b.png i x.png koje cemo

imati kao izbor kada kliknemo na strelicu padajuce liste.

Sada cemo promjenjivoj box dodati Item listener (koji sluzi da kada kliknemo na jednu od opcija, da

se nesto desi , tj. u nasem slucaju da se promjeni slika koja se nalazi u sklopu naseg prozora).

~ 79 ~

Ovaj put necemo praviti objekat za HandlerClass (niti cemo posebno definisati HandlerClass kao u

proslim primjerima) , koji cemo dodjeliti promjenjivoj box tj. box.addItemListener(/* HandlerClass

objekat*/). Vec cemo napraviti anonimnu unutrasnju klasu na mjestu gdje nam je potrebna.

Ukucali smo box.addItemListener kao i inace , zatim smo otvorili obicnu zagradu u kojoj cemo

staviti anonimnu unutrasnju klasu a ono sto ona radi jeste da implementira ItemListener interfejs .

tj.klasu koju smo prije posebno pravili, sada cemo napraviti unutar tih zagrada(obicne zagrade su

oblast vazenja ove klase) . To izgleda:

box.addItemListener( new ItemListener( ){ public void itemStateChanged(ItemEvent event){

if(event.getStateChange() == ItemEvent.SELECTED)

picture.setIcon(pics[box.getSelectedIndex()]);

}});

New Item Listener je klasa , koja ima samo jednu metodu koju treba “overvrite” tj. itemStateChanged

metodu sa parametrima u zagradi (ItemEvent event). U tjelu metode cemo napisati ono sto zelimo da

se desi u kada se dogadjaj dogodi (u ovom primjeru dogadjaj je , kada u padajucoj listi selektujemo

jednu od imena od dve slike (tj. b.png ili x.png)). U tjelu metode smo napisali if izjavu pomocu koje

cemo razabrati koja od opcija je selektovana :

if ( event.getStateChange( ) == ItemEvent.SELECTED )- ova if izjava nam govori sta je

selektovano . Ako je uslov tacan izvrsava se picture.setIcon(pics[box.getSelectedIndex( ) ] ) -

picture je promjenjiva tipa JLabel , setIcon( ) metoda mjenja sliku , koja je navedena kao argument

tj. (pics[box.getSelectedIndex) . pics je Array koji sadrzi dve slike , koja od dve slike ce biti izabrana

zavisi od onoga sto je selektovano . Onda smo dodali u prozor box i picture , i postavili sliku b.png

kao default sliku u prozoru.

Glavna klasa Main je standardnog izgleda kao iz proslog primjera.

prozor 1: Kada pokrenemo program

dobicemo Prozor 2: Kada kliknemo na strelicu

dobicemo:

Prozor 3:Kada izaberemo x.png

dobicemo:

~ 80 ~

Lekcije 70 i 71: JList

Jlist je lista za nas graficki korisnicki interfejs. Mi cemo napraviti program koji ce sadrzavati Jlist- u u

kojoj ce biti ponudjena imena 4 boje ( tj. black, red, blue, white) i kada kliknemo na jednu od boja

promjenice se pozadina naseg prozora u tu boju. Imamo dve klase : Glavna Main i Gui. Klasa Gui:

import java.awt.*; import java.awt.event.*; import javax.swing.*; import javax.swing.event.*; public class Gui extends JFrame{ private JList list; private static String[] colornames={"black", "red","blue", "white"}; private static Color[] colors = {Color.BLACK, Color.RED, Color.BLUE, Color.WHITE}; public Gui(){ super("title"); setLayout(new FlowLayout()); list = new JList (colornames); list.setVisibleRowCount(4); list.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION); add(new JScrollPane(list)); list.addListSelectionListener( new ListSelectionListener(){ public void valueChanged(ListSelectionEvent event){ getContentPane().setBackground(colors[list.getSelectedIndex()]); } } ); } }

Dakle na pocetku smo importovali : java.awt.* , java.awt.event.* , javax.swing.* i

java.swing.event.* . Nakon toga smo klasu Gui extends za JFrame.

Unutar Gui klase smo napravili jednu promjenjivu list tipa Jlist , i dva array-a :

private static String[ ] colornames = {“black”, “red”, “blue”,”white”} – ovaj array ce nam

sluziti da skladisti imena boja koje cemo staviti u nasu list(tj JList-u ).

private static Color[ ] colors = {Color.Black, Color.RED, Color.BLUE, Color.White} –

dok ce ovaj array skladistiti stvarne boje za nasu pozadinu.

Onda smo kreirali konstruktor, podesili naslov i raspored. 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). Takodje smo definisali koliko ce nasa Jlist prikazivati vidljivih

opcija(za one koje ne mogu stati pojavi se scrollbar) . Vrijednost smo stavili na 4 ukucavsi:

list.setVisibleRowCount(4).

Nakon toga smo definisali koliko se opcija moze selektovati , mi smo stavili da se moze selektovati

samo jedana: list.setSelectionMode(ListSelectionModel.INGLE_INTERVAL_SELECTION). Na

kraju smo dodali tu listu u prozor. Da smo napisali samo add(list) , u slucaju da smo stavili da

prikazuje samo dvije opcije ( a mi imamo 4, ne bih se prikazivale 2 opcije vec sve 4 bez scroll bara.

Zato smo ukucali : add(new JScrollPane(list)).

~ 81 ~

Sada imamo prozor koji ima listu ali kada bih smo kliknuli na neku od boja nista se ne bih promjenilo ,

zato moramo dati malo funkcionalnosti nasoj listi. Ukucali smo:

list.addListSelectionListener( new ListSelectionListener(){ public void valueChanged(ListSelectionEvent event){ getContentPane().setBackground(colors[list.getSelectedIndex()]); } } );

Jedino sto cemo objasnavati iz ovog prozora jeste getContentPane().setBackground(

/*Color.imeBojeUkojuZelimoPromejnitiPozadinu*/) - jeste nacin na koji definisemo nasu pozadinu .

u zagradi smo stavili colors[list.getSelectedIndex( )]); - colors je Array koji sadrzi boje,

list.getSelectedIndex( ) ce nam dati broj (indeks) koji string iz array-a list je selektovan. Buduci da

indeks list odgovara indeksu boje u colors, boja koja je selektovana ce se pojaviti kao boja pozadine

prozora.

Glavna klasa Main je ista kao u proslom primjeru pa je necemo prikazivati ovde.

kada pokrenemo program dobicemo:

kada pritisnemo black dobicemo crnu pozadinu :

Kada pritisnemo red :

Kada pritisnemo blue :

~ 82 ~

~ 83 ~

Lekcije 72 i 73: Multiple Selection Lists

U ovoj lekciji cemo praviti prozor u kome cemo imati listu sa ljeve i desne strane , i izmedju njih dugme

koje kada pritisnemo sve sto smo selektovali sa ljeve strane predje u desnu stranu (listu). Imamo dve

klase: Glavna Main i klasa Gui. Klasa Gui:

import java.awt.*; import java.awt.event.*; import javax.swing.*; import javax.swing.event.*; public class Gui extends JFrame { private JList leftlist; private JList rightlist; private JButton movebutton; private static String[] food ={"bacon","ham","eggs","milk","beef"}; public Gui(){ super("the title"); setLayout(new FlowLayout()); leftlist = new JList(food); leftlist.setVisibleRowCount(3); leftlist.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION); add(new JScrollPane(leftlist)); movebutton = new JButton("Move -->"); movebutton.addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent event){ rightlist.setListData(leftlist.getSelectedValues()); } } ); add(movebutton); rightlist = new JList(); rightlist.setVisibleRowCount(3); rightlist.setFixedCellWidth(100); rightlist.setFixedCellHeight(15); rightlist.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION); add(new JScrollPane(rightlist)); } }

Napravili smo 4 promjenjive. Dve tipa JList , leftlist i rightlist. Jednu tipa JButton , koju smo nazvali

movebutton. I jedan Array food.

Zatim smo napravili konstruktor, podesili naslov prozora, rasored. Nakon toga unutar konstruktora smo

promjenjivoj leftlist dodjelili Array food. Dalje smo ukucali leftlist.setVisibleRowCount(3) – sto

prakticno znaci koliko stvari u listi zelimo da vidimo(tj. koja ce biti visina liste).

Nakon toga smo definisali da mozemo selektovati vise opcija tako sto smo ukucali:

leftlist.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION). Na posljetku

smo leftlist stavili u prozor: add(new JScrollPane(leftlist).

Sada kada imamo leftlist dodanu u prozor, definisali smo movebutton , tako sto smo ukucali sledecece

movebutton = new JButton (“Move ”); - sto znaci da ce na movebutton pisati “Move ”) , I dodali

smo ga u prozor add(new JScrollPane(movebutton)).

~ 84 ~

Nakon sto smo definisali i dodali movebutton prozoru , moramo ga isprogramiirati da kada oznacimo

nesto sa ljeve strane , i pritisnemo movebutton da se to prebaci na desnu listu. To smo uradili na nacin da

smo dodali ActionListener.

rightlist.setListData ( leftlist.getSelectedValues ( ) ) - rightlist.setListData( ) – ce uzeti podatke koji se

nalaze u zagradi i staviti ih u rightlist. U zagradi imamo leftlist.getSelectedValues( )) - sto znaci sve one

stvari koje smo selektovali u leftlist.

Sada smo definisali rightlist: rightlist = new Jlist ( ) , mozemo primjetiti da nismo nista stavili u zagradi i

da ona nema nikavu vrijednost. S obzirom na to nece se prikazati na ekranu, a mi to ne zelimo. Stoga

moramo cemo podesiti height i width (osim sto cemo podesiti nacin selektovanja, i koliko stvari moze da

prikaze ). Dakle rightlist.setFixedCellWidth(100) , rightlist.setFixedCellHeight(15) . Sada smo sigurni

da ce se prikazati u prozor (naravnno u slucaju da ga dodamo sa add). Sada cemo rightlist dodati u

program : add(new JScrollPane(rightlist).

Glavna klasa Main nam je ista kao u proslim lekcijama.

kada pokrenemo program dobicemo Kada selektujemo bacon i ham izgledace:

Kada pritisnemo Dugme “Move ” , bacon i ham ce preci u desnu listu:

Akosada selektujemo iz ljeve liste npr. ham, egg i milkpritisnemo Move , u desnoj listi ce se naci ove tri

stvari , dok ce bacon i ham nestati sa desne liste:

~ 85 ~

Lekcije 74,75 i 76 Mouse Events

U ovoj lekciji cemo praviti program koji ce reagovati na mis. Napravicemo prozor koji ce imati bjelu

pozadiu i status bar koji ce nam govoriti sta smo uradli sa misem. Imao glavnu klasu Main i klasu Gui :

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Gui extends JFrame{ public JPanel mousepanel; public JLabel statusbar; public Gui(){ super("the title"); mousepanel = new JPanel(); mousepanel.setBackground(Color.WHITE); add(mousepanel, BorderLayout.CENTER); statusbar = new JLabel("default"); add(statusbar, BorderLayout.SOUTH); HandlerClass handler = new HandlerClass(); mousepanel.addMouseListener(handler); mousepanel.addMouseMotionListener(handler); } private class HandlerClass implements MouseListener, MouseMotionListener{ public void mouseClicked(MouseEvent event){ statusbar.setText(String.format("mouse is clicked at %d,%d", event.getX(), event.getY())); } public void mousePressed(MouseEvent event){ statusbar.setText("mouse is pressed"); } public void mouseReleased(MouseEvent event){ statusbar.setText("the mouse is released"); } public void mouseEntered(MouseEvent event){ statusbar.setText("the mouse entered"); mousepanel.setBackground(Color.BLUE); } public void mouseExited(MouseEvent event){ statusbar.setText("the mouse exited"); mousepanel.setBackground(Color.WHITE); } public void mouseDragged(MouseEvent event){ statusbar.setText("the mouse is dragging"); } public void mouseMoved(MouseEvent event){ statusbar.setText("the mouse is moved"); }}}

prvo smo importovali klase: java.awt.* , java.awt.event.* i javax.swing.* . Nakon toga smo klasu Gui

extends za JFrame (da mozemo koristiti prozore) . Zatim smo napravili dve promjenjive :

mousepanel tipa JPanel

statusbar tipa JLabel

Zatim smo napravili konstruktor , podesili naslov ali nismo podesavali raspored. Onda smo promjenjivoj

mousepanel dodjelili vrijednost : mousepanel = new JPanel() - stavili smo da je ova promjenjiva

jednaka necemu pa je mozemo koristiti.

~ 86 ~

Dalje smo mouspanel podesili boju pozadine u bjelu boju: mousepanel.setBackground

(Color.WHITE) . Nakon toga smo mousepanel dodali u prozor i usput definisali gdje ce se nalaziti:

add(mousepanel, BorderLayout.CENTER). BorderLayout.Center znaci da ce se ova “ploca”(JPanel)

nalaziti na sredini prozora i ako budemo povecavali prozor ona ce ga popunjavati.

Definisali smo vrijednos promjenjive statusbar : statusbar = new JLabel(“default”); . I dodali smo

statusbar u prozor i podesili ga da bude na dnu prozora: add(statusbar , BorderLayout.SOUTH).

Kreiracemo Objekat za klasu HandlerClass , koji se zove handler. Nakon sto smo definisali i dodali ove

dve promjenjive u prozor. Promjenjivoj mousepanel cemo dati malo funkcionalnosti tako sto cemo mu

dodati MouseListener i MouseMotionListener , tj: mousepanel.addMouseListener(handler) i

mousepanel.addMouseMotionListener(handler);.

S obzirom da smo u zagradama stavili objekat handler. Unutar klase Gui cemo kreirati unutrasnju

HandlerClass koja ce rukovoditi dogadjajima. Tu klasu cemo implementirati sa MouseListener i

MouseMotionListener . MouseListener interfejs ima 5 metoda koje moramo “overvrite” a to su :

1. mouseClicked

2. mousePressed

3. mouseReleased

4. mouseEntered

5. mouseExited

dok MouseMotionListener ima dve metode koje moramo “overvrite” a to su:

1. mouseDragged

2. mouseMoved

Kada smo “overvrite” ove metode i odredili sta ce se desavati u zavisnosti koja od ovih sedam se desi,

mozemo pokrenuti ovaj program (Klasa Main je ista kao u prosloj lekciji).

Kada pokrenemo dobicemo: Kada kursor stavimo u prozor boja ce se

promjeniti u plavu i u status baru ce pisati “you moved mouse”

~ 87 ~

Kada kliknemo negdje:

Kada pritisnemo tipku misa: Kada pritisnemo , drzimo i povlacimo mis

po prozoru : Kada pritisnemo, drzimo, povucemo mis po prozoru I naposljetku ga pustimo na nekoj drugoj

lokaciji:

Kada izadjemo sa kursorom iz prozora:

~ 88 ~

Lekcija 77: Adapter Class

U ovoj lekciji cemo uciti o Adapter klasama. U prosloj lekcij kada smo implementirali MouseListener i

MouseMotionListener , svih sedam metoda(za svaki slucaj kada: kliknemo , kada pritisnemo mis, kada

pustimo mis, kada udjemo u prostor, kada izadjemo , kada se pomjeramo unutar prozora , kada

prevlacimo) smo morali “overvrite”. Nekada zelimo da nas program reaguje samo na to kada npr.

korisnik klikne u prozor, pa da ne bih smo morali “overvrite” ostale metode i gubiti vrijeme , Java je

smislila rjesenje tj Adapter klasu( ono sto adapter klasa radi jeste da ona vec implementirala interfejs i

“overvrite” sve metode koje su prazne i nerade nista) tako da samo moramo “overvrite” one metode koje

cemo koristiti tj. u ovom slucaju mouseClicked . Napravicemo program koji ce u status baru govoriti

koliko smo puta kliknuli desni klik a koliko puta ljevi klik. Imao dve klase glavnu Main i klasu Gui.

Klasa Gui:

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Gui extends JFrame{ private String details; private JLabel statusbar; public Gui(){ super("the title"); statusbar = new JLabel("the default text"); add(statusbar, BorderLayout.SOUTH); addMouseListener(new Mouseclass()); } class Mouseclass extends MouseAdapter{ public void mouseClicked(MouseEvent event){ details = String.format("you clicked %d", event.getClickCount()); if(event.isMetaDown()) details +="with right mouse button"; else if(event.isAltDown()) details +="whit center mouse button"; else details +="with left mouse button"; statusbar.setText(details); } } }

prvo smo importovali java.awt.* , java.awt.event.* i javax.swing.* . Zatimo smo nasljedili klasu

JFrame. Unutar Gui klase smo napravili dve promjenjive :

1. details tipa String

2. statusbar tipa JLabel

Zatim smo napravili konstruktor unutar kojeg smo definisali naslovnu liniju. Zatim smo dodjelili

statusbar vrijednos “the default text” sto ce pisati cim pokrenemo program, i dok ne kliknemo nista.

Nakon toga smo statusbar dodali u prozor i postavili ja na juznu granicu (tj. BorderLayout.South) ili u

donji dio prozora.

Na kraju smo dodali MouseLIstener : addMouseListener(new Mouseclass( ) ) , new Mouseclass( ) je

objekat klase Mouseclass koju cemo sada napraviti izvan konstruktora ali unutar klase Gui.

~ 89 ~

Ukucali smo private class Mouseclass extends MouseAdapter. MouseAdapter je ugradjena klasa u

Javi i ona ce nam dozvoliti da “overvrite” samo one metode koje nam trebaju.

Posto mi samo trebamo metodu koja definise klik misa, unutar Mousecalss cemo samo kreirati tu metodu.

U tjelu metode mouseClicked(MouseEvent event) smo napisali :details = String.format (“you clicked

%d, event.getCLickCount( ) ). Kao prvo dodjelili smo neku vrijednost promjenjivoj details.

event.getClickCount( ) broji koliko smo puta kliknuli bilo koje dugme misa. Dalje smo napravili if izjavu

koja ce nam govoriti koje smo dugme kliknuli. Event.isMetaDown( ) se odnosi na desni klik misa.

Event.isAltDown( ) se odnosi na kada kliknemo na scrollbutton . Dok se smo pod elese (tj. ako nijedan od

ovih if i elseif nije zadovoljen broji kao ljevi klik misa. Klasa Main je ista kao u proslim lekcijama.

korak: 1 Kada pokrenemo program korak: 2 Kada kliknemo 7 puta ljevim klikom

misa

korak: 4 Kada kliknemo 9 puta sa desnim

klikom misa onih 7 ce se ponistiti korak: 3 Kada kliknemo 1 ljevi sada ce se

onih 9 desnim klikom ponistiti

~ 90 ~

Lekcija 78: File Class

U ovoj lekciji cemo pricati o fajlovima. U javi mozemo kreirati i modifikovati fajlove. Do sada smo

kreirali kompjuterske programe koji su koristili promjenjive i slicno(npr skladisti broj 5 u promjenjivoj

broj). Ali kada jednom izadjemo iz programa sve ove stvari nestanu, tako kada pokrenemo program

ponovo sve stvari koje smo urdili prosli put nestanu. Za sada cemo samo napraviti program koji ce nam

govoriti da li neki fajl postoji ili ne na nasem racunaru. Imacemo samo jednu klasu Main koja izgleda:

import java.io.File; public class Main { public static void main(String args[]){ File x = new File("E://Users//Djordje//Workspace//Djordje//src//lekcija78//djordje.txt"); if(x.exists()) System.out.println(x.getName() + " file does exist"); else System.out.println("This file doesn't exist"); } }

Importovali smo java.io.File sto je fajl klasa, i ono sto file klasa radi jeste da nam daje informacije o

fajlovima da li postoje, velicina, put…

Unutar Main klase smo napravili objekat za klasu File koji smo nazvali x. kao sto vidimo umjesto da smo

ukucali File x = new File( ). Mi smo odmah popunili zagradu sa putanjom tekstualne datoteke djordje.txt

koja se nalazi na E disku.

Dalje smo napravili if instrukciju da testiramo da li ovaj fajl postoji na nacin sto smo unutar testa za if

instrukciju ukucali x.exists( ) ili imepromjenjive.exists( ). Dakle ako metoda: x.exists( ) vraca true znaci

da djordje fajl postoji(x je objekat koji predstavlja File klasu. Ako postoji ispisuje se x.getName( ) + “

file does exist”. x.getName( ) uzima ime djordje.txt jer smo u zagradi objekta x upisali cjeli put do te

datoteke. Ako fajl ne postoji izvrsava se ono pod else tj. na ekranu cemo dobiti “This file doesn‟t exist”.

Moramo primjetiti da u putu do datoteke djordje.txt nismo koristili jedan backslash \ vec dva \\ iz razloga

sto se jedan backslash odnosi na novi red ili tab tj. \n odnosno t\ .

Kada pokrenemo ovaj program , s obzirom da djordje.txt postoji upravo na adresi koju smo naveli

dobicemo:

djordje.txt file does exist

Medjutim ako preimenujemo fajl bilo u Windows Exproreru, promjenimo putanju, ili promjenimo ime

fajla u samoj datoteci dobicemo:

This file doesn't exist

~ 91 ~

Lekcija 79: Creating Files

U ovoj lekciji cemo nauciti kako kreirati fajl pomocu Jave. Imacemo jednu klasu Main:

import java.util.*; public class Main { public static void main(String args[]){ final Formatter x; try{ x = new Formatter("firstfile.txt"); System.out.println("you created file successfuly"); } catch(Exception e){ System.out.println("you got an error"); } } }

Prvo smo inportovali java.util.* .

Zatim smo napravili promjenjivu x koja je vrste Formatter. Foramtter promjenjiva sluzi da “outputs”

String u fajl. To je prilicno kao printf osim sto ne pokazuje na ekranu vec u fajl.

Dalje smo napisali:

try{

x = new Formatter(“firstfile.txt”); System.out.println(“you created file successfully”);

} catch(Exception e){

System.out.println(“you got an error”);}

try – znaci pokusaj , ono sto se pokusava izvrsiti je ono unutar viticastih zagrada. Mi unutar try viticastih

zagrada imamo: x = new Formatter(“firstfile.txt”); i System.out.println(“you created file

successfully”). x = new Formatter(“fistfile.txt”) – dodjelili smo vrijednost promjenjivoj x tipa

Formatter , tj ono u zagradama , a ono sto se nalazi u zagradi kod ove vrste promjenjive je put fajla koji

zelimo “output” , mi smo stavili firstfile.txt ali posto takav fajl ne postoji Java ga kreira (i firstfile.txt je

kreiran i nalazi se na racunaru, vjerovatno u folderu u kojem je nasa klasa). 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.

catch(Exception e){ - Exception je ustvari error u Javi ( tako je nazvan) . U tjelu catch smo upisali

System.out.println(“you got an error”) - sto znaci ako try ne uspije na ekranu ce nam se prikazati “you

got an error” i fajl nece biti kreiran.

~ 92 ~

Lekcija:80 Writing to Files

U ovoj lekciji cemo nauciti kako se dodaju podatci u nas fajl. Imamo dve klase CreateFile, i glavnu klasu

Main. Klasa Createfile izgeda:

import java.util.*; import java.io.*; import java.lang.*; public class CreateFile { private Formatter x; public void createF(){ try{ x = new Formatter("info.txt"); } catch(Exception e){ System.out.println("Error"); }} public void WriteonFile(){ x.format("%s%s%s", " Trbovic "," Djordje ", " 17-11/RPI"); } public void close(){ x.close(); }}

Importovali smo java.util.* , java.io.* , java.lang.* . Unutar klase CreateFile smo napravili jednu

promjenjivu tipa Formatter koju smo nazvali x. Zatim smo u 3 metode:

otvorili/kreirali fajl tj. public void createF( ) .

pisali u fajlu tj. public void WriteonFile ( u fajlu pisemo tako sto napisemo

imeforamterpromjenjive.format(“argument1”, “argument2”). )

zatvorili fajl (obavezno zatvoriti fajl, jer ako fajl slucajno ostane otvoren moze doci do error-a tj.

public void close( ) (fajl zatvaramo tako sto napisemo imeformatterpromjenjive.close( ) ) .close( )

je ugradjena metoda koju smo inportovali.

Glavna klasa Main izgleda:

public class Main { public static void main(String args[]){ CreateFile cf = new CreateFile(); cf.createF(); cf.WriteonFile(); cf.close(); } }

Dakle kreirali smo objekat za klasu CreateFile koji smo nazvali cf. Zatim smo pozvali metodu koja kreira

fajl na nacin cf.createF( ) koja je kreirala fajl “info.txt”. Nakon toga smo napisali cf.WriteonFile( ) -

cime smo pozvali metodu koja upisuje u fajl , i upisali smo “ Trbovic Djordje 17-11/RPI”. Nakon toga

smo zatvorili fajl da ne bih doslo do errora( to moramo raditi obvezno) pozvavsi metodu close iz klase

CreateFile , tako sto smo ukucali imeobjektakojipredstavljaklasuCreateFile.close( ) odnosno cf.close( ).

Dobili smo novi fajl koji se naziva info i koji sadrzi “Trbovic Djordje 17-11/RPI” .

~ 93 ~

Lekcija 81: Reading From Files

U ovoj lekciji cemo uciti kako se cita iz fajla. To se radi pomocu Scanner-a koji smo koristili za unos

teksta od strane korisnika. Napravicemo Program koji ce citati podatke sa tekstualnog fajla

“UEFAChampionsLeagueWinners.txt” i prikazati ih na ekranu. Imamo dve klase. Glavana klasa Main i

klasa ReadFile koja izgleda:

import java.util.*; import java.io.*; public class ReadFile { private Scanner x; public void openFile(){ try{ x = new Scanner(new File("UEFAChampionsLeagueWinners.txt")); }catch(Exception e){ System.out.println("you have an error"); } } public void readFiles(){ while(x.hasNext()){ String a = x.next(); String b = x.next(); String c = x.next(); System.out.printf("%s %s %s \n",a,b,c); }} public void closeFiles(){ x.close(); } }

Prvo smo inportovali java.util.* jer se tu nalazi Scanner i inportovali smo java.io.* jer se tu nalazi alat za

citanje iz fajlova. Napravili smo promjenjivu x tipa Scanner. Zatim smo napravili tri metode:

OpenFIle

ReadFiles

CloseFiles

U prvoj metodi(OpenFile) u sklopu try smo promjenjivoj x dodjelili vrijednost (new File(/*ime fajla ili

putanja*/).Tj ukucali smo : x = new Scanner(new File(E:\\Users\\Djordje\\workspace\\Djordje

\\src\\lekcija81\\UEFAChampionsLeagueWinners.txt”)). Moramo primjetiti da kada smo koristili

Scanner da bih smo upisivali nesto da smo u zagradi stavljali (System.in) a sada smo u zagradi stavili

(new File(/*ime fajla ili putanja pa ime fajla*/).

Druga metoda nam sluzi da program cita iz fajlova i da procitano ispisuje na ekran. Kreirali smo while

petlju u cijim smo zagradama ukucali x.hasNext( ) ili imepromjenjiveScanner.hasNext( ).

While(x.hasNext) – znaci sve dok promjenjiva x ima nesto da se petlja izvrsava. x.hasNext( ) – jeste ono

sto promjenjiva x ima ( a ima tekst koji se nalazi u fajlu “UEFAChampionsLeagueWinners.txt” jer smo u

metodi OpenFile , x dodjelili taj fajl). Unutar while petlje imamo naredbe: String a = x.next( ) , String

b = x.next( ), String c = x.next( ). a/b/c.next( ) - oznacava svaki sledeci string.

~ 94 ~

U fajlu UEFAChampionsLeagueWinners.txt imamo tekst koji izgleda:

Real Madrid 9

AC Milan 7

CF Liverpool 5

Bayern Munich 4

FC Barcelona 4

Dakle kada while petlja prodje kroz ovu Scanner promjenjivu prvo na sto ce naici jeste Real i dodjelice

ga a (tj. String a = x.next , gdje je x.next Real), dalje se Madrid dodjeljuje promjenjivoj b (tj. String b =

x.next, sada je x.next Madrid). Dalje imamo broj 9(tj. broj 9 se dodjeljuje promjenjivoj c (odnosno String

c = x.next, gdje je sad x.next broj 9 koji nema svojsto broja vec Stringa). Sada se a,b,c prikazuju na

ekranu i usput formatiraju pomocu naredbe System.out.printf(“%s%s%s \n”, a,b,c). Ovo je samo jedno

prolazenje kroz while petlju , petlja ce se vrtiti sve dok u fajlu ima teksta odnosno sve dok je uslov

x.hasNext( ) true.

Zadnja metoda ili CloseFile nam sluzi da zatvorimo fajl da ne bih doslo do nekih error-a.

Glavana metoda Main izgleda:

public class Main { public static void main(String args[]){ ReadFile R = new ReadFile(); R.OpenFile(); R.ReadFiles(); R.CloseFiles(); } }


Real Madrid 9

AC Milan 7

CF Liverpool 5

Bayern Munich 4

FC Barcelona 4

Tj. ono isto sto se nalazi unutar tekstualnog fajla UEFAChampionsLeagueWinners.

~ 95 ~

Lekcija 82: Exception Handling

Exception je u Javi ustvari naziv za Error. Kada korisnik uradi nesto sto ne bih trebao uraditi , pojavi se

error i cjeli se prorgram zaustavlja , zato je bitno rukovoditi “error-ima”. To radimo pomocu try i catch.

try{kod koji treba da se izvrsi}catch(Exception e){ono sto ce se desiti ako se pojavi error}. Napravicemo

program za djeljenje, koji ce djeliti dva int broja. Imao jednu klasu Main koja izgleda:

import java.util.Scanner; public class Main { public static void main(String args[]){ Scanner input = new Scanner(System.in); System.out.println("enter the first number"); int n1 = input.nextInt(); System.out.println("enter the second number"); int n2 = input.nextInt(); int sum = n1/n2; System.out.println("the result is: "+sum); x=2; } }

Kada pokrenemo ovaj program prikazace se ”Enter the first number” kada unesemo prvi broj prikazace se

“enter the second number”. Kada unesemo ta dva broja prvi broj ce biti podjeljen sa drugim i dobicemo

neki rezultat npr:

enter the first number

32

enter the second number

4

the result is: 8

ali ako broj 32 ili neki drugi podjelimo sa nulom dobicemo error koji npr izgleda: Exception in thread

"main" java.lang.ArithmeticException: / by zero at lekcija82.Main.main(Main.java:11)

Dakle cjeli program ce se srusiti samo zato sto smo podjelili sa nulom. Mi ovo mozemo spreciti tako sto

cjeli kod stavimo unutar viticastih zagrada koje se nalaze poslije komande try i poslije tih viticastih

zagrada napisemo catch(Exception e) i otvorimo viticaste zagrade da napisemo sta ce se izvrsiti ako se

desi neki error. Kada zapakujemo kod u try i catch izgledace ovako:

import java.util.Scanner; public class Main { public static void main(String args[]){ try{ Scanner input = new Scanner(System.in); System.out.println("enter the first number"); int n1 = input.nextInt(); System.out.println("enter the second number"); int n2 = input.nextInt(); int sum = n1/n2; System.out.println("the result is: "+sum); }catch(Exception e){ System.out.println("you can't do that"); } } }

~ 96 ~

Poslije try i viticastih zagrada uvjek mora biti catch sa viticastim zagradama. try – ustvari kaze pokusaj

izvrsiti ovaj dio koda, dok catch ako se pojavi error u djelu koda kod try izvrsi dio koda unutar catch.

Mozemo primjetiti da u obicnim zagradama poslije catch imamo argumente kojima definisemo sta zelimo

da “catch” ili “uhvatimo” mi smo napisali : Exception e (sto znaci da “hvata” errore sve vrste( tj ako bilo

sta podje po zlu) . Postoje razlicite vrste errora : aritmeticki, input, math error …)

Ako sada pokrenemo program i podjelimo sa nulom , opet se djeljenje nece moci izvrstiti ali ce se zato

izvrstiti dio koda koji se nalazi unutar viticastih zagrada poslije catch. Tj. pisace “you can‟t do that” i

program ce zavrsiti sa radom a da nije izracunao ono sto je trebao. Ako zelimo da se program radi sve dok

ne dobijemo kolicnik dva broja mozemo sve ovo umetnuti u do while petlju. Sada klasa Main izgleda

ovako:

import java.util.Scanner; public class Main { public static void main(String args[]){ int x = 1; do{ try{ Scanner input = new Scanner(System.in); System.out.println("enter the first number"); int n1 = input.nextInt(); System.out.println("enter the second number"); int n2 = input.nextInt(); int sum = n1/n2; System.out.println("the result is: "+sum); x=2; }catch(Exception e){ System.out.println("you can't do that"); } }while(x==1); } }

Dakle ova petlja ce se izvrsiti bar jednom. Ili bolje receno izvrsavace se sve dok je promjenjiva x (koju

smo kreirali specijalno da nam posluzi kao test u obicnim zagradama poslije while) jednaka broju 1. Ako

se ono pod try izvrsi vidimo da ce se vrijednost promjenjive x promjeniti na 2 , sto znaci da se ova petlja

nece nastaviti izvrsavati vise. Ali ako se ono pod try ne izvrsi , tj. ako se izvrsi catch promjenjiva x ce

idalje ostati ista (tj x ==1) i uslov pod while ce biti ispunjen tako da ce se dio koda pod do izvrsavati

iznova i iznova dok se ne izvrsi try odnosno dok vrijednos vise ne bude jednaka 1. Mi sa time dobijamo

da ce se nas program iznova i iznova pokretati sve dok ne podjelimo ova dva broja kako treba.

Kada pokrenemo ovaj kod iznad i ako sada podjelimo prvi broj sa nulom, opet se nece izvrsiti djeljenje

vec ce nam pisati “You can‟t do that” i program ce se pokrenuti ponovo (zahvaljujuci do while petlji) sve

dok se ne podjele dva broja bez error-a/Exception-1.

~ 97 ~

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. Iamo glavnu klasu Main i klasu Layout:

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Layout extends JFrame{ private JButton lb; private JButton cb; private JButton rb; private FlowLayout layout; private Container container; public Layout(){ super("the title"); layout = new FlowLayout(); container = getContentPane(); setLayout(layout); lb = new JButton("left"); add(lb); lb.addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent event){ layout.setAlignment(FlowLayout.LEFT); layout.layoutContainer(container); }}); cb = new JButton("center"); add(cb); cb.addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent event){ layout.setAlignment(FlowLayout.CENTER); layout.layoutContainer(container); }}); rb = new JButton("right"); add(rb); rb.addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent event){ layout.setAlignment(FlowLayout.RIGHT); layout.layoutContainer(container); }}); }

Prvo smo inportovali : javax.swing.*, java.awt.* i java.awt.event.*. 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. layout tipa FlowLayout

2. container tipa Container

Dalje smo napravili konstruktor i podesili naslovnu liniju. Nakon toga smo upisali: layout = new

FlowLayout( ) - ustvari smo podesili da objekat layout tipa FlowLayout sadrzi podesavanja koja

poravnavaju u ljevo (layout = new FlowLayout - FlowLayout ima default podesavanje koje poravnava u

centar)..

~ 98 ~

container = getContentPane( ) , ovo sluzi samo da zna gdje da smjesti stvari. Sada cemo postaviti vazeci

raspored tako sto smo ukucali setLayout(layout) ili setLayout(imeobjektaFlowLayout).

Definisali smo lb i dodjelili mu tekst left tj. lb = new JButton(“left”). Zatim smo lb dodali u prozor tako

sto smo ukucali add(lb). Zatim smo dodjelili funkcionalnost lb ukucavsi:

lb.addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent event){ layout.setAlignment(FlowLayout.LEFT); layout.layoutContainer(container); } } );

Komentarisacemo samo layout.setAlignment(FlowLayot.Left) . pomocu ove naredbe mjenjamo

poravnanje . Sve ce biti poravnato na ljevo. Dakle kada zelimo da promjenimo kako ce nesto biti

poravnato ukucamo : imepromjenjiveFlowLayout.setAlignment(FlowLayout.LEFT). Umjesto LEFT

moze biti CENTER (koji poravnava centralno) i RIGHT koji poravnava na desno.

layout.layoutContainer(container), ovo prilicno znaci preuredi sve u zavisnosti od toga koji je nas

Layout ili “raspored”.

Nakon toga smo ovo isto uradili za cb i za rb. Naravno za cb smo stavili da pise “center” i da je Raspored

podesen na layout.setAlignment(FlowLayout.Center) i za rb smo stavili da pise “right” (unutar

“button-a” ) Ii podesil poravnanje na desno tj layout.setAlignment(FlowLayout.RIGHT) .

Glavna klasa Main izgleda:

import javax.swing.*; public class Main { public static void main(String args[]){ Layout l = new Layout(); l.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); l.setSize(300,100); l.setVisible(true); } }


kor: 1 default podesavanja gdje su

"buttoni" poravnati centralno

kor: 3 Kada pritisnemo dugme "left" ,

dugmad ce se poravnati na ljevo

kor: 2 Kada pritisnemo dugme "right" ,

"buttoni" ce se poravnati u desno

kor: 4 Kada pritisnemo dugme "center"

, buttoni ce se poravnati centralno

~ 99 ~

Lekcija 84: Drawing Grpahics

U ovoj lekciji cemo obradjivati grafiku. Imamo dve klase glavnu Main i klasu Bla koja izgleda:

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Bla extends JPanel{ public void paintComponent(Graphics g){ super.paintComponent(g); this.setBackground(Color.WHITE); g.setColor(Color.BLUE); g.fillRect(25,25,100,30); g.setColor(new Color(192,168,1)); g.fillRect(25, 65, 100, 30); g.setColor(Color.RED); g.drawString("this is some text",25,120); } }

Importovali smo java.awt.* , java.awt.event.*i javax.swing.* . Kao sto vidimo klasu Bla smo extend za

Jpanel klasu. Da bih smo crtali u Javi moramo imati metodu paintComponent, koja u parametrima ima

objekat koji predstavlja Graphics klasu. To smo uradili tako sto smo ukucali: public void

paintComponent(Graphics g) . g je objekat klase Graphics. Unutar paintComponent metode mozemo

sada stvarati “grafiku”. Prvu stvar koju moramo uraditi je ustvari “houskeeping” ili odrzavanje. Ukucali

smo super.paintComponent(g); . Pomocu super. Pozivamo metode iz superklase. Pozvali smo metodu

paintComponent I prosljedili parametar g (tj. objekta klase Graphics).

Zatim smo ukucali : this.setBackground(Color.White) , this. – sto znaci ovaj objekat(tj. objekat koji se

nalazi u parametrima unutar metode). Cjela ova naredba postavlja bjelu boju kao pozadinu objekta g).

Da bih smo crtali objekte u Javi prvo moramo podesiti boju koju zelimo koristiti , to cinimo tako sto

ukucamo imeobjektaGraphics.setColor(Color.bojakujuzelimo), ili npr. g.setColor(Color.Blue); . Kada

odredimo boju mozemo poceti sa crtanjem , mi cemo nacrtati pravougaonik. Ukucacemo : g.fillRect(

25,25,100,30) , ili imeGraphicsobjekta.fillRect(polozajodakle pocinje po x osi, polozaj od kojeg pocinje

po y osi, sirina, visina).

Poslije toga smo nacrtali jos jedan pravougaonik ukucavsi: g.setColor(new Color(192,168,1)) i

g.fillRect(25,65,100,30) . Kao sto mozemo primjetiti boju smo podesili na drugaciji nacin . Podesili smo

“Custom” boju tj boju sa RGB vrijednostima gdje je 192 broj koji oznacava koliko crvene boje zelimo,

168 koliko zelene zelimo , I 1 oznacava koliko plave boje zelimo.

Nakon toga smo nacrtali “String” ukucavsi: g.setColor(Color.RED) i g.drawString(“this is some

text”,25,120) ili objekatGraphics.drawString(“stringKojiCeSePojavitiNaEkranu”, polozaj po x osi gdje

ce se pojaviti tekst , polozaj po y osi gdje ce se pojaviti tekst ).

Moramo naznaciti da smo kod svakog crtanja mjenjali boju tj. g.setColor(/*boja*/), sto ne moramo raditi ,

mogli smo jednom postaviti boju i onda crtati ove pravougaonike i string.

~ 100 ~

Glavna klasa Main ima izgled:

import javax.swing.*; public class Main { public static void main(String args[]){ JFrame f = new JFrame("Title"); f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); Bla b = new Bla(); f.add(b); f.setSize(400,250); f.setVisible(true); } }

Importovali smo javax.swing.*.

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.

Zatim smo prozoru f definisali “default” operaciju za zatvaranje tj.

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Nakon toga smo kreirali objekat b koji predstavlja klasu Bla.

Ukucali smo f.add(b); sto prilicno znaci da smo u prozor f dodali objekat b koji predstavlja klasu Bla .

Podesili smo velicinu f prozora na sirina 400 i visina 250 i postavili ga vidljivim.


Dakle imamo dva pravougaonika jedan plave boje , jedan neke znj boje i jedan String “this is some

text”…

~ 101 ~

Lekcija 85:JColorChooser

U ovoj lekciji cemo uciti o JColorChooser. Napravicemo prozor koji ce imait dugme koje kada

pritisnemo izace nam dijaloski okvir da biramo boju koja ce se implementirati na prozor. Imamo dve klase

glavnu klasu Main i klasu Bla koja izgleda:

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Bla extends JFrame{ private JButton b; private Color color = (Color.WHITE); private JPanel panel; public Bla(){ super("the title"); panel = new JPanel(); panel.setBackground(color); b = new JButton("Choose a color"); b.addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent event){ color = JColorChooser.showDialog(null, "Pick a color", color); if(color==null){ color = (color.WHITE); } panel.setBackground(color); }}); add(panel, BorderLayout.CENTER); add(b, BorderLayout.SOUTH); } }

Prvo smo importovali : java.awt.* , java.awt.event.* i javax.swing.*. Nakon toga smo klasu Bla extends

za klasu JFrame.

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, podesili naslov. Unutar konstruktora smo promjenjivoj panel

dodjelili bilo kakvu vrijednost da bih je mogli koristiti tj: panel = new JPanel() . Nakon toga smo podesili

boju pozadine promjenjivoj panel koja uzima boju od Color promjenjive koju smo nazvali color tako sto

smo ukucali: panel.setBackground(color) ili imePromjenjiveJPanel.setBackground(

imePromjenjiveColor).

Nakon toga smo definisali promjenjivu b , stavili smo da ce na dugmetu pisati “Choose a color” tj ukucali

smo: b = new JButton(“Chose a color”). Kada smo to uradili onda smo dodali funkcionalnost

promjenjivoj b tako sto smo dodali ActionListener tj: b.addActionListener(/*unutar zagrada smo

kreirali anonimnu unutrasnju klasu ActionListener (tj. new ActionListener( ) ) koja zahtjeva da se

overvrite metoda actionPerformed unutar koje ce se prosljediti argumenti (ActionEvent event) .

~ 102 ~

Ovu metodu smo overvrite tako sto smo unutar klase ActionListener ukucali : public void

actionPerformed(ActionEvent event){ /*ono sto se nalazi unutar ove metode je ono sto ce se desavati

kada kliknemo na promjenjivu b, ili na prozoru na dugme “Chose a color” */}

Dakle ono sto ce se desavati kada kliknemo na promjenjivu b jeste ono sto pise unutar actionPerformed

metode tj: Promjenjiva Color ce biti jedanaka boji koju izaberemo iz dijaloskog okvira JColorChooser

koji ce se pojaviti kada klikemo na button “Chose a color”. To smo izveli tako sto smo ukucali :

Color = JColorChooser.showDialog(null, “Pick a color”, color). Dakle imaju tri parametra prvi je null

i on oznacava poziciju (tj. pojavice se na centru ekrana), zatim “Pick a color” je ono sto ce pisati na

naslovnoj liniji dijaloskog okvira koji ce se pojaviti, dok je treci argument promjenjiva color , tj. pocetna

boja koja je odabrana( u nasem slucaju bjela boja). Da za treci argument stavimo Color.Blue kada se

pokrene dijaloski okvir da izaberemo boju , boja koju smo stavili kao treci argument ce biti automatski

postavljena kao izabrana boja (to je u nasem slucaju “BLUE” , I ako bih odmah kliknuli OK nas prozor

bih postao plav).

Ispod toga imao napisano: if(color == null) { color = Color.White} – sto znaci ako korisnik pokrene

dijaloski okvir i ne izabere nista ( tj. null , sto znaci da je pritisnuo “X” ili “Cancel”) , da ce boja prozora

biti bjela. Da nemamo ovo if i ovo sto slijedi ispod kada ne bih izabrali nista boja bih se promjenila u neku

default sivu boju.

Na kraju unutar metode actionPerformed imamo panel.setBackground(color) , tj boja koju smo izabrali

iz dijaloskog okvira se skladistila u promjenjivu color i tu promjenjivu smo prosljedili da bude boja

pozadine promjenjive panel.

Sada izvan metode actionPerformed i klase ActionListener unutar samog konstruktora moramo dodati

ove promjenijve u prozor , to smo ucinili tako sto smo ukucali:

add(b, BorderLayout.SOUTH) – samo add(b) znaci da je “button” b dodan u prozor , dok

BorderLayout.SOTH znaci da ce se nalaziti na donjem djelu prozora.

add(panel, BorderLayout.CENTER) – isti slucaj samo sto ce se “panel” nalaziti na centralnom djelu

ekrana i sirice se kako se siri prozor I popunjavati sav prozor.

Glavna kalsa Main ima izgled:

import javax.swing.*; public class Main { public static void main(String args[]){ Bla b = new Bla(); b.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); b.setSize(425,200); b.setVisible(true); } }

Dakle inportovali smo javax.swing.* da bih smo mogli koristiti prozore. Napravili smo objekat b koji

predstavlja klasu Bla i pomocu tog objekta definisali neke stvari sto vidimo iznad.


~ 103 ~

Kada kliknemo na “Choose a color” pojavice se dijaloski okvir

Dijaloski okvir ima 5 tabova za biranje boje , ako npr kliknemo na RGB :

Ako iz taba Swatches izaberemo npr crvenu boju i kliknemo OK :

Ako sada idemo na “Choose a color” i pritisnemo samo “OK” a da ne izaberemo boju , boja ce se vratiit

na Bijelu kao na prvoj slici.

~ 104 ~

Lekcija 86: Drawing More Stuff

U ovoj lekciji cemo uciti kako se crtaju , jos neki oblici. Imacemo dve klase glavnu Main i klasu Bla:

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Bla extends JPanel { public void paintComponent(Graphics g){ g.setColor(Color.BLUE); g.drawLine(10, 10, 250, 30); g.setColor(Color.RED); g.drawRect(10, 50, 100, 30); g.setColor(Color.GREEN); g.fillOval(10, 90, 100, 30); g.setColor(Color.YELLOW); g.fill3DRect(10, 130, 100, 40, true); } }

Dakle prvo smo importovali java.awt.* , java.awt.event.* i javax.swing. Klasu smo extend za JPanel.

Kao sto znamo da bih smo crtali oblike , moramo to raditi u metodi paintComponent, pa smo je shodno

tome kreirali i u parametrima stavili Graphics g.

Unutar paint Component metode smo nacrtali :

Liniju odnostno : g.drawLine(10,10, 250, 30) ili g.drawLine(pozicija po x osi, pozicija po y osi,

sirina , visina)

Pravougaonik g.drawRect(10 , 50 ,100 , 30)

“Oval” g.fillOval(10,90,100,30)

“3D” Pravougaonik tj. g.fill3DRect(10, 130, 100, 40, true) tj. g.fill3DRect (pozicija po x osi,

pozicija po y osi, sirina , visina, da li da dobije “3D odlike” (mozemo staviti true ili false) ).

Moramo naglasiti razliku izmedju draw i fill , draw samo nacrta oblik dok fill nacrta oblik i popuni ga

bojom koju smo odredili pomocu g.setColor(Color.bojaKojuZelimo).

Glavna klasa Main Izgleda:

import javax.swing.*; import java.awt.*; public class Main { public static void main(String args[]){ JFrame f = new JFrame("title"); f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); Bla b = new Bla(); b.setBackground(Color.WHITE); f.setSize(500,500); f.setVisible(true); f.add(b); } }

~ 105 ~

Kada pokrenemo

program dobijemo:

Lekcija 87: Series Finale

U ovoj lekciji cemo malo obradjivati “String-ove” . Imacemo jednu glavnu klasu Main, koja izgleda:

public class Main { public static void main(String args[]){ String a ="apples"; String b ="djordje"; String c ="DJORDJE"; System.out.println("duzin stringa a je: "+a.length()); if(b.equals(c)){ System.out.println("string b je isti kao string c");} else{ if(b.equalsIgnoreCase(c)){ System.out.println("b je isti kao c, ako ignorisemo velika/mala slova"); }else{ System.out.println("string b nije isti kao string c");} }}}

Kreirali smo tri promjenjive tipa String tj:

String a =”apples”

String b =”djordje”

String c =”DJORDJE”

Svakom stringu smo dodjelili neku vrijednost. Zatim smo ukucali a.length , ili

imePromjenjiveTipaString.length sto nam prikazuje koliko karaktera ima dati string. To smo prikazali na

ekranu pomocu naredbe System.out.println( ).

Dalje smo uporedjivali promjenijivu b sa promjenivom c(obe su tipa String), na nacin da samo ukucali :

b.equals(c) ili imePromjenjiveKojuZelimoUporediti.equals(ImePromjenjiveSaKomZelimoUporediti).

Kao rezultat tog uporedjivanja bih smo dobili logicku vrijednost false, sto znaci da string b nije isti kao

string c. Medjutim sem uporedjivanja Stringova pomocu b.equals(c ) , stringove mozemo uporedjivati

tako da zanemarimo velika/mala slova, u ovom slucaju ukucali smo: b.equalsIgnoreCase(c) ili :

imePromjenjivekojuZelimoUporediti.equalsIgnoreCase(ImePromjenjiveSaKojomUporedjujemo). Kao

rezultat bih smo dobili logicku vrijednost true tj. da su ova dva stringa ista ako zanemarimo da li su pisani

velikim ili malim slovimaj.

Kada pokrenemo kod dobijemo:

~ 106 ~

duzin stringa a je: 6

string b je isti kao string c, ako ignorisemo velika/mala slova

the new boston java programiranje (begginer).pdf

Documents