Zavrsen seminarski rad java
sascha1988
sascha1988

Zavrsen seminarski rad java

39 str.
6broj preuzimanja
1000+broj poseta
100%od3broj ocena
Opis
Java seminarski rad
20 poeni
poeni preuzimanja potrebni da se preuzme
ovaj dokument
preuzmi dokument
pregled3 str. / 39
ovo je samo pregled
3 prikazano na 39 str.
preuzmi dokument
ovo je samo pregled
3 prikazano na 39 str.
preuzmi dokument
ovo je samo pregled
3 prikazano na 39 str.
preuzmi dokument
ovo je samo pregled
3 prikazano na 39 str.
preuzmi dokument

Beogradska poslovna škola

Seminarski rad – Java Tema: Petlje i logika

Student:

Branimir Topalović

2A1/0299/03

Sadržaj:

Contents

1

2

3 Uvod 3

4 Donošenje odluka 3

5 Izvođenje poređenja 3

6 Izraz IF 5

7

8 Blokovi iskaza 6

9 Klauzula else 8

10 Logički operatori 11

10.1 Logičke operacije AND 11

10.2 Poređenje operatora && i & 12

10.3 Logičke operacije OR 14

10.4 Bulove operacije NOT 14

11 Kondicioni operator 15

12 Iskaz switch 17

12.1 Pravljenje prekidača 19

13 Petlje 24

13.1 Vrste petlji 26

13.1.1 Ugnježđene petlje 29

13.2 Iskaz continue 29

13.3 Označeni iskaz continue 30

13.3.1 Isprobajte Označeni iskaz continue 30

13.4 Korišćenje iskaza break u petljama 32

13.5 Označeni iskaz break 35

14 Zaključak 38

15 Literatura: 38

16 Net beans – slike koda 39

Uvod U ovom poglavlju naučićemo kako da u svojim Java programima donosimo odluke i pravimo izbore. Osim toga, naučićemo i kako da svoje programe „nateramo“ da ponavljaju određene skupove akcija sve dok se ne ispuni neki konkretan uslov. U ovom poglavlju ćemo naučiti:

• Kako se porede vrednosti podataka;

• Kako se definišu logički izrazi;

• Kako da korišćenjem logičkih izraza izmenite redosled izvršenja iskaza programa;

• Kako se biraju različiti izrazi u zavisnosti od vrednosti nekog logičkog izraza;

• Koliko dugo traju vaše promenljive;

• Kako da ponovite neki blok koda određen broj puta;

• Kako da ponavljate neki blok koda sve dok je određeni logički izraz tačan;

• Kako se petlje i blokovi iskaza razbijaju na manje celine;

• Šta su tvrdnje i kako se koriste.

Svi naši iole značajni programi koristiće bar neke, a najčešće skoro sve, jezičke mogućnosti i programerske tehnike o kojima ćemo govoriti u ovom poglavlju, tako da je veoma bitno da ih dobro savladate.Ali pre svega prvo ćemo razmotroti donošenje odluka u kodu i posledice koje te odluke imaju na način na koji se program izvršava.

Donošenje odluka Pravljenje izbora biče jedan od fundamentalnijih elemenata svih naših programa. Tu pre svega mislimo na odluke tipa: „Ukoliko korisnik želi da unese još podataka, primiti još jednu vrednost sa tastature“ ili „Ukoliko je stanje u banci previše povoljno, kupiti sportski automobil, u suprotnom obnoviti mesečnu autobusku kartu“. O kakvoj god odluci da je reč, u kontekstu programiranja potrebno je izvršiti poređenje nekih promenljivih, konstanti i vrednosti iskaza i zatim, u zavisnosti od rezultata datog poređenja, izvršiti jednu ili drugu grupu iskaza. Prema tome, da biste mogli da razumete proces donošenja odluka u programima, najpre treba da vam bude jasno kako se izvršavaju poređenja.

Izvođenje poređenja Relacioni operatori Opis

> Vraća vrednost true ukoliko je levi operand veći od desnog, a false u suprotnom. >= Vraća vrednost true ako je levi operand veći ili jednak sa desnim, a false u

suprotnom. == Vraća vrednost true ako je levi operand jednak sa desnim, a false u suprotnom. != Vraća vrednost true ako levi operand nije jednak sa desnim , a false u suprotnom. <= Vraća vrednost true ako je levi operand manji ili jednak sa desnim, a false u

suprotnom.

< Vraća vrednost true ako je levi operand manji od desnog, a false u suprotnom. U Javi postoji šest relacionih operatora za poređenje dve vrednosti. Mogu se porediti vrednosti promenljivih, konstanti ili izraza izvedenih iz Javinih osnovnih tipova podataka – byte, short, int, long, char, float ili double.

Kao što vidite svaki od ovih operatora može vratiti ili vrednost true ili vrednost false, što ih čini podesnim za proces donošenja odluka. Iz ovoga možete zaključiti i to da za čuvanje rezultata poređenja možete da koristite promenljive tipa boolean. U prethodnom poglavlju ste naučili kako se deklarišu bulove promenljive. Na primer, mogli bismo da deklarišemo Bulovu promenljivu state i da joj dodelimo vrednost koja će biti rezultat poređenja:

boolean state = false; // Definisanje i inicijalizovanje promenljive

state = x – y < a + b; // Smeštanje rezultata poređenja x-y i a+b

Promeljiva state će u iskazu dodele dobiti vrednost true ako je x – y manje od a + b, a false u suprotnom.

Da biste razumeli na koji način se prethodni izraz evoluira, vratite se na trenutak na tabelu u kojoj smo naveli prioritete operatora. Videćete da operatori poređenja imaju niži prioritet aritmetičkih operatora, što znači da se aritmetičke operacije uvek izvode pre poređenja, osim, naravno, ako zagradama nije drugacije naznačeno. Izraz

x – y == a + b

daje true ako je x-y jednako sa to a+b, jer se ovi aritmetički podizrazi prvi evaluiraju, a dobijene vrednosti onda postaju operandi operatora ==. Naravno, stavljanje zagrada bi nam pomoglo, iako one nisu neophodne, zato što onda ne bi bilo nikakve sumnje u to šta se ovde zapravo dešava.

(x – y) == (a + b)

Ukoliko levi i desni operand relacionog operatora pripadaju različitim tipovima, vrednosti se promovišu isto kao i u mešanim aritmetičkim izrazima koje smo vam prikazali u prethodnom poglavlju. Dakle, ukoliko promenljiva aDouble pripada tipu double, a number tipu int:

aDouble < number + 1

rezultat izraza number + 1 biće izračunat kao tip int i ta vrednost će biti promovisana u tip double pre njenog poređenja sa promenljivom aDouble.

Izraz IF

Prvi iskaz koji može da koristi rezultat nekog poređenja koji ćemo ovde razmotriti jeste iskaz if. Iskaz if u svom najjednostavnijem obliku izgleda ovako:

If(expression)

statement;

Reč expression može da bude bilo koji izraz koji pri izračunavanju daje vrednost true ili false. Ovaj mehanizam je grafički prikazan na slici.

Ukoliko je vrednost izraza expression true, iskaz koji sledi nakon iskaza if se izvršava; u suprotnom, on se neće izvršiti. Evo kako to izgleda u praksi:

If(number%2 != 0) // Proverava da li je broj neparan

++number; // Ako jeste, pretvara se u paran

Uslov if unutar zagrada proverava da li je vrednost promenljive number parna, tako što poredi ostatak nakon deljenja sa dva sa 0. Ukoliko ostatak nije jednak 0, vrednost promenljive number je neparan i u tom slučaju se dodaje 1 kako bi postalo paran. Ukoliko je vrednost u startu parna, iskaz kojim se povećava vrednost promenljive number se ne izvršava.

Skreće se pažnja na to kako je poravnat izraz u drugom redu. To je učinjeno kako bi se videlo da on zavisi od uslova if. Preporučuje se da u svojim programima uvek poravnate iskaze tako da ukazuju na strukturu programa. Kao smernice u tome kako da se poravnaju iskazi mogu da posluže i komplikovaniji primeri.

Jednostavni iskazi if nekada zauzimaju samo jedan red. Prethodni primer smo mogli da napišemo i ovako:

If(number%2 !=0) ++number; // Ako je broj neparan pretvara se u paran

Ovo je sasvim u redu. Kompajler ignoriše višak prostota i znake za početak novog reda – znak tačka – zarez ponaša se kao graničnik iskaza. Pišući if iskaze na ovaj način uštedećete malo prostora, a nekada to može da doprinese i razumljivosti – recimo, kada imate nekoliko uzastopnih ovakvih poređenja. Ipak, uopšteno govoreći, bolje je da iskaze sa akcijama ne pišete u onom redu u kome se neki uslov proverava.

Blokovi iskaza

U osnovi, gde god u Javi imate jedan izvršni iskaz, možete imati i blok iskaza koji ćete staviti u vidu vitičaste zagrade. Ovo se odnosi i na iskaze unutar blokova iskaza, što znači da jedan blok iskaza u vitičastim zagradama uvek možete da ugnjezdite unutar nekog drugog. Mogućnost korišćenja blokova na svim onim mestima na kojima možete da koristite jedan iskaz znači da u okviru osnovnog iskaza if koji ste upravo videli takođe možete imati blok iskaza. Prema tome, iskaz if može imati i ovakav oblik:

If(expression) {

statement 1;

statement 2;

...

statement n;

}

U ovom slučaju ako je vrednost iskaza expression true izvršiće se svi iskazi koji su obuhvaćeni sledećim blokom. Naravno, ako izostavimo vitičaste zagrade, u kodu više nećemo imati blok:

If(expression)

statement 1;

statement 2;

...

statement n;

U ovom slučaju, samo prvi iskaz, statement 1 neće biti izvršen kada iskaz if da rezultat false; ostali iskazi se izvršavaj bez obzira na vrednost izraza expression. Iz ovoga možete videti da poravnavanje predstavlja samo vizuelnu potporu ovog mehanizma. Ono ni na koji način ne utiče na način izvršenja koda programa. Iako izgleda kao da nekoliko iskaza pripada iskazu if, zbog izostavljanja zagrada, to se odnosi samo na prvi iskaz. Dakle, poravnanje u ovom slučaju nije bilo pravilno zato što navodi na pogrešan zaključak. Prethodni kod je trebalo napisati ovako

If(expression)

statement 1;

statement 2;

...

statement n;

U ovoj knjizi smo se pridržavali konvencije da se vitičasta zagrada kojom se blok otvara nalazi uvek u isotm redu u kome se nalazi uslov if. Vitičasta zagrada kojom se blok zatvara poravnata je sa prvim slovom, i , ključne reči if. Svi iskazi u ovoj knjizi poravnati su na ovaj način kako bi bilo očigledno da pripadaju bloku. Ovo je u skladu i sa načinom koji smo koristili i u primerima u kojima se definiše klasa i blokovima koji pripadaju metodima. Postoje druge konvencije koje će se možda vama više svideti. Čest slučaj je i da se vitičaste zagrade koje ograničavaju blok nalaze u poslednjim redovima takodje poravnate. Jedino je bitno da u onoj konvenciji koju izaberete budete dosledni.

Evo jednog praktičnog primera iskaza if u kome postoji blok iskaza:

If (number%2 != 0) { //Proverava da li je broj neparan

//Ako jeste, pretvara se u paran i izbacuje se poruka

++number;

System.out.println(“Number was forced to be even end is now” +number ) ;

}

Ukoliko if izraz pri izračunavanju vrati true, izvršiće se oba ova iskaza, a u suprotnom, kada je vrednost iskaza if false, ne izvršava se ni jedan. Preporučuje se da kod koji zavisi od uslova iskaza if uvek stavljate u vitičaste zagrade, čak i kada je u pitanju samo jedan iskaz. Ovakva praksa čini kod preglednim i smanjuje mogućnost pogrešnog tumačenja logike programa.

Blokovi iskaza nisu samo zgodan način za grupisanje iskaza – oni utiču na život i dostupnost promenljivih. Na blokove iskaza ćemo se vratiti u nastavku poglavlja kada budemo govorili o oblasti važenja promenljivih. U medjuvremenu, razmotrimo nešto detaljnije šta sve može da se učini sa iskazima tipa if.

Klauzula else

Osnovni iskaz if može da se proširi dodavanjem klauzule else. Na ovaj način se u iskazu ili bloku iskaza obezbedjuje i i alternativni izbor koji se izvršava kada se izračunavanjem iskaza expression u okviru iskaza if dobije vrednost false. Na slici možete da vidite kako izgleda sintaksa ovog iskaza i kako u tom slučaju izgleda tok programa.

Da Ne

.

if (expression) {

statement1;

} else {

statement2;

}

next_statement;

Ovim je obezbedjen eksplicitni izbor izmedju dve akcije – jedan kada iskaz if ima vrednost true i drugi, kada je njegova vrednost false. Ovo što ste sada videli primenićemo u konzolnom programu, a istovremeno ćemo isprobati i metod random () klase Math.

Isprobajte if-else

Kada upišete kod ovog programa, sačuvajte ga u vidu datoteke po imenu NumberCheck.java. Zatim ga kompajlirajte i pokrenite nekoliko puta kako biste videli koje će vam rezultate prikazati.

public class NumberCheck {

public static void main (String[] args) {

int number = 0;

number = 1+ (int) (100*Math.random()); // Slučajan izbor celobrojne vrednosti

// izmedju 1 i 100

If (number %2 == 0) { // Provera da li je parna

System.out.println (“ You have got an even number, “ + number); // Paran je

} else {

System.out.println(“You hav got an odd number, + number); // Neparan je

}

}

}

Poređenje enumeracionih vrednosti

Promenljive tipa enumeracije ne možete da poredite korišćenjem operatora poređenja, ali možete korišćenjem metoda koji postoji u okviru svakog objekta enumeracije. Pretpostavimo da smo najpre definisali tip enumeracije.

enum Season { spring, summer, fall, winter }

Zatim bismo mogli da definišemo i inicijalizujemo promenljivu tipa Season sledećim iskazom:

Season season = Season.summer;

Ukoliko bismo kasnije želeli da proverimo aktuelnu vrednost promenljive season, mogli bismo da napišemo:

If(season.equals(Season.spring) {

System.out.println(“Spring has sprung, the grass is riz.”);

} else {

System.out.println(“It isn/’t Spring!”);

}

Ovim smo pozvali metod equals() za enumeraciju na koju se odnosi promenljiva season. Ovaj metod će uporediti vrednost promenljive season sa vrednođću unutar zagrada i izbaciti rezulat true ako su iste, a false ako su različite. Metod equals() bismo mogli da upotrebimo i za opređenje promenljive season sa drugom promenljivom tipa season – na primer:

Season best = Season.winter; //Nova promenljiva inicijalizovan je vrednošću winter

If(season.equals(best)) {

System.out.println(“season is the same as best, and is equal to “+ best);

} else {

System.out.println(“ season has the value “+season +

“ and best has the value “ + best);

Nakon definisanja promenljive best, proverili smo da li je vrednost promenljive season jednaka sa vrednošću best. Ako jeste, izvršava se prvi iskaz sa izlazom. Ako promenljive best i season nisu jednake, izvršava se iskaz sa izlazom koji se nalazi u bloku else.

Logički operatori Testovi koje smo do sada stavljali u if izraze bili su relativno jednostavni, međutim, stvarnost je obično znatno složenija. Vrlo često ćete imati situaciju da u nekoj putanji izvršenja kombinujete više uslova – na primer, moglo bi da vam bude potrebno da se svi oni istovremeno evaluiraju kao true. Recimo, uslovi za vožnju toboganom mogli bi da budu starost preko 12 godina i visina veća od 120cm, a manja od 180cm. Ako se samo jedan od ovih uslova ne ispuni, nema ništa od vožnje. Isto tako, nekada će vam biti potrebno da se bilo koji od više postavljenih uslova ispuni – na primer, jeftinije karte dobijaju lica mladja od 16 ili starija od 65 godina.

U obe ove situacije, ali u mnogim drugim, možete da koristite logičke operatore i pomoću nijih kombinujete nekoliko izraza koji mogu imati vrednost true ili false. S obzirom na to da se ovi operatori primenjuju na vrednosti tipa boolean, oni se nazivaju i bulovi operatori. Postoji per logičkih operatora koji se mogu primeniti na boolean vrednosti:

Simbol Puno ime

& logički AND

&& uslovni AND

| logički OR

|| uslovni OR

! logička negacija (NOT)

Ovo su veoma jednostavni operatori; jedino što bi eventualno moglo da vas zbuni jeste izbor između dva operatora za svako AND i OR. Dodatni operatori u ovoj tabeli su bitovni operatori & ili | iz prethodnog poglavlja, koje takođe možete da primenite na boolean vrednosti, i koji imaju za nijansu drugačiji efekat od operatora && i ||. Najpre ćemo vam uopšteno reći za šta se svaki od ovih operatora koristi, a onda ćete kroz primere videti i kako se koriste.

Logičke operacije AND

U situacijama kada imate dva logička izraza koji moraju da se ispune da bi i konačan rezultat bio pozitivan – recimo, da budete i bogati i zdravi – možete da koristite oba operatora AND, && ili &. Oba operatora AND daće isti rezultat iz logičkog izraza. Ubrzo ćemo vam reći i po čemu se oni razlikuju, ali najpre razmotrimo kako se koriste. Sve što sada sledi u jednakoj meri se odnosi i na & i na &&.

Pogledajmo kako logički operatori mogu da pojednostave naš poslednji primer. Prilikom provere promenljive tipa char, u cilju određivanja da li je u pitanju malo i veliko slovo, mogli smo da upotrebimo operator &&. Vrednost koja se proverava treba istovremeno da bude veća ili jednaka sa ‘A’ i (AND) manja ili jednaka sa ‘Z’. Ako se pri izračunavanju oba uslova dobije true, u pitanju je veliko slovo. Oslanjajući se na naš prethodni program u kome je neka vrednost sačuvana u pormenljivoj tipa char po imenu symbol, operator && bi mogao da na pomogne da proveru velikog slova izvedemo korišćenje samo jednog iskaza if:

If (symbol >= ‘A’ && symbol <= ‘Z’ )

System.out.println(“You have the capital letter ” + symbol);

U tabeli prioriteta iz poglavlja 2 možete videti da se relacioni operatori izvršavaju pre operatora &&, tako da nam zagrade nisu neophodne. U ovom slučaju iskaz sa izlazom se izvršava samo ako oba iskaza povezana operatorom && pri izračunavanju vrate true. Međutim, u skladu sa onim što smo već rekli, bolje je da stavimo zagrade. Kôd će tako biti čitkiji, a opasnost da napravimo grešku manja.

Rezultat operacije && je, zapravo, sasvim jednostavan – true, samo ako oba operanda pri evaluaciju vrate true; u suprotnom, rezultat ove operacije biće false.

A sada ćemo malo da izmenimo skup iskaza if iz našeg poslednjeg primera.

Poređenje operatora && i &

Pogledajmo sada po čemu se razlikuju oeratori && i &. Osnovna razlika izmedju njih jeste to što uslovni && uopšte ne izračunava vrednost operanda na desnoj strani ukoliko je evaluacijom levog operanda dobijen rezultat false, jer će rezultat u svakom slučaju biti false. Ova situacija, kada se levi operand izračuna kao false, može da učini kôd bržim.

Primera radi, obratite pažnju na sledeći primer:

Int number = 50;

If (number<40 && (3*number - 27)>100) {

System.out.println(“number = ” + number);

}

U ovom slučaju izraz (3*number - 27)>100 se nikada neće izvršiti zato što pri evaluaciji izraza number<40 uvek dobije false. Ali, ako bismo ove iskaze neznatno izmenili,

Int number = 50;

If(number<40 & (3*number - 27)>100) {

System.out.println(“number = “ + number);

}

efekat bi bio drugačiji. U ovom slučaju uvek se evaluira ceo logički izraz. Iako je levi operand sa leve strane operatora & izračunat i iznosi false, a krajnji ishod potpuno izvestan, u ovom slučaju ćemo uvek imati i evaluaciju desnog operanda ((3*number - 27)>100).

Da li to, onda, znači da treba uvek da koristite operator &&, kako bi programi bili brži, i zaboravite na operator &? Nikako. Sve zavisi od toga šta u konkretnoj situaciji želite da postignete. U većini slučajeva moći ćete da koristite operator &&, ali će postojati i situacije u kojima ćete želeti da se obavezno evaluira i desni operand. Isto tako, dešavaće se da želite da se desni oerand nikako ne evaluira ukoliko evaluacija levog da rezultat false.

Prva situacija bi mogla da bude kada izraz sa desne strane operatora podrazumeva i promenu vrednosti promenljive, a vi želite da se ona u svakom slučaju izmeni. Evo jednog takvog iskaza:

If(++value%2 == 0 & ++count < limit) {

// Učiniti nešto

}

U ovom sčučaju vrednost promenljive count se povećava u savkom slučaju. Da smo, umesto operatora & upotrebili &&, vrednost promenljive count bi se uvećavala za jedan samo ako se levi operand operatora AND evaluira na true. Dakle, rezultat se menja u zavisnosti od operatora.

Drugu grupu situacija ilustrovaćemo sledećim primerom:

If(count > 0 && total/count > 5) {

//Učiniti nešto...

}

U ovom slučaju desni operand operatora && izvršiće se samo ako se levi operand evaluira na true – odnosno, ako promenljiva count ima pozitivnu vrednost. Da smo ovde upotrebili operator &, aispostavi se da je vrednost promenljive count nula, na kraju bismo imali pokušaj deljenja vrednosti promenljive total nulom, što bi, u odsustvu koda koji to sprečava, dovelo do prekida programa.

Logičke operacije OR

Operatori tipa OR, | i ||, koriste se kada želite rezultattreue ukoliko jedan ili oba operatora pri evaluaciji budu treu. Logički operator OR, ||, ima sličan efekat kao i logički NAD, u tom smislu da sprečava procenu desnog operanda ukoliko se pri evaluaciji levog dobije true. Ako se pri izračunavanju levog operanda dobije true, jasno je i da će krajnji rezultat biti true, bez obzira da li je vrednost desnog true ili false.

Evo jednog primera. Jeftinije ulaznice imaju sva lica mlađa od 16 godina i starija od 65; ovu situaciju ćemo proveriti pomoću sledećeg iskaza if:

If(age < 16 || age>= 65) {

ticketPrice *= 0.9; // Umanjene cene za 10%

}

Vrednost promenljive ticketPrize smnjuje se za 10% ukoliko se pri izračunavanju bilo kog od ova dva uslova dobije true. Naravno, jasno je da u ovom slučaju nije moguće da se oba uslova evaluiraju na true.

Kod operatora | i ||, rezultat false dobijate samo ako se pri evaluaciji oba operanda dobije false. Ako je jedan od njih true, i kranji rezultat je true.

Bulove operacije NOT

Sledeći tip logičkih operatora, !, primenjuje se na jedan boolean operand, što rezultira inverznom vrednošću operanda. Dakle, ako je vrednost Bulove promenljive po imenu state, true, izraz !state će rezultirati vrednošću false; nasuprot tome, vrednost false će izrazom !state biti promenjena u true. Da biste videli kako se ovaj operand koristi u izrazima, neznatno ćemo izmeniti deo koda u kome smo se bavili jeftinijim ulaznicama:

If(!(age >= 16 && age < 65)) {

ticketPrice *= 0.9; //Smanjuje cenu karte za 10%

}

Izraz (age >= && age < 65) ima vrednost true ukoliko je vrednost promenljive age izmedju 16 i 64. Ljudi te starosti nemaju popust, što znači da se popust dobija samo kada se ovaj izraz evaluira na false. Primenom operatora ! na rezultat izraza dobićemo željeni efekat.

Operator ! bismo mogli da primenimo i na omiljeni izraz Čarlsa Dikensa:

!(Income>Expedniture)

Ukoliko se ovaj izraz evaluira na true, rezultat je siromaštvo, koje u najboljem slučaju počinje onog trenutka kada banka počne da odbija vaše čekove.

Naravno, kad god je potrebno, logički operatori mogu i da se kombinuju. Kada bi uprava nekog zabavnog parka odlučila da obezbedi popust za svakoga ko je mlađi od 12 godina i niži od 125cm, kao i za svakoga ko je stariji od 65 i viši od 187 cm, to bismo mogli da formulišemo sledećim testom:

If((age < 12 && height < 48) || (age > 65 && height > 72)) {

ticketPrice *= 0.8; // 20% niža cena ulaznice

}

Operator && ima viši prioritet od operatora || , tako da nam zagrade ovde nisu bile potrebne. Međutim, njihovo stavljanje je učinilo jasnijim kombinovanje poređenja, a kôd postao čitkiji.

Nemojte mešati bitovne operatore &, | i ! sa logičkim operatorima identičnog izgleda. Vrsta operatora koji ćete koristiti u svakom konkretnom slučaju zavisi od tipa operanda. Bitovni operatori se primenjuju na celobrojne vrednosti i njihovi rezultati su takođe celi brojevi. Logički operatori se primenjuju na operande koji imaju Bulove vrednosti i njihov rezultat je takođe Bulova vrednost – true ili false. Ukoliko je to potrebno, u istom izrazu možete da koristite i bitovne i logičke operatore.

Kondicioni operator

Kondicioni operator se nekada naziva i ternarni operator zato što ima tri operanda. Najbolje ćete ga razumeti kroz primer. Pretpostavimo da imamo dve promenljive tipa int čija su imena yourAge i myAge i da sada veću od njih želimo da oddelimo trećoj promenljivoj, older, koja takođe pripada tipu int. Do nađeg cilja stići ćemo sledećim iskazom:

older = yourAge>myAge ? yourAge : myAge;

Prvi od tri operanda kondicionog operatora je logički izraz – u ovom slučaju, to je izraz yourAge>myAge. Ukoliko se pri izračunavanju ovog izraza dobije true, operand koji sledi nakon simbola ? - ovde je to promenljiva yourAge, evaluira se i dobijeni rezltat predstavlja rezultat operacije. Ako se pri evaluaciji izraza yourAge>myAge dobije false, tada se evaluira treći operand, koji dolazi odmah iza znaka dve začke – u ovom slučaju, myAge i dobijeni rezultat predstavlja rezultat operacije. Prema tme, rezultat ovog kondicionog izraza je yourAge, ako je yourAge veće od myAge u suprotnom. Ova vrednost se zatim smešta u promenljivu older. Korišćenje kondicionog operatora u ovom iskazu dodele ekvivalentno je sledećem iskazu if:

If(yourAge > myAge) {

older = yourAge;

} else {

older = myAge;

}

Skrećemo vam pažnju na to da kondicioni operator nije iskaz, već samo operator, tako da ga možete koristiti i u složenijim izrazima sa više drugih operatora.

Uopšteno govoreći, kondicioni operator može da se napiše ovako:

logical_expression ? expression : expression2

Ukoliko se pri evaluaciji operanda logical_expression dobije true, rezultat operacije predstavlja vrednost izraza expression1, a ako se pri izračunavanju logical_expression dobije false, rezultat operacije biće vrednost expression2. Skrećemo vam pažnju na to da ako dođe do evaluacije izraza expression1 zato što vrednost logical_expression true, tada izraz expression2 neće biti evaluiran, i obratno.

Kondicioni operatori mogu da se koriste u čitavom nizu situacija. Veoma često oni se koriste za kontrolu izlaza u zavisnosti od rezultata nekog izraza ili vrednosti neke promenljive. Možete da varirate poruku izborom jednog ili drugog tekstualnog niza u zavisnosti od naznačenog uslova.

Iskaz switch

Iskaz switch možete da koristite prilikom izbora jedne od nekoliko mogućnosti koje se baziraju na skupu fiksiranih vrednosti za dati izraz. Izraz mora da rezultira celim brojem koji ne pripada tipu long, ili vrednošću tipa enumeracije. To znači da izraz koji kontroliše iskaz switch može da rezultira vrednosšću tipa char, byte, short ili int, konstantom enumeracije.

U svom uobičajenom obliku, iskaz switch funkcioniše poput rotacionih prekidača kod kojih takođe možete da izaberete jednu od ponuđenih opcija. Na modelima nekih proizvođača veš mašina uoravo na ovaj način, dakle okretanjem kružnog prekidača, možete da izaberete rezličite kombinacije parametara – odnosno, programe za pamuk, vunu ili sintetička vlakna.

Evo kako izgleda iskaz switch u koji je ugrađena logika za veš mašinu:

switch(wash) {

case 1: // program 1 je za pamuk

System.out.println(“Cotton selected”);

break;

case 2; // program 2 je za platno

System.out.println(“Linen selected”);

break;

case 3; // progrma 3 je za vunu

System.out.println(“Wool selected”);

break;

default: // nije validna vrednost za pranje

System.out.println(“Slection error”);

break;

}

Izbor iskaza switch određen je vrednosšću izraza koji se nalazi unutar malih zagrada nakon ključne reči switch. u ovom slučaju to je jednostavno promenljiva wash koji bi pre toga morala da se deklariše kao tip char, byte, short ili int. Moguće opcije iskaza switch definišu se jednom ili više vrednosti grananja, koji se nazivaju i oznake grananja, a definišu korišćenjem ključne reči case. U osnovi, oznaka grananja, sastoji se

od ključne reči case iza koje dolazi konstantna vrednost koja predstavlja vrednost datog izbora, a zatim dve tačke. Iskazi koji se izvršavaju kada se izabere data alternativa navedeni su iza oznake grananja. Sve oznake grananja i iskazi koji su na njima povezani stavljaju se unutar zagrada iskaza switch. u prethodnom slučaju imali smo tri vrednosti grananja, kao i posebnu vrednost sa oznakom default, koji predstavlja novu ključnu reč. Konkretna vrednost grananja biva izabrana ukoliko je vrednost izraza switch ista kao i konkretna vrednost grananja. Grananje default biva izabrano kada vrednost izraza switch ista kao i konkretna vrednost grananja. Iako smo u prethodnom primeru redom poređali grananja prema njihovoj vrednosti, ona mogu da se postave bilo kojim redosledom.

Kada se izabere neko konkretno grananje, odmah zatim izvršavaju se iskazi koji slede nakon njegove oznake. Dakle, ukoliko promenljiva wash dobije vrednost 2, izvršavaj se iskazi:

case 2: // program 2 je za platno

koji slede. U ovom slučaju to su iskazi:

System.out.println(“Linen selected”);

break;

Kada se izvrši iskaz break, izvršenje se nastavlja do iskaza koji sledi nakon zatvorene zagrade koji pripada iskazu switch. Iskaz break nije obavezan u svakom grananju, ali ako ga ne stavite na kraju iskaza grananja, izvršiće se redom iskazi sledećeg grananja i tako sve dok program ne stigne do nekog iskaz break ili do kraja bloka switch. Obično to nije ono što ste vi želeli. Iskaz break nakon iskaz default u našem primeru nije obavezan, ali nam omogućava da, bez opasnosti da eventualno zaboravimo da njime završimo prethodni iskaz, kasnije dodamo još jednu oznaku grananja.

Svaki izbor koji je obuhvaćen iskazom switch mora da ima svoju oznaku i sve vrednosti grananja moraju biti različite. Grananje default koje smo imali u prethodnom primeru je, uopšteno govoreći, stvar vašeg izbora. Kao što smo rekli, ono se bira kada vrednosti izraza koji pripada iskazu switch ne odgovara nijednoj od definisanih vrednosti grananja. Ukoliko ne naznačite slučaj default, a vrednost izraza switch se ne polčopi ni sa jednom od oznaka grananja, neće se izvršiti nijedan iskaz bloka switch, a izvršenje će se nastaviti od iskaza koji sledi nakon zatvaranja zagrade koja pripada iskazu switch.

Prethodni iskaz switch ćemo sada da izmenimo kako bi se izraz koji ga kontroliše koristila promenljiva tipa enumeracije. Pretpostavimo da smo na sledeći način definisali tip enumeracije WashChoise:

enum WashChoise { cotton, linen, wool } // Definiše tip enumeracije

Sada možemo da kodiramo iskaz switch:

WashChoise wash = WashChoise.linen; //Inicijalna vrednost promenljive

//Neki dodatni kôd koji bi trebao da promeni vrednost wash...

switch(wash) {

case cotton:

System.out.println(“Cotton selected”);

break;

case linen:

System.out.println(“Linen selected”);

break;

case wool:

System.out.println(“Wool selected”);

break;

}

Iskaz switch se i uvom slučaju kontroliše vrednošću promenljive wash. Skrećemo vam pažnju na način na koji se konstante enumeracije koriste kao vrednosti grananja. U ovom kontekstu morate da ih napišete bez kvalifikovanja imenom tipa enumeracije, u protivnom se kôd neće kompajlirati. Korišćenje konstanti enumeracije kao vrednosti grananja čini iskaz switch sasvim očiglednim. Sasvim je jasno na šta se svaki slučaj odnosi. S obzirom na to da premenljivoj tipa enumeracije ne možete da dodelite vrednost koja nije definisana kao konstanta enumeracije, ove ne moramo da definišemo i podrazumevani slučaj.

Pravljenje prekidača

U ovom primeru postoji iskaz switch, koji kontroliše celobrojni tip, i iskaz switch koji kontroliše tip enumeracije:

public class TrySwitch {

enum WashChoise {cotton, linen, wool, syntetic} //Definisanje tipa enumeracije

public static void main(String[] args) {

WashChoise wash = WashChoise.cotton; //Promenljive za definisanje programa pranja

// Celobrojnom promenljivom clothes koja navodi se odeća koja se pere

//1:majice 2:duksevi 3:čarape 4:čaršavi 5:pantalone

int clothes = 3;

switch(clothes) {

case 1:

System.out.println(“Washing shirts.”);

wash = WashChoise.cotton;

break;

case 2:

System.out.println(“Washing sweaters.”);

wash = WashChoise.wool;

break;

case 3:

System.out.println(“Washing socks.”);

wash = WashChoise.wool;

break;

case 4:

System.out.println(“Washing sheets.”);

wash = WashChoise.linen;

break;

case 5:

System.out.println(“Washing pants.”);

wash = WashChoise.syntetic;

break;

default:

System.out.println(“Unknown washing – default syntetic.”);

break;

}

// Izbor temperature pranja

System.out.println(“Wash is “+ wash”);

switch(wash) {

case wool:

System.out.println(“Temperature is 120.”);

break;

case cotton:

System.out.println(“Temperature is 170.”);

break;

case syntetic:

System.out.println(“Temperature is 130.”);

break;

case linen:

System.out.println(“Temperature is 180.”);

break;

}

}

}

Trebalo bi da dobijete sledеći izlaz:

Washing socks.

Wash is wool

Temperature is 120.

U ovom primeru ima nešto više koda, što je posledica broja slučajeva u dva iskaza tipa switch. Najpre smo definisali tip enumeracije, WashChoise, a zatim i promenljivu ovog tipa u okviru metoda main():

WashChoise wash = WashChoise.cotton; //Promenljive za definisanje programa pranja

Početna vrednost promenljive wash je proizvoljna. Za tip WashChoise mogli smo da izaberemo bilo koju od mogućih konstanti enumeracije.

Zatim smo definisali i inicijalizovali promenljivu koji se identifikuje rublje koje treba da se opere:

int clothes = 3;

Inicijalna vrednost promenljive clothes odnosi se na čarape, a u nekom realnijem primeru bismo do ove vrednosti stigli na neki način – odnosno, ona ne bi bila automatski dodeljena. Za kontrolu sledećeg iskaza switch koristi se promenljiva clothes. Za svako grananje iskaza switch postoji izlaz u kome se navodi šta će se prati i vrednost promenljive wash koja odgovara konstanti enumeracije. U ovakav iskaz switch se obično stavlja i podrazumevano grananje zbog toga što njegov kontrolni izraz za switch numerički, a kada se do vrednosti stiže nekim izračunavanjem, uvek postoji mogućnost da rezultat bude i nedozvoljena vrednost. Ukoliko ne postoji podrazumevano grananje, a izraz switch rezultira vrednošću koja ne odgovara nijednom predviđenom slučaju, izvršenje jednostavno nastavlja od iskaza koji sledi nakon bloka switch.

Nakon prvog iskaza switch, prikazuje se tip programa mašine:

System.out.println(“Wash is “ + wash);

U prethodnom poglavlju ste videli da se predstavljanje vrednosti koja je konstanta enumeracije u vidu znakovnog niza dobija ime te enumerisane vrednosti onako kako je ono navedeno u definiciji tipa.

Konačno, promenljivu wash smo upotrebili kao izraz koji kontroliše grananje u sledećem bloku switch. S obzirom na to da promenljiva tipa enumeracije mora imatu konstantu enumeracije kao svoju vrednost, a sve moguće vrednosti su predstavljanje u iskazu switchm ovde nam nije neophodno podrazumevano grananje.

Skrećemo vam pažnju i na to da smo vrednosti različitih vrsta rublja mogli da definišemo kao konstantne vrednosti:

final int SHIRTS = 1;

final int SWEATERS = 2;

final int SOCKS = 3;

final int SHEETS = 4;

final int PANTS = 5;

Vrednost promenljive clothes bi u tom slučaju bila očiglednija:

int clothes = SOCKS;

Za tip clothes mogli smo da koristimo i enumeraciju , ali ćemo ostaviti vamo da pogledate kako bi u tom slučaju izgledao ovaj primer.

Oblast važenja promeljive

Oblast važenja promenljive predstavlja deo programa u kome može da se referencira njeno ime – drugim rečima, to je područje u kome možete da koristite datu promenljivu u okviru programa. Sve promenljive koje smo do sada deklarisali u našim primerima definisane su u kontekstu metoda – u našem slučaju to je metod main(). Promenljive koje se deklarišu u okviru metoda nazivaju se lokalne promenljive zato što su dostupne samo unutar metoda u kome su deklarisane. Međutim, ne mora da znači da će ovakve promenljive u svakom delu koda biti dostupne za metod u kome su deklarisane. Obratite pažnju na sledeći fragment koda u kome imamo promenljive koje su definisane u okviru ugneždenih blokova:

{

int n = 1; //Deklariše i definiše n

// Referenca do n je ovde u redu

// Referenca do m ovde pravi grešku zato što m još uvek ne postoji

{

// Referenca do n je i ovde u redu

// Referenca do m i dalje pravi grešku

int m = 2 //Deklariše i definiše m

// Reference do m i n su ovde u redu – obe postoje

} // m u ovom trenutku nestaje

// Referenca do m sada pravi grešku

// Referenca do n je i dalje u redu

} // n u ovom trenutku nestaje tako da više ne možete da je referencirate

Promenljiva ne može da postoji pre nego što je deklarišete; dakle, možete da je referencirate tek nakon što je deklarišete. Ona nastavlja da postoji sve do kraja bloka u kome je definisana, što obuhvata i sve blokove koji su ugnježđeni u blok koji sadrži njenu deklaraciju. Promenljiva n napravljena je u prvom iskazu spoljnog bloka i nastavlja da postoji i u unutrašnjem bloku. Promenljiva m postoji samo u unutrašnjem bloku zato što se tu nalazi njena deklaracija. Nakon zagrade koja označava kraj unutrašnjeg bloka, m prestaje da postoji tako da ne može da se referencira. Promenljiva n i dalje postoji i dostupna je sve do zatvaranja zagrade koja označava kraj spoljnog bloka.

Prema tome, pravilo koje određuje dostupnost lokalnih promenljivih je krajnje jednostavno. Lokalne promenljive su u programu dostupne samo između pozicije na kojoj su deklarisane i kraja bloka u kome je deklaracija izvršena. Na kraju bloka u kome su deklarisane one jednostavno prestaju da postoje. Evo primera u kome ćemo vam to i prikazati:

Petlje

Petlje vam omogućavaju ponavljanje izvršenja određenih iskaza ili blokova programa. Šptreba za ponavljanjem nekih blokova koda javlja se u gotovo svakom programu ukoliko ste uradili prvo vežbanje na kraju prethodnog poglavlja, u skladu sa onim što ste do tog trenutka naučili, mogli biste da napravite program sličan ovome:

public class TryExample1_1 {

public static void main(String[] args) {

byte value = 1;

value *= 2;

System.out.println(“Value is now “+value);

value *= 2;

System.out.println(“Value is now “+value);

value *= 2;

System.out.println(“Value is now “+value);

value *= 2;

System.out.println(“Value is now “+value);

value *=2;

System.out.println(“Value is now “+value);

value *= 2;

System.out.println(“Value is now “+value);

value *= 2;

System.out.println(“Value is now “+value);

value *= 2;

System.out.println(“Value is now “+value);

}

}

Kao što vidite, siti par iskaza upisan je osam puta. Možete biti sigurni da je ovo teži način. Kada bi neka kompanija na ovaj način računala platu za svakoh svog zaposlenog, program nikada ne bi bio gotov. Petlje vas oslobađaju ovih problema. Metod main() bismo mogli da napišemo tako da učini što i ceo prethodni kod:

public static void main(String[] args) {

byte value = 1;

for (int i=0; i<8 ; i++) {

value *= 2;

nema postavljenih komentara
ovo je samo pregled
3 prikazano na 39 str.
preuzmi dokument