PROGRAMI RANJE (1. letnik) JAVA - scv.si · 2015. 3. 11. · 6.5 Break in continue stavek 56 6.5.1 Break stavek 56 6.5.2 Continue stavek 57 6.5.3 Primeri 57 7 METODE 60 7.1.1 Deklaracija

Višje

ešolski

PROG

ŠOLSKI CVIŠJA ST

strokov

GRAMI

Gradivo

Sesta

V

CENTER VETROKOVNA

vni prog

IRANJ

JAVA

o za interno u

avil: Srečko Z

Velenje, 2015

ELENJE ŠOLA

gram: I

JE (1. l

A

uporabo

Zorman

5

nforma

letnik)

atika

)

ŠC VELENJE INFORMATIKA, PROGRAMIRANJE (1. letnik) Stran 2

Vsebina 1 DIAGRAMI POTEKA 6 1.1 DP Popoldanske aktivnosti 8 1.2 DP Največja vrednost N vstavljenih števil 9 1.3 DP Vsota 10-ih vstavljenih števil 10 1.4 DP Število vstavljenih števil 11 1.5 DP Vsota števil od 1 do N 12 1.6 DP Vsota prvih N števil - Gausov algoritem 13 1.7 DP Štetje števil glede na kriterij 14 1.8 DP Vsota naravnih števil od X do Y 15 1.9 DP Geometrijsko zaporedje 1, 2, 4, 8, 16... 16 1.10 DP Največji skupni delitelj 17 1.11 DP Vsota števk 18 1.12 DP Pretvorba arabske številke v rimsko 19 1.13 DP Ploščina trikotnika 20 1.14 DP Vsota števil od X do Y 21 2 UVOD 22 2.1 Struktura programa 22 3 PODATKI, SPREMENLJIVKE 26 3.1.1 Osnovni podatkovni tipi 27 3.1.2 Literali (vrednosti spremenljivk) 28 3.1.3 Znaki 29 3.1.4 Realna števila 31 4 VHODNO IZHODNE OPERACIJE 32 4.1 Standardni vhod in izhod 32 4.1.1 Standardni izhod (standard output) 32 4.1.2 Standardni vhod (standard input) 33 5 OPERATORJI, IZRAZI, STAVKI 34 5.1.1 Aritmetični operatorji za cela in realna števila 34 5.1.2 Operatorji prirejanja 35 5.1.3 Relacijski operatorji 35 5.1.4 Logični operatorji (!, &&, ||) 36 5.1.5 Bitni operatorji ( &, |, ^, ~, <<, >> ) 36 5.1.6 Prioritete operatorjev 37 6 KRMILNI STAVKI 38 6.1 Odločitveni stavki 39 6.1.1 If stavek 39 6.2 Switch stavek 44 6.3 While stavek 49 6.3.1 Do while stavek 51 6.4 For stavek 54 6.5 Break in continue stavek 56 6.5.1 Break stavek 56 6.5.2 Continue stavek 57 6.5.3 Primeri 57 7 METODE 60 7.1.1 Deklaracija metode 60 7.1.2 Statične metode 60 7.1.3 Metode objekta 61 7.1.4 Formalni in dejanski parametri metode 63 8 TABELA OZ. POLJE 65 8.1 Izboljšana oblika for stavka 69 8.1.1 Prenos polja v metodo razreda 70

8.1.2 Uporaba polja ocen izpita 71 8.2 Večdimenzionalna polja (tabele) 74 8.3 Urejanje podatkov 77 8.3.1 Urejanje po metodi izbora najmanjšega elementa 77 8.3.2 Urejanje po metodi mehurčkov (bubble sort) 78 8.3.3 Binarno iskanje 79 8.3.4 Urejanje z vstavljanjem 80 9 RAZRED 81 9.1 Uvod v razrede, objekte in metode 81 9.1.1 Razredi (angl. Classes) 88 9.2 Atributi oz. polja razreda 90 9.3 Metode razreda 91 9.4 Lokalne in globalne spremenljivke 92 9.4.1 Večkratno definirane metode 94 9.4.2 Konstruktor 94 10 OSNOVNE KNJIŽNICE 98 10.1 Razred Math 99 10.2 Razred Character 100 10.3 Razred String 101 10.4 Razred Stringbuffer 103 10.5 Naključna števila 104 10.6 Besedilni dokumenti 105 10.6.1 Branje 105 10.6.2 Pisanje 106 10.7 Razred Enum 106 11 IZJEME 108 11.1 Vrste izjem 108 12 GRAFIKA (AWT, SWING) 111 12.1 Enostavno okno 112 12.2 Metode razreda Graphics za risanje geometrijskih likov 114 12.2.1 Konstruktorji in metode razreda Color 114 12.3 Applet 116 13 POGOVORNA OKNA 121 13.1 WindowBuilder 123 14 VAJE 126 14.1.1 Izpis obvestila 126 14.1.2 Izpis obvestila na zaslon 126 14.1.3 Izračun vsote dveh vnesenih celih števil 126 14.1.4 Ploščine in obsega pravokotnika 126 14.1.5 Zamenjava vrednosti spremenljivk 126 14.1.6 Povprečna starost in povprečna teža 127 14.1.7 Vrednosti relacijskih izrazov 127 14.1.8 Tranzitivnost števil 127 14.1.9 Višine študentov 127 14.1.10 Program za telesno težo 127 14.1.11 Število pozitivnih in negativnih števil 128 14.1.12 Izris pravokotnika 128 14.1.13 Izris pravokotnega trikotnika 128 14.1.14 Izračun fakultete 129 14.1.15 Tabela naključnih števil 129 14.1.16 Izračun obresti 129 14.1.17 Frekvenca pojavitev posameznih ocen študentov 130 14.1.18 Izračun vsote členov zaporedja 130


14.1.19 Praštevilo 130 14.1.20 Števila iz območja, ki so deljiva s tri ali pet 130 14.1.21 Izris sinusne krivulje v besedilnem načinu 131 14.1.22 Izris lika 132 14.1.23 Prestopno leto 132 14.1.24 Največji skupni delitelj 133 14.1.25 Izpis trikotnika števil 133 14.1.26 Dan v tednu 133 14.1.27 Besedilni dokument 133 14.1.28 Izpis lika 134 14.1.29 Reverzni niz 134 14.1.30 Število besed 134 14.1.31 Ločila 134 14.1.32 Meni 134 14.1.33 Največja števka 134 14.1.34 Binarna vrednost 135 14.1.35 Dolžina števila 135 14.1.36 Dan v tednu 135 14.1.37 Določitev ocene 135 14.1.38 Vsota števil deljivih s tri 135 14.1.39 Vsota števil deljivih s pet ali sedem 136 14.1.40 Izpis angleške abecede v padajočem zaporedju 136 14.1.41 Izpis trikotnika števil 136 14.1.42 Izpis enakostraničnega trikotnika 136 14.1.43 Produkt lihih števil 136 14.1.44 Vsota inverznih števil 136 14.1.45 Vsota števil z enako prvo in zadnjo števko 137 14.1.46 Polje realnih števil 137 14.1.47 Frekvenca pojavitev metov kocke 137 14.1.48 Ustvarjanje in izpis šahovnice 138 14.1.49 Kocka naključnih števil 138 14.1.50 Evidenca študentov 140 14.1.51 Evidenca višin oseb 140 14.1.52 Urejenje števil v tabeli 141 15 LITERATURA 142

Stran 5 ŠC VELENJE INFORMATIKA, PROGRAMIRANJE (1. letnik)

Kazalo slik Slika 1: Diagram poteka za izračun zneska plačila .................................................................................................. 7 Slika 2: Diagram poteka za popoldanske aktivnosti ................................................................................................. 8 Slika 3: Diagram poteka za največjo vrednost n vstavljenih števil ........................................................................... 9 Slika 4: Diagram poteka za vsoto 10-ih vstavljenih števil ....................................................................................... 10 Slika 5: Diagram poteka za število vstavljenih števil .............................................................................................. 11 Slika 6: Diagram poteka za vsoto števil od 1 do n ................................................................................................. 12 Slika 7: Diagram poteka za vsoto prvih n števil ...................................................................................................... 13 Slika 8: Diagram poteka za štetje števil glede na kriterij ........................................................................................ 14 Slika 9: Diagram poteka za vsoto naravnih števil od x do y ................................................................................... 15 Slika 10: Diagram poteka za geometrijsko zaporedje ............................................................................................ 16 Slika 11: Diagram poteka za največji skupni delitelj ............................................................................................... 17 Slika 12: Diagram poteka za vsoto števk ............................................................................................................... 18 Slika 13: Diagram poteka za pretvorbo arabske številke v rimsko ......................................................................... 19 Slika 14: Diagram poteka za ploščino trikotnika ..................................................................................................... 20 Slika 15: Diagram poteka za vsoto števil od X do Y ............................................................................................... 21 Slika 16: Diagram poteka za if stavek (oblika 1) .................................................................................................... 39 Slika 17: Diagram poteka za if stavek (oblika 2) .................................................................................................... 39 Slika 18: Diagram poteka za if stavek (oblika 3) .................................................................................................... 40 Slika 19: Diagram poteka za if stavek (oblika 4) .................................................................................................... 40 Slika 20: Diagram poteka za gnezden if stavek (oblika 5) ..................................................................................... 41 Slika 21: Diagram poteka za while stavek (oblika 1) .............................................................................................. 49 Slika 22: Diagram poteka za while stavek (oblika 2) .............................................................................................. 49 Slika 23: Diagram poteka za do while stavek (oblika 1) ......................................................................................... 51 Slika 24: Diagram poteka za do while stavek (oblika 2) ......................................................................................... 51 Slika 25: Diagram poteka za for stavek (oblika 1) .................................................................................................. 54 Slika 26: Diagram poteka za for stavek (oblika 2) .................................................................................................. 54 Slika 27: For stavek (združen števec in pogoj) ...................................................................................................... 55 Slika 28: Formalni in dejanski parameter ............................................................................................................... 63 Slika 29: Prenos parametrov ................................................................................................................................. 63 Slika 30: Prenos parametrov ................................................................................................................................. 96 Slika 31: Del izpeljanih razredov razreda Throwable ........................................................................................... 109 Slika 32: Koordinatni sistem ................................................................................................................................ 112 Slika 33: Koordinate gradniki ............................................................................................................................... 112 Slika 34: Enostavno okno .................................................................................................................................... 113 Slika 35: Geometrijski liki ..................................................................................................................................... 116 Slika 36: Applet geometrijski liki ........................................................................................................................... 118 Slika 37: Pretvorba eurov v dolerje ...................................................................................................................... 119 Slika 38: Sierpinski trikotniki ................................................................................................................................ 120 Slika 39: Sierpinski trikotniki – primer izvajanja ................................................................................................... 121 Slika 40: Izpis sporočila ....................................................................................................................................... 122 Slika 41: Vno predmeta ....................................................................................................................................... 123 Slika 42: Izpis predmeta ...................................................................................................................................... 123 Slika 43: Določitev mesta prenosa ....................................................................................................................... 124 Slika 44: Izbor elementov .................................................................................................................................... 124


1 DIAGRAMI POTEKA

Algoritem pomeni splošen postopek (metodo) za reševanje problemov. Računalnik zna izvrševati le postopke, ki so mu predpisani z njemu razumljivimi ukazi. V računalništvu algoritem pomeni postopek (metodo), ki jo lahko izvaja računalnik, da pride do rešitve problema. Algoritem lahko zapišemo na več različnih načinov: z naravnim jezikom (npr. kuharski recept), diagrami poteka (grafičen prikaz strukture programa), struktogrami (grafičen prikaz strukture programa), psevdokodo ... Program je v programskem jeziku zapisan algoritem. Vsak računalniški problem lahko rešimo z izvršitvijo različnih aktivnosti, ki jih moramo izvršiti v pravilnem vrstnem redu oz. zaporedju. Program mora biti zapisan natančno po pravilih zapisovanja programa (sintaksa programskega jezika), saj računalnik lahko "razume" le omejen nabor ukazov. Diagrami poteka uporabljajo grafične simbole za prikaz strukture algoritma oz. postopka reševanja problema. Elementi diagramov poteka

Grafični simbol oz. element Pomen

Začetek ali konec diagrama

Vhodno/izhodne operacije

Proces oz. aktivnost (operacije)

Definiran proces (podprogram)

Odločitev oz. vejitev (pogoj)

Povezovalni element (nadaljevanje strani)

Povezovalni element (konec strani)

Pot izvajanja


Programi za risanje diagramov poteka: Microsoft Visio, yED (brezplačni program za izdelavo diagramov

poteka). Dostopen na https://www.yworks.com/en/products_download.php (1. 10. 2015).

... Terminologija Spremenljivka - celica v pomnilniku, kjer je

shranjena vrednost (a,b,c,s,p). Izraz (angl. expression) - izračunljiva formula ali

predpis, po katerem se izračuna določena vrednost.

Prirejanje vrednosti - zapis oz. vpis vrednosti v spremenljivko (← ali =).

Primer Diagram poteka za izračun zneska plačila. Uporabnik vpiše število opravljenih ur in znesek urne postavke.

Slika 1: Diagram poteka za izračun zneska plačila


1.1 DP Popoldanske aktivnosti

Če bo popoldan lepo vreme, pojdi na košarko v nasprotnem preberi knjigo. Kasneje preveri, če že znaš pesem, ki ste se jo začeli učiti v šoli. Če je ne znaš, jo beri tako dolgo, da jo boš znal povedati brez besedila. Zvečer pojdi spat.

Slika 2: Diagram poteka za popoldanske aktivnosti


1.2 DP Največja vrednost N vstavljenih števil

Uporabnik vnese koliko števil bo vstavil (N). Program za N vnesenih števil izpiše največje število.

Slika 3: Diagram poteka za največjo vrednost n vstavljenih števil


Tabela: Sled izvajanja

N NAJVECJE_

STEVILO STEVILO STEVEC STEVEC <

N =>

STEVILO > NAJVECJE_

STEVILO => 5 10 1 1 < 5 resnično 8 2 8 > 10 neresnično 2 < 5 resnično 15 15 > 10 resnično 15 3 3 < 5 resnično 4 4 > 15 neresnično 4 4 < 5 resnično 8 8 > 15 neresnično 5 5 < 5 neresnično

1.3 DP Vsota 10-ih vstavljenih števil

Izračun vsote 10-ih vstavljenih števil. Tabela: Sled izvajanja

VSOTA STEVILO STEVEC STEVEC

< 10 => 0 1 1 <= 10 resnično 2 2 2 2 <= 10 resnično 4 2 3 3 <= 10 resnično 6 2 4 4 <= 10 resnično 8 2 5 5 <= 10 resnično

10 2 6 6 <= 10 resnično 12 2 7 7 <= 10 resnično 14 2 8 8 <= 10 resnično 16 2 9 9 <= 10 resnično 20 4 10 10 <= 10 resnično 22 2 11 11 <= 10 neresnično

Slika 4: Diagram poteka za vsoto 10-ih vstavljenih števil


1.4 DP Število vstavljenih števil

Uporabnik vnaša števila dokler ne vnese vrednost števila 0. Program izpiše število vstavljenih števil. Tabela: Sled izvajanja

STEVILO_ STEVIL STEVILO

STEVILO <> 0 =>

0 15 15 <> 0 resnično 1 78 78 <> 0 resnično 2 2 2 <> 0 resnično 3 45 45 <> 0 resnično 4 76 76 <> 0 resnično 5 3 3 <> 0 resnično 6 0 0 <> 0 neresnično

Slika 5: Diagram poteka za število vstavljenih števil


1.5 DP Vsota števil od 1 do N

Izračun vsote celih števil od 1 do N. N je zgornja meja, ki jo določi uporabnik. Npr. N = 5 Izračun: 1 + 2 + 3 + 4 + 5 Vsota je 15. Tabela: Sled izvajanja

N STEVEC_I STEVILO <>

0 => VSOTA 1 0

5 2 1 <= 5 resnično 1 3 2 <= 5 resnično 3 4 3 <= 5 resnično 6 5 4 <= 5 resnično 10 6 5 <= 5 resnično 15 6 <= 5 neresnično

Slika 6: Diagram poteka za vsoto števil od 1 do n


1.6 DP Vsota prvih N števil - Gausov algoritem

Izračun vsote celih števil od 1 do N. N je zgornja meja, ki jo določi uporabnik. Izračun vsote z uporabo Gaussovega algoritma. Vsota = N * (N+1) / 2 Npr. N = 5 Izračun: Vsota = 5 * (5+1) / 2 Vsota = 30 / 2 Vsota = 15

Slika 7: Diagram poteka za vsoto prvih n števil


1.7 DP Štetje števil glede na kriterij

Uporabnik vnaša števila, dokler ne vnese števila 0 (0 - konec vnosa). Ugotovimo in izpišemo število vnesenih števil, ki so večja od 50.

Slika 8: Diagram poteka za štetje števil glede na kriterij


1.8 DP Vsota naravnih števil od X do Y

Izračun vsote naravnih števil iz območja od števila X do števila Y. Uporabnik določi območje za izračun (X .. Y).

Slika 9: Diagram poteka za vsoto naravnih števil od x do y


1.9 DP Geometrijsko zaporedje 1, 2, 4, 8, 16...

Podano je geometrijsko zaporedje 1, 2, 4, 8, 16 ... Določite i-ti člen, ki povzroči, da je vsota i-členov zaporedja večja od 450. i-člen = 2 * (i-1)-člen

Slika 10: Diagram poteka za geometrijsko zaporedje


1.10 DP Največji skupni delitelj

Največji skupni delitelji (NSD) dveh celih števil (Evklidov algoritem). NSD(X,X) = X NSD(X,Y) = NSD(Y,X) Če je X > Y => NSD(X,Y) = NSD(X-Y,Y) Uporabnik vpiše dve celi števili. Program poišče in izpiše največji skupni delitelj vnesenih števil. Npr. X = 16, Y = 12 NSD(12, 16) = 4 Tabela: Sled izvajanja

X Y X <> Y => X > Y 16 12 16 <> 12 resnično 16 > 12 4 4 <> 12 resnično 4 > 12 8 4 <> 8 resnično 4 > 8 4 4 <> 4 neresnično

Slika 11: Diagram poteka za največji skupni delitelj


1.11 DP Vsota števk

Izračun vsote števk celega števila. Število vstavi uporabnik. 8 % 3 = 2 % ostanek po celoštevilčnem deljenju 8 / 2 = 4 / celoštevilčno deljenje Npr. število = 124 vsota števk = 1 + 2 + 4 = 7

Slika 12: Diagram poteka za vsoto števk


1.12 DP Pretvorba arabske številke v rimsko

Pretvorba arabskega števila v rimsko število ( 1- I, 2 - II, 3 - III, 4 - IV, 5 - V, 6 - VI, 7 -VII, 8 - VIII, 9 - IX, 10 - X, 20 - XX, 30 - XXX, 40 - XL, 50 - L, 60 - LX, 90 - XC, 100 - C... 400 - CD, 500 - D, 900 - CM, 1000 -M)

Slika 13: Diagram poteka za pretvorbo arabske številke v rimsko


1.13 DP Ploščina trikotnika

Izračun ploščine trikotnika, če so znane vse tri stranice trikotnika. Heronov obrazec ploščina =

s = (a + b + c) / 2; Pogoj za obstoj trikotnika: vsota poljubnih dveh stranic je večja od tretje stranice.

Slika 14: Diagram poteka za ploščino trikotnika


1.14 DP Vsota števil od X do Y

Vsota števil od števila X do števila Y (Gaussov postopek): Gaussov postopek (Y > X) Vsota = x + (x+1) + (x+2) + (x+3) + ... + (y-2) + (y-1) + y enačbi seštejemo (+) Vsota = y + (y-1) + (y-2) + (y-3) + ... + (x+2) + (x+1) + x -------------------------------------------------------------- 2*Vsota = (x+y) + (x+y) + (x+y) +... + (x+y) + (x+y) +(x+y) |__________________________________________| (y-x + 1) elementov 2 * Vsota = (x+y) * (y-x+1) Vsota = ((x+y) * (y-x+1)) / 2 Če je x = 1: 2 * Vsota = (1+y) * (y) Vsota = ((1+y) * (y)) / 2

Slika 15: Diagram poteka za vsoto števil od X do Y


2 UVOD

Java je objektno usmerjeni, prenosljivi programski jezik, ki ga je razvil James Gosling s sodelavci v podjetju Sun Microsystems. Projekt, ki se je v začetku (leta 1991) imenoval Oak (hrast). Razvit je bil kot zamenjava za programski jezik C++. Jave ne smemo zamenjevati z jezikom JavaScript, ki ima podobno ime ter podobno skladnjo (programski jezik C). Java različica 1.0 je bila objavljena leta 1996. Javo vzdržuje in posodablja Oracle - Sun Microsystems. Spletišče: http://docs.oracle.com/en/java (15.1.2015). Tolmač za javo je vgrajen v večino spletnih brskalnikov. Javanski program (angl. applet) se lahko izvaja kot del HTML dokumenta. Poznamo 3 vrste Jave: J2SE - standardna različica Jave za osebne računalnike, J2ME - različica Jave za mini naprave (mobiteli, pametni televizorji ...), J2EE - poslovna različica Jave. V Javi programiramo tudi aplikacije na mobilnih telefonih (J2ME) in pametnih telefonih z operacijskim sistemom Android. Različice programskega jezika Java: JDK 1.0 (January 21, 1996), JDK 1.1 (February 19, 1997), J2SE 1.2 (December 8, 1998), J2SE 1.3 (May 8, 2000), J2SE 1.4 (February 6, 2002), J2SE 5.0 (September 30, 2004), Java SE 6 (December 11, 2006), Java SE 7 (July 28, 2011). Java SE 8.

2.1 Struktura programa

Primer 1: Izpis obvestila na zaslon. Program na zaslon izpiše besedilo: Primer prvega programa. Pozdrav.

1. public class P1_1 // najava razreda P1_1 2. { 3. public static void main(String[] args) 4. { // Izpis na zaslon z uporabo standardnega izhodnega toka - razred System. 5. // Izhodni tok je samodejno na voljo za izhodne podatke 6. System.out.print("Primer prvega programa."); 7. System.out.print("\n"); // prehod v novo vrstico new line \n 8. System.out.print("Pozdrav."); 9. } // konec metode main


10. } // konec razreda P1_1

Primer prvega programa. Pozdrav.

Vsak program v Javi vsebuje vsaj en razred. Program začnemo s public class, ki predstavlja najavo razreda. Rezerviranki class sledi ime razreda (P1_1). Ime razreda je identifikator, ki ga po dogovoru začnemo z veliko začetnico. Če je ime sestavljeno iz več besed, jih zapišemo brez presledkov; vsako besedo začnemo z veliko začetnico. Identifikator je zaporedje znakov, ki vsebuje črke, števke, podčrtaj in znak dolar ($). Ime identifikatorja se ne začne s števko in ne vsebuje presledkov. Java razlikuje velike in male črke (angl. case sensitive). Identifikatorja stevilo1 in Stevilo1 sta dva različna identifikatorja. Deklaracija razreda vsebuje eno ali več metod razreda. V programu moramo določiti metodo main (vrstica 3). Metoda main predstavlja mesto začetka izvajanja vsakega programa. Metode predstavljajo aktivnosti razreda in lahko vrnejo informacije o zaključku izvedbe aktivnosti. Rezerviranka void določa, da metoda ne vrne vrednosti. String[] args v okroglih oklepajih je zahtevan del deklaracije metode main. Predstavlja vhodne argumente metode. Telo metode je območje med zavitimi oklepaji (v primeru od vrstice 4 do vrstice 9). Izpis na zaslon izvede ukaz System.out.print. System.out.print("Primer prvega programa.") izpiše na zaslon besedilo med dvojnimi narekovaji (argument metode). Objekt System.out predstavlja standardni izhodni objekt za izpis informacij v izhodnem oknu. Komentarji so zapisani med znaki /* in */ (večvrstični) ali za znakom // (enovrstični). Komentar je lahko tudi čez več vrstic. Vsak stavek se konča s podpičjem. Komentar Komentar je del kode, ki jo prevajalnik (angl. compiler) izpusti in je namenjen za opombe in opise (dokumentiranje) programske kode. Komentar lahko zapišemo na dva načina: // komentar v vrstici (vsebina desno od // se obravnava kot komentar); /* blok s komentarjem */. V besedilo lahko vstavimo tudi posebne znake - ubežne sekvence (angl. escape sequence): \n (angl. Newline) Postavitev utripalke na začetek naslednje vrstice. \t (angl. Horizontal tab) Premik utripalke na položaj naslednjega tabulatorja. \r (angl. Carriage return) Postavitev utripalke na začetek trenutne vrstice. Izhodni znaki za potrditveno tipko

prepisujejo znake v trenutni vrstici. \\ (angl. Backslash) Izpis poševnice nazaj. \" (angl. Double quote) Izpis dvojnega narekovaja. Izpis besedila z metodo printf Metodo System.out.printf (f angl. “formatted”) uporabljamo za oblikovanje izpisa podatkov. Sintaksa: public PrintStream printf(String format, Object... args) V prvem argumentu (format) določimo obliko izpisa; v ostalih argumentih pa podatke oz. informacije, ki jih izpisujemo. Argumente med seboj ločimo z vejico. Prvi argument lahko vsebuje besedilo izpisa in oblikovalna določila.


Ukaz System.out.printf("\n\n%s\n%s\n","Primer novega", "izpisa") izpiše: dva prehoda v novo vrstico (\n), besedilo (%s; drugi argument), prehod v novo vrstico (\n), besedilo (%s, tretji argument) in prehod v novo vrstico.

Primer novega izpisa

Primer 2: Izračun vsote dveh celih števil. Uporabnik vpiše dve celi števili. Program izpiše rezultat v obliki: Vsota števil število_1 + število_2 = vsota. Java ima definirane razrede, ki jih lahko uporabljamo v programih. Definirani razredi so združeni v pakete (angl. packages) - poimenovane skupine pomensko sorodnih razredov - Java class library oz. Java Application Programming Interface (Java API).

1. // Najava uporabe (deklaracija) razreda Scanner iz paketa java.util 2. import java.util.Scanner; 3. 4. public class Vsota 5. { 6. public static void main(String[] args) 7. { 8. // ustvarimo primerek objekta Scanner za vnos v ukaznem oknu 9. Scanner vhod = new Scanner(System.in); 10. //spremenljivke za vhodna števila podatkovnega tipa integer 11. int operand1; //prvo število 12. int operand2; //drugo število 13. int vsota; //spremenljivka rezultat podatkovnega tipa integer 14. System.out.print("Prvo celo število: "); //izpis obvestila za vnos 15. operand1 = vhod.nextInt(); //branje prvega števila 16. 17. System.out.print("Drugo celo število: "); //izpis obvestila za vnos 18. operand2 = vhod.nextInt(); //branje drugega števila 19. 20. // izračun vsote 21. vsota = operand1 + operand2; 22. //izpis rezultata 23. System.out.printf("Vsota števil %d + %d = %d.", operand1, operand2, vsota); 24. } // konec metode main 25. }

Prvo celo število: 45 Drugo celo število: 56 Vsota števil 45 + 56 = 101.

import java.util.Scanner; je najava deklaracije, ki omogoča prevajalniku poiskati razred, ki je uporabljen v programu. Določi uporabo razreda Scanner iz paketa java.util. public class Vsota predstavlja začetek deklaracije razreda Vsota. Ime dokumenta (datoteke) je Vsota.java. Izvajanje programa se začne v metodi main (od vrstice 6 do vrstice 24). Deklaracija in ustvarjanje predmeta (objekta) razreda Scanner za pridobitev vrednosti vnosa Vrstica 9


Scanner vhod = new Scanner(System.in); je deklaracijski stavek, ki določi ime (vhod) in podatkovni tip (Scanner) spremenljivke za branje podatkov (besedil in števil). Podatke lahko pridobimo iz različnih virov (vnos uporabnika, shranjeni dokumenti ...). Pred uporabo predmeta Scanner ga moramo ustvariti in mu določiti vir podatkov. Znak = predstavlja prireditveni stavek; izraz desno od znaka enačaj (=) se ovrednoti (izračuna) in shrani v spremenljivko vhod. Izraz vsebuje rezerviranko new, ki ustvari nov primerek objekta Scanner. Ta objekt vsebuje znake, ki jih uporabnik vpiše preko tipkovnice. Standardni vhodni objekt System.in omogoča programu branje vhodnih zlogov informacij uporabnika. Scanner pretvori vnesene podatke v celoštevilčni podatkovni tip. Vrstice 11, 12 in 13 vsebujejo deklaracijo spremenljivk v katere se shranjujejo celoštevilčne vrednosti (podatkovni tip integer). Pred vnosom podatkov uporabniku izpišemo obvestilo. Ukaz System.out.print("Prvo celo število: ") obvesti uporabnika, glede aktivnosti, ki jo mora izvršiti. Vrstica 15 operand1 = vhod.nextInt() uporabi vhodno metodo nextInt razreda Scanner, da prebere celoštevilno vrednost vnesenega podatka. Na tem mestu se program ustavi, da uporabnik vpiše podatek in potrdi vnos s potrditveno tipko (Enter). Predvideno je, da uporabnik vnese celoštevilčni podatek. V nasprotem primeru se izvajanje programa prekine (napaka pri izvajanju). V primeru veljavnega vnosa celega števila se vnesena vrednost shrani v spremenljivko operand1. Izpis obvestila in branje drugega operanda oz. števila se izvede v vrsticah 17 in 18. Seštevanje števil izvedemo z uporabo spremenljivk. V vrstici 21 vsota = operand1 + operand2; v prireditvenem stavku izračunamo vrednost izraza desno od znaka enačaj (=). Operator + izračuna vsoto vrednosti operandov. Rezultat seštevanja se shrani v spremenljivko vsota. Razlaga stavka: spremenljivki vsota določimo vrednost izraza operand1 + operand2. Po izvršitvi seštevanja v vrstici 23 System.out.printf("Vsota števil %d + %d = %d.", operand1, operand2, vsota) z metodo System.out.printf izpišemo rezultat seštevanja. Oblikovalno določilo %d predstavlja mesta izpisa celih števil (drugi, tretji in četrti parameter). Vsoto števil lahko izračunamo tudi v printf stavku. V tem primeru namesto vrstic 21 in 23 zapišemo stavek: System.out.printf("Vsota števil %d + %d = %d.", operand1, operand2, (operand1 + operand2)); Pomnilniška slika Spremenljivke predstavljajo lokacije oz. mesta v pomnilniku, kjer so shranjeni podatki. Po izvršitvi stavka v vrstici 15, ko uporabnik potrdi vnos števila se v pomnilnik shrani vnesena vrednost. Predpostavimo, da uporabnik vnese vrednost 45. Računalnik shrani vrednost 45 na lokacijo spremenljivke operand1 v pomnilnik in prepiše obstoječo vrednost na tej lokaciji (prejšnja vrednost na tej lokaciji je izgubljena). operand1 45 Po izvršitvi stavka v vrstici 18, ko uporabnik potrdi vnos drugega števila. Predpostavimo, da uporabnik vnese vrednost 56. operand1 45

operand2 56 Po izvršitvi seštevanja oz. stavka v vrstici 21. operand1 45

operand2 56


vsota 101 Osnovna struktura oz. lupina programa public class <ime_razreda> { public static void main(String[] args) { // stavki } }

3 PODATKI, SPREMENLJIVKE

Podatki Program obdeluje podatke, ki jih shranjuje v pomnilniku in se med izvajanjem programa lahko spreminjajo ali so konstantni. Podatek je shranjen v pomnilniku na enoličnem naslovu – pomnilniški lokaciji in zasede toliko prostora, kot ga potrebujemo glede na podatkovni tip podatka. Spremenljivke Spremenljivka je pomnilniška lokacija (celica), v kateri je shranjena posamezna vrednost. Ime spremenljivke ali konstante naj bo smiselno in naj pove čim več o vlogi spremenljivke. Ime je lahko poljubna kombinacija črk (angleška abeceda) in števk ter znaka podčrtaj ('_'). Prvi znak mora biti obvezno črka ali znak '_'. Prevajalnik razlikuje velike in majhne črke. St in st sta dve različni spremenljivki. Za ime ne smemo uporabiti imena rezervirank. Tabela: Rezerviranke

abstract double int strictfp ** boolean else interface super break extends long switch byte final native synchronized case finally new this catch float package throw char for private throws class goto * protected transient const * if public try continue implements return void default import short volatile do instanceof static while

* rezerviranka trenutno ni v uporabi ** rezerviranka dodana v verziji Java 2 Vse rezervirane besede pišemo z malimi črkami. Lastnosti spremenljivk:

ime spremenljivke, podatkovni tip, naslov pomnilniške lokacije, kjer je spremenljivka shranjena, vrednost spremenljivke.


Podatkovne tipe delimo v dve skupini in sicer: osnovni podatkovni tipi, referenčni podatkovni tip (oz. kazalci).

3.1.1 Osnovni podatkovni tipi

Spremenljivke (podatki) so shranjene v računalniku v enem ali več zlogih (angl. byte). Različnih možnih znakov je toliko, da lahko shranimo vsak znak v enem zlogu (8 bitov). Da prevajalniku povemo, koliko prostora naj rezervira za posamezno spremenljivko, moramo pred uporabo spremenljivke deklarirati oz. najaviti. Sintaksa: <podatkovni_tip> <ime_spremenljivke> [ = <vrednost>][, <ime_spremenljivke> [= <vrednost>] ...] ;

// [ ] - opcija Najprej zapišemo podatkovni tip spremenljivke, nato ime spremenljivke ali več spremenljivk istega tipa (če jih je več, jih med seboj ločimo z vejico). Deklariramo lahko tudi vsako spremenljivko posebej. Deklaracija predstavlja stavek, ki ga zaključimo s podpičjem (;). Osnovni podatkovni tipi so:

celoštevilčni podatkovni tipi: byte, short, int (integer), long; realni podatkovni tip: float: realno število enojne natančnosti, double: realno število dvojne natančnosti; znakovni podatkovni tip: char (character); en znak (črka, cifra ali drugi znak); logični podatkovni tip: boolean.

Primeri deklaracij: int x, y, z; // Deklaracija treh celoštevilčnih spremenljivk x, y in z. short i = 10, j = 10; // Deklaracija in inicializacija celoštevilčnih spremenljivk i in j. byte k = 22; // Deklaracija in inicializacija spremenljivke k. double pi = 3.14159; // Deklaracija in inicializacija spremenljivke pi. char znak = 'z'; // Deklaracija in inicializacija znakovne spremenljivke znak. Spremenljivki lahko določimo vrednost iz predpisanega območja glede na to, kakšnega podatkovnega tipa je.

Podatkovni tip Število zlogov Območje oz. obseg

byte 1 zlog (8 bitov) od -127 do + 127

short 2 zloga (16 bitov) od –32,768 do +32,767 (–215 to 215 – 1)

int 4 zlogi (32 bitov) od –2,147,483,648 do +2,147,483,647

(–231 do 231 – 1)

long 8 zlogov (64 bitov) od –9,223,372,036,854,775,808 do

+9,223,372,036,854,775,807 (–263 do 263 – 1)

char 2 zloga '\u0000' do '\uFFFF' (0 do 65535)

float 4 zlogi (IEEE 754) Negativno območje: –3.4028234663852886E+38 do –1.40129846432481707e–45 Pozitivno območje: 1.40129846432481707e–45 do 3.4028234663852886E+38

double 8 zlogov (IEEE 754) Negativno območje: –1.7976931348623157E+308 do


Podatkovni tip Število zlogov Območje oz. obseg

–4.94065645841246544e–324 Pozitivno območje: 4.94065645841246544e–324 do 1.7976931348623157E+308

boolean 1 true ali false

Kazalci (referenčni podatkovni tip) Kazalčne spremenljivke se uporabljajo za dostop do vrednosti primerkov objektov posameznih razredov. Te spremenljivke so posebnega podatkovnega tipa, ki ga ni možno spremeniti (podatkovni tip). Vrednost kazalčne spremenljivke je pomnilniški naslov. Spremenljivke razrednih objektov (predmetov) in spremenljivke polj oz. tabel so kazalci oz. referenčni podatkovni tip. Privzeta vrednost kazalčne spremenljivke je null (kazalec ne kaže na objekt v pomnilniku). Kazalčno spremenljivko lahko uporabimo za dostop do vrednosti predmeta deklariranega podatkovnega tipa. Primer: Oseba oseba = new Oseba("Janez","Novak");

3.1.2 Literali (vrednosti spremenljivk)

Literali so vrednosti, ki jih uporabljamo v programski kodi brez izračunov oz. računskih izrazov. Npr. byte stevilo = 68; char znak ='A'; Vrednosti spremenljivk celoštevilčnih podatkovnih tipov byte, int, long, short lahko določimo v desetiškem, osmiškem ali šestnajstiškem številskem sistemu. Vrednosti oz. literali, ki se začno s predpono 0, se interpretirajo kot osmiška števila; vrednosti, ki se začno s predpono 0x ali 0X se interpretirajo kot šestnajstiška števila. Celoštevilski literali so zaporedja števk (0..9), pred katerimi lahko stoji predznak (+ oz. -). Med tisočicami ni pike, in ne smemo uporabiti decimalne vejice. Prav tako za njih ne smemo uporabiti znanstvenega zapisa. Pogosto uporabimo literale za inicializacijo (dodeljevanje začetnih vrednosti) spremenljivk. Npr.: int desetisko_stevilo = 68; int osmisko_stevilo = 012; int sestnajstisko_stevilo = 0x32; Besedilne vrednosti predstavlja zaporedje znakov med dvojnimi narekovaji npr. "besedilo". Npr.: "besedilna vrednost" "prva vrstica\ndruga vrstica" "\"Besedilo v narekovajih\"" Podatkovna tipa String in char lahko vsebujeta katerikoli Unicode znak (UTF-16). Npr.: char znak ='\u0030'; // znak 0 String besedilo ="\u0050"; Primer:

1. public class P1_3 2. { 3. public static void main(String[] args)


4. { 5. // deklaracija 6. int a; 7. int b; 8. int rezultat; 9. // obdelava 10. a = 5; b = 2; 11. a = a + 1; 12. rezultat = a - b; 13. // izpis 14. System.out.printf("\nVrednost spremenljivke rezultat je: %d", rezultat); 15. } // konec main 16. } // konec P1_3

Vaja: Napišite program, ki bo izračunal porabo goriva avtomobila. Vhodni podatki:

število prevoženih kilometrov – st_prevoz_km število litrov, ki smo jih natočili – st_litrov

Izhodni podatki:

poraba na 100 km - poraba Izračun: st_prevoz_km ... st_litrov 100 ... poraba poraba = st_litrov * 100 / st_prevoz_km Algoritem: vnos vhodnih podatkov izračun porabe izpis porabe

3.1.3 Znaki

Znakovni podatkovni tip (char) v bistvu določa nepredznačeno celo število. To število je interpretirano kot znak v kodni shemi Unicode. Znak je predstavljen s 16-bitno kodo sestavljeno iz 16 bitov (znaki 0 ali 1). V tej tabeli ima črka 'a' vrednost '\u0061', črka 'A' pa vrednost 'u\0041' in znak '0' vrednost '\u0030'. Znak lahko zapišemo: • med dvema enojnima narekovajema: 'A', • z njegovo šestnajstiško kodo: '\u0041'. \u je ubežna sekvenca, ki "določa" numerično kodo. Znakovna konstanta je črka med enojnima narekovajema. Če narekovaje izpustimo se interpretira kot spremenljivka. Med enojnima narekovajema ne sme biti več znakov (npr. 'avto'). Znake, ki jih ni na tipkovnici, lahko določimo s pomočjo ubežnih sekvenc. Primeri ubežnih sekvenc:

\n - nova vrstica, \t - tabulator, \b - pomik za znak v levo,


\r - pomik na začetek vrstice, \f - pomik na novo stran, \\ - poševna črta nazaj, \' - enojni narekovaj, \" - dvojni narekovaj.

Dec Šest Znak Dec Šest Znak 0 00 NUL '\0' 16 10 DLE (data link escape) 1 01 SOH (start of heading) 17 11 DC1 (device control 1) 2 02 STX (start of text) 18 12 DC2 (device control 2) 3 03 ETX (end of text) 19 13 DC3 (device control 3) 4 04 EOT (end of transmission) 20 14 DC4 (device control 4) 5 05 ENQ (enquiry) 21 15 NAK (negative ack.) 6 06 ACK (acknowledge) 22 16 SYN (synchronous idle) 7 07 BEL '\a' (bell) 23 17 ETB (end of trans. blk) 8 08 BS '\b' (backspace) 24 18 CAN (cancel) 9 09 HT '\t' (horizontal tab) 25 19 EM (end of medium) 10 0A LF '\n' (new line) 26 1A SUB (substitute) 11 0B VT '\v' (vertical tab) 27 1B ESC (escape) 12 0C FF '\f' (form feed) 28 1C FS (file separator) 13 0D CR '\r' (carriage ret) 29 1D GS (group separator) 14 0E SO (shift out) 30 1E RS (record separator) 15 0F SI (shift in) 31 1F US (unit separator) 32 20 SPACE 48 30 0 33 21 ! 49 31 1 34 22 " 50 32 2 35 23 # 51 33 3 36 24 $ 52 34 4 37 25 % 53 35 5 38 26 & 54 36 6 39 27 ´ 55 37 7 40 28 ( 56 38 8 41 29 ) 57 39 9 42 2A * 58 3A : 43 2B + 59 3B ; 44 2C , 60 3C < 45 2D - 61 3D = 46 2E . 62 3E > 47 2F / 63 3F ? 64 40 @


Dec Šest Znak Dec Šest Znak 65 41 A 97 61 a 66 42 B 98 62 b 67 43 C 99 63 c 68 44 D 100 64 d 69 45 E 101 65 e 70 46 F 102 66 f 71 47 G 103 67 g Dec Šest Znak Dec Šest Znak 72 48 H 104 68 h 73 49 I 105 69 i 74 4A J 106 6A j 75 4B K 107 6B k 76 4C L 108 6C l 77 4D M 109 6D m 78 4E N 110 6E n 79 4F O 111 6F o 80 50 P 112 70 p 81 51 Q 113 71 q 82 52 R 114 72 r 83 53 S 115 73 s 84 54 T 116 74 t 85 55 U 117 75 u 86 56 V 118 76 v 87 57 W 119 77 w 88 58 X 120 78 x 89 59 Y 121 79 y 90 5A Z 122 7A z 91 5B [ 123 7B { 92 5C \ '\\' 124 7C | 93 5D ] 125 7D } 94 5E ^ 126 7E ~ 95 5F _ 127 7F DEL 96 60 `

3.1.4 Realna števila

Uporabljamo jih predvsem pri matematičnih operacijah. Omogočajo zapis večjih števil in decimalnega dela. Zavzamejo več pomnilniškega prostora in izvajanje je počasnejše. Realne konstante so zaporedja števk z možnim predznakom, decimalnim delom in eksponentnim delom. Eksponentni del označimo s črko e (E) in celoštevilsko konstanto. Ta določa, da moramo število pred decimalno vejico premakniti za toliko mest v desno, kolikor je velikost konstante za znakom e. V realni konstanti ne sme biti presledkov. Pozor: uporabljamo decimalno piko in ne decimalne vejice. Izpustimo lahko pozitivne predznake in vse ničle pred decimalno piko. Npr.: 56.345, .056, .8e-5, 1002., 23.5.


Vaja: Napišite program, ki izpiše znesek denarja, ki ga mora vrniti prodajalka, če vstavimo znesek računa in vplačan znesek kupca. Vhodni podatki:

znesek računa – znesek_racuna vplačan znesek – znesek_placan

Izhodni podatki:

vračilo – znesek_vracilo Izračun: znesek_vracilo = znesek_racuna - znesek_placan Algoritem: vnos vhodnih podatkov izračun vračila izpis vračila Povzetek Podatkovne tipe delimo na osnovne podatkovne tipe in reference (referenca je mesto oz. lokacija, kjer je predmet oz. objekt shranjen v pomnilniku). Osnovni podatkovni tipi so boolean, byte, char, short, int, long, float in double. Podatkovni tip float predstavlja realna števila enojne natančnosti; podatkovni tip double pa realna števila dvojne natančnosti.

4 VHODNO IZHODNE OPERACIJE

4.1 Standardni vhod in izhod

Za standardni vhod/izhod (angl. Input/Output) uporabljamo metode razredov keyboard, screen, files ali kombinacije le teh. Vnos in izpis podatkov v preprostih programih izvršimo v konzolnem oknu (angl. console input/output). Za vhod/izhod lahko uporabimo tudi pogovorna okna.

4.1.1 Standardni izhod (standard output)

Za izpis na standardni izhod (zaslon) v konzolnem oknu uporabljamo metode razreda System.out. Pri tem nam ni potrebno ustvariti primerka objekta System.out. V programu nam je le-ta vedno na voljo. Za izpis v konzolnem oknu uporabljamo metode: print( ), printf( ) in println( ).

Metoda Opis

print( ) Metodo print() uporabljamo za izpis na zaslon. Utripalka (angl. cursor) ostane za zadnjim izpisanim znakom.

println( ) Metoda println() izvede izpis na zaslon kot metoda print() le da se utripalka po izpisu pomakne na začetek nove vrstice.

printf( ) Metodo uporabljamo za oblikovanje izpisa v konzolnem oknu.

Postopek izpisa Uporabimo objekt standardnega izhoda razreda System (System.out).


Uporabimo metode razreda PrintStream (printf(), print(), println()). Objekt System.out je objekt razreda PrintStream. Metodo System.out.printf uporabljamo za oblikovanje izpisa v standardnem izhodu. Sintaksa: System.out.printf( oblikovano-besedilo [, arg1, arg2, … ] ); Oblikovano besedilo vsebuje besedilno vrednost z oblikovalnimi določili. Če v besedilu uporabimo oblikovna določila, potem uporabimo argumente (arg1 ...). Sintaksa oblikovnega določila: % [zastavica] [širina] [.natančnost] znak_pretvorbe

Zastavica Pomen

- leva poravnava (privzeto desna poravnava)

+ prikaz plus ( + ) ali minus ( - ) znaka v številčni vrednosti

0 številne vrednosti se zapolnijo z znakom 0 (privzeti zapolnitveni znak je presledek)

, izpis ločila tisoč (,)

presledek izpiše znak minus (-), če je število negativno oz. znak presledek ( ), če je število pozitivno

Širina določa število znakov argumenta in predstavlja najmanjše število znakov izpisa. Natančnost določa za decimalna števila število decimalnih mest; za besedilo pa dolžino podniza. Decimalna števila se zaokrožujejo na zahtevano natančnost.

Znak pretvorbe Pomen

d desetiško število [byte, short, int, long]

f realno število [float, double]

c znak

C znak - velike črke

s besedilo (String)

S besedilo - velike črke

h pomnilniški naslov (referenca ali kazalec)

Primeri: System.out.printf("Skupaj: %,10.2f%n", dblVrednost); System.out.printf("Skupaj: %-10.2f: ", dblVrednost); System.out.printf("% 4d", intVrednost); String s = "Besedilo"; System.out.printf("Besedilna vrednost %s je na naslovu %h", s, s);

4.1.2 Standardni vhod (standard input)

Za vnos podatkov s standardnega vhoda (tipkovnica) uporabimo razred Scanner. Na voljo je tudi razred System.in, ki ima funkcionalne pomanjkljivosti. Predmet System.in obstaja in je na voljo brez ustvarjanja. V praksi raje uporabljamo razred Scanner. Predmet Scanner moramo pred uporabo ustvariti.


Vnos podatkov v programu predstavlja zaporedje znakov podatkovnega tipa String. Z metodami pretvorimo besedilno vrednost v znak, celo število, realno število itd. Najpogosteje uporabljene metode razreda Scanner:

Metoda Opis

hasNext() Preverimo, če so na voljo podatki? Vrne logično vrednost true ali false.

nextInt() Vnos oz. branje celega števila.

nextDouble() Vnos oz. branje realnega števila.

next() Vnos oz. branje besedila (ločitveni znak presledek).

nextLine() Vnos oz. branje preostanka besedila v vrstici.

Metode za branje posameznega znaka ni. Uporabimo branje besedila. Postopek branja Ustvarimo primerek objekta razreda Scanner

// najavimo uporabo (deklaracija) razreda Scanner import java.util.Scanner; // ustvarimo primerek objekta razreda Scanner za branje podatkov Scanner vhod = new Scanner(System.in); Do podatkov, ki jih uporabnik vnese preko tipkovnice, dostopamo z uporabo metod razreda Scanner

// deklaracija spremenljivk int stevilo1; double stevilo2; String besedilo; stevilo1 = vhod.nextInt(); // preberi celo število in ga shrani v stevilo1 stevilo2 = vhod.nextDouble(); // preberi realno število in ga shrani v stevilo2 besedilo = vhod.nextLine(); // preberi besedilo in ga shrani v spremenljivko besedilo

5 OPERATORJI, IZRAZI, STAVKI

Operandi so podatki, nad katerimi izvajamo operacije. Operatorji določajo vrsto operacije, ki se izvede nad enim ali več operandi. Poznamo več vrst operatorjev in sicer: aritmetični, relacijski, logični.

5.1.1 Aritmetični operatorji za cela in realna števila

Operator Opis Primer

* množenje x * 10 / deljenje x / y

% ostanek celoštevilčnega deljenja 15 % 3 + seštevanje a + b - odštevanje d - e

Rezultat celoštevilčnega deljenja je celo število. Rezultat izraza 8 / 5 je 1. Decimalni del rezultata celoštevilčnega deljenja se "odreže" (brez zaokroževanja). Operator % predstavlja ostanek po deljenju. Uporablja se večinoma za izračun ostanka po celoštevilčnem deljenju. Npr. 10 % 6 je 4 in 15 % 7 je 1.


Oklepaje uporabljamo za določanje vrstnega reda izračuna posameznih delov izrazov. Izraz x * (y+z) predstavlja izračun vsote y + z in nato množenje z x. Izraz (x * (y+z)) določa najprej izračun najbolj notranjih delov izraza (v tem primeru y+z) in nato zunanjih delov. Če ne uporabljamo oklepajev se vrstni red izračuna izraza določi na osnovi pravil prioritete.

Operator Operacija Vrstni red izračuna * /

%

množenje deljenje ostanek po deljenju

Več operatorjev te vrste, izračun z leve proti desni.

+ -

seštevanje odštevanje

Več operatorjev te vrste, izračun z leve proti desni.

= prireditev Po izračunu izraza desno od enačaja.

5.1.2 Operatorji prirejanja

Operator prirejanja = združuje z desne proti levi, kar pomeni, da se najprej ovrednoti desna stran in nato leva. Veliko stavkov v jeziku je krajše oblike. Npr. sprem_x = sprem_x + c zapišemo krajše sprem_x += c; Podobno velja še za:

Krajši zapis Daljši zapis a += b; a = a + b; a -= b; a = a - b; a *= b; a = a * b; a /= b; a = a / b; a %= b; a = a % b;

5.1.3 Relacijski operatorji

Uporabljamo jih za zapis logičnih pogojev v odločitvah.

Operator Opis Primer Pomen == enakost (je enako) x == y x je enak y != neenakost (ni enako) x != y x ni enak y (x je različen od y) < manjše x < y x je manjši kot y > večje x > y x je večji kot y <= manjše ali enako x <= y x je manjši ali enak y >= večje ali enako x >= y x je večji ali enak y

Zgled: int a = 5, b = 6; if (a == b) a+=1; else b+=1;


Izraz Vrednost izraza (7 == 4) false (34 > 6) true (23 != 32) true (1 >= 1) true (12 < 10) false

Izraz Vrednost izraza (a < b) true (a==b) false (a != 5) false

5.1.4 Logični operatorji (!, &&, ||)

Operator ! je logična negacija (NOT). Nahaja se levo od operanda in vrne logično nasprotno vrednost. Npr. !(67 == 67) // false (ker je izraz desno od ! true) !(16 <= 14) // true (ker je (16 <= 14) false) !true // false !false // true Operatorja && - logični in (angl. logical and) in || - logični ali (angl. logical or) uporabljamo z dvema operandoma. Logična tabela za logični in (&&) in ali (||).

operand 1 operand 2 logični in - && logični ali - || false false false false false true false true true false false true true true true true

Izraz Izraz je sestavljen iz operatorjev in operandov. Operandi so lahko konstante, spremenljivke, klici funkcij ali poljubna kombinacija prejšnjih. Izjema je operator prirejanja, pri katerem mora biti na levi strani spremenljivka. Vsak izraz ima svojo vrednost. Vrednosti pri aritmetičnih operatorjih so znane. Vrednost prireditvenega operatorja je kar vrednost izraza na desni strani znaka =. Vrednosti logičnih operatorjev sta 0 (neresnično - false) ali 1 (resnično - true). Vrstni red izračunavanja izrazov Operatorji (z izjemo operatorja prirejanja in unarnih operatorjev) združujejo izraz od leve proti desni. To pravilo velja med enakimi operatorji. Stavek:

b = e + 4 - 10 + q; se izračuna kot:

b = (((e + 4) - 10) + q); Če v izrazu nastopajo operatorji z različno prioriteto, se najprej izračunajo tisti z najvišjo prioriteto in tako naprej proti najnižji prioriteti.

5.1.5 Bitni operatorji ( &, |, ^, ~, <<, >> )

Bitni operatorji ovrednotijo izraz na osnovi posameznih bitov, ki predstavljajo vrednost operanda.

Operator Pomen Opis & AND bitni logični IN () | OR bitni logični ALI () ^ XOR (exclusive or) logični ekskluzivni ALI ()


Operator Pomen Opis ~ NOT komplement << SHL (shift left) pomik v levo >> SHR (shift right) pomik v desno

x y x & y 0 0 0 0 1 0 1 0 0 1 1 1

x y x | y 0 0 0 0 1 1 1 0 1 1 1 1

x y x ^ y 0 0 0 0 1 1 1 0 1 1 1 0

x ~x 0 1 1 0

Zgled: Dve spremenljivki x in y podatkovnega tipa char vsebujeta vrednosti 195 (11000011) in 87 (01010111). Zgled: char a = 195; char b = 87; char c; c = a & b; // vrednost 67 (01000011)

a = 195 1 1 0 0 0 0 1 1 & b = 87 0 1 0 1 0 1 1 1 c = 67 0 1 0 0 0 0 1 1

Obstajajo standardne pretvorbe, če so operandi različnih (mešanih) podatkovnih tipov. To izvršuje prevajalnik v mešanih izrazih. Operator za pretvarjanje med podatkovnimi tipi - () Operator za pretvarjanje nam omogoča, da izraz določenega podatkovnega tipa pretvorimo v drug podatkovni tip tako, da pred izraz v okrogle oklepaje zapišemo željen podatkovni tip. int celo_st; float realno_st = 3.14; celo_st = (int) realno_st; // realno število pretvorimo v celo število (vrednost 3)

5.1.6 Prioritete operatorjev

Prioriteta Kategorija Operator Združevanje 1 (najvišja) () [] . (dot operator) z leve v desno 2 unarni ++, - -, !, ~ z desne v levo 3 mnogokratni *, /, % z leve v desno 4 povečevalni +, - z leve v desno 5 bitni pomik >>, << z leve v desno 6 relacijski >, >=, <, <= z leve v desno 7 enakost ==, != z leve v desno 8 bitni in (AND) & z leve v desno 9 bitni ekskluzivni ali (XOR) ^ z leve v desno 10 bitni ali (OR) | z leve v desno 11 logični in (AND) && z leve v desno


Prioriteta Kategorija Operator Združevanje 12 logični ali (OR ) || z leve v desno 13 pogojni ?: z desne v levo 14 prireditev =, +=, -=, *=, /=, %=, >>=,

<<=, &=, ^=, |= z desne v levo

15 (najnižja) vejica , z leve v desno Združevanje določa pravilo, kateri del se izračuna oz. ovrednoti najprej, če imamo več operatorjev na istem nivoju prioritete in niso uporabljeni oklepaji. a = 5 * 7 % 2; // Izraz se lahko ovrednoti kot: a = 5 * (7 % 2); // v primeru desnega združevanja a = (5 * 7) % 2; // v primeru levega združevanja

6 KRMILNI STAVKI

Preden lahko napišemo program, ki vrne rešitev problema, moramo poznati postopek rešitve problema in programske konstrukte. Stavki programa se izvajajo eden za drugim v zaporedju kot so zapisani v programu. Proces imenujemo sekvenčno izvajanje (angl. sequential execution). Različni stavki programskega jezika omogočajo, da določimo drugačno zaporedje izvajanja (naslednji stavek izvajanja ni naslednji stavek v zaporedju). Program je sestavljen iz zaporedja stavkov (sekvence), odločitvenih stavkov (selekcije) in ponavljanja stavkov (iteracije). Blok stavkov je več stavkov, ki so med seboj ločeni s podpičjem in se nahajajo med zavitima oklepajema npr. { stavek1; stavek2; ... }. Če želimo, da je samo en stavek, potem ne uporabimo oklepajev oz. oznake za blok stavkov. V primeru, ko želimo sestavljeni stavek pa uporabimo blok stavkov. Če želimo, da se izvrši stavek ali blok stavkov samo v primeru določene vrednost pogoja oz. izraza, potem uporabimo odločitveni stavek. Odločitveni stavki

if stavek; switch stavek.

Stavki ponavljanja (zanke) Ponavljanje se lahko izvede določeno število krat npr. n – krat ali dokler je izpolnjen pogoj.

while stavek; do while stavek; for stavek.


6.1 Odločitveni stavki

6.1.1 If stavek

Če želimo, da se določen stavek (ali sestavljen stavek) izvede le ob določenem pogoju, potem uporabimo if stavek. If stavek predstavlja izbiro med več različnimi zaporedji stavkov. Sintaksa (oblika 1):

stavek1; if (pogoj) stavek2; stavek3;

Slika 16: Diagram poteka za if stavek (oblika 1)

Pogoj je izraz, ki se ovrednosti s true ali false. Le v primeru, če je pogoj izpolnjen (true), se izvede stavek2. Če pogoj ni izpolnjen (false), se stavek2 ne izvede in izvajanje se nadaljuje z naslednjim stavkom, ki sledi stavku if (stavek3). Če želimo, da se izvede sestavljen stavek, potem uporabimo blok stavkov.

stavek1; if (pogoj) { stavek2; stavek3; //... } stavek4;



Sintaksa z else (oblika 2):

stavek1; if (pogoj) stavek2; else stavek3; stavek4;


// ali stavek1; if (pogoj) { stavek2_1; stavek2_2; // ... } else { stavek3_1; stavek3_2; // ... } stavek4;


Stavke if lahko tudi gnezdimo (v stavku if je if stavek).


stavek1; if (pogoj_a) stavek2; else if (pogoj_b) stavek3; else if (pogoj_c) stavek4; else stavek_5; stavek6;

Slika 20: Diagram poteka za gnezden if stavek (oblika 5)

Primer: Uporabnik vnese število doseženih točk na izpitu. Če je število doseženih točk večje ali enako 50, potem program v izhodnem oknu izpiše obvestilo "Izpit ste opravili.", v nasprotnem izpiše "Izpita niste opravili." 1. //najava uporabe razreda Scanner 2. import java.util.Scanner; 3. public class If1 { 4. 5. public static void main(String[] args) { 6. // izpis obvestila za vnos točk 7. System.out.print("Število točk: "); 8. // v spremenljivko stevilo_tock zapišemo vnos uporabnika 9. double stevilo_tock = new Scanner(System.in).nextInt(); 10. if (stevilo_tock >= 50) // če je število točk večje ali enako 50 11. System.out.printf("Izpit ste opravili."); //izpis obvestila za opravljen izpit 12. else // sicer 13. System.out.printf("Izpita niste opravili."); //izpis obvestila za neopravljen izpit 14. } // konec metode main 15. 16. } //konec razreda Primer izvajanja:

Število točk: 60 Izpit ste opravili.

Primer: Uporabnik vnese število doseženih točk na izpitu. Če je število doseženih točk večje ali enako 50, potem program v izhodnem oknu izpiše obvestilo "Izpit ste opravili.", v nasprotnem izpiše dve vrstici obvestila (uporabimo dva programska stavka):


"Izpita niste opravili." "Naslednji izpit je v zimskem izpitnem roku." 1. //najava uporabe razreda Scanner 2. import java.util.Scanner; 3. public class If1_1 { 4. 5. public static void main(String[] args) { 6. // izpis obvestila za vnos točk 7. System.out.print("Število točk: "); 8. // v spremenljivko stevilo_tock zapišemo vnos uporabnika 9. double stevilo_tock = new Scanner(System.in).nextInt(); 10. if (stevilo_tock >= 50) // če je število točk >= 50 11. System.out.printf("Izpit ste opravili."); //izpis obvestila za opravljen izpit 12. else 13. { // sicer programski blok 14. System.out.println("Izpita niste opravili."); //izpis obvestila za neopravljen izpit 15. //izpis obvestila za neopravljen izpit 16. System.out.println("Naslednji izpit je v zimskem izpitnem roku."); 17. } // konec sicer bloka 18. } // konec metode main 19. 20. } // konec razreda Primer izvajanja:

Število točk: 30 Izpita niste opravili. Naslednji izpit je v zimskem izpitnem roku.

Primer: Uporabnik vnese število doseženih točk na izpitu. Program določi oceno izpita in jo izpiše v izhodnem oknu. Kriterij za določitev ocene Število točk Ocena 0-49 5 50-59 6 60-69 7 70-79 8 80-89 9 90-100 10 1. //najava uporabe razreda Scanner 2. import java.util.Scanner; 3. 4. public class If_1_2 { 5. 6. public static void main(String[] args) { 7. // izpis obvestila za vnos točk 8. System.out.print("Število točk: "); 9. // v spremenljivko stevilo_tock zapišemo vnos uporabnika 10. double stevilo_tock = new Scanner(System.in).nextInt(); 11. int ocena; // ocena izpita


12. 13. // določitev ocene 14. if (stevilo_tock >= 90) // če je število točk večje ali enako 90 15. ocena = 10; 16. else // sicer 17. if (stevilo_tock >= 80) // če je število točk večje ali enako 80 18. ocena = 9; 19. else // sicer 20. if (stevilo_tock >= 70) // če je število točk večje ali enako 70 21. ocena = 8; 22. else // sicer 23. if (stevilo_tock >= 60) // če je število točk večje ali enako 60 24. ocena = 7; 25. else // sicer 26. if (stevilo_tock >= 50) // če je število točk večje ali enako 50 27. ocena = 6; 28. else 29. ocena = 5; // v vsakem drugem primeru je ocena 5 30. // izpis ocene 31. System.out.printf("Ocena izpita: %d", ocena); 32. } // konec metode main 33. 34. } //konec razreda Primer izvajanja:

Število točk: 70 Ocena izpita: 8

Primer: Uporabnik vpiše tri cela števila (vnos). Program poišče največjo vneseno vrednost in jo izpiše v izhodnem oknu. 1. //najava uporabe razreda Scanner 2. import java.util.Scanner; 3. 4. public class If_2_1 { 5. 6. public static void main(String[] args) { 7. int stevilo1; //deklaracija celoštevilčne spremenljivke 8. int stevilo2; //deklaracija celoštevilčne spremenljivke 9. // ustvarimo primerek objekta rezreda Scanner za vnos 10. // izpis opisa aktivnosti 11. System.out.println("Vnos treh celih števil"); 12. System.out.println("------------------------------------------------------"); 13. // obvestilo za vnos 14. System.out.print("Prvo število: "); 15. // vneseno prvo število shranimo v spremenljivko stevilo1 16. stevilo1 = new Scanner(System.in).nextInt(); 17. // obvestilo za vnos 18. System.out.print("Drugo število: "); 19. // vneseno drugo število shranimo v spremenljivko stevilo2 20. stevilo2 = new Scanner(System.in).nextInt(); 21. 22. // v spremenljivko stevilo1 shranimo večje število od prvih dveh vnesenih števil


23. if (stevilo2 > stevilo1) // če je drugo število večje od prvega potem 24. stevilo1 = stevilo2; // v spremenljivko stevilo1 določimo vrednost drugega števila 25. 26. // obvestilo za vnos 27. System.out.print("Tretje število: "); 28. // vneseno tretje število shranimo v spremenljivko stevilo2 29. stevilo2 = new Scanner(System.in).nextInt(); 30. 31. /* če je tretje število, ki je shranjeno v spremenljivki stevilo2 večje od do 32. sedaj največjega, potem ga shranimo v spremenljivko stevilo1*/ 33. if (stevilo2 > stevilo1) 34. stevilo1 = stevilo2; // v spremenljivko stevilo1 shranimo vrednost spremenljivke stevilo2 35. System.out.println("------------------------------------------: "); 36. System.out.printf("Največje število: %d", stevilo1); 37. } // konec metode main 38. 39. } // konec razreda Primer izvajanja:

Vnos treh celih števil ------------------------------------------------------ Prvo število: 569 Drugo število: 400 Tretje število: 560 ------------------------------------------: Največje število: 569

6.2 Switch stavek

Kadar imamo več možnih vrednosti kot dve (pri stavku if) in se mora izvršiti le določeno zaporedje stavkov, potem uporabimo stavek switch. Glede na vrednost izraza se običajno izvrši le eno zaporedje stavkov izmed vseh možnih. Izbira poteka na podlagi vrednosti nekega izraza, ki mora vrniti vrednost podatkovnega tipa celega števila ali znaka. Izvede se zaporedje stavkov pri katerem se oznaka (konstanta_x) ujema z vrednostjo izraza. Sintaksa stavka switch: switch (izraz) { case konstanta_1: zaporedje_stavkov_1; break; case konstanta_2: zaporedje_stavkov_2; break; . . . default: privzeto_zaporedje_stavkov; }


Primer: switch (x) { case 1: System.out.println("x je 1"); break; case 2: System.out.println("x je 2"); break; default: System.out.println("x vrednost ni 1 ali 2"); } Stavek switch ovrednoti izraz in preveri, če se ujema z vrednostjo prve konstante (konstanta_1). Če se ujema, izvrši zaporedje_stavkov_1, dokler ne naleti na rezerviranko break. Stavek break povzroči vejitev (skok) iz stavka switch oz. izvajanje programa se nadaljuje na koncu stavka switch. Če izraz ni enak vrednosti konstanta_1, potem program preveri, če je enak vrednosti druge konstante (konstanta_2). Če se ujema, izvrši zaporedje_stavkov_2 dokler ne naleti na rezerviranko break. Če izraz ni enak nobeni izmed vrednosti konstant, potem program izvede stavke, ki so zapisani v default delu (če obstaja). switch stavek if stavek switch (x) { case 1: System.out.println("x je 1"); break; case 2: System.out.println("x je 2"); break; default: System.out.println("x vrednost ni ne 1 in ne 2"); }

if (x == 1) { System.out.println("x je 1"); } else { if (x == 2) { System.out.println("x je 2"); } else { System.out.println("x vrednost ni ne 1 in ne 2"); } }

Pri posamezni vrednosti konstante oz. izbiri ne smemo pozabiti vključiti rezerviranke break. Če je ne vključimo, program nadaljuje izvajanje ostalih delov v switch stavku. Namesto konstant npr. konstanta_1 ne smemo uporabiti izrazov npr. (i+3). Primer: Uporabnik vnese število doseženih točk na izpitu. Program določi oceno in jo izpiše v izhodnem oknu (uporabimo stavek switch). Število točk Ocena 0-49 5 50-59 6 60-69 7


70-79 8 80-89 9 90-100 10 //najava uporabe razreda Scanner import java.util.Scanner; public class Switch1_1 { public static void main(String[] args) { // izpis obvestila za vnos točk System.out.print("Število točk: "); // v spremenljivko stevilo_tock shranimo vnos uporabnika int stevilo_tock = new Scanner(System.in).nextInt(); int ocena; // ocena izpita // določitev ocene switch (stevilo_tock / 10) // število točk delimo z 10 { // blok switch stavka case 10: // število točk med 90 in 100 case 9: ocena = 10; break; case 8: // število točk med 80 in 89 ocena = 9; break; case 7: // število točk med 70 in 79 ocena = 8; break; case 6: // število točk med 60 in 69 ocena = 7; break; case 5: // število točk med 50 in 59 ocena = 6; break; default: ocena = 5; } // konec bloka switch stavka // izpis ocene System.out.printf("Ocena izpita: %d", ocena); } // konec metode main } // razreda Primer izvajanja:

Število točk: 55 Ocena izpita: 6

Primer: Uporabnik vnaša števila iz intervala od 1 do 5 dokler ne zaključi vnosa z vnosom vrednosti -1.


Program tekoče izračunava frekvenco pojavitev posameznih števil brez uporabe polj. Program po vnosu izpiše frekvenco pojavitev v izhodnem oknu. 1. //najava uporabe razreda Scanner 2. import java.util.Scanner; 3. 4. public class Switch_2_1 { 5. 6. public static void main(String[] args) 7. { 8. // deklaracija in inicializacija spremenljivk za določitev frekvence 9. int st1=0, st2=0, st3=0, st4=0, st5=0; // st1 - število ocen 1 ... st5 - število ocen 5 10. int stevilo; // spremenljivka za vnos 11. do 12. { // blok zanke 13. // izpis obvestila za vnos 14. System.out.print("Vnesi število iz intervala od 1 do 5 <-1 - konec>: "); 15. stevilo = new Scanner(System.in).nextInt(); 16. // glede na vneseno število povečamo ustrezno spremenljivko frekvenc števil za 1 17. switch (stevilo) // zadnje vneseno število 18. { // blok switch 19. case 1: 20. ++st1; // povečamo st1 za 1 21. break; 22. case 2: 23. ++st2; // povečamo st2 za 1 24. break; 25. case 3: 26. ++st3; // povečamo st3 za 1 27. break; 28. case 4: 29. ++st4; // povečamo st4 za 1 30. break; 31. case 5: 32. ++st5; // povečamo st5 za 1 33. break; 34. } // konec bloka switch 35. 36. } while (stevilo != -1); // konec bloka zanke 37. 38. 39. // izpišemo frekvence pojavitev ocen 40. System.out.printf("Število\tŠtevilo pojavitev\n"); 41. System.out.printf("%d\t%d\n",1,st1); 42. System.out.printf("%d\t%d\n",2,st2); 43. System.out.printf("%d\t%d\n",3,st3); 44. System.out.printf("%d\t%d\n",4,st4); 45. System.out.printf("%d\t%d\n",5,st5); 46. } // konec metode main 47. 48. } //konec razreda Primer izvajanja:

Vnesi število iz intervala od 1 do 5 <-1 - konec>: 5 Vnesi število iz intervala od 1 do 5 <-1 - konec>: 4


Vnesi število iz intervala od 1 do 5 <-1 - konec>: 5 Vnesi število iz intervala od 1 do 5 <-1 - konec>: 4 Vnesi število iz intervala od 1 do 5 <-1 - konec>: 2 Vnesi število iz intervala od 1 do 5 <-1 - konec>: -1 Število Število pojavitev 1 0 2 1 3 0 4 2 5 2


6.3 While stavek

Sintaksa: stavek1; while (pogoj) stavek2; stavek3;

Slika 21: Diagram poteka za while stavek (oblika 1)

// ali stavek1; while (pogoj) { stavek2_1; stavek2_2; ... } stavek3;

Slika 22: Diagram poteka za while stavek (oblika 2)

Stavek2 (telo zanke) se izvaja tako dolgo, dokler je izpolnjen pogoj. Če pogoj ob prvem ovrednotenju ni izpolnjen, potem se stavek2 nikoli ne izvede. Ko prvič ni izpolnjen pogoj, se nadaljuje izvajanje programa v stavku, ki sledi stavku while (v našem primeru je to stavek 3). Zgledi: 1. /** Primer z zmanjševanjem števca. 2. * Uporabnik vpiše pozitivno celo število. 3. * Program na zaslon izpiše seznam števil od vnesenega števila do števila 1. */ 4. 5. import java.util.Scanner; 6.


7. public class while1_1 { 8. 9. 10. public static void main(String[] args) { 11. int stevilo; // spremenljivka za vnos števila 12. System.out.println("Vpišite pozitivno celo število: "); 13. stevilo = new Scanner(System.in).nextInt(); 14. while (stevilo > 0) //dokler je število večje od nič 15. { 16. System.out.print(stevilo); //v izhodno okno izpišemo število 17. if (stevilo > 1) // zadnje izpisano število 18. System.out.print(", "); //izpišemo vejico s presledkom 19. stevilo = stevilo - 1; // zmanjšamo vrednost števila za ena 20. } 21. } 22. } Primer izvajanja:

Vpišite pozitivno celo število: 25 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

1. /* 2. * Izračun vsote števil od 1 do N. 3. * N - celo število 4. */ 5. import java.util.Scanner; 6. public class while1_2 { 7. 8. public static void main(String[] args) { 9. System.out.print("Vpiši N: "); 10. //v spremenljivko N preberemo vrednost celega števila 11. int N = new Scanner(System.in).nextInt(); 12. int i = 1; // inicializiramo števec zanke 13. int vsota = 0; // začetna vrednost vsote je 0 14. while (i <= N) // dokler je števec manjši ali enak N 15. { 16. vsota = vsota + i; // vsoti prištejemo trenutno vrednost števca 17. //izpišemo vrednost vsote do vrednosti števca 18. System.out.printf("Vsota števil od 1 do %d je %d.\n",i,vsota); 19. i = i + 1; // števec povečamo za ena 20. } 21. // izpišemo vrednost vsote 22. System.out.printf("\nVsota števil od 1 do %d je %d.",N,vsota); 23. } 24. } Primer izvajanja:

Vpiši N: 6 Vsota števil od 1 do 1 je 1. Vsota števil od 1 do 2 je 3. Vsota števil od 1 do 3 je 6.


Vsota števil od 1 do 4 je 10. Vsota števil od 1 do 5 je 15. Vsota števil od 1 do 6 je 21. Vsota števil od 1 do 6 je 21.

6.3.1 Do while stavek

Od while stavka se razlikuje po tem, da se ne glede na pogoj izvede vsaj enkrat, kar je posledica tega, da se pogoj testira po izvršitvi stavka zanke (stavek2 ali blok stavkov { stavek2_1; stavek2_2}). Sintaksa: stavek1; do stavek2; while (pogoj); stavek3;

Slika 23: Diagram poteka za do while stavek (oblika 1)

// ali stavek1; do { stavek2_1; stavek2_2; ... } while (pogoj); stavek3;

Slika 24: Diagram poteka za do while stavek (oblika 2)

Ko se v preverjanju pogoja ugotovi, da pogoj ni izpolnjen, se nadaljuje izvajanje programa v stavku, ki sledi stavku while (v našem primeru je to stavek 3).


Primeri: 1. /* Ugotavljanje naključnega števila od 1 do 10. Računalnik izbere naključno število. 2. * Uporabnik v čim manj poskusih ugane izbrano število. */ 3. import java.util.Random; // razred naključna števila 4. import java.util.Scanner; 5. public class do1 { 6. 7. public static void main(String[] args) { 8. Random nakljucno = new Random(); 9. int nakljucno_stevilo = nakljucno.nextInt(10); 10. int stevilo, i=0; 11. do // ponavljaj 12. { 13. i = i + 1; // števec poskusov 14. // izpišemo obvestilo za vnos števila 15. System.out.printf("Ugani število med 1 in 10 (%d.): ",i); 16. // v spremenljivko stevilo preberemo vrednost števila 17. stevilo = new Scanner(System.in).nextInt(); 18. // dokler je vneseno število različno od naključno izbranega 19. } while (nakljucno_stevilo != stevilo); 20. if (nakljucno_stevilo == stevilo) // je število uganjeno 21. // izpišemo število poskusov 22. System.out.printf("Čestitke ...\nŠtevilo poskusov: %d. ",i); 23. else 24. // izpišemo neuspešno uganjevanje 25. System.out.print("Izbranega števila niste uganili."); 26. } 27. } Primer izvajanja:

Ugani število med 1 in 10 (1.): 5 Ugani število med 1 in 10 (2.): 10 Ugani število med 1 in 10 (3.): 6 Čestitke ... Število poskusov: 3.

Predavatelj za vsakega študenta vpiše število doseženih točk izpita (od 0 do 100). Vnos se zaključi z vnosom -1. Program izračuna in izpiše število študentov in povprečje doseženih točk. Psevdokod algoritma: določi vsoto točk na 0 določi število študentov na 0 ponavljaj število_študentov povečaj za 1 izpiši obvestilo za vnos preberi število točk če je število točk različno od -1 potem vsota točk <- vsota točk + število točk sicer število_študentov <- število_študentov - 1


dokler število točk različno od -1 če je število_študentov večje od 0 potem izpiši število študentov izračunaj in izpiši povprečje točk 1. /* Predavatelj za vsakega študenta vpiše število doseženih točk izpita (od 0 do 100). 2. * Vnos se zaključi z vnosom -1. Program izračuna in izpiše število študentov in 3. * povprečje doseženih točk. */ 4. import java.util.Scanner; 5. 6. public class povprecje { 7. private static Scanner vhod = new Scanner(System.in); 8. 9. public static void main(String[] args) { 10. double stevilo_tock; // število točk posameznega študenta 11. double vsota_tock = 0; //skupaj točke vnesenih študentov 12. int stevilo_studentov = 0; //števec - štetje vnosov točk 13. do //ponavljamo 14. { 15. stevilo_studentov = stevilo_studentov + 1; //povečamo števec študentov 16. // izpišemo obvestilo za vnos točk i-tega študenta 17. System.out.printf("Število točk %d-tega študenta: ",stevilo_studentov); 18. stevilo_tock = vhod.nextDouble(); //vnesemo točke i-tega študenta 19. if (stevilo_tock != -1) // je konec vnosa točk 20. // vsoti točk prištejemo vnesene točke 21. vsota_tock = vsota_tock + stevilo_tock; 22. else 23. stevilo_studentov = stevilo_studentov - 1; // vnos -1 ne upoštevamo 24. } while (stevilo_tock != -1); // dokler ni vnos zaključka vnosa (-1) 25. if (stevilo_studentov > 0) // je število študentov večje od 0 26. { //izpis števila študentov 27. System.out.printf("Število študentov: %d.\n", stevilo_studentov); 28. // izračun in izpis povprečja točk 29. System.out.printf("Povprečje točk: %f.", (vsota_tock / stevilo_studentov)); 30. } 31. } 32. } Primer izvajanja:

Število točk 1-tega študenta: 56 Število točk 2-tega študenta: 54 Število točk 3-tega študenta: 80 Število točk 4-tega študenta: -1 Število študentov: 4. Povprečje točk: 47,250000.


6.4 For stavek

For stavek na enem mestu združuje inicializacijo števca, določitev pogoja ponavljanja in izraz spremembe števca po vsaki izvršitvi telesa oz. bloka zanke. Podobno kot pri stavku while se pogoj preverja na začetku. Sintaksa:

stavek1; for (inicializacija; pogoj; sprememba_stevca) stavek2; stavek3;

Slika 25: Diagram poteka za for stavek (oblika 1)

ali

stavek1; for (inicializacija; pogoj; sprememba_stevca) { stavek2_1; stavek2_2; ... } stavek3;

Slika 26: Diagram poteka za for stavek (oblika 2)

Stavek (stavek2) ali blok stavkov v for stavku se izvršuje dokler je izpolnjen pogoj. V inicializacijskem delu deklariramo in določimo začetno vrednost spremenljivke, ki jo uporabimo za števec v zanki.


V delu sprememba števca pa določimo spremembo števca (povečujemo oz. zmanjšujemo spremenljivko števca - korak). Postopek izvajanja: 1. Izvrši se inicializacija (le enkrat; ob vstopu v zanko for). 2. Preveri se pogoj. Če pogoj ni izpolnjen, se nadaljuje izvajanje programa za stavkom for. 3. Izvrši se telo oz. blok for stavka, ki je lahko posamezen stavek ali blok stavkov ({stavek2_1; stavek2_2... }). 4. Izvrši se sprememba števca in izvajanje se nadaljuje v točki 2. Zgled:

Slika 27: For stavek (združen števec in pogoj)

Dela inicializacija in sprememba števca sta opcijska (podpičja so obvezna). Npr. zapišemo lahko for (;n<10;). V posamezen del lahko zapišemo več stavkov, ki jih med seboj ločimo z vejico (,). V tem primeru je vejica ukazni separator. Zgled: for ( n = 0, i = 50 ; n != i ; n++, i-- ) b { // obdelava... } V inicializaciji priredimo spremenljivki n vrednost 0 in spremenljivki i vrednost 50. Pogoj: spremenljivka n ni enaka spremenljivki i. Ker se n povečuje za ena in i zmanjšuje za ena bo pogoj zanke izpolnjen po 25-ih izvršitvah zanke, ko bosta spremenljivki n in i imeli vrednost 25. Primeri: 1. /* 2. * Program izpiše zaporedje: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, Konec! 3. */ 4. public class for1_1 { 5. 6. public static void main(String[] args) { 7. // zanka for števec i se spreminja od 10 do 0 (korak -1) 8. for (int i = 10; i > 0; i--) 9. System.out.printf("%d,",i); // izpis vrednosti števca i 10. System.out.print("Konec!"); // po zaključku zanke izpišemo še "Konec!" 11. } 12. } Primer izvajanja:

10,9,8,7,6,5,4,3,2,1,Konec! 1. /* Predavatelj za vsakega študenta vpiše število doseženih točk izpita (od 0 do 100). 2. * Na začetku izvajanja se vnese število študentov. 3. * Program izračuna in izpiše število študentov in povprečje doseženih točk. */ 4. import java.util.Scanner; 5.


6. public class Povprecje { 7. //razred naključna števila 8. private static Scanner scanner = new Scanner(System.in); 9. 10. public static void main(String[] args) { 11. double stevilo_tock; // število točk posameznega študenta 12. double vsota_tock = 0; //skupaj točke vnesenih študentov 13. int stevilo_studentov; //število študentov 14. // izpišemo obvestilo za vnos števila študentov 15. System.out.print("Število študentov: "); 16. stevilo_studentov = scanner.nextInt(); //vnesemo število študentov 17. // for stavek i=1 .. stevilo_studentov (korak 1) 18. for (int i = 1; i <= stevilo_studentov; i++) 19. { 20. // izpišemo obvestilo za vnos točk i-tega študenta 21. System.out.printf("Število točk %d-tega študenta: ",i); 22. stevilo_tock = scanner.nextDouble(); //vnesemo točke i-tega študenta 23. vsota_tock = vsota_tock + stevilo_tock; // vsoti točk prištejemo vnesene točke 24. } 25. if (stevilo_studentov > 0) // je število študentov večje od 0 26. { // izračun in izpis povprečja točk 27. System.out.printf("Povprečje točk: %f.", (vsota_tock / stevilo_studentov)); 28. } 29. } 30. }

6.5 Break in continue stavek

6.5.1 Break stavek

Break stavek v switch stavku povzroči vejitev (skok) iz stavka switch oz. izvajanje programa se nadaljuje na koncu stavka switch. Break stavek lahko uprabimo tudi v kateremkoli telesu oz. bloku zanke. Break stavek v zanki ustavi izvajanje zanke in izvajanje se nadaljuje s prvim stavkom, ki sledi zanki. V praksi se izogibamo uporabi stavka break v telesu oz. bloku zanke. Primer: Zanka for se bi brez uporabe stavka break v if stavku izvršila 10-krat. Stavek break se izvrši, ko ima števec vrednost 6. Izvajanje zanke for se prekine. // zanka s spreminjanjem števca od 1 do 10 (korak 1) for (int i=1; i <= 10; i++) { if (i == 6) //vrednost števca i je enaka šest? break; //izhod iz zanke for System.out.printf ("Vrednost števca je %d.\n", i); //izpis vrednosti števca } System.out.println ("Stavek za zanko for."); Primer izvajanja:


Vrednost števca je 1. Vrednost števca je 2. Vrednost števca je 3. Vrednost števca je 4. Vrednost števca je 5. Stavek za zanko for.

V zankah ne potrebujemo stavka break (ga ne uporabljamo).

6.5.2 Continue stavek

Uporaba stavka continue v zanki povzroči, da se preostanek telesa zanke izpusti in se začne naslednje izvajanje zanke, če je pogoj zanke resničen. Primer: Zanka for se bi brez uporabe stavka continue v if stavku izvršila v celoti 10-krat. Stavek continue se izvrši, ko ima števec vrednost 6. V tem primeru se stavki v telesu zanke za stavkom continue ne izvršijo in se nadaljuje izvajanje naslednje ponovitve zanke for. // zanka s spreminjanjem števca od 1 do 10 (korak 1) for (int i=1; i <= 10; i++) { if (i == 6) //vrednost števca i je enaka šest? continue; //vejitev oz. skok v preverjanje pogoja zanke System.out.printf ("Vrednost števca je %d.\n", i); //izpis vrednosti števca } System.out.println ("Stavek za zanko for."); Primer izvajanja:

Vrednost števca je 1. Vrednost števca je 2. Vrednost števca je 3. Vrednost števca je 4. Vrednost števca je 5. Vrednost števca je 7. Vrednost števca je 8. Vrednost števca je 9. Vrednost števca je 10. Stavek za zanko for.

V zankah ne potrebujemo stavka continue. V dobri praksi se v zankah ne uporablja stavek continue.

6.5.3 Primeri

Izračun povprečne vrednosti n števil Primeri: 1. /* Izračun povprečne vrednosti n števil. N določi uporabnik. Števila vpiše uporabnik. */ 2. public static void main(String[] args) { 3. double vsota = 0; // vsota vnesenih števil 4. System.out.print("Število števil - N: "); 5. int n; // število števil 6. Scanner vhod = new Scanner(System.in);


7. n = vhod.nextInt(); //vnos celega števila 8. // zanka for, števec i => 1 .. n 9. double stevilo; // vnos števila 10. for (int i=1; i<=n; i++) 11. { // obvestilo za vnos i-tega števila 12. System.out.printf("%d. število: ",i); 13. // vnos števila 14. stevilo = vhod.nextDouble(); 15. // vsoti prištejemo i-to število 16. vsota = vsota + stevilo; 17. } / /for 18. // izračun povprečja 19. if (n > 0) // je vpisano vsaj eno število 20. { 21. // izračun povprečja 22. double povprecje = vsota / n; 23. // izpis povprečja 24. System.out.printf("Povprečje števil je %f.", povprecje); 25. } // if 26. } // main Izvajanje:

Število števil - N: 4 1. število: 5 2. število: 6 3. število: 9 4. število: 8 Povprečje števil je 7,000000.

Preštevanje sodih in lihih števil 1. /* Preštevanje sodih in lihih števil. 2. * Uporabnik vpisuje cela števila dokler ne vpiše števila 0. 3. */ 4. public static void main(String[] args) { 5. // število sodih in lihih števil inicializiramo na 0. 6. int stevilo_soda = 0, stevilo_liha=0; 7. Scanner vhod = new Scanner(System.in); 8. // zanka do while 9. int stevilo; // vpis števila 10. do 11. { // obvestilo za vnos števila 12. System.out.print("Število: "); 13. // vnos števila 14. stevilo = vhod.nextInt(); 15. // je število različno od 0 16. if (stevilo != 0) 17. { 18. // če je ostanek po celoštevilčnem deljenju z 2 enak 0 => sodo število 19. if (stevilo % 2 == 0 ) // je sodo 20. stevilo_soda = stevilo_soda + 1; 21. else 22. stevilo_liha = stevilo_liha + 1; 23. } // if 24. } while (stevilo !=0); // dokler je število različno od 0


25. // izpis števila sodih in lihih števil 26. System.out.printf("Število sodih števil: %d.\n", stevilo_soda); 27. System.out.printf("Število lihih števil: %d.", stevilo_liha); 28. } //main Izvajanje:

Število: 5 Število: 10 Število: 78 Število: 24 Število: 69 Število: 21 Število: 0 Število sodih števil: 3. Število lihih števil: 3.

Izris pravokotnika v besedilnem načinu 1. /* Izris pravokotnika z znakom '*'. 2. * Uporabnik vpiše stranici pravokotnika (a in b). 3. * */ 4. public static void main(String[] args) { 5. int stranica_a, stranica_b; // stranici pravokotnika 6. Scanner vhod = new Scanner(System.in); // primerek objekta za vnos podatkov 7. //izpis obvestila 8. System.out.print("Stranica a (število stolpcev): "); 9. // vnos stranice a 10. stranica_a = vhod.nextInt(); 11. //izpis obvestila 12. System.out.print("Stranica b (število vrstic): "); 13. // vnos stranice b 14. stranica_b = vhod.nextInt(); 15. // izris pravokotnika v besedilnem načinu 16. // zanka stevec i => 1 .. stranica_b (število vrstic) 17. for (int i =1; i<= stranica_b; i++) 18. { 19. // zanka stevec j => 1 .. stranica_a (število stolpcev) 20. for (int j =1; j<= stranica_a; j++) 21. System.out.print('*'); // izpis znaka '*' 22. // prehod v novo vrstico 23. System.out.println(""); 24. } // for vrstice 25. } // main Primer izvajanja:

Stranica a (število stolpcev): 5 Stranica b (število vrstic): 3 ***** ***** *****


7 METODE

Najboljši način razvoja in vzdrževanja večjega programa je, da ga izdelamo iz manjših delov oz. modulov. Takšen pristop imenujemo deli in vladaj. Večji problem razbijemo na manjše dele, ki jih rešimo in jih nato povežemo v celoto. V Javi izdelujemo programske rešitve s kombinacijo uporabe vgrajenih razredov in metod v programski knjižnici (Java Application Programming Interface - Java API) in izdelavo lastnih razredov in metod. Sorodne razrede združujemo v pakete, ki jih vključujemo v programske rešitve. Java API vsebuje veliko zbirko definiranih razredov, ki vsebujejo metode za izvajanje aktivnosti, npr. matematičnih izračunov, obdelave nizov, obdelave znakov, vhodno/izhodne operacije, uporaba zbirk podatkov, delo z medmrežjem, obdelava besedilnih dokumentov, preverjanje napak itd. Metode omogočajo lažjo modularno zasnovo programa z ločevanjem aktivnosti v samostojne programske enote. Metoda predstavlja poimenovano zaporedje stavkov, ki predstavlja rešitev manjšega problema. S klici metod izvajamo isto zaporedje stavkov nad različnimi podatki. Metode predstavljajo tudi operacije, ki so na voljo nad posameznim objektom. Primeri: metoda za bančno transakcijo (datum, znesek, namen), metoda za vpis ocene predmeta (datum, predmet, ocena), metoda za izračun kvadratnega korena (število) ...

Metodo izvršimo s klicem metode. Ločimo dve vrsti metod: metode, ki ne vračajo vrednosti (klic metode je samostojen stavek) in metode, ki vračajo vrednost (klic metode je sestavni del izraza).

7.1.1 Deklaracija metode

// glava metode <določila načina dostopa> <podatkovni tip rezultata> <ime metode> ( [<podatkovni tip> <ime>] [, <podatkovni ti > <ime>] ) { // telo metode // stavki [ return <izraz>; ] // metode, ki vračajo vrednosti } // konec metode <določila načina dostopa> npr. public static Podatkovni tip void določa, da metoda ne vrača vrednosti. Seznam formalnih parametrov metode je lahko prazen (). Formalni parameter je določen s podatkovnim tipom in imenom. Formalni parametri so med seboj ločeni z vejico. Formalni parametri predstavljajo lokalne spremenljivke, ki so dosegljive samo znotraj metode.

7.1.2 Statične metode

Metode najpogostejše izvajamo kot klic metode nad izvodom objekta določenega razreda. Včasih izvršitev metode ni odvisna od vsebine objekta. Takšne metode so v razredih definirane kot statične z uporabo rezerviranke static. Statične metode lahko uporabljajo le statične lastnosti (polja) in statične metode. Statične metode razreda uporabljamo za splošne aktivnosti.


Za statično spremenljivko obstaja ena sama vrednost spremenljivke za celoten razred, zato jih imenujemo tudi spremenljivke razreda (ang. class variables). Statične metode so tipične za razrede, ki predstavljajo aplikacije in razrede, ki služijo kot knjižnice (npr. razred Math): deklariramo jih z dostopnim določilom static, v pomnilniku so shranjene samo enkrat, niso vezane na posamezne objekte, ampak so skupne za celoten razred, uporabljamo jih tudi brez ustvarjanja (obstoja) objekta, statične metode ne morejo posegati v polja (atribute) posameznih objektov, metoda main() je vedno statična, statična metoda v razredu, ki je namenjen ustvarjanju objektov, je skupna (enaka) za vse izvode objekte.

Klic oz. izvršitev statične metode razreda: <ImeRazreda>.<imeMetode> (< dejanski parametri >); Konstantno polje je deklarirano z rezerviranko final. Konstantnega polja po inicializaciji ne moremo spreminjati. Rezerviranka static omogoča dostop do metode z uporabo imena razreda Math npr. Math.PI. Statična polja imajo enako vrednost za vse izvode objekte razreda. Metodo main določimo z rezerviranko static. To omogoča Java Virtual Machine (JVM), da lahko izvede klic metode main brez ustvarjanja primerka objekta razreda.

7.1.3 Metode objekta

Metode objekta so vezane na posamezne objekte (primerke razreda). Razred (tip) objekta določa metode, ki so na voljo za posamezen objekt. Tipične so za razrede, ki so namenjeni ustvarjanju objektov. Metode objekta omogočajo dostop do posameznih polj (atributov) objekta. Pri deklaraciji metod objektov ne uporabimo dostopnega določila static. Ob klicu metode objekta vedno navedemo tudi ime objekta, ki mu metoda pripada. Klic oz. izvršitev metode objekta: <ime objekta>.<ime metode> (<dejanski parametri>) <ime razreda>.<ime objekta>.<ime metode> (<dejanski parametri>) Metode z več parametri Metode pogosto zahtevajo več informacij, da lahko izvršijo ustrezne aktivnosti. Oglejmo si primer metode, ki za tri cela števila vrne najmanjše število. 1. /* Vnos treh celih števil. 2. * Program poišče najmanjše vneseno število in ga izpiše na zaslon.*/ 3. // najava uporabe razreda Scanner 4. import java.util.Scanner; 5. // razred 6. public class Metode1 { 7. // metoda main 8. public static void main(String[] args) { 9. Scanner vhod = new Scanner(System.in); 10. int stevilo1, stevilo2, stevilo3; // celoštevilčne spremenljivke 11. // izpis obvestila 12. System.out.print("Vpiši tri cela števila (ločena s presledki): "); 13. stevilo1 = vhod.nextInt(); // vnos 1. števila 14. stevilo2 = vhod.nextInt(); // vnos 2. števila


15. stevilo3 = vhod.nextInt(); // vnos 3. števila 16. // izpis najmanjšega števila 17. System.out.printf("Najmanjše število je %d.", 18. najmanjseStevilo(stevilo1,stevilo2,stevilo3)); 19. } // metoda main 20. 21. // metoda vrne najmanjše število 22. public static int najmanjseStevilo(int stevilo1, int stevilo2, int stevilo3) 23. { 24. // prvo število je najmanjše 25. int najmanjse = stevilo1; 26. // če je drugo število manjše od do sedaj najmanjšega 27. if (stevilo2 < najmanjse) 28. najmanjse = stevilo2; // drugo število je najmanjše 29. // če je tretje število manjše od do sedaj najmanjšega 30. if (stevilo3 < najmanjse) 31. najmanjse = stevilo3; // tretje število je najmanjše 32. return najmanjse; // vrnemo rezultat 33. } // metoda najmanjseStevilo 34. } // razred Metode1 Primer izvajanja:

Vpiši tri cela števila (ločena števila s presledki): 25 487 63 Najmanjše število je 25.

Klic metode Ob klicu metode navedemo ime metode in dejanske parametre metode. Dejanski in formalni parametri se morajo ujemati v številu in podatkovnem tipu glede na vrstni red parametrov. Dejanski parameter je lahko vrednost spremenljivke, konstante ali izraza. Navadne spremenljivke se prenašajo po vrednosti, objekti pa po referenci. Pri prenosu po vrednosti prejme metoda kopijo vrednosti dejanskega parametra. Klic metode, ki vrača vrednost je sestavni del izraza. Klic metode, ki ne vrača vrednost je samostojni stavek.

Klic metode znotraj razreda v katerem se nahaja metoda

o <imeMetode> (<dejanski parametri>) npr. najmanjseStevilo(stevilo1,stevilo2,stevilo3) 1. // primer prenosa parametra po vrednosti 2. public class B { 3. // metoda main 4. public static void main(String[] args) { 5. double stevilo = 20; //deklaracija in inicializacija 6. // klic metode dvakratStevilo je samostojni stavek 7. dvakratStevilo(stevilo); // stevilo- dejanski parameter 8. // izpis 9. System.out.printf("Vrednost števila v metodi main po izvršitvi metode dvakratStevilo je %f.\n", stevilo); 10. } // metoda main 11. 12. // metoda dvakratStevilo 13. public static void dvakratStevilo(double stevilo)


14. { 15. stevilo = 2 * stevilo; // sprememba vrednosti spremenljivke parametra 16. System.out.printf("Vrednost števila v izpisu v metodi dvakratStevilo je %f.\n", stevilo); 17. } // metoda dvakratStevilo 18. } Primer izvajanja:

Vrednost števila v izpisu v metodi dvakratStevilo je 40,000000. Vrednost števila v metodi main po izvršitvi metode dvakratStevilo je 20,000000.

Slika 28: Formalni in dejanski parameter Klic metode iz drugega razreda Metode, ki so vezane na objekte

o <imeRazreda>.<imeObjekta>.<imeMetode>(<dejanski parametri>) Samostojne (statične) metode

o <imeRazreda>.<imeMetode>(<dejanski parametri>) Vračanje kontrole izvajanja v stavek klica metode Če metoda ne vrača vrednosti (podatkovni tip void), potem se izvajanja programa nadaljuje za stavkom klica

metode po zaključku bloka metode (}) ali po izvršitvi stavka return. Če metoda vrača vrednost, potem se izvajanje programa nadaljuje v stavku klica metode po izvršitvi stavka return

<izraz>.

7.1.4 Formalni in dejanski parametri metode

Formalne parametre metode navedemo ob deklaraciji metode in so določeni s podatkovnim tipom in imenom. Ob klicu metode se dejanski parametri prenesejo v isto ležeče formalne parametre metode. Formalni parametri predstavljajo lokalne spremenljivke metode, ki so dostopne samo znotraj telesa metode. Število formalnih in dejanskih parametrov se mora ujemati. Podatkovni tipi isto ležečih dejanskih parametrov morajo biti skladni oz. kompatibilni s formalnimi parametri. Podatkovna tipa sta skladna oz. kompatibilna, če je podatkovni tip dejanskega parametra vsebovan v podatkovnem tipu formalnega parametra. Zgled prenosa dejanskih parametrov v formalne parametre metode:

Slika 29: Prenos parametrov


Klic metode obseg_pravokotnika ni samostojni stavek. 1. /* Izračun obsega pravokotnika 2. * 3. * najava uporabe razreda Scanner */ 4. import java.util.Scanner; 5. // razred 6. public class Metode1 { 7. // metoda main 8. public static void main(String[] args) { 9. Scanner vhod = new Scanner(System.in); 10. double dolzinaA, sirinaB; //stranice pravokotnika 11. // izpis obvestila 12. System.out.print("Vpiši dolžino in širino pravokotnika: "); 13. dolzinaA = vhod.nextDouble(); // vnos dolžine 14. sirinaB = vhod.nextDouble(); // vnos širine 15. System.out.printf("Obseg pravokotnika s tranicami %f in %f je %f.", dolzinaA, sirinaB, 16. obseg_pravokotnika(dolzinaA,sirinaB)); // dejanska parametra dolzinaA in sirinaB 17. } // metoda main 18. 19. /* metoda za izračun obsega pravokotnika 20. * vhod: stranicaA - dolžina pravokotnika, stranicaB - širina pravokotnika 21. * rezultat: obseg pravokotniak 22. */ 23. public static double obseg_pravokotnika(double stranica A, double stranicaB)

// formalna parametra stranicaA in stranicaB 24. { 25. double obseg = 2 * stranicaA + 2 * stranicaB; // deklaracija in izračun obsega 26. return obseg; // vračanje rezultata 27. } // metoda obseg_pravokotnika 28. } // razred Metode1 Primer izvajanja:

Vpiši dolžino in širino pravokotnika: 4 8 Obseg pravokotnika s stranicami 4,000000 in 8,000000 je 24,000000.


Pretvarjanje podatkovnih tipov pri klicu metod Pretvorba podatkovnih tipov se izvede v primerih klica metode s parametri, kjer se parameter pretvori iz podatkovnega tipa manjšega obsega v podatkovni tip večjega obsega (ni izgube podatkov). Npr. klic metode Math.sqrt (9) povzroči izvršitev metode, ki pričakuje vhodni parameter podatkovnega tipa double. Deklariran seznam parametrov metode povzroči pretvorbo celoštevilčne vrednosti 9 v vrednost podatkovnega tipa double 9.0. Tabela pretvorb

Podatkovni tip Ustrezni podatkovni tipi pretvorbe

double /

float double

long float ali double

int long ali float ali double

char int ali long ali float ali double

short int ali long ali float ali double

byte short ali int ali long ali float ali double

boolean /

8 TABELA OZ. POLJE

Tabela oz. polje je zaporedje elementov enakega podatkovnega tipa. Elementi polja so shranjeni na sosednjih pomnilniških lokacijah. Vrednost posameznega elementa dobimo tako, da za ime spremenljivke polja med oglatimi oklepaji zapišemo indeks elementa. ime polja ime [indeks] elementi polja polje_stevil polje_stevil[0] 94 polje_stevil[1] -16 polje_stevil[2] 37 polje_stevil[3] -48 polje_stevil[4] -27 polje_stevil[5] 31 polje_stevil[6] -58 polje_stevil[7] -61 polje_stevil[8] -75 polje_stevil[9] -76 Polje na sliki ima ime polje_stevil in vsebuje 10 elementov. Indeksi polja so od 0 do 9 (prvi indeks polja je vedno 0 ne glede na dolžino polja). Indeks polja je vedno pozitivna celoštevilčna vrednost. Vrednost tretjega elementa polja: polje_stevil[2]. Število elementov polja predstavlja spremenljivka length. Izraz ime_polja.length predstavlja dolžino polja oz. število elementov polja. Spremenljivki length ne moremo spremeniti vrednosti, ker je konstanta (final). Polje na sliki vsebuje 10 elementov. Elementi polja: polje_stevil[0], polje_stevil[1], polje_stevil[2] ..., polje_stevil[9]. Vrednost elementa polje_stevil[0] je 94, polje_stevil[1] je -16, polje_stevil[2] je 37 ..., polje_stevil[9] je -76. Vsoto vrednosti prvih dveh elementov zapišemo: int vsota_prvega_in_drugega_elementa = polje_stevil[0] + polje_stevil[1]; Tako kot pri spremenljivkah, moramo tudi polje deklarirati oz. najaviti pred uporabo. Sintaksa deklaracije: podatkovni_tip[] ime = new razred_podatkovni_tip[število_elementov];


Primer: int[] polje_stevil = new int[10]; Deklaracija ustvari nov objekt desetih elementov podatkovnega tipa int. V spremenljivko polje_stevil se shrani pomnilniški naslov oz. referenca, kje se nahaja polje v pomnilniku. Ob ustvarjanju polja se vsem elementom polja določi privzeta vrednost. Tabela privzetih vrednosti

Podatkovni tip Privzeta vrednost

Osnovni številčni podatkovni tipi (int, double ...) 0

Logični podatkovni tip (boolean) false

Reference (kazalci) na objekte null Deklaracijo in ustvarjanje lahko izvedemo v dveh korakih: int[] polje_stevil; // deklaracija polja polje_stevil = new int[10]; // ustvarjanje polja V stavku polje_stevil = new int[10]; se v spremenljivko polja polje_stevil shrani referenca oz. pomnilniški naslov nahajališča oz. mesta polja v pomnilniku. V posameznem deklaracijskem stavku lahko ustvarimo več polj. int[] polje_stevil1 = new int[ 10 ], polje_stevil2 = new int[ 5 ]; Stavek ustvari dva polja celih števil. Prvo polje polje_stevil1 ima 10 elementov, drugo polje polje_stevil2 pa 5 elementov. Če v deklaraciji najavimo samo eno spremenljivko, potem lahko oglate oklepaje postavimo za rezerviranko podatkovnega tipa ali za ime spremenljivke, npr. int[] polje_stevil = new int[ 10 ]; // ali int polje_stevil[] = new int[ 10 ]; Deklariramo lahko polje poljubnega podatkovnega tipa. Polja osnovnih podatkovnih tipov vsebujejo vrednosti deklariranih podatkovnih tipov. Polja referenčnih tipov vsebujejo pomnilniške naslove oz. reference na objekte, ki so elementi polja. Polje polje_nizov deklarirano z izrazom String[] polje_nizov = new String[ 5 ]; vsebuje vrednosti referenc na objekte String.


Deklaracija polja z inicializacijo vrednosti Ob deklaraciji polja lahko določimo začetne vrednosti elementov polja. Začetne vrednosti določimo s seznamom vrednosti, ki ga zapišemo med zavite oklepaje. int[] polje_stevil3 = { 3, 5, 6, 2, 8, 7, 3, 5, 9, 8 }; Dolžina polja v oglatih oklepajih izpustimo, ker je določena s številom elementov seznama začetnih vrednosti. Zgled: 1. // deklaracija in določitev začetnih vrednosti polja 2. int[] polje_stevil3 = { 3, 5, 6, 2, 8, 7, 3, 5, 9, 8 }; 3. // izpis naslovne vrstice 4. System.out.printf("\tIndeks\tpolje_stevil3\n"); // \t - tabulator (oblikovanje stolpcev) 5. // zanka za vse elemente polja, indeks i ==0 .. število elementov polja 6. for (int i=0; i<polje_stevil3.length;i++) 7. // izpis vrednosti indeksa in elementa polja 8. System.out.printf("\t%d\t%d\n",i,polje_stevil3[i]); Primer izvajanja: Indeks polje_stevil3 0 3 1 5 2 6 3 2 4 8 5 7 6 3 7 5 8 9 9 8 Primeri 1. /* V polje se zapišejo ocene izpita predmeta (ocene od 1 do 10). 2. * Uporabnik določi število ocen. 3. * Izračun povprečne ocene predmeta in števila pozitivnih ocen. */ 4. public static void main(String[] args) { 5. // konstanta za število ocen 6. final int stevilo_ocen; 7. // deklacija objekta za vnos podatkov 8. Scanner vhod = new Scanner (System.in); 9. // izpis obvestila 10. System.out.print("Število ocen: "); 11. // vnos števila ocen 12. stevilo_ocen = vhod.nextInt(); 13. // deklaracija polja celoštevilčnih vrednosti 14. int [] polje = new int[stevilo_ocen]; 15. // zanka for za vnos ocen izpita, števec => 0 .. število ocen - 1 16. for (int i=0; i<polje.length; i++) 17. { // obvestilo za vnos ocene (i+1) 18. System.out.printf("%d. ocena: ",(i+1)); 19. polje[i] = vhod.nextInt(); 20. } // for 21.


22. // izpis vrednosti polja in izračun povprečne ocene ter števila pozitivnih ocen 23. int vsota_ocen = 0; //deklariramo in inicializiramo vsoto ocen - 0 24. //deklariramo in inicializiramo število pozitivnih ocen - 0 25. int stevilo_pozitivnih_ocen = 0; 26. // izpis naslovne vrstice 27. System.out.printf("%8s%10s\n","Indeks","polje[i]"); 28. // zanka for za izpis elementov polja, števec => 0 .. dolžina polja - 1 29. for (int i=0; i<polje.length; i++) 30. { // izpis vrednosti indeksa in elementa polja 31. System.out.printf("%8d%10d\n",i,polje[i]); 32. // vrednost elementa prištejemo vsoti 33. vsota_ocen = vsota_ocen + polje[i]; 34. // preverimo če je ocena večja od 5 35. if (polje[i] > 5) 36. stevilo_pozitivnih_ocen++; // za ena povečamo število pozitivnih ocen 37. } 38. // izpišemo število pozitivnih ocen in povprečje ocen 39. System.out.printf("Število pozitivnih ocen je %d.\n",stevilo_pozitivnih_ocen); 40. System.out.printf("Povprečje vseh ocen je %f.\n",((double)vsota_ocen/polje.length)); 41. } // main Primer izvajanja:

Število ocen: 5 1. ocena: 8 2. ocena: 6 3. ocena: 7 4. ocena: 5 5. ocena: 9 Indeks polje[i] 0 8 1 6 2 7 3 5 4 9 Število pozitivnih ocen je 4. Povprečje vseh ocen je 7,000000.

1. /* Število samoglasnikov v besedilu. 2. * Uporabnik vnese besedilo. 3. * Izpis števila samoglasnikov 4. * */ 5. public static void main(String[] args) { 6. // deklaracija objekta niza besedila 7. String besedilo = new String(); 8. // deklaracija objekta za vnos podatkov 9. Scanner vhod = new Scanner(System.in); 10. // izpis obvestila za vnos 11. System.out.print("Besedilo: "); 12. besedilo = vhod.nextLine(); 13. // besedilo pretvorimo v velike črke 14. besedilo = besedilo.toUpperCase(); 15. // deklaracija polja zamoglasnikov 16. String samoglasniki = "AEIOU"; 17. // deklaracija polja za štetje samoglasnikov - AEIOU


18. int [] polje_stevilo_samoglasnikov = new int [5]; 19. // zanka za vse znake besedila, števec od 0 .. dolžina besedila - 1 20. for (int i=0; i<besedilo.length(); i++) 21. { // mesto i-tega znaka besedila v nizu samoglasniki 22. int indeks_samoglasniki = samoglasniki.indexOf(besedilo.substring(i, i+1)); 23. if (indeks_samoglasniki != -1) // je i-ti znak besedila samoglasnik 24. // povečamo število teh samoglasnikov za 1 25. polje_stevilo_samoglasnikov[indeks_samoglasniki] = 26. polje_stevilo_samoglasnikov[indeks_samoglasniki] + 1; 27. } // for 28. // izpis števila samoglasnikov 29. // zanka za vse možne samoglasnike, števec od 0 do dolžina niza samoglasniki - 1 30. for (int i=0; i<samoglasniki.length(); i++) 31. { 32. // izpis samoglasnika in števila pojavitev samoglasnika v besedilu 33. System.out.printf("%s%5d\n",samoglasniki.charAt(i), polje_stevilo_samoglasnikov[i]); 34. } // for 35. } // main Primer izvajanja:

Besedilo: Število samoglasnikov. A 2 E 1 I 2 O 3 U 0

8.1 Izboljšana oblika for stavka

Izboljšana oblika for stavka omogoča iteracijo (ponavljanje) skozi elemente polja brez uporabe števca. Pri tej obliki ni možna napaka, da števec zavzame vrednost zunaj območja elementov polja. Sintaksa: for (parameter : ime_polja) stavek; Parameter je podatkovnega tipa elementa polja npr. int ime_polja; ime_polja predstavlja vrednost elementa polja skozi katerega poteka iteracija (ponavljanje) zanke. Primer 1. /* Izračun vsote celoštevilčnega polja z uporabo izboljšanje oblike stavka for. */ 2. public static void main( String[] args ) 3. { 4. // deklaracija in določitev elementov polja 5. int[] polje = { 8, 3, 4, 8, 5, 6, 7, 7, 2 }; 6. int vsota = 0; // vsota, začetna vrednost <= 0 7. // zanka vsak element polja prištejemo vsoti 8. for ( int element_polja : polje ) 9. vsota += element_polja; // vsota <= vsota + element polja 10. // izpis vsote 11. System.out.printf( "Vsota elementov polja je %d\n", vsota ); 12. } // main


Primer izvajanja: Vsota elementov polja je 50.

8.1.1 Prenos polja v metodo razreda

Za prenos polja metodi uporabimo ime polja brez oglatih oklepajev. Pri klicu metode se v metodo prenese referenca oz. pomnilniški naslov objekta v pomnilniku. Vsako polje ima določeno dolžino s poljem length. Zaradi tega ni potrebno pri prenosu posredovati še velikosti polja. Primeri // deklaracija polja za urne dnevne temperature double[] dnevneTemperature = new double [24]; // glava metode void spremeniTemperature( double[] poljeTemperatur ) // klic metode spremeniTemperature(dnevneTemperature); V razredu PoljaPrenos1 je polje poljeCene deklarirano v metodi main in je lokalno dostopno samo znotraj metode main. Pri klicu metode spremeniOdstotek smo uporabili prvi argument ime polja. Prenos polja pomeni, da se prenese kopija reference oz. pomnilniškega naslova, kjer je lokacija polja v pomnilniku. Zaradi tega se spremembe nad poljem poljeCene v metodi spremeniOdstotek odražajo tudi kot spremembe polja v klicani metodi main. Večina programskih jezikov uporablja prenos parametrov po referenci in po vrednosti. Java podpira samo prenos po vrednosti. Če je argument metode celotno polje ali element polja, ki je posamezen objekt referenčnega podatkovnega tipa, potem klicana metoda prejme kopijo reference oz. pomnilniškega naslova. Če je argument metode posamezen element tabele osnovnega podatkovnega tipa (int, double ...), potem klicana metoda prejme kopijo vrednosti elementa. Zgled v nadaljevanju demonstrira razliko med prenosom polja in prenosom vrednosti elementa polja, ki je osnovnega podatkovnega tipa. 1. // Prenos polja metodi razreda; spreminjanje vrednosti polja. 2. public class PoljaPrenos1 { 3. public static void main(String[] args) { 4. double[] poljeCene = {56,34,78,34,65,78.6,20}; 5. // izpis osnovnih cen 6. System.out.println("Izpis osnovnih cen."); 7. izpis(poljeCene); // klic metode izpis 8. // povečanje cen za 20 odstotokov 9. spremeniOdstotek(poljeCene, 20); // klic metode spremeniOdstotek 10. System.out.println("Povečanje vseh cen za 20 %."); 11. System.out.println("Izpis spremenjenih cen."); 12. izpis(poljeCene); // klic metode izpis 13. spremeniCena(poljeCene[1], 10); // klic metode spremeniCena za drugi element polja 14. System.out.printf("Vrednost drugega elementa polja v metodi main je %f.", 15. poljeCene[1]); 16. } // main 17. 18. // metoda poveča vrednosti elementov polja za določen odstotek 19. public static void spremeniOdstotek(double[] poljeCene, double odstotek) 20. { // zanka za vse elemente polja; števec od 0 do dolžina polja - 1 21. for (int i=0; i<poljeCene.length; i++)


22. // vrednosti polja povečamo za odstotek 23. poljeCene[i] = poljeCene[i] * (1+odstotek/100); 24. } //metoda spremeniOdstotek 25. 26. // metoda poveča vrednost parametra cena za določen odstotek in izpiše povečano vrednost 27. public static void spremeniCena(double cena, double odstotek) 28. { 29. System.out.printf("Vrednost povečane cene drugega eelementa polja (%f)", cena); 30. // vrednost cena povečamo za odstotek 31. cena = cena * (1+odstotek/100); 32. // izpis 33. System.out.printf(" za odstotek (%f) je %f.\n",odstotek,cena); 34. } //metoda spremeniCena 35. 36. // izpis polja 37. public static void izpis(double[] poljeCene) 38. { //izpis naslovne vrstice 39. System.out.printf("%8s%8s\n","Element", "Cena"); 40. // zanka for za vse elemente polja; števec od 0 do število elementov polja - 1 41. for (int i=0; i<poljeCene.length; i++) 42. System.out.printf("%6d%14f\n",(i+1),poljeCene[i]); 43. } //metoda izpis 44. } // razred PoljaPrenos1 Primer izvajanja:

Izpis osnovnih cen. Element Cena 1 56,000000 2 34,000000 3 78,000000 4 34,000000 5 65,000000 6 78,600000 7 20,000000 Povečanje vseh cen za 20 %. Izpis spremenjenih cen. Element Cena 1 67,200000 2 40,800000 3 93,600000 4 40,800000 5 78,000000 6 94,320000 7 24,000000 Vrednost povečane cene drugega eelementa polja (40,800000) za odstotek (10,000000) je 44,880000. Vrednost drugega elementa polja v metodi main je 40,800000.

8.1.2 Uporaba polja ocen izpita

Ustvarimo razred s poljem tabele, ki vsebuje ocene posameznega izpita. Določimo metode: povprečje ocen, število pozitivnih ocen, najslabša ocena, najboljša ocena, izpis ... 1. /* Razred OceneIzpita */


2. public class OceneIzpita { 3. private double[] poljeOcen; // tabela ocen posameznega izpita predmeta 4. private String nazivPredmeta; //naziv predmeta 5. 6. // konstruktor razreda 7. public OceneIzpita(double [] tPoljeOcen, String tNazivPredmeta) 8. { 9. setNazivPredmeta(tNazivPredmeta); // inicializacija naziva predmeta 10. poljeOcen = tPoljeOcen; // ocene predmeta 11. } // konstruktor 12. 13. // metoda vrni naziv predmeta 14. public String getNazivPredmeta() { 15. return nazivPredmeta; 16. } // metoda getNazivPredmeta 17. 18. // metoda set naziv predmeta 19. public void setNazivPredmeta(String nazivPredmeta) { 20. this.nazivPredmeta = nazivPredmeta; 21. } // metoda setNazivPredmeta 22. 23. public double najmanjsaOcena() 24. { // prva ocena je najmanjša 25. double tNajmanjsaOcena = poljeOcen[0]; 26. // zanka od druge do zanje ocene 27. for (int i=1; i< poljeOcen.length; i++) 28. // je i-ta ocena manjša od najmanjše 29. if (poljeOcen[i] < tNajmanjsaOcena) 30. tNajmanjsaOcena = poljeOcen[i]; // t-ta ocena je nova najmanjša 31. return tNajmanjsaOcena; 32. } //metoda najmanjsaOcena 33. 34. 35. public double povprecnaOcena() 36. { // izracun povprečne ocene 37. double vsotaOcen = 0; // vsota ocen, inicializacija na 0 38. // zanka za vse ocene 39. for (int i=0; i< poljeOcen.length; i++) 40. // trenutno oceno prištejemo vsoto 41. vsotaOcen = vsotaOcen + poljeOcen[i]; 42. // vračanje povprečja 43. return (vsotaOcen / poljeOcen.length); 44. } //metoda povprecnaOcena 45. 46. 47. public double najvecjaOcena() 48. { // prva ocena je največja 49. double tNajvecjaOcena = poljeOcen[0]; 50. // zanka od druge do zanje ocene 51. for (int i=1; i< poljeOcen.length; i++) 52. // je i-ta ocena večja od največje 53. if (poljeOcen[i] > tNajvecjaOcena) 54. tNajvecjaOcena = poljeOcen[i]; // t-ta ocena je nova največja 55. return tNajvecjaOcena;


56. } //metoda najvecjaOcena 57. 58. // metoda za izpis naziva predmeta 59. public void izpisNazivaPredmeta() 60. { 61. System.out.printf("Predmet: %s.\n",getNazivPredmeta()); 62. } // metoda izpisNazivaPredmeta 63. 64. // izpis polja ocen v obliki dveh stolpcev 65. public void izpisOcen() 66. { // izpis naslovne vrstice 67. System.out.printf("%-8s%8s\n","Študent","Ocena"); 68. // zanka za vse elemente polja 69. for (int i=0; i < poljeOcen.length; i++ ) 70. System.out.printf("%-8d%8f\n",(i+1), poljeOcen[i]); 71. } // metoda izpisOcen 72. 73. // obdelava ocen 74. public void obdelavaOcen() 75. { 76. izpisNazivaPredmeta(); // izvršitev metode 77. izpisOcen(); // izvršitev metode 78. // izpis povprečne ocene 79. System.out.printf("Povprečna ocena je %f.\n", povprecnaOcena()); 80. // izpis najmanjše ocene 81. System.out.printf("Najmanjša ocena je %f.\n", najmanjsaOcena()); 82. // izpis največje ocene 83. System.out.printf("Največja ocena je %f.\n", najvecjaOcena()); 84. } // metoda obdelavaOcen 85. } 1. /* Razred za testiranje delovanja razreda OceneIzpita */ 2. public class TestOceneIzpita { 3. public static void main(String[] args) { 4. // dekaracija in inicializacija polja ocen 5. double [] poljeOcen = {6,7,7,6,8,6,5,9}; 6. // deklaracija in ustvarjanje objekta OceneIzpita 7. OceneIzpita tOceneIzpita = new OceneIzpita(poljeOcen, "Programiranje"); 8. // klic metode 9. tOceneIzpita.obdelavaOcen(); 10. } // main 11. } //razred TestOceneIzpita Primer izvajanja:

Predmet: Programiranje. Študent Ocena 1 6,000000 2 7,000000 3 7,000000 4 6,000000 5 8,000000 6 6,000000 7 5,000000 8 9,000000 Povprečna ocena je 6,750000.


Najmanjša ocena je 5,000000. Največja ocena je 9,000000.

8.2 Večdimenzionalna polja (tabele)

Večdimenzionalna polja (tabele) si lahko predstavljamo kot polje (tabelo), ki ima za elemente drugo polje (tabelo). Podatki dvodimenzionalne tabele so razporejeni v vrstice in stolpce. V dvodimenzionalni tabeli dostopamo do elementov z dvema indeksoma. Element je določen najprej z indeksom vrstice in nato indeksom stolpca. ime polja stolpec[0] stolpec[1] stolpec[2] stolpec[3] stolpec[4]

poljeInt vrstica[0] -13 3 -5 37 71 vrstica[1] -3 69 19 51 49 vrstica[2] 16 -70 75 -71 76 vrstica[3] -41 54 -35 -50 -10 vrstica[4] 56 -17 -100 -74 4 vrstica[5] -52 -52 -90 -100 48 vrstica[6] 15 -75 90 5 -9 vrstica[7] 61 -60 -42 33 93 vrstica[8] 91 -30 -34 -24 -51 vrstica[9] 19 19 -46 97 31

ime polja stolpec[0] stolpec[1] stolpec[2] stolpec[3] stolpec[4] poljeInt vrstica[0] poljeInt[0][0] poljeInt[0][1] poljeInt[0][2] poljeInt[0][3] poljeInt[0][4]

vrstica[1] poljeInt[1][0] poljeInt[1][1] poljeInt[1][2] poljeInt[1][3] poljeInt[1][4] vrstica[2] poljeInt[2][0] poljeInt[2][1] poljeInt[2][2] poljeInt[2][3] poljeInt[2][4] vrstica[3] poljeInt[3][0] poljeInt[3][1] poljeInt[3][2] poljeInt[3][3] poljeInt[3][4] vrstica[4] poljeInt[4][0] poljeInt[4][1] poljeInt[4][2] poljeInt[4][3] poljeInt[4][4] vrstica[5] poljeInt[5][0] poljeInt[5][1] poljeInt[5][2] poljeInt[5][3] poljeInt[5][4] vrstica[6] poljeInt[6][0] poljeInt[6][1] poljeInt[6][2] poljeInt[6][3] poljeInt[6][4] vrstica[7] poljeInt[7][0] poljeInt[7][1] poljeInt[7][2] poljeInt[7][3] poljeInt[7][4] vrstica[8] poljeInt[8][0] poljeInt[8][1] poljeInt[8][2] poljeInt[8][3] poljeInt[8][4] vrstica[9] poljeInt[9][0] poljeInt[9][1] poljeInt[9][2] poljeInt[9][3] poljeInt[9][4]

Na sliki je dvodimenzionalna tabela, ki vsebuje deset vrstic in pet stolpcev. Vsak element tabele je določen z izrazom ime_tab_spremenljivke[indeks_vrstice][indeks_stolpca]. Vsi elementi prve vrstice imajo indeks vrstice 0, vsi elementi tretjega stolpca imajo indeks stolpca 4. Sintaksa deklaracije: podatkovni_tip[][] ime = new razred_podatkovni_tip[število_elementov][število_elementov]; Primer: int[][] polje_stevil = new int[10][5]; Deklaracija polja z inicializacijo vrednosti Ob deklaraciji polja lahko določimo začetne vrednosti elementov polja. Začetne vrednosti določimo s seznamom vrednosti, ki vsebuje seznam vrednosti vrstice. int[][] poljeInt = { {-24,-57,-35,13,-99}, {30,-46,-61,69,7}, {85,98,99,55,-97},


{-14,57,94,-43,72}, {21,59,74,76,-17}, {77,-42,10,-40,3}, {-42,-79,99,52,43}, {98,75,-38,50,2}, {85,30,-13,-11,84}, {-94,-98,-67,-60,27} }; Začetne vrednosti so združene v zavitih oklepajih po posameznih vrsticah. Vrednosti {-24,-57,-35,13,-99} predstavljajo elemente prve vrstice z indeksom vrstice 0, npr. poljeInt[0][0] = -24, poljeInt[0][1] = -57, poljeInt[0][2] = -35, poljeInt[0][3] = 13 in poljeInt[0][4] = -99. Dvodimenzionalna polja z različnim številom elementov v vrsticah Deklaracija z inicializacijo dveh vrstic z različnim številom elementov double[][] poljeVrstice = { {5, 12.5, 8}, {78, 6, 2.1, 5, 9} }; Prva vrstica polja poljeVrstice vsebuje tri elemente, druga pa pet elementov. Primeri: 1. /* Primer izpisa dvodimenzionalne tabele celih števil. 2. * Primer inicializacije in izpisa dvodimenzionalne tabele znakov angleške abecede. */ 3. 4. public class PoljaDvodim1 { 5. 6. public static void main(String[] args) { 7. // deklaracija in inicializacija dvodimenzionalnega polja 10 x 5 8. int[][] poljeInt = { {-24,-57,-35,13,-99}, {30,-46,-61,69,7}, {85,98,99,55,-97}, 9. {-14,57,94,-43,72}, {21,59,74,76,-17}, {77,-42,10,-40,3}, 10. {-42,-79,99,52,43}, {98,75,-38,50,2}, {85,30,-13,-11,84}, 11. {-94,-98,-67,-60,27} }; 12. 13. char [][] poljeChar = new char [5] []; // ustvarimo pet vrstic 14. poljeChar[0] = new char [3]; // prva vrstica ima tri stolpce 15. poljeChar[1] = new char [2]; // druga vrstica ima dva stolpca 16. poljeChar[2] = new char [3]; // tretja vrstica ima tri stolpce 17. poljeChar[3] = new char [5]; // četrta vrstica ima pet stolpcev 18. poljeChar[4] = new char [5]; // peta vrstica ima pet stolpcev 19. // klic metode za izpis 20. izpis(poljeInt); 21. // klic metode za določitev elementov tabele znakov angleške abecede 22. ustvariZnake(poljeChar); 23. // izpis prazne vrstice 24. System.out.println(); 25. // klic metode za izpis 26. izpis(poljeChar); 27. } // main 28. 29. // metoda za izpis dvodimenzionalnega polja celih števil 30. public static void izpis(int[][] poljeStevila) 31. { 32. System.out.println("Dvodimenzionalna tabela celih števil"); 33. // zanka vrstice, števec od 0 do število vrstic - 1 34. for (int vrstica = 0; vrstica<poljeStevila.length; vrstica++) 35. { 36. // zanka stolpci, števec od 0 do število stolpcev trenutne vrstice - 1 37. for (int stolpec=0; stolpec<poljeStevila[vrstica].length; stolpec++ ) 38. // izpis elementa polja 39. System.out.printf("%8d", poljeStevila[vrstica][stolpec]); 40. // prehod v novo vrstico 41. System.out.println();


42. } //zanka vrstice 43. } // izpis 44. 45. // metoda za inicializacijo znakov angleške abecede: A .. Z 46. public static void ustvariZnake(char[][] poljeZnaki) 47. { // zanka vrstice, števec od 0 do število vrstic - 1 48. for (int vrstica = 0; vrstica<poljeZnaki.length; vrstica++) 49. { // zanka stolpci, števec od 0 do število stolpcev trenutne vrstice - 1 50. for (int stolpec=0; stolpec<poljeZnaki[vrstica].length; stolpec++ ) 51. // določitev naključnega znaka 52. poljeZnaki[vrstica][stolpec] = (char) (65 + (int) (Math.random()* (90-65+1))); 53. } //zanka vrstice 54. } // ustvariZnake 55. 56. // metoda za izpis dvodimenzionalnega polja znakov 57. public static void izpis(char[][] poljeZnaki) 58. { 59. System.out.println("Dvodimenzionalna tabela znakov angleške abecede"); 60. // zanka vrstice, števec od 0 do število vrstic - 1 61. for (int vrstica = 0; vrstica<poljeZnaki.length; vrstica++) 62. { // zanka stolpci, števec od 0 do število stolpcev trenutne vrstice - 1 63. for (int stolpec=0; stolpec<poljeZnaki[vrstica].length; stolpec++ ) 64. // izpis elementa polja 65. System.out.printf("%8c", poljeZnaki[vrstica][stolpec]); 66. // prehod v novo vrstico 67. System.out.println(); 68. } //zanka vrstice 69. } // izpis 70. } Primer izvajanja:

Dvodimenzionalna tabela celih števil -24 -57 -35 13 -99 30 -46 -61 69 7 85 98 99 55 -97 -14 57 94 -43 72 21 59 74 76 -17 77 -42 10 -40 3 -42 -79 99 52 43 98 75 -38 50 2 85 30 -13 -11 84 -94 -98 -67 -60 27 Dvodimenzionalna tabela znakov angleške abecede Y N L J Q F J T J R F E P W M I Y C


8.3 Urejanje podatkov

Pogosto se v praksi srečamo z nalogo, da moramo podatke urediti po predpisanem vrstnem redu. Podatke lahko uredimo na več možnih načinov.

8.3.1 Urejanje po metodi izbora najmanjšega elementa

poiščemo najmanjše število v neurejeni tabeli, postavimo ga na prvo mesto neurejenega dela tabele, hkrati pa število, ki je bilo do tedaj na prvem mestu

neurejenega dela tabele postavimo na mesto, na katerem smo našli najmanjše število v neurejeni tabeli, neurejeni del tabele se s tem zmanjša za eno število, to ponavljamo dokler v neurejenem delu tabele ne ostane samo eno število, ki je hkrati največje v urejeni tabeli. Pomembno je, da si shranimo indeks oz. mesto, na katerem najdemo najmanjše število v neurejenem delu tabele in začetni indeks oz. mesto neurejenega dela tabele. Zgled: Neurejene tabela ima 8 elementov {45,80,32,12,40,60,70,72}.

Indeks

0 1 2 3 4 5 6 7

45 80 32 12 40 60 70 72 Indeks min. ele.: 3. 12 80 32 45 40 60 70 72 Indeks min. ele.: 2. 12 32 80 45 40 60 70 72 Indeks min. ele.: 4. 12 32 40 45 80 60 70 72 Indeks min. ele.: 3. 12 32 40 45 80 60 70 72 Indeks min. ele.: 5. 12 32 40 45 60 80 70 72 Indeks min. ele.: 6. 12 32 40 45 60 70 80 72 Indeks min. ele.: 7. 12 32 40 45 60 70 72 80

urejeni del tabele neurejeni del tabele Primer: 1. // urejanje po metodi izbora najmanjšega elementa 2. public static void urediMinimalno(double[] tabelaStevil) 3. { 4. // ponavljanje => n-1 krat z vrednostmi indeksov od 0 do dolžina tabele-2 5. for (int i=0; i<=tabelaStevil.length-2;i++) 6. { 7. int indeksMinimalnega = i; // prvi indeks neurejenega dela tabele določimo za minimalnega 8. /* ponavljanje - vrednosti indeksov neurejenega dela tabele razen prvega elementa neurejenega dela 9. poiščemo indeks najmanjšega elementa v enurejenem delu tabele */ 10. for (int j=i+1; j<=tabelaStevil.length-1;j++) 11. if (tabelaStevil[j] < tabelaStevil[indeksMinimalnega]) 12. indeksMinimalnega = j; 13. /* če je indeks minimalnega elementa tabele različen od indeksa prvega elementa v neurejenem delu tabele */ 14. if (indeksMinimalnega !=i) 15. { // zamenjava elementov v tabeli 16. double pomoznoStevilo = tabelaStevil[indeksMinimalnega]; 17. tabelaStevil[indeksMinimalnega] = tabelaStevil[i]; 18. tabelaStevil[i] = pomoznoStevilo;


19. } 20. } // zanka for 21. } // metoda urediMinimalno Število primerjav, ki jih opravimo je: prvo pregledovanje: n-1, drugo = n-2,...in pri zadnjem 1. Skupaj je primerjav: n * (n-1) / 2.

8.3.2 Urejanje po metodi mehurčkov (bubble sort)

začnemo na začetku tabele, primerjamo i-ti in i+1-vi element tabele; če nista v predpisanem zaporedju, ju

zamenjamo, v enem prehodu skozi tabelo pomaknemo največje število na konec tabele, manjša števila pa pomikamo

proti začetku tabele, zgornja koraka ponavljamo dokler ni tabela urejena.

Zgled: Indeks 0 1 2 3 4 5 6 7

45 80 32 12 40 60 70 72 Prehod 1:

45 32 80 12 40 60 70 72 45 32 12 80 40 60 70 72 45 32 12 40 80 60 70 72 45 32 12 40 60 80 70 72 45 32 12 40 60 70 80 72 45 32 12 40 60 70 72 80 Prehod 2:

32 45 12 40 60 70 72 80 32 12 45 40 60 70 72 80 32 12 40 45 60 70 72 80 Prehod 3:

12 32 40 45 60 70 72 80 Prehod 4:

12 32 40 45 60 70 72 80 Primer: 1. // urejanje po metodi mehurčkov 2. public static void urediMehurcki(double[] tabelaStevil) 3. { 4. // zastavica - vsaj enea zamenjava v posameznem prehodu 5. boolean urejena = false; 6. // dokler tabela ni urejena 7. while (!urejena) 8. {


9. // zastavica - trenutni prehod je brez zamenjave 10. urejena= true; 11. // zanka za en prehod, vrednostmi indeksov od 0 do dolžina tabele-2 12. for (int j=0; j<=tabelaStevil.length-2;j++) 13. // primerjava sosednjih elementov tabele 14. if (tabelaStevil[j] > tabelaStevil[j+1]) 15. { 16. // zamenjava vrednosti sosednjih elementov 17. double pomoznoStevilo = tabelaStevil[j]; 18. tabelaStevil[j] = tabelaStevil[j+1]; 19. tabelaStevil[j+1] = pomoznoStevilo; 20. // še ni urejena, saj smo opravili vsaj eno zamenjavo v tekočem prehodu 21. urejena = false; 22. } // if 23. } // while 24. } // metoda urediMehurcki Program lahko izboljšamo, če upoštevamo, da je smiselno pregledovati tabelo v naslednjem prehodu le še do mesta, kjer smo v prejšnem prehodu napravili zadnjo zamenjavo. Od mesta zadnje zamenjave naprej so podatki že urejeni.

8.3.3 Binarno iskanje

Problem iskanja določenega elementa v urejenem zaporedju elementov. Pogoj za binarno iskanje je, da so elementi tabele urejeni po velikosti. Urejeno tabelo razdelimo enakomerno na dve polovici. Iskani podatek je lahko v prvi ali v drugi polovici tabele. Ustrezno polovico tabele izberemo s pomočjo primerjave iskanega podatka s sredinskim elementom tabele. Z eno primerjavo izločimo polovico tabele. Iskanje nadaljujemo na isti način v izbrani polovici. Postopek ponavljamo dokler ne najdemo števila, ki ga iščemo ali dokler ne ugotovimo, da iskanega števila ni v tabeli. Indeks 0 1 2 3 4 5 6 7

12 32 40 45 60 70 72 80 Ugotovimo, če je število 32 element tabele? spodaj= 0 zgoraj= 7 sredina=: 3 Iskano število 32 je manjše ali enako kot 45. spodaj= 0 zgoraj= 3 sredina=: 1 Iskano število 32 je manjše ali enako kot 32. spodaj= 0 zgoraj= 1 sredina=: 0 Iskano število 32 je večje kot 12. spodaj= 1 zgoraj= 1 sredina=: 1 Število 32 je v tabeli na indeksu 1. Primer 1. // binarno iskanje števila v urejenem polju 2. public static int iskanjeBinarno 3. (double[] tabelaStevil, // polje števil 4. double iskanoStevilo ) // število, ki ga iščemo v tabeli


5. { 6. // spodaj - spodnji indeks tabele, zgoraj - zgornji indeks tabele 7. // v katerem iščemo iskano število 8. int spodaj, zgoraj, sredina; 9. spodaj = 0; 10. zgoraj = tabelaStevil.length -1; 11. while (spodaj < zgoraj) 12. { 13. sredina = (spodaj + zgoraj) / 2; 14. if (iskanoStevilo > tabelaStevil[sredina]) 15. spodaj = sredina + 1; 16. else 17. zgoraj=sredina; 18. } 19. if (iskanoStevilo == tabelaStevil[spodaj]) 20. return spodaj; 21. else 22. return -1; 23. }

8.3.4 Urejanje z vstavljanjem

Navadno vstavljanje Vse elemente od drugega mesta do konca tabele vstavimo na ustrezno mesto v urejeni del tabele. Vedno primerjamo vrednost elementa, ki ga vstavljamo z vsemi predhodnimi elementi, dokler ne naletimo na prvega manjšega v urejeni tabeli. Pri tem vse večje elemente pomikamo za eno mesto v desno, da pridobimo prostor za vstavljanje na ustrezno mesto v urejeni del tabele. Z ustreznim vstavljanjem enega elementa se urejeni del tabele poveča za ena. Običajno si pomagamo s stražarjem (v tabelo pred prvi element vstavimo element, ki ga vstavljamo), da lažje zaključimo vstavljanje. 1. // urejanje z vstavljanjem 2. public static void urediZVstavljanjem (double[] tabelaStevil) 3. { 4. // od drugega do zadnjega elementa 5. for (int i = 1; i<=tabelaStevil.length-1;i++) 6. { 7. // shranimo vrednost itega elementa 8. double itiElement=tabelaStevil[i]; 9. int j; 10. boolean premik = false; 11. for (j=i-1;j>=0 && tabelaStevil[j]>itiElement;j--) 12. { 13. tabelaStevil[j+1]=tabelaStevil[j]; // premik elementov v desno 14. premik=true; 15. } 16. // če je bil premik v desno 17. if (premik) 18. // vstavimo na ustrezno mesto itega 19. tabelaStevil[j+1]=itiElement; 20. } // for 21. } // urediZVstavljanjem


Binarno vstavljanje Vse elemente od drugega mesta do konca tabele vstavimo na ustrezno mesto v urejeni del tabele. Elementi, ki se nahajajo v tabeli levo od elementa, ki ga vstavljamo, so urejeni. To nam omogoča uporabo binarnega iskanja mesta, na katerega bomo ta element vstavili. Ko ugotovimo mesto, premaknemo vse elemente urejenega dela tabele od mesta vstavljanja elementa do konca urejenega dela tabele za eno mesto v desno. Primer 1. // urejanje z binarnim vstavljanjem 2. public static void urediZBinarnimVstavljanjem 3. (double tabelaStevil[]) 4. { 5. // od drugega do n-tega elementa 6. for (int i = 1; i<=tabelaStevil.length-1;i++) 7. { 8. // shranimo vrednost itega elementa 9. double itiElement=tabelaStevil[i]; 10. // leva in desna meja področja iskanja (v urejenem delu) 11. int levi1=0,desni1=i-1; 12. while (levi1 <= desni1) 13. { 14. // indeks sredinskiinskega 15. int sredinski= (levi1 + desni1) / 2; 16. // primerjamo itiElement z vrednostjo sredinskiinskega 17. if (itiElement < tabelaStevil[sredinski]) 18. // nov desni indeks področja iskanja 19. desni1=sredinski - 1; 20. else 21. // nov levi indeks področja iskanja 22. levi1 = sredinski +1 ; 23. } //while 24. // prepis v desno 25. for (int j=i-1; j >= levi1; j--) 26. tabelaStevil[j+1] = tabelaStevil [j]; 27. // postavimo itiElement na ustrezno prosto mesto 28. tabelaStevil[levi1] = itiElement; 29. } // for 30. } // urediZBinarnimVstavljanjem

9 RAZRED

9.1 Uvod v razrede, objekte in metode

Java je objektno (predmetno) usmerjen programski jezik. Programska koda je sestavljena iz dveh ali več razredov. Razred z metodami (angl. methods) in polji (lastnostmi) ima določene aktivnosti razreda. Razredi predstavljajo komponente za razvoj programov. Metodam razreda pravimo tudi funkcije. Metode in razredne spremenljivke (polja) določajo razred. Ustvarimo lahko več objektov (primerkov) istega razreda. Ustvarimo definicijo razreda Izpiti, ki bo osnova za podatke o izpitih. V razredu Izpiti najprej določimo metodi za izpis obvestila besedilne konstante in vrednosti vhodnega argumenta.


1. /* Izpiti.java | razred Izpiti z dvema metodama za izpis obvestila 2. public class Izpiti 3. { 4. // metoda razreda, izpis pozdravnega obvestila 5. public void izpisObvestila() 6. { 7. System.out.println("Dobrodošli v izpitni sistem.\n"); 8. } //konec metode 9. // metoda razreda, izpis obvestila vrednosti vhodnega argumenta 10. public void izpisObvestila (String besedilo) 11. { 12. System.out.println(besedilo); 13. } // konec metode 14. } // konec razreda Najavo razreda začnemo z rezerviranko public. V začetnih programih vsak razred določimo public. Vsaka najava razreda vsebuje rezerviranko class, ki ji sledi ime razreda in med zavitima oklepajema določene metode in spremenljivke razreda (polja). Razred Izpiti vsebuje metodi izpisObvestila() in izpisObvestila (String besedilo). Razred ne vsebuje metode main, ki predstavlja mesto začetka izvajanja programa. Začetek izvajanja bomo v tem primeru določili v drugem razredu, ki ga bomo uporabili za testiranje razreda Izpiti. V metodah smo uporabili rezerviranki public in void. Rezerviranka public določa, da lahko metodo uporabljamo oz. izvedemo klic metode tudi v drugih razredih. Rezerviranka void določa, da metoda ne vrača nobene vrednosti. Podatkovnemu tipu rezultata metode sledi ime metode (izpisObvestila). Ime metode zapišemo z malo začetnico. Če je ime sestavljeno iz več besed, potem vsako novo besedo zapišemo z veliko začetnico. Za imenom v okroglih oklepajih določimo parametre metode. V drugi metodi smo uporabili vhodni parameter besedilo podatkovnega tipa razreda String. Obe metodi vsebujeta le stavek za izpis System.out.println. V prvi metodi izpišemo vrednost besedilne konstante, v drugi pa vrednost vhodnega parametra metode. Za preverjanje delovanja moramo zapisati še testni razred, ki vsebuje tudi metodo main.

/* TestIzpiti.java */ 1. //najava uporabe razreda Scanner 2. import java.util.Scanner; 3. 4. //razred IzpitiTest z metodo za začetek izvajanja programa 5. public class TestIzpiti 6. { 7. public static void main(String[] args) 8. { // metoda main 9. 10. // ustvarimo primerek objekta oz. predmet razreda Izpiti 11. Izpiti tIzpit = new Izpiti(); 12. // ustvarimo primerek objekta razreda Scanner za vnos 13. Scanner besedilo = new Scanner(System.in); 14. // izpis obvestila za vnos naziva izpita 15. System.out.println("Vnesite obvestilo: "); 16. // vnos besedila 17. String tObvestilo = besedilo.nextLine(); 18. // izpis vnesenega besedila 19. System.out.print("Izpis obvestila: "); 20. // izpis z uporabo metode izpisObvestila razreda Izpiti 21. tIzpit.izpisObvestila(tObvestilo); 22. } //konec metode main


23. } //konec razreda IzpitiTest V 2. vrstici najavimo uporabo razreda Scanner. V razredu TestIzpiti ustvarimo javno statično metodo main, ki ima vhodni parameter, ki predstavlja polje predmetov String in se imenuje args. V polju args so shranjeni vsi vhodni parametri ukazne funkcije, ki jih lahko posredujemo ob zagonu programa. S stavkom Izpiti tIzpit = new Izpiti() v 11. vrstici ustvarimo nov objekt tIzpit razreda Izpiti. Nato ustvarimo nov objekt besedilo razreda Scanner, v katerega shranimo uporabnikov vnos besedila v zaslonskem oknu. Z metodo besedilo.nextLine() v spremenljivko tObvestilo zapišemo vrednost vpisanega besedilo uporabnika. V vrstici 19 izpišemo na zaslon besedilo "Izpis obvestila: ". V 21. vrstici s stavkom tIzpit.izpisObvestila(tObvestilo) izvedemo metodo izpisObvestila(tObvestilo) razreda Izpiti. tObvestilo predstavlja argument metode, ki se prenese v vhodni parameter besedilo metode izpisObvestila. Metoda izpiše na zaslon vrednost vhodnega parametra. Prevajanje programa z več razredi v ukaznem oknu V ukaznem oknu se premaknemo v mapo, ki vsebuje izvorno kodo programa in vpišemo ukaz: javac Izpiti.java TestIzpiti.java Ukaz prevede oba navedena dokumenta programske kode. Če imamo v mapi samo dokumente te aplikacije, potem lahko uporabimo krajši ukaz: javac *.java Znak * predstavlja vse dokumente, ki imajo v imenu dokumenta priponko "java". Zakaj ni potrebno najaviti deklaracije uporabe razreda String, System in v našem primeru razreda Izpiti? Razreda String in System sta v paketu java.lang. Paket java.lang ima privzeto samodejno najavo, zato razredov tega paketa ni potrebno najavljati z import stavkom. Razredi, ki so v isti mapi se obravnavajo kot da so v istem paketu (angl. default package) in jih prav tako ne najavljamo s stavkom import. Primer izvajanja:

Vnesite obvestilo: Test delovanja metode razreda. Izpis obvestila: Test delovanja metode razreda.

Najava uporabe (deklaracija) razreda Scanner v vrstici 2 ni potrebna, če na vseh mestih v programu uporabljamo sklic celotnega imena paketa in imena razreda. V našem primeru moramo potem vrstico 13. zapisati v obliki: java.util.Scanner besedilo = new java.util.Scanner(System.in); Celotno ime paketa razreda Scanner je "java.util". UML razredni diagram razreda Izpiti

Izpiti

+izpisObvestila(String besedilo) Iz UML diagrama je razvidno, da ima razred Izpiti javno metodo izpisObvestila (znak "+" pred metodo določa, da je metoda javna). Spremenljivke, set in get metode Spremenljivke deklarirane znotraj metode so lokalne in jih lahko uporabljajo samo v metodi v kateri so deklarirane. Objekt (predmet) običajno ima lastnosti oz. atribute. Lastnosti razreda obstajajo pred, med in po izvršitvi metode razreda. Razredi imajo eno ali več metod za spreminjanje in dostop do vrednosti polj oz. razrednih spremenljivk. Razredne spremenljivke so deklariranje znotraj razreda pred razrednimi metodami (zunaj področja metod).


Vsak predmet oz. objekt razreda uporablja oz. vzdržuje svoje kopije razrednih spremenljivk, ki jih imenujemo tudi izvodne spremenljivke. Razred Izpiti razširimo z razredno spremenljivko. Za spreminjanje in dostop do vrednosti razredne spremenljivke uporabimo metode. 1. // razred Izpiti z razredno spremenljivko izpit 2. public class Izpiti { 3. // razredna spremenljivka oz. polje razreda 4. private String izpit; 5. 6. // metoda - konstruktor za določitev začetne vrednosti 7. public Izpiti(String tIzpit) 8. { 9. izpit = tIzpit; 10. } // konec metode Izpiti 11. 12. // metoda vrne vrednost razredne spremenljivke 13. public String getIzpit() 14. { 15. // vračanje vrednosti 16. return izpit; 17. } // konec metode 18. 19. // metoda določi vrednost razredne spremenljivke 20. public void setIzpit(String tIzpit) 21. { 22. // določitev vrednosti 23. izpit = tIzpit; // v razredno spremenljivko zapišemo vrednost vhodnega parametra 24. } // konec metode setIzpit 25. 26. public void izpis() 27. { 28. // izpis 29. System.out.print(getIzpit()); 30. } // konec metode izpis 31. } // konec razreda Izpiti V 4. vrstici je deklarirana razredna spremenljivka izpit kot razredna spremenljivka razreda String. private String izpit; Rezerviranka private določa, da je razredna spremenljivka dosegljiva oz. vidna samo znotraj razreda v katerem je deklarirana (v našem primeru znotraj razreda Izpiti). Do privatnih razrednih spremenljivk dostopamo z metodami razreda. Če deklariramo razredno spremenljivko z rezerviranko public, potem je razredna spremenljivka dostopna oz. dosegljiva tudi v ostalih razredih. Ta način redko uporabimo, ker so s tem programi nepregledni in je večja verjetnost napak. Pomni! Vsako razredno spremenljivko oz. polje in metodo deklariramo s pridevnikom dostopa. Konstruktor


Metodo razreda z enakim imenom kot je ime razreda imenujemo konstruktor. Konstruktor je metoda, ki določi privzete (začetne vrednosti) vrednosti razrednih spremenljivk in ne vrne nobene vrednosti (ne vsebuje stavka return). Če razred nima določenega konstruktorja, se uporabi privzeti Java konstruktor (brez argumentov), ki ne izvede aktivnosti oz. ne določi privzete vrednosti razrednih spremenljivk. Razred lahko vsebuje več konstruktorjev, ki se med seboj razlikujejo po številu vhodnih argumentov. Konstruktor razreda Izpiti ima vhodni parameter tIzpit. Ob ustvarjanju novega predmeta razreda Izpiti uporabimo parameter za določitev začetne vrednost razredne spremenljivke oz. polja razreda. Metoda setIzpit (vrstice 20-24) določi vrednost razredne spremenljivke in ne vrne nobene vrednosti (rezerviranka void). Metoda ima vhodni argument, ki sprejme vrednost, ki se shrani kot nova vrednost razredne spremenljivke izpit. Metoda getIzpit vrne vrednost razredne spremenljivke izpit. Ta metoda omogoča dostop do razredne spremenljivke izpit zunaj razreda Izpiti. Metoda nima argumentov in za izvajanje ne potrebuje dodatnih informacij. Metoda vrne vrednost tipa razreda String. Metodam, ki vračajo vrednosti, moramo določiti podatkovni tip rezultata (podatkovni tip je različen od void). Te metode po uspešni izvršitvi aktivnosti vrnejo rezultat metodi iz katere je bila metoda klicana. Return stavek v 16. vrstici vrne vrednost izvodne razredne spremenljivke izpit (vrednost se vrne v stavek v katerem je bil uporabljen klic metode getIzpit). Metoda izpis ne vrne vrednosti in nima vhodnih parametrov. Metoda izpiše vrednost razredne spremenljivke. Testni razred za preverjanje delovanja razreda Izpiti. 1. // najava uporabe (deklaracija) razreda Scanner 2. import java.util.Scanner; 3. 4. //razred TestIzpiti 5. public class TestIzpiti 6. { 7. // metoda main 8. public static void main(String[] args) 9. { // izpis obvestila za vnos naziva izpita 10. System.out.print("Vpišite naziv izpita: "); 11. // ustvarjanje primerka objekta Scanner za vnos v ukaznem oknu 12. Scanner tVnos = new Scanner(System.in); 13. // branje vnosa v predmet razreda String 14. String strIzpit = tVnos.nextLine(); 15. // ustvarjanje predmeta razreda Izpiti 16. Izpiti tIzpit = new Izpiti(strIzpit); 17. // izvršitev metode izpis() razreda Izpiti 18. tIzpit.izpis(); 19. } // konec metode main 20. } // konec razreda TestIzpiti Primer izvajanja:

Vpišite naziv izpita: Programiranje Programiranje

Razred TestIzpiti ustvari predmet razreda Izpiti in demonstrira uporabo metode izpis(). V prvem delu metode main izvedemo branje oz. vnos naziva izpita v lokalno spremenljivko strIzpit. V vrstici 16 ustvarimo nov predmet razreda Izpiti in ga shranimo v lokalno spremenljivko tIzpit podatkovnega tipa razreda Izpiti. V vrstici 18 izvršimo metodo izpis() razreda Izpiti. Metoda na zaslon izpiše vrednost razredne spremenljivke oz. polja razreda Izpiti.


Set in get metode Privatna polja razreda upravljamo (uporabljamo) preko razrednih metod. Razredi vsebujejo javne metode za spreminjanje in branje vrednosti polj. V razredu Izpiti je get metoda getIzpit(); set metoda pa setIzpit(String tIzpit). UML razredni diagram razreda Izpiti

Izpiti

-izpit: String

<constructor> Izpiti(String tIzpit) +getIzpit() : String +setIzpit(String tIzpit) +izpis()

Oglejmo si še primer preprostega programa za vodenje stanja na dveh transakcijskih računih. 1. // razred transakcijski račun - TRR 2. public class TRR 3. { 4. private double stanje; // stanje na računu 5. private String stevilkaTR; // številka transakcijskega računa 6. 7. public TRR(String tTR, double tStanje) // konstruktor 8. { 9. stanje = tStanje; 10. stevilkaTR = tTR; 11. } // konec konstruktorja 12. 13. public void setStevilkaTR(String tTR ) // metoda za spremembo številke TR 14. { 15. stevilkaTR = tTR; 16. } // konec metode za spremembo številke TR 17. 18. public void setStanje(double tStanje) // metoda za določitev stanja na TR 19. { 20. stanje = tStanje; 21. } // konec metode za določitev stanja na TR 22. 23. public double getStanje() // metoda vrne stanja TR 24. { 25. return stanje; 26. } // konec metode vrne stanja TR 27. 28. public String getStevilkaTR() // metoda vrne številko TR 29. { 30. return stevilkaTR; 31. } // konec metode vrne številko TR 32. 33. public void transakcija(double tSprememba) // metoda spremeni stanje TR 34. { 35. stanje = stanje + tSprememba;


36. } // konec metode spremeni stanje TR 37. 38. } //konec razreda TRR 1. // testni razred 2. import java.util.Scanner; 3. public class TestTRR { 4. 5. public static void main(String[] args) 6. { // metoda main 7. // ustvarimo primerek objekta rezreda Scanner za vnos podatkov 8. Scanner vnos = new Scanner(System.in); 9. // izpis obvestila za vnos 10. System.out.println("Podatki o 1. računu: "); 11. System.out.print("Številka računa: "); 12. // vnos uporabnika shranimo v razredno spremenljivko tipa Razreda String 13. String tStevilka1 = vnos.nextLine(); 14. // deklaracija oz. najava spremenljivk za dva transakcijska računa - tipa razreda TRR 15. TRR tRacun1; 16. TRR tRacun2; 17. // v predmetno spremenlivko shranimo izvod predmeta TRR 18. tRacun1 = new TRR(tStevilka1,0.0); 19. // izpis obvestila za vnos 20. System.out.println("Podatki o 2. računu: "); 21. System.out.print("Številka računa: "); 22. // vnos uporabnika shranimo v razredno spremenljivko tipa Razreda 23. String tStevilka2 = vnos.nextLine(); 24. // v predmetno spremenlivko shranimo izvod predmeta TRR 25. tRacun2 = new TRR(tStevilka2,0.0); 26. // izpis obvestila za vnos pologa na prvi račun 27. System.out.print("Znesek pologa na račun 1: "); 28. // vnos uporabnika shranimo v spremenljivko tipa Double 29. Double tZnesek = vnos.nextDouble(); 30. // klic metode transakcija s posredovanjem vrednosti pologa 31. tRacun1.transakcija(tZnesek); 32. // izpis številke in stanja prvega TR 33. System.out.println("Stanje na računih"); 34. System.out.println("________________________________________________"); 35. System.out.print(tRacun1.getStevilkaTR()); 36. System.out.print(" "); 37. System.out.printf("=> %f\n",tRacun1.getStanje()); 38. // izpis številke in stanja drugega TR 39. System.out.println("________________________________________________"); 40. System.out.print(tRacun2.getStevilkaTR()); 41. System.out.print(" "); 42. System.out.printf("=> %f",tRacun2.getStanje()); 43. } // konec metode main 44. } // konec TestTRR Izvajanje

Podatki o 1. računu: Številka računa: 1234-1 Podatki o 2. računu: Številka računa: 1234-2


Znesek pologa na račun 1: 630 Stanje na računih _______________________________________ 1234-1 => 630,000000 ________________________________________________ 1234-2 => 0,000000

Povzetek Deklaracija javnega razreda (rezerviranka public) je vedno shranjena v dokumentu, ki ima enako ime kot je ime razreda in ima priponko ".java". Deklaracija oz. najava razreda vsebuje rezerviranko class, ki ji sledi ime razreda. Z rezerviranko public so deklarirane metode, ki jih lahko uporabljamo oz. izvršimo v drugem razredu. Z rezerviranko void so določene metode, ki po izvršitvi aktivnosti ne vrnejo vrednosti. Po dogovoru ime metode začnemo z malo črko in nato vse sestavljene besedo zapišemo z veliko začetnico (npr. spremeniStanjeRacuna). Če so za imenom metode prazni oklepaji, potem metoda ne potrebuje parametrov za izvršitev aktivnosti metode. Telo metode je zapisano znotraj zavitih oklepajev - { }. Izvajanje programa se začne v metodi z imenom main. Nov izvod objekta (predmeta) razreda ustvarimo z rezerviranko new. Klic metode objekta izvršimo tako, da imenu spremenljivke sledi ločilo oz. znak ".", ime metode in znotraj okroglih oklepajev seznam argumentov metode, ki so med seboj ločeni z vejico. Razred v UML notaciji predstavimo s pravokotnikom, ki vsebuje tri dele: na vrhu je ime razreda; v srednjem delu so razredne spremenljivke oz. polja razreda; v spodnjem delu so metode (aktivnosti) razreda. Znak plus (+) pred spremenljivko ali metodo predstavlja javne metode (public); znak minus (-) pa zasebne (private). Spremenljivke deklarirane znotraj metode so lokalne in se lahko uporabljajo samo znotraj metode. Razred običajno vsebuje eno ali več metod za upravljanje razrednih spremenljivk (polj) razreda. Razredne spremenljivke imenujemo tudi polja razreda. Polja razreda so deklarirana zunaj telesa razreda. Vsak izvod objekta razreda vzdržuje svoje kopije polj razreda. Polja razreda predstavljajo izvodne spremenljivke razreda. Spremenljivke in metode deklarirane z rezerviranko private so dostopne samo v metodah razreda v katerem so deklarirane. Razredne spremenljivke (polja razreda) lahko uporabljajo vse razredne metode. Razlika med poljem in lokalno spremenljivko je tudi v tem, da polja vsebujejo privzete oz. začetne vrednosti, lokalne spremenljivke pa ne. Privzeta vrednost polja podatkovnega tipa String je null. Po izvršitvi klica metode, ki vrača vrednost, se vrne vrednost na mesto klica metode. Razredi omogočajo dostop do vrednosti zasebnih polj preko javnih metod.

9.1.1 Razredi (angl. Classes)

Osnovni koncepti objektnega programiranja so razred, objekt, atribut in metoda. Ustvarjanje razredov:

o deklaracija glave razreda, o deklaracija atributov oz. polj, o deklaracija konstruktorjev, o deklaracija metod.

Ustvarjanje objektov


o operator new ustvari objekt med izvajanjem programa, o objekt v pomnilniku predstavljajo vrednosti atributov, o objekti nekega razreda imajo iste atribute z različnimi vrednostmi atributov.

Programske komponente so objekti (angl. objects), ki predstavljajo elemente realnega sveta. Razred (angl. class) sestavljajo vsi objekti iste vrste (tipa razreda). Objekt je primerek (angl. instance) določenega razreda. Npr. razred osebe združuje vse osebe. Posamezna oseba (recimo Janez Novak) je objekt razreda osebe. Vsak objekt vsebuje polja oz. atribute (angl. attributes) in metode (angl. methods) razreda. Atributi opisujejo lastnosti (stanje) objekta. Metode določajo aktivnosti oz. operacije objekta. Sintaksa razreda: [ public ] [ ( abstract | final ) ] class <ime_razreda> { // atributi oz. polja razreda // metode razreda } // konec razreda Z rezerviranko public določimo, da je razred dostopen oz. je na voljo vsem razredom v vseh paketih. Če izpustimo rezerviranko public, potem je razred na voljo samo razredom v istem paketu. V enem dokumentu (*.java) lahko deklariramo samo en public razred. V public razredu je ime dokumenta enako imenu razreda (<ime_dokumenta> = <ime_razreda>). Npr. // MojClass.java public class MojClass { } Z rezerviranko abstract določimo, da je razred abstrakten. Abstrakten razred vsebuje le glave metod. Vsebina metod je določena v nasledniku (potomcu) razreda. Objekta (predstavnika) abstraktnega razreda ne moremo ustvariti. Z rezerviranko final določimo, da razreda ni možno razširiti (nima naslednikov oz. potomcev). Program vsebuje enega ali več razredov. Zagonski razred (z metodo main) predstavlja začetno mesto izvajanja programa.


9.2 Atributi oz. polja razreda

Atributi oz. polja razreda opisujejo stanje oz. lastnosti razreda. Sintaksa deklaracije polja: [ ( public | private | protected ) ] [ ( final | volatile ) ] [ static ] [ transient ] <podatkovni_tip> <ime_polja> [ = <izraz> ] ; Primer: public class Cas { // glava razreda // privatni atributi oz. polja private int ure; private int minute; private int sekunde; } Razred Cas vsebuje tri celoštevilčne atribute ure, minute in sekunde. Določila dostopa V deklaraciji polja lahko opcijsko uporabimo določilo dostopa public ali private ali protected. Določila dostopa določajo dostopnost polj v drugih razrednih. Običajno uporabljamo princip skrivanja podatkov, kar pomeni, da so polja dostopna samo znotraj razreda.

Dostopno določilo Dostop

brez določila Vsi razredi v istem paketu.

public Vsi razredi ne glede na paket.

private Samo znotraj razreda.

protected Iz kateregakoli razreda v istem paketu in iz kateregakoli podrazreda ne glede na paket. Z rezerviranko final določimo, da je polje konstanta. Vrednost konstante se po začetni inicializaciji ne spreminja. Po dogovoru zapišemo imena konstant z velikimi črkami. Z rezerviranko volatile določimo, da do polja dostopa več niti (angl. threads). Vsi objekti polja deklariranega z rezerviranko static dostopajo do iste kopije polja (si delijo isto vrednost). Polja objektov (angl. instance field) deklariramo brez rezerviranke static. V tem primeru ima vsak objekt svojo kopijo vrednosti polja. Z rezerviranko transient določimo, da med serializacijo ne bo shranjena vrednost polja objekta. Zgled: 1. // primer razreda za čas 2. public class Cas { // glava razreda 3. // privatni atributi oz. polja 4. private int ure; // 0-23 5. private int minute; // 0-59 6. private int sekunde; // 0-59 7. 8. // metoda za določitev časa 9. public void setCas( int u, int m, int s ) 10. {


11. // preverjanje ustreznosti podatkov 12. if ( (u>=0 && u<24) && (m>=0 && m<60) && (s>=0 && s<60) ) 13. { 14. ure = u; 15. minute = m; 16. sekunde = s; 17. } 18. else 19. throw new IllegalArgumentException("Vrednost časa je zunaj območja." ); 20. } // konec metode setCas 21. 22. // metoda vrne čas v obliki uu:mm:ss (10:22:30) 23. public String vrniCas() 24. { 25. return String.format( "%02d:%02d:%02d", ure, minute, sekunde ); 26. } // konec metode vrniCas 27. } 1. // testni razred 2. public class TestCas { 3. public static void main(String[] args) { 4. Cas ura = new Cas(); // ustvarimo objekt razreda 5. // izpis vrednosti po ustvarjanju objekta 6. System.out.println(ura.vrniCas()); 7. // določimo vrednost z uporabo metode razreda 8. ura.setCas(11, 20, 25); 9. // izpis vrednosti po določitvi vrednosti 10. System.out.println(ura.vrniCas()); 11. } 12. } Primer izvajanja:

00:00:00 11:20:25

9.3 Metode razreda

Metode razreda določajo aktivnosti oz. operacije objekta. Sintaksa deklaracije metode: [ ( public | private | protected ) ] ( [ abstract ] | [ final ] [ static ] [ native ] [ synchronized ] ) <podatkovni_tip_rezultata> <ime_metode> ( [ <seznam_formalnih_parametrov> ] ) { // stavki metode [return <izraz>]; }

Dostopno določilo Dostop

brez določila Vsi razredi v istem paketu.

public Vsi razredi ne glede na paket.

private Samo znotraj razreda.

protected Iz kateregakoli razreda v istem paketu in iz kateregakoli podrazreda ne glede na paket.


Z rezerviranko static deklariramo razredno metodo, ki lahko dostopa samo do razrednih polj. Brez rezerviranke static deklariramo objektno metodo, ki lahko dostopa do vseh polj razreda. Z določilom abstract določimo abstraktno metodo, ki vsebuje le glavo metode brez bloka oz. telesa metode. Če razred vsebuje abstraktne metode, potem mora tudi razred biti deklariran z določilom abstract. Abstraktna metoda ne sme v deklaraciji uporabljati določil final, static, native, synchronized ali private. Z rezerviranko native deklariramo metodo, ki vsebuje le glavo metode. Metoda je zapisana v jeziku C++ (shranjena je v posebni knjižnici). Z rezerviranko synchronized deklariramo metodo, ki se lahko istočasno izvaja le v eni niti (angl. thread). Primer razredne metode: 1. // razred zaposleni 2. class Zaposleni 3. { 4. private static int steviloZaposlenih; // razredno polje 5. // razredna metoda 6. static void setsteviloZaposlenih (int stevZaposlenih) 7. { 8. steviloZaposlenih = stevZaposlenih; 9. } 10. } // razred zaposleni

9.4 Lokalne in globalne spremenljivke

Lokalne spremenljivke so deklarirane v telesu oz. bloku metode in obstajajo samo v bloku v katerem so deklarirane. Globalne spremenljivke razreda so deklarirane v bloku razreda pred metodami razreda. Globalne spremenljivke razreda imenujemo tudi atributi oz. polja razreda. Vsak objekt razreda ima svoje vrednosti polj. Polja razreda obstajajo oz. so dostopna znotraj vseh metod razreda. Primer zgradbe razreda 1. public class DosegSpremenljivk { 2. /* vsak objekt razreda DosegSpremenljivk ima tri globalne atribute oz. polja, ki so dostopni celemu razredu */ 3. private double polje1; // atribut oz. polje 4. private int polje2; // atribut oz. polje 5. private char polje3; // atribut oz. polje 6. 7. public int metoda1() 8. { 9. // lokalni spremenljivki dostopni samo v metodi metoda1 10. int stevilo1 = 2; 11. double stevilo2 = 4.5; 12. /* 13. * obstajajo stevilo1, stevilo2, polje1, polje2, polje3 14. * ... 15. * */ 16. return stevilo1; 17. } 18. 19. public char metoda2() 20. { 21. // lokalna spremenljivka dostopna samo v metodi metoda2 22. char znak = 'a'; 23. /* 24. * obstajajo znak, polje1, polje2, polje3


25. * ... 26. * */ 27. return znak; 28. } 29. } V razredu DosegSpremenljivk so polja razreda: polje1, polje2, polje3. Polja obstajajo (so na voljo) v metodah metoda1 in metoda2. V metodi metoda1 so deklarirane lokalne spremenljivke stevilo1 in stevilo2, ki obstajata znotraj bloka metode metoda1. V metodi metoda1 obstajajo tudi polja razreda polje1, polje2 in polje3. V metodi metoda2 je deklarirana lokalna spremenljivka znak, ki obstajata znotraj bloka metode metoda2. V metodi metoda2 obstajajo tudi polja razreda polje1, polje2 in polje3. Primer razreda z metodo main: 1. public class DosegSpremenljivk2 { 2. // globalni spremenljivki dostopni v celemu razredu 3. private double polje1 = 3.2; 4. private int polje2 = 12; 5. 6. public static void main(String[] args) { 7. // lokalna spremenljivka dostopna samo v metodi main 8. int stevilo1 = 2; 9. /* 10. * obstajajo stevilo2 = 2, polje1 = 3.2, polje2 = 12 11. * */ 12. } 13. 14. public int metoda1() 15. { 16. // lokalna spremenljivka dostopna samo v metodi metoda1 17. int stevilo2 = 4; 18. /* 19. * obstajajo stevilo2 = 4, polje1 = 3.2, polje2 = 12 20. * */ 21. return stevilo2; 22. } 23. } Statične spremenljivke (ang. class variables) tipične so za razrede, ki predstavljajo aplikacije, vendar lahko nastopajo tudi v razredih, ki opisujejo zgradbo

objektov, deklarirane so z rezerviranko static, sprememba vrednosti je dostopna vsem objektom in metodam v razredu, obstaja samo ena kopija spremenljivke, vrednost iste kopije spremenljivke uporabljajo vse metode in vsi objekti, spremenljivka obstaja tudi v primeru, ko ne ustvarimo nobenega objekta.

Spremenljivke oz. polja objekta (angl. instance variables) nastopajo v razredih, ki opisujejo definicijo oz. zgradbo objektov, deklaracija brez dostopnega določila static, vsak objekt ima svojo kopijo spremenljivke (svojo vrednost polja), sprememba vrednosti se odraža samo znotraj objekta.


9.4.1 Večkratno definirane metode

Metode z enakim imenom in različnim številom parametrov imenujemo večkratno definirane metode (angl. overloading). Prevajalnik izbere ustrezno metodo na osnovi števila parametrov in podatkovnih tipih posameznih parametrov. // večkratno definirana metoda izpis // metoda izpis brez parametrov void izpis () { System.out.println ("Višja šola"); } // metoda izpis z enim parametrom void izpis (String besedilo) { System.out.println (besedilo); } Večkratno definirana metoda se ne sme razlikovati samo v podatkovnem tipu rezultata, ki ga vrača metoda.

9.4.2 Konstruktor

Konstruktor (angl. constructor) je posebna metoda, ki se izvrši ob ustvarjanju objekta in določi začetne vrednosti atributov oz. polj objekta (inicializacija). Konstruktor je metoda z enakim imenom, kot je ime razreda. Konstruktor ne vrača vrednosti (ni določen podatkovni tip rezultata). Če razred ne vsebuje konstruktorja, potem prevajalnik ustvari privzeti konstruktor brez parametrov. 1. // razred XY 2. class XY 3. { 4. private int stevilo; // polje stevilo 5. 6. XY (int st) // konstruktor 7. { 8. //this predstavlja naslov objekta, na katerega se nanaša klic metode 9. this.stevilo = st; 10. } // konstruktor 11. 12. } // razred XY 13. 14. // razred TestXY 15. class TestXY 16. { 17. 18. public static void main (String [] args) // metoda main 19. { 20. // deklaracija in ustvarjanje objekta razreda XY z uporabo konstruktorja 21. XY objektXY1 = new XY (25); 22. XY objektXY2 = new XY (22); 23. } // metoda main 24. 25. } // razred TestXY


Primer dveh konstruktorjev: 1. // razred krog 2. public class Krog { 3. // polja 4. private int x, y; // koordinate 5. private int polmer; // polmer 6. 7. Krog () // konstruktor 8. { 9. this (0, 0, 1); 10. } 11. 12. Krog (int x, int y, int polmer) // konstruktor 13. { 14. this.x = x; 15. this.y = y; 16. this.polmer = polmer; 17. } 18. 19. // metode vrni (angl. get) in določi (angl. set) 20. public int vrniPolmer() { return polmer; } 21. 22. public void dolociPolmer(int polmer) { this.polmer = polmer; } 23. 24. public void dolociX(int x) { this.x = x; } 25. 26. int vrniX () { return x; } 27. 28. public void dolociY(int y) { this.y = y; } 29. 30. int vrniY () { return y; } 31. 32. } // razred krog 1. // razred TestKrog 2. public class TestKrog { 3. 4. public static void main(String[] args) { 5. // ustvarjanje objekta brez parametrov 6. Krog krog1 = new Krog(); 7. System.out.printf("Krog 1:\n"); 8. System.out.printf("Središče (%d,%d).\n", krog1.vrniX(), krog1.vrniY()); 9. System.out.printf("Polmer %d.\n", krog1.vrniPolmer()); 10. 11. // ustvaranje objekta z dejanskimi parametri (začetne vrednosti) 12. Krog krog2 = new Krog(50,80,100); 13. System.out.printf("Krog 2:\n"); 14. System.out.printf("Središče (%d,%d).\n", krog2.vrniX(), krog2.vrniY()); 15. System.out.printf("Polmer %d.\n", krog2.vrniPolmer()); 16. } // main 17. } // razred TestKrog


Objekti razreda Krog v metodi main():

Slika 30: Prenos parametrov

Primer razreda datum Ustvarimo razred datum. Polja: dan, mesec, leto. Metode: Datum(int dan, int mesec, int leto), void dolociDatum(int dan, int mesec, int leto), String izpis(), String izpisImeMeseca(), boolean prestopnoLeto(int leto).

1. // razred Datum 2. public class Datum { 3. // polja oz. atributi 4. int dan; 5. int mesec; 6. int leto; 7. 8. // konstante imen mesecov


9. static final String [ ] meseci = {"", "januar", "februar", "marec", "april", "maj", "junij" ,"julij" , 10. "august" ,"september", "oktober", "november" ,"december" 11. } ; 12. 13. // število dni v mesecu 14. static final int [ ] mesecDni = {0,31,29,31,30,31,30,31,31,30,31,30,31} ; 15. 16. // konstruktor Datum 17. public Datum(int dan, int mesec, int leto) { 18. if (mesec>=1 && mesec<=12) 19. if ( (dan>=1 && dan<=mesecDni[mesec]) ) 20. { 21. this.dan = dan; 22. this.mesec = mesec; 23. this.leto = leto; 24. } 25. else 26. throw new IllegalArgumentException("Vrednost datuma je zunaj območja." ); 27. else 28. throw new IllegalArgumentException("Vrednost datuma je zunaj območja." ); 29. // prestopno leto 30. if ((mesec == 2) && (dan==29) && !prestopnoLeto(leto) ) 31. throw new IllegalArgumentException( "Vrednost datuma je zunaj območja." ); 32. } // konstruktor Datum 33. 34. // določi Datum 35. public void dolociDatum(int dan, int mesec, int leto) { 36. if (mesec>=1 && mesec<=12) 37. if ( (dan>=1 && dan<=mesecDni[mesec]) ) 38. { 39. this.dan = dan; 40. this.mesec = mesec; 41. this.leto = leto; 42. } 43. else 44. throw new IllegalArgumentException("Vrednost datuma je zunaj območja." ); 45. else 46. throw new IllegalArgumentException( "Vrednost datuma je zunaj območja." ); 47. // prestopno leto 48. if ((mesec == 2) && (dan==29) && !prestopnoLeto(leto) ) 49. throw new IllegalArgumentException( "Vrednost datuma je zunaj območja." ); 50. } // dolociDatum 51. 52. // izpis v obliki d.m.llll 53. public String izpis() { 54. return dan + "." + mesec + "." + leto; 55. } // izpis 56. 57. // izpis v obliki d.mesec.llll 58. public String izpisImeMeseca() { 59. return dan + ". " + meseci[mesec] + " " + leto; 60. } //izpisImeMeseca 61. 62. // prestopno leto 63. public boolean prestopnoLeto(int leto)


64. { 65. boolean prestopno; 66. if (leto % 4 == 0) 67. prestopno = true; 68. else 69. prestopno = false; 70. if (leto % 100 == 0 && leto % 400 == 00) 71. prestopno = true; 72. else 73. if (leto % 100 == 0) 74. prestopno = false; 75. return prestopno; 76. } // prestopno leto 77. 78. } // razred Datum 1. // test delovanja razreda Datum 2. public class DemoDatum { 3. 4. public static void main(String[] args) { 5. Datum datum1 = new Datum(16,2,2015); 6. System.out.printf("Vrednost datuma je %s. \n", datum1.izpis()); 7. System.out.printf("Vrednost datuma je %s. \n", datum1.izpisImeMeseca()); 8. datum1.dolociDatum(16, 5, 1980); 9. System.out.printf("Vrednost datuma je %s. \n", datum1.izpis()); 10. System.out.printf("Vrednost datuma je %s. \n", datum1.izpisImeMeseca());

11. } // main 12. 13. } // razred DemoDatum

10 OSNOVNE KNJIŽNICE

Knjižnice v razvojnih okoljih programerjem olajšajo izdelavo programov. Java vsebuje veliko razredov, ki so združeni v sorodne pakete. Ti paketi predstavljajo Java API (angl. Application Programming Interface). Skupno število paketov je izjemno veliko in se dopolnjuje z novimi verzijami različic Jave (npr. Java SE 8). Na voljo so paketi za vhodno izhodne operacije, tiskanje, delo z omrežjem, delo z zbirkami podatkov, risanje v grafičnem načinu, grafični vmesnik ...

Paket Opis

java.lang (angl. Java Language) Osnovni razredi jezika. Delo s števili (Number), matematične funkcije (Math), delo z nizi (String, StringBuffer) in drugi sistemski razredi. Paket je samodejno vključen v program.

java.util (angl. Java Utilities) Delo z datumi in časi (Date), generatorji naključnih števil (Random), vhodno izhodne operacije (Scanner), shranjevanje in obdelava večje količine podatkov.

java.io (angl. Java Input/Output) Vhodno izhodne operacije (Files, Streams, Object Serialization).

java.awt (angl. Java Abstract Window Toolkit )

Razredi za delo v grafičnem načinu v prejšnjih verzijah Jave. V novejših verzijah Jave se za grafični vmesnik uporabljajo razredi paketa javax.swing.

java.applet (angl. Java Applet) Razredi za izdelavo apletov, ki se uporabljajo v HTML dokumentih in se


Paket Opis

izvajajo v brskalnikih.

java.net (angl. Java Networking) Razredi za delo in komunikacijo v medmrežju (Internet).

java.sql (angl. Java SQL) Razredi za delo z zbirkami podatkov.

javax.swing (angl. Java Swing GUI Components)

Razredi za delo z grafičnimi vmesniki.

javax.media (angl. Java Media Framework)

Razredi za multimedije.

javax.swing.event (angl. Java Swing Event)

Razredi za upravljanje dogodkov.

javax.xml.ws (angl. JAX-WS) Razredi za spletne storitve (angl. services). Dokumentacija paketov in razredov verzije JSE8 je objavljena na Oraclovem spletišču http://docs.oracle.com/javase/8/docs/api/index.html (29. 1. 2015).

10.1 Razred Math

Razred Math je v paketu java.lang (v naprej deklariranem paketu). Razred Math vsebuje veliko statičnih metod, ki jih lahko uporabimo za izračun standardnih matematičnih kalkulacij.

Metoda Opis Primer

abs( x ) absolutna vrednost abs( 45.8 ) = 45.8 abs( -12.2 ) = 12.2

ceil( x ) zaokroži x na najmanjše celo število, ki ni manjše od x ceil( 9.2 ) = 10.0 ceil( -9.8 ) = -9.0

cos( x ) kosinus kota (x v radianih) cos( 0.0 ) = 1.0

exp( x ) e na potenco števila x exp( 1.0 ) = 2.71828 exp( 2.0 ) = 7.38906

floor( x ) zaokroži število x na največje celo število, ki ni večje kot x floor( 9.2 ) = 9.0 floor( -9.7 ) = -10,0

log( x ) logaritem števila x (osnova e) log( Math.E ) = 1,0 log( Math.E * Math.E ) = 2,0

max( x, y ) večja vrednost od števil x in y max( 1.3, 11.5) = 11.5 max( -2.8, -10. ) = -2,8

min( x, y ) manjša vrednost od števil x in y min( 1.3, 11.5 ) = 2.3 min( -2.8, -10. ) = -10.

pow( x, y ) potenco števila x na y pow( 2.0, 8.0 ) = 256,0 pow( 9.0, 0.5 ) = 3,0

sin( x ) sinus kota (x v radianih) sin( 0,0 ) = 0,0

sqrt( x ) kvadratni koren števila x sqrt( 900,0 ) = 30,0 Razred Math vsebuje dva polja, ki predstavljata matematični konstanti PI in E. Polja sta določena z določili public, final in static. Math.PI (3.141592653589793) Math.E (2.718281828459045)


10.2 Razred Character

Razred Character vsebuje metode za delo z znaki.

Metoda Opis Primer

boolean isUpperCase(char znak) Je velika črka. Character.isUpperCase(znak)

boolean isLowerCase(char znak) Je mala črka. Character.isLowerCase('o')

char toUpperCase(char znak) Pretvori v veliko črko. Character.toUpperCase('h')

char toLowerCase(char znak) Pretvori v malo črko. Character.toLowerCase('Z')

boolean isLetterOrDigit(char znak) Je črka ali številka. Character.isLetterOrDigit('8')

boolean isDigit(char znak) Je števka ('0' .. '9') Character.isDigit('4')

boolean isLetter(char znak) Je črka. Character.isLetter(znak)

boolean isWhiteSpace(char znak) Je neviden presledek (presledek, tabulator, nova vrstica, vnašalka ali pomik naprej).

Character.isWhiteSpace(znak)

String toString(char znak) Pretvori znak v niz oz. besedilo. Character.toString(znak)

1. /* Primer uporabe metod razreda Character */ 2. public class MZnaki { 3. public static void main(String[] args) { 4. char znak1, znak2; // deklaracija spremenljivk znak1, znak2 5. // določitev vrednosti 6. znak1 = 'A'; 7. znak2 = 49; // '1' 8. // izpis 9. if (Character.isDigit(znak1)) // je znak1 števka 10. System.out.printf("Znak %s je števka.\n",znak1); 11. else 12. System.out.printf("Znak %s ni števka.\n",znak1); 13. if (Character.isDigit(znak2)) // je znak2 števka 14. System.out.printf("Znak %s je števka.\n",znak2); 15. else 16. System.out.printf("Znak %s ni števka.\n",znak2); 17. String niz1; // ustvarjanje objekta tipa String 18. // določitev vrednosti niza (znak1 v niz1, znak2 v niz2) 19. niz1 = Character.toString(znak1); 20. // ustvarjanje objekta niza z določitvijo začetnih vrednosti 21. String besedilo1 = "Vrednost niza znaka " + znak1 + " je " + niz1 + ".\n"; 22. // izpis 23. System.out.println(besedilo1); 24. } 25. } Primer izvajanja:

Znak A ni števka. Znak 1 je števka. Vrednost niza znaka A je A.


10.3 Razred String

Najpogostejše metode razreda String Spoznali smo že, da podatkovni tip char omogoča delo s posameznim znakom. Vrednost spremenljivke char zapišemo v enojnih narekovajih. char znak = 'D'; Vrednost znakovne spremenljivke je pozitivna celoštevilčna vrednost, ki predstavlja ta znak v Unicode kodni tabeli. String je zaporedje znakov oz. besedilo oz. niz, ki se obravnava kot podatkovni element. String je objekt oz. predmet razreda String. String vrednost je besedilo med dvojnimi narekovaji.

String vrednost Pomen "Janez Kotnik" ime in priimek "Celjska 5" naslov "3000 Celje" poštna številka in kraj +386 41-555-112 telefonska številka

Besedilno vrednost shranimo v String referenco oz. kazalec. String imepriimek1 = new String ("Janez Kotnik"); //ali String imepriimek2 = "Janez Kotnik"; Prvi deklaracijski stavek inicializira spremenljivko imepriimek1, da njena vrednost vsebuje pomnilniški naslov na katerem je v pomnilniku shranjeno besedilo Janez Kotnik. Spremenljivka imepriimek1 se sklicuje na besedilni objekt v pomnilniku. Razred String vsebuje več konstruktorjev za inicializacijo objektov. 1. /* Primer uporabe različnih konstruktorjev razreda String */ 2. public class String1_1 { 3. 4. public static void main( String[] args ) 5. { // polje oz tabela znakov 6. char[] tab_besedilo = { 'r', 'o', 'j', 's', 't', 'n', 'i', ' ', 'd', 'a', 'n' }; 7. // string objekti 8. String besedilo = new String( "vse najboljše" ); 9. // uporaba String konstruktorjev 10. String besedilo1 = new String(); 11. String besedilo2 = new String( besedilo ); 12. String besedilo3 = new String( tab_besedilo ); 13. String besedilo4 = new String( tab_besedilo, 8, 3 ); 14. // izpis 15. System.out.printf( "besedilo1 = %s\nbesedilo2 = %s\nbesedilo3 = %s\n 16. besedilo4 = %s\n",besedilo1, besedilo2, besedilo3, besedilo4 ); 17. } // main 18. } // razred Primer izvajanja:

besedilo1 = besedilo2 = vse najboljše besedilo3 = rojstni dan besedilo4 = dan

Vse metode razreda String so javne (public). Indeks prvega polja besedilne vrednosti je 0.


Metoda Opis

char charAt(int pos) Vrne znak z določenega položaja v besedilu. String besedilo = new String( "vse najboljše" ); char znak = besedilo.charAt(4); //vrne n

int compareTo(String s) Primerjava dveh nizov. Vrednost: 0 - niza sta enaka, negativno število - klican niz je manjši od argumenta, pozitivno število - klican niz je večji od argumenta.

String besedilo1 = new String( "Andrej" ); String besedilo2 = new String( "Boris" ); int primerjava = besedilo1.compareTo(besedilo2); //-1 =>besedilo1 < besedilo2

boolean equals(String s)

Primerjava enakosti nizov. String besedilo1 = new String( "Andrej" ); boolean enaka = besedilo1.equals("Andrej"); // true

boolean equalsIgnoreCase(String s)

Primerjava enakosti nizov brez razlikovanja velikih in malih znakov. String besedilo1 = new String( "Andrej" ); boolean enaka = besedilo1. equalsIgnoreCase ("andrej"); // true

String [ static method ] format(String oblika, Object... arg)

Vrne oblikovano besedilo glede na oblikovna določila in argumente.Argumenti so enaki kot pri metodi System.out.printf(). besedilo1 = String.format(“Skupni znesek je %9.2f Eurov\n”, 202.45); // besedilo1 = Skupni znesek je 202,45 Eurov

int indexOf(char ch)

Mesto prve pojavitve znaka v nizu. Če najde znak v nizu, vrne mesto pojavitve, sicer vrne -1. String besedilo = new String( "vse najboljše" ); int kje = besedilo.indexOf('e'); // 2

int length( )

Dolžina niza. String besedilo = new String( "vse najboljše" ); int dolzina = besedilo.length(); // 13

String[ ] split(String regex)

Delitev niza glede na izraz ujemanja. Vrne polje nizov. String stavek = "Razdelitev stavka na besede."; String besede[]; besede = stavek.split(" "); for (int i=0; i < besede.length;i++) System.out.println(besede[i]); // " " izraz ujemanja

String substring(int n, int m)

Vrne podniz niza od indeksa n do indeksa m-1. String stavek = "Vrne podniz danega niza."; String podniz = stavek.substring(3, 6);// del

String toLowerCase( )

Pretvori v male črke. String stavek = "Pretvori v male črke."; stavek = stavek.toLowerCase();

String toUpperCase( )

Pretvori v velike črke. String stavek = "Pretvori v velike črke."; stavek = stavek.toUpperCase();

String trim( )

Vrne niz brez presledkov na začetku in koncu niza. String stavek = " Besedilo s presledki na začetku in koncu besedila. "; stavek = stavek.trim(); // odstranitev začetnih in končnih presledkov

String [ static method ] valueOf(<osnovni podatkovni tip> n)

Pretvori osnovni podatkovni tip v String. int n = 123; String s = String.valueOf(n);


10.4 Razred Stringbuffer

V primerjavi z razredom String razred StringBuffer omogoča dinamično spreminjanje dolžine niza. Razred java.lang.StringBuffer podpira delo z zaporedjem znakov oz. nizi. Dolžino in vsebino niza lahko spreminjamo z metodami razreda. Konstruktorji: StringBuffer(), StringBuffer(CharSequence seq), StringBuffer(int capacity), StringBuffer(String str). Ustvarjanje objekta: StringBuffer imepriimek1 = new StringBuffer ("Janez Kotnik"); // ali StringBuffer imepriimek2 = "Janez Kotnik"; 1. /* Primer uporabe razreda StringBuffer */ 2. public class R12 { 3. /* Primer uporabe različnih konstruktorjev razreda StringBuffer */ 4. public static void main( String[] args ) 5. { 6. // deklaracija in ustvarjanje stringbuffer objekta 7. StringBuffer besedilo = new StringBuffer( "vse najboljše" ); 8. // uporaba konstruktorjev 9. StringBuffer besedilo1 = new StringBuffer(); 10. besedilo1.append("Slavljenec "); 11. StringBuffer besedilo2 = new StringBuffer( besedilo ); 12. StringBuffer besedilo3 = new StringBuffer(20); 13. besedilo3.append("za rojstni dan."); 14. // izpis 15. System.out.printf("besedilo1 = %s\nbesedilo2 = %s\nbesedilo3 = %s\n", 16. besedilo1, besedilo2, besedilo3); 17. } // main 18. } // razred Primer izvajanja:

besedilo1 = Slavljenec besedilo2 = vse najboljše besedilo3 = za rojstni dan.

Metoda Opis

StringBuffer append(char[] str)

Na konec niza doda niz str.

StringBuffer append(char[] str, int offset, int len)

Na konec niza doda podniz niza str. Začetek podniza - indeks offset, dolžina podniza - len. StringBuffer besedilo1 = new StringBuffer("dober "); System.out.println("Besedilo pred dodajanjem = " + besedilo1); char[] besedilo2 = new char[] {'l','e','p',' ','d','a','n'}; besedilo1.append(besedilo2, 4, 3); // dodajanje 3 znakov od indeksa 4 naprej System.out.println("Besedilo po dodajanju = " + besedilo1); // izpis Besedilo pred dodajanjem = dober Besedilo po dodajanju = dober dan

StringBuffer append(int i) Na konec niza doda besedilno vrednost celega števila i. StringBuffer besedilo1 = new StringBuffer("Število je: "); besedilo1.append(25); // dodajanje besedila 25

int capacity() Kapaciteta oz. razpoložljivost niza. StringBuffer besedilo = new StringBuffer("Besedilo vsebuje 27 znakov.");


System.out.printf("Dolžina niza je %d.\n", besedilo.length()); System.out.printf("Kapaciteta niza je %d.\n", besedilo.capacity()); // izpis Dolžina niza je 27. Kapaciteta niza je 43.

StringBuffer delete(int start, int end)

Brisanje podniza. Brisanje od indeksa start do indeksa end. StringBuffer besedilo = new StringBuffer("Besedilo vsebuje 27 znakov."); besedilo.delete(8, 19); // brisanje od indeksa 8 do 19 System.out.printf("Besedilo po brisanju: %s", besedilo);

StringBuffer insert(int offset, String str)

Vstavljanje niza str v niz na mestu offset. StringBuffer besedilo = new StringBuffer("Šolski Velenje."); besedilo.insert(7, "Center "); // vstavljanje System.out.printf("Besedilo po vstavljanju: %s", besedilo); // izpis Besedilo po vstavljanju: Šolski Center Velenje.

void setLength(int newLength)

Določi dolžino niza. StringBuffer besedilo = new StringBuffer("Šolski Center Velenje."); besedilo.setLength(13); System.out.printf("Besedilo po spremembi dolžine: %s", besedilo); // izpis Besedilo po spremembi dolžine: Šolski Center

10.5 Naključna števila

Ustvarjanje naključnih števil z uporabo metod razreda java.util.Random Vključimo uporabo metod razreda Random. import java.util.Random; Konstruktor ustvari nov generator naključnih števil. Privzeta vrednost seed (semena) je sistemski čas v milisekundah.

Metoda Opis

double nextDouble()

Vrne naključno število med 0.0 in 1.0 (manjše od 1.0). Random generator = new Random(); double nakljucnoDouble; // vrne naključno število med 0.0 in 1.0 (manjše od 1.0) nakljucnoDouble = generator.nextDouble();

int nextInt() Vrne naključno celo število iz obsega celih števil (int) od –2147483648 do +2147483647. Random generator = new Random(); int nakljucnoStevilo; // naključno celo število iz obsega celih števil nakljucnoStevilo = generator.nextInt( );

int nextInt(n) Vrne naključno celo število med 0 in n-1. Random generator = new Random(); int nakljucnoStevilo; // naključno celo število med 0 in 9 nakljucnoStevilo = generator.nextInt(10); Naključno celo število iz območja med x in y (x in y sta celi števili). nakljucnoStevilo = x + generator.nextInt(y-x+1); Naključno celo število iz območja med 5 in 10.


Metoda Opis

nakljucnoStevilo = 5 + generator.nextInt(10-5+1); Ustvarjanje naključnih števil z uporabo metode random() razreda java.lang.Math

Metoda Opis

double random() Vrne naključno število med 0.0 in 1.0 (manjše od 1.0). int nakljucnoStevilo; // naključno celo število med 5 in 10; 5 - spodnja meja, 10 - zgornja meja nakljucnoStevilo = 5 + (int) (Math.random()*(10-5+1)); // naključno vrednost med 0 in 1 pomnožimo z (zgornja meja -spodnja meja +1) // dobljeno vrednost pretvorimo v celo število // dobljeni vrednosti prištejemo spodnjo mejo

10.6 Besedilni dokumenti

Aktivnost Opis

Branje Vsebino besedilnega dokumenta preberemo z uporabo metod objekta razreda Scanner.

Pisanje Vsebino besedilnega dokumenta ustvarjamo oz. spreminjamo z uporabo metod objekta razreda PrintWriter.

10.6.1 Branje

Ustvarimo vhodni objekt razreda Scanner, objekta razreda File. Scanner branjeDokument = new Scanner( new File("ImeDokumenta.txt") ); Do vrednosti dokumenta dostopamo z metodami nextInt(), nextDouble() ... razreda Scanner. int stevilo1, stevilo2; double stevilo3; … stevilo1 = branjeDokument.nextInt(); // branje celoštevilčne vrednosti stevilo2 = branjeDokument.nextInt(); // branje celoštevilčne vrednosti stevilo3 = branjeDokument.nextDouble(); // branje decimalne vrednosti Zapremo dokument z metodo close(). branjeDokument.close(); // zapremo besedilni dokument Primer: 1. /* Program izpiše seznam celih števil besedilnega dokumenta in izračuna vsoto števil. */ 2. import java.util.Scanner; // uporaba Scanner razreda 3. import java.io.*; // uporaba razreda file stream in exception 4. public class Vnos_dokument1 { 5. 6. public static void main(String[] args) { 7. // deklaracija spremenljivk 8. Scanner besDokument = null; // objekt razreda Scanner 9. int stevilo, vsota = 0; // trenutno število, vsota števil 10. try 11. { // ustvarimo objekt razreda Scanner za branje vrednosti iz besedilnega dokumenta


12. besDokument = new Scanner( new File("C:\\Users\\Srečko\\eclipse\\ 13. besedilni_dokument1_1\\bin\\stevila.txt") ); 14. } 15. catch (FileNotFoundException e) // izjema dokument ne obstaja 16. { 17. System.out.printf("Dokument stevila.txt ne obstaja."); 18. System.exit(1); 19. } 20. System.out.printf("Seznam števil: "); 21. while (besDokument.hasNext()) 22. { 23. stevilo = besDokument.nextInt(); // branje celoštevilčne vrednosti 24. System.out.printf("%d, ",stevilo); 25. vsota = vsota + stevilo; 26. } 27. System.out.printf("\nVsota števil v dokumentu je %d.",vsota); 28. besDokument.close(); // zapremo besedilni dokument 29. } 30. }

10.6.2 Pisanje

Ustvarimo izhodni objekt razreda PrintWriter, ki je podrazred razreda PrintStream. Scanner besDokument = new Scanner( new File("ImeDokumenta.txt") ); Uporabimo metode razreda PrintStream (printf(), print(), println()). int stevilo1, stevilo2, vsota; ... vsota = stevilo1 + stevilo2; // izpis v besedilni dokument besDokument.printf("Vsota števil %d in %d je %d.",stevilo1, stevilo2, vsota); Zapremo dokument z metodo close(). besDokument.close(); // zapremo besedilni dokument

10.7 Razred Enum

Razred java.lang.Enum podpira uporabo naštevnega podatkovnega tipa. Naštevni podatkovni tip uporabimo, kadar imamo seznam veljavnih vrednosti. Enum tip je referenčni podatkovni tip. Enum podatkovni tip je deklariran z rezerviranko enum. 1. // naštevni podatkovni tip 2. public enum Ocena { 3. nzd(5), zd(6), db(7), pdb(8), pdb_(9), odl(10); // seznam ocen 4. int ocena; // atribut oz. polje naštevnega tipa 5. Ocena(int tOcena) // konstruktor 6. { 7. ocena = tOcena; 8. }


9. 10. int VrniOcena() // metoda vrne oceno 11. { 12. return ocena; 13. } 14. } // enum Ocena 1. // uporaba naštevnega tipa Ocena 2. public class DemoOcena { 3. public static void main(String[] args) 4. { 5. // izpis 6. System.out.println("Ocene:"); 7. // zanka za vse elemente naštevnega seznama Ocena 8. for (Ocena oc : Ocena.values() ) 9. { // izpis naziva ocene in številčne vrednosti 10. System.out.println(oc + " (" + oc.VrniOcena() + ")"); 11. } // for 12. } //main 13. } // DemoOcena Primer izvajanja:

Ocene: nzd (5) zd (6) db (7) pdb (8) pdb_ (9) odl (10)

Metoda Opis

String name() Vrne vrednost enum konstante.

int ordinal() Vrne ordinalno (zaporedno) mesto konstante. Ocena oc = Ocena.db; System.out.println("Zaporedno mesto je " + oc.ordinal() + "."); System.out.println("Ime konstante ocene dobro je " + oc.name() + ".");


11 IZJEME

Programska koda mora biti zanesljiva in trdoživa. K temu pripomore tudi mehanizem izjem, ki je vgrajen v jezik in izvajalno okolje. Z izjemami predvidimo neobičajne okoliščine delovanja in nanje ustrezno reagiramo. Izjeme so torej nepričakovani dogodki ali napake, ki se pojavijo med izvajanjem programa, ki povzročijo prekinitev izvajanja programa. Izjeme povzročijo dogodki kot so deljenje z nič, branje neobstoječe datoteke, nepravilen URL naslov, dostop do elementa polja z indeksom izven meja tabele ... Vsaka metoda lahko poleg običajne vrnjene vrednosti vrne tudi objekt, ki opisuje izjemni dogodek. Temu rečemo, da metoda sproži izjemo (angl. throws an exception). Izvajanje metode se zaključi v trenutku, ko sproži izjemo. Takrat se ustvari nov objekt,ki opisuje to izjemo, in ta potuje nazaj po klicnem skladu (method call stack), dokler ne najde primernega prestreznika izjem (exception handler).

11.1 Vrste izjem

Razred Throwable je skupni predhodnik vseh izjemnih dogodkov. Iz njega sta izpeljana razreda Error in Exception. Razred Error je namenjen opisu izjemnih napak, zaradi katerih se program ne more več nadaljevati. Razred Exception opisuje izjeme, katerih obravnavo vključimo v kodo programa. Razred RuntimeException je neposredno izpeljan iz razreda Exception. Opisuje izjeme, ki so posledica napake v programu (dostop do elementa polja, ki ne obstaja). Izjemam te vrste se s previdnejšim kodiranjem izognemo in jih v kodi ne prestrezamo. Ostali potomci razreda Exception opisujejo izjeme, ki jih v programu težko zaznamo in preprečimo (npr. nedovoljen dostop do dokumenta). Zanje poskrbimo s programsko obravnavo (prestrezanjem) izjem. Kadar med delovanjem metode lahko pride do izjeme, tako metodo posebej označimo. V glavi metode z rezerviranko throws označimo tip možne izjeme. public int ustvariDokument(String imeDokumenta) throws FileNotFoundException, IOException Ko v metodi zaznamo neobičajni dogodek, ki povzroči nepravilno delovanje metode, znotraj metode sprožimo izjemo: throw new IOException("Dokument ne obstaja."); S stavkom throw prekinemo izvajanje metode ter posredujemo izjemo (novo ustvarjeni objekt IOException z opisom izjeme mora biti tipa Throwable) po klicnem skladu do ustreznega prestreznika izjem. Kjer kličemo metode, ki razglašajo izjeme, imamo tri možnosti za obravnavo izjem: - izjemo lahko spustimo nazaj po klicnem skladu, - izjemo prestrežemo in jo ustrezno obdelamo ali - izjemo prestrežemo in sprožimo drugo izjemo (novo izjemo obravnavamo v drugem delu kode). Kadar se odločimo za možnost, da izjemo spustimo nazaj po klicnem skladu, moramo v glavi metode le razglasimo njen tip (npr. throws IOException). S tem določimo, da metoda ne obravnava izjem, ampak jih posreduje po klicnem skladu. Obravnava izjem (angl. exception handling) pomeni prestrezanje sproženih izjem z ustreznim odzivom. Prestreznik izjem zapišemo s stavkom try (try catch finally). Sintaksa stavka try: try { // stavki, ki lahko sprožijo izjemo } catch (Exception1 e) { // obravnava izjeme Exception1 } catch (Exception2 e) { // obravnava izjeme Exception2 }


finally { // stavki za ustrezen konec aktivnosti } } Kodo pri kateri lahko pride do izjeme, postavimo v blok try. Vsako posamezno izjemo obravnava lasten prestreznik catch. Pri tem lahko izjeme tudi združujemo in jih več obravnavamo v istem prestrezniku. Ker so vse izjeme izpeljane iz razreda Exception, lahko univerzalni prestreznik za vse izjeme zapišemo: catch (Exception e) { // obravnava vseh izjem } Obravnava izjem z izpisom sporočila izjeme: catch (Exception e) { System.out.println(e.getMessage()); // metoda getMessage vrne sporočilo izjeme e.printStackTrace(); // izpis klicnega sklada } Stavki znotraj bloka finally se izvedejo v vsakem primeru (če je do izjeme prišlo ali tudi če do izjeme ni prišlo). Blok finally je opcijski in ni potrebno, da ga uporabimo.

Slika 31: Del izpeljanih razredov razreda Throwable

Primer: 1. /* Izračun količnika dveh števil. */ 2. import java.util.Scanner; 3. public class Izjeme1 { 4. public static void main(String[] args) { 5. double stevilo1, stevilo2; 6. Scanner vhod = new Scanner (System.in); //objekt za vnos števil; branje s tipkovnice 7. // branje števil 8. System.out.print("Vpiši 1. število (deljenec):"); 9. stevilo1 = vhod.nextDouble(); 10. System.out.print("Vpiši 2. število (delitelj):"); 11. stevilo2 = vhod.nextDouble(); 12.


13. // izpis količnika 14. System.out.printf("%f / %f = %f", stevilo1, stevilo2, 15. kolicnik(stevilo1, stevilo2) ); 16. vhod.close(); // zapremo delo z vhodnim tokom; 17. } // metoda main 18. 19. public static double kolicnik (double deljenec, double delitelj) 20. { 21. return deljenec / delitelj; 22. } //metoda kolicnik 23. 24. } // razred Primer izvajanja:

Vpiši 1. število (deljenec):56 Vpiši 2. število (delitelj):napaka Exception in thread "main" java.util.InputMismatchException at java.util.Scanner.throwFor(Unknown Source) at java.util.Scanner.next(Unknown Source) at java.util.Scanner.nextDouble(Unknown Source) at Izjeme1.main(Izjeme1.java:12)

Izvajanje programa se v primeru neustreznega vnosa prekine in izpiše se obvestilo, da je v programu prišlo do izjeme InputMismatchException. V nadaljevanju je izpisano obvestilo klicev sklada (angl. stack trace). Program spremenimo v bolj trdoživ program. Upoštevamo možne napake in jih vključimo v proženje izjem. Možne napake: neustrezen vnos števil (vsebuje črke), deljenec je enak 0 (deljenje z nič). 1. /* Izračun količnika dveh števil s prestrezanjem izjem. */ 2. import java.util.InputMismatchException; 3. import java.util.Scanner; 4. public class Izjeme1 { 5. public static void main(String[] args) { 6. double stevilo1, stevilo2; 7. Scanner vhod = new Scanner (System.in); // objekt za vnos števil; branje s tipkovnice 8. boolean ponoviVnos = true; // napaka pri vnosu 9. // zanka oz. ponavljanje do veljavnega vnosa in izračuna 10. do 11. { 12. try 13. { // blok možnosti izjem 14. // branje števil 15. System.out.print("Vpiši 1. število (deljenec):"); 16. stevilo1 = vhod.nextDouble(); 17. System.out.print("Vpiši 2. število (delitelj):"); 18. stevilo2 = vhod.nextDouble(); 19. // izpis količnika 20. System.out.printf("%f / %f = %f", stevilo1, stevilo2, 21. kolicnik(stevilo1, stevilo2) ); 22. ponoviVnos = false; // brez napake 23. } 24. catch (InputMismatchException inputMismatchException)


25. { 26. System.err.printf( "\nIzjema: %s\n", 27. inputMismatchException ); 28. vhod.nextLine(); // razveljavimo vnos 29. System.out.println("Vpisati morate števila. Ponovite vnos.\n" ); 30. } 31. catch (ArithmeticException arithmeticException) 32. { 33. System.err.printf( "\nDeljenje z nič:: %s\n", 34. arithmeticException ); 35. vhod.nextLine(); // razveljavimo vnos 36. System.out.println("Deljenec mora biti različen od nič. Ponovite vnos.\n" ); 37. } 38. } while (ponoviVnos); 39. vhod.close(); // zapremo delo z vhodnim tokom; 40. } // metoda main 41. 42. public static double kolicnik (double deljenec, double delitelj) 43. throws ArithmeticException 44. { 45. if (delitelj == 0) // delitelj je enak nič 46. throw new ArithmeticException("Izjema: delitelj je enak nič."); // proženje izjeme 47. return deljenec / delitelj; 48. } //metoda kolicnik 49. 50. } // razred Izjeme Primer izvajanja:

Vpiši 1. število (deljenec):40 Vpiši 2. število (delitelj):10st Izjema: java.util.InputMismatchException Vpisati morate števila. Ponovite vnos. Vpiši 1. število (deljenec):40 Vpiši 2. število (delitelj):10 40,000000 / 10,000000 = 4,000000

12 Grafika (awt, swing)

Platforma JFC (Java Foundation Classes) vključuje dva paketa knjižnic za gradnjo grafičnih uporabniških vmesnikov (angl. Graphical User Interface ali GUI), to sta AWT (angl. Abstract Windowing Toolkit) in Swing. AWT je starejši in je hkrati osnova grafičnih gradnikov. Swing je novejši in nudi grafične elemente, katerih videz je neodvisen od okolja operacijskega sistema. Gradniki swing so izpeljani iz gradnikov AWT in se začnejo na J, npr. JFrame, JButton ... Programsko okno si predstavljamo kot platno katerega vsebino mora določiti program. Vsaka komponenta je predstavljena v vsebniku (angl. Container).


Koordinatni sistem:

Slika 32: Koordinatni sistem

Gradniki vsebnika imajo lego in velikost določeno glede na koordinatni sistem vsebnika.

Slika 33: Koordinate gradniki

12.1 Enostavno okno

Osnova programa z grafičnim uporabniškim vmesnikom je okno, ki je objekt razreda JFrame. Okno ima vlogo vsebnika, v katerega lahko vstavimo druge gradnike. Razred JFrame se nahaja v paketu javax.swing, zato moramo napovedati uporabo razreda: import javax.swing.JFrame; Ustvarimo nov objekt razreda JFrame: JFrame okno = new JFrame(); Objekt okna prikažemo na zaslonu (naredimo vidnega) s klicem metode setVisible(true). Z metodo setDefaultCloseOperation() določimo privzeto operacijo, ki se izvede ob zapiranju okna. Kot dejanski parameter ji podamo celo število, ki določa vrsto operacije. Definirana konstanta EXIT_ON_CLOSE razreda JFrame določa, da se ob zaprtju okna program konča z uporabo metode exit razreda System. okno.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);


Oknu določimo ime z uporabo metode setTitle(). okno.setTitle("Risanje"); Ustvarimo nov objekt razreda JPanel: JPanel p = new JPanel(); Ustvarjen objekt dodamo vsebini okna in oknu določimo velikost 600x400. okno.add(p); // vstavljanje plošče okno.setSize(600, 400); // velikost okna Izvajanje:

Slika 34: Enostavno okno

Primer programa: 1. /* Prazno programsko okno (komponenti JFrame in JPanel). */ 2. import javax.swing.JFrame; 3. import javax.swing.JPanel; 4. 5. public class G1 { 6. public static void main(String[] args) { 7. JFrame okno = new JFrame(); // okno 8. // zapiranje okna predstavlja izhod iz programa 9. okno.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 10. okno.setVisible(true); // okno vidno 11. okno.setTitle("Risanje"); 12. JPanel p = new JPanel(); // plošča 13. // v okno dodamo ploščo 14. okno.add(p); 15. okno.setSize(600, 400); // velikost okna 16. } //main 17. 18. } // razred G1 Grafični vmesnik vključuje veliko elementov oz. gradnikov (angl. components). Osnovni gradniki so gumbi (angl. button), stikala (angl. checkbox), radijski gumbi (angl. radio button), vnosna polja (text field), seznami (angl. list), oznake (label), menujske vrstice (menu bar), orodne vrstice (toolbar) in drugi. Zanimiv gradnik je vsebnik (razred Container), ki lahko vsebuje druge gradnike. Vsebniki so lahko osnovni ali vmesni. Osnovni vsebniki, kot sta na primer JFrame ali JApplet, določajo samostojna okna in tako predstavljajo osnovni gradnik, zato jih ne moremo vključevati v druge vsebnike. Vsak grafični program mora


vsebovati vsaj en osnovni vsebnik. Vmesni vsebniki je npr. plošča (JPanel) v katero vstavljamo druge gradnike. Gradnike lahko združujemo v skupine ...

12.2 Metode razreda Graphics za risanje geometrijskih likov

Opis

public abstract void drawLine(int x1, int y1, int x2, int y2) Črta med točkama (x1, y1) in (x2, y2).

public void drawRect(int x,int y,int width,int height) Pravokotnik določen z levo zgornjo točko (x, y) ter širino (width) in višino (height).

public abstract void drawRoundRect(int x,int y,int width,int height,int arcWidth, int arcHeight) Pravokotnik z zaobljenimi robovi določen z levo zgornjo točko (x, y), širino (width) in višino (height) ter širino (arcWidth) in višino (arcHeight) loka.

public abstract void fillRoundRect(int x,int y, int width, int height,int arcWidth, int arcHeight) Pravokotnik s polnilom z zaobljenimi robovi določen z levo zgornjo točko (x, y), širino (width) in višino (height) ter širino (arcWidth) in višino (arcHeight) loka. Polnilo je trenutne barve.

public abstract void drawOval(int x,int y,int width, int height) Elipsa določena z levo zgornjo točko (x, y), širino (width) in višino (height).

public abstract void fillOval(int x,int y,int width, int height) Elipsa s polnilom določena z levo zgornjo točko (x, y), širino (width) in višino (height).

public abstract void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle) Krožni izsek iz začetne točke (x, y) določen s širino (width) in višino (height) ter začetnim (startAngle) in končnim kotom (arcAngle).

public abstract void drawPolyline(int[] xPoints,int[] yPoints, int nPoints) Poligon povezanih črt določenih s poljem x in y koordinat. Lik je zaprt, če sta koordinati prve in zadnje točka enaki.

public abstract void drawString(String str, int x,int y) Izpis besedila dejanskega parametra str. Najbolj levi znak se začne na položaju točke (X,Y).

Razred Color vsebuje konstante in metode za delo z barvami.

12.2.1 Konstruktorji in metode razreda Color

Opis

public Color( int red, int green, int blue ) Ustvari barvo za parametre rdeča (angl. red), zelena (angl. green), modra (angl. blue) iz intervala med 0 in 255.

public Color( float red, float green, float blue ) Ustvari barvo za parametre rdeča (angl. red), zelena (angl. green), modra (angl. blue) iz intervala med 0.0 in 1.0.

public int getRed(); public int getGreen(); public int getBlue() Vrne vrednost med 0 in 255, ki predstavlja vsebino barve (rdečo ali zeleno ali modro vsebino).

public Color getColor() Vrne vrednost Color objekta.

public void setColor( Color c ) Določi vrednost barve parametra.


Tabela konstant barv Konstanta barve RGB vrednost RED 255,0,0 GREEN 0,255,0 BLUE 0,0,255 ORANGE 255,200,0 PINK 255,175,175 CYAN 0,255,255 MAGENTA 255,0,255 YELLOW 255,255,0 BLACK 0,0,0 WHITE 255,255,255 GRAY 128,128,128 LIGHT_GRAY 192,192,192 DARK_GRAY 64,64,64

Primer: 1. /* Demonstracija risanja geometrijskih likov */ 2. import java.awt.Color; 3. import java.awt.Graphics; 4. import javax.swing.JComponent; 5. import javax.swing.JFrame; 6. import javax.swing.JPanel; 7. 8. class Platno extends JComponent { 9. public void paint(Graphics g) { 10. g.drawLine(10, 40, 200, 40); //črta 11. g.drawRect (10, 50, 200, 200); //pravokotnik 12. g.drawOval(80, 100, 70, 70); // elipsa 13. g.setColor(Color.BLUE); // modra barva 14. g.fillRoundRect(200, 200, 50, 70,5,5); // pravokotnik s polnilom 15. g.drawString("Uporaba metod razreda Graphics", 200, 20); 16. g.setColor(Color.DARK_GRAY); // temno siva 17. g.fillArc(300,300,50,50,0,180); // krožni izsek 18. } 19. } 20. 21. public class G2 { 22. public static void main(String[] a) { 23. JFrame okno = new JFrame(); // okno 24. // zapiranje okna predstavlja izhod iz programa 25. okno.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 26. okno.setVisible(true); // določi vidno 27. okno.setTitle("Risanje geometrijskih likov"); // naslov 28. okno.setSize(600, 400); // velikost okna 29. okno.getContentPane().add(new Platno()); // dodajanje 30. } // main 31. } // razred


Izvajanje:

Slika 35: Geometrijski liki

12.3 Applet

Apleti so javanski programčki, ki se ne izvajajo samostojno. Uporabljamo jih za razširitev zmogljivosti izvajalnega okolja. Aplet se izvaja v pregledovalniku Applet Viewer ali v oknu brskalnika (vstavimo ga v HTML dokument). Telo apleta je razred, ki je izpeljan iz razreda Applet (java.applet) ali pa iz njega izpeljanega razreda JApplet (Swing komponenta). Oba razreda vsebujeta metode za vzpostavitev, zagon, zaustavitev in uničenje apleta (init(), start(), stop(), destroy()). V samostojnih programih se izvajanje kode začne v zagonski metodi main(), v apletu pa je zagonska metoda init(). Struktura apleta: public class <ImeAppleta> extends Applet { // metoda paint public void paint(Graphics g) { } // paint } // class public class <ImeAppleta> extends JApplet { // metoda init public void init() { } // init } // class Applet je sestavljen iz javnega (public) razreda (class), ki je razširitev (extends) oziroma podrazred razreda Applet. Razred vsebuje javno (public) metodo z imenom paint, ki dobi za parameter objekt razreda Graphics z imenom g in ne vrača nobenega rezultata (void). Metoda paint običajno vsebuje stavke, ki se izvedejo vsakič, ko je potrebno obnoviti sliko.


Razreda Applet in Graphics sta že definirana. Razred Applet pripada paketu java.applet, razred Graphics pa paketu java.awt. Značka za vključitev appleta v HTML dokument je applet in ima tri obvezne parametre. Z lastnostma width in height določimo velikost pravokotnega področja, ki je na voljo appletu, s code pa določimo v katerem dokumentu je preveden razred appleta. Primer: 1. /* Applet demo risanje geometrijskih likov. */ 2. import java.applet.Applet; 3. import java.awt.Color; 4. import java.awt.Graphics; 5. 6. public class Applet1 extends Applet { 7. 8. public void paint(Graphics g) 9. { 10. g.drawLine(10, 40, 200, 40); //črta 11. g.drawRect (10, 50, 200, 200); //pravokotnik 12. g.drawOval(80, 100, 70, 70); // elipsa 13. g.setColor(Color.BLUE); // modra barva 14. g.fillRoundRect(200, 200, 50, 70,5,5); // pravokotnik s polnilom 15. g.drawString("Uporaba metod razreda Graphics", 200, 20); 16. g.setColor(Color.DARK_GRAY); // temno siva 17. g.fillArc(300,300,50,50,0,180); // krožni izsek 18. } 19. } 1.  2. <!DOCTYPE html> 3. <html> 4. <head> 5. <title>Primer appleta</title> 6. </head> 7. <body> 8. 9. <applet width="600" height="400" code="Applet1.class"> 10. </applet> 11. 12. </body> 13. </html> Delovanje apleta testiramo tako, da v ukaznem oknu odpremo pregledovalnik apletov, ki mu kot dejanski parameter (argument) določimo html dokument: appletviewer aplet.html Običajno html dokument odpremo v spletnem brskalniku.


Izvajanje v brskalniku:

Slika 36: Applet geometrijski liki

Primer: 1. // Aplet pretvori znesek v eurih v dolarje. 2. import java.awt.BorderLayout; 3. import java.awt.Container; 4. import java.awt.event.ActionEvent; 5. import javax.swing.JApplet; 6. import javax.swing.JButton; 7. import javax.swing.JLabel; 8. import javax.swing.JPanel; 9. import javax.swing.JTextField; 10. 11. 12. public class PretvoriEuroDolar extends JApplet { 13. // gradniki vmesnika 14. JLabel lblZnesekEur = new JLabel("Znesek v EUR"); 15. JLabel lblTecaj = new JLabel("Tečaj (EUR->$)"); 16. JTextField txtZnesekEur = new JTextField(10); 17. JTextField txtTecaj$ = new JTextField("1.1298",10); 18. JButton btnIzracun = new JButton("Izračun"); 19. JLabel lblRezultat = new JLabel(); 20. 21. // zagonska metoda apleta 22. public void init() 23. {


24. // gradnike vstavimo v plošče 25. JPanel plosca1 = new JPanel(); 26. plosca1.add(lblZnesekEur); 27. plosca1.add(txtZnesekEur); 28. JPanel plosca2 = new JPanel(); 29. plosca2.add(lblTecaj); 30. plosca2.add(txtTecaj$); 31. JPanel plosca3 = new JPanel(); 32. plosca3.add(btnIzracun); 33. plosca3.add(lblRezultat); 34. 35. // vsebnik 36. Container vsebina = getContentPane(); 37. // plošče vstavimo v vsebnik 38. vsebina.add(plosca1, BorderLayout.NORTH); 39. vsebina.add(plosca2, BorderLayout.CENTER); 40. vsebina.add(plosca3, BorderLayout.SOUTH); 41. 42. // metoda poslušalca odzivnega dogodka 43. btnIzracun.addActionListener(new ActionListner () 44. { 45. // odzivni dogodek 46. public void actionPerformed(ActionEvent d) { 47. String rezultat; 48. rezultat = txtZnesekEur.getText() + " eurov je " + 49. Math.round(Double.parseDouble(txtZnesekEur.getText()) * 50. Double.parseDouble(txtTecaj$.getText()) * 100)/100.0 +" $." ; 51. lblRezultat.setText(rezultat); 52. } //actionPerformed 53. } // addActionListener 54. ); 55. } // init 56. } // razred PretvoriEuroDolar Izvajanje:

Slika 37: Pretvorba eurov v dolerje

ŠC V

Ustv 1. U2. Tr3. P

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40.

VELENJE

varjanje Sier

stvarimo enarikotnik razdeonavljamo ko

// Izris Simport jaimport japublic cl

rpinskih trik

akostranični telimo na štiriorak 2 na vs

ierpinskih trikavax.swing.*;ava.awt.* ; ass Ser extepublic static public static public static public Ser() } publ publ } publ

INFOR

kotnikov

trikotnik. manjše ena

seh trikotnikih

kotnikov */ ;

ends JFrame{ final int VEL final int KON int tocka1X ,

{ super ("SsetSize(// A simptocka1Xtocka1Ytocka2Xtocka2Ytocka3Xtocka3YsetVisibsetDefau

lic Point vrniSreturn ne}

lic void paint super.patrikotRisnew Poi

lic void trikot// pogoj if (p1.disKONEC// riši trikGraphicsg.drawLg.drawLg.drawL

MATIKA, PR

kostranične th.

Slika 38

{ IKOSTOKNA

NECPOSTOP, tocka1Y , to

Ser"); VELIKOSTOple triangle

X = (int) getSiY = 40; X = 20; Y = (int) getSiX = (int) getSiY = (int) getSile (true) ; ultCloseOper

Sredino ( Poiew Point ( ( i

( Graphics gaint (g) ; i (new Point nt (tocka3X,

Risi ( Point pzaključka

stance (p2) <POSTOPKA

kotnik s g = getGraine ( (int) p1.ine ( (int) p2.ine ( (int) p3.

ROGRAMIRA

trikotnike.

8: Sierpinski

A = 400; // vePKA=10; // krocka2X , tock

OKNA, VELIK

ze().getWidt

ze().getHeigze().getWidtze().getHeig

ration (JFram

int p1 , Pointnt ) (p1.getX

g ) {

(tocka1X, to tocka3Y ));

p1, Point p2,

< KONECPOA && p2.dista

phics(); .getX(),(int) p.getX(),(int) p.getX(),(int) p

ANJE (1. letn

trikotniki

elikost okna riterij zaključkka2Y , tocka3

KOSTOKNA)

h() / 2 ; // 1/2

ht() - 20; h() - 20; ht() - 20;

me.EXIT_ON

t p2 ) { X() + p2.getX(

cka1Y), new

Point p3 ) {

STOPKA &&ance ( p3 ) <

p1.getY(),(intp2.getY(),(intp3.getY(),(int

ik)

ka risanja 3X , tocka3Y

;

2 širine okna

N_CLOSE);

())/2 , (int) (p1

Point (tocka

& p1.distance KONECPOS

) p2.getX(),(i) p3.getX(),(i) p1.getX(),(i

Y ; // točke trik

1.getY() + p2

a2X, tocka2Y

e (p3) < STOPKA) ret

int) p2.getY()int) p3.getY()int) p1.getY()

Stran

kotnika

2.getY ())/2);

Y ),

turn ;

)); )); ));

120


41. // rekurzivni izris treh trikotnikov 42. Point m12 = vrniSredino(p1,p2); 43. Point m23 = vrniSredino(p2,p3); 44. Point m31 = vrniSredino(p3,p1); 45. // rekurzivni klici 46. trikotRisi (p1, m12, m31); 47. trikotRisi(p2, m23, m12); 48. trikotRisi (p3, m31, m23); 49. } 50. 51. public static void main ( String [ ] args ) { 52. new Ser(); 53. } 54. } Izvajanje:

Slika 39: Sierpinski trikotniki – primer izvajanja

13 POGOVORNA OKNA

Do sedaj smo v primerih uporabljali izhodno okno za izpis obvestil in informacij. V programih pogosto izpisujemo obvestila v pogovornih oknih. Razred JOptionPane iz paketa javax.swing vsebuje metode za izpis sporočil v pogovornih oknih. Paket javax.swing vsebuje razrede grafičnega vmesnika (angl. graphical user interfaces - GUIs). GUI komponente olajšajo izdelavo programskih vmesnikov (vnosne maske, prikazi oz. izpisi ...). import javax.swing.JOptionPane; Izpis obvestila Metodo showMessageDialog uporabljamo za izpis obvestila v pogovornem oknu. JOptionPane.showMessageDialog(null, "Sporočilo v pogovornem oknu.\n


(Uporaba razreda JOptionPane.)","Sporočilo", JOptionPane.INFORMATION_MESSAGE);

Parameter Opis

Prvi parameter Komponenta znotraj katere se prikaže pogovorno okno. Vrednost null predstavlja privzeti okvir (pogovorno okno je na sredini zaslona).

Drugi parameter Besedilo sporočila.

Tretji parameter Naslov pogovornega okna.

Četrti parameter Vrsta sporočila: JOptionPane.ERROR_MESSAGE - napaka, JOptionPane.INFORMATION_MESSAGE - informacija, JOptionPane.WARNING_MESSAGE - opozorilo, JOptionPane.QUESTION_MESSAGE - vprašanje, JOptionPane.PLAIN_MESSAGE - besedilo.

1. /* najava uporabe razreda JOptionPane iz paketa javax.swing 2. paket javax.swing vsebuje razrede grafičnega vmesnika (ang. graphical user interfaces GUIs) */ 3. import javax.swing.JOptionPane; 4. 5. public class P2_4_okna 6. { 7. public static void main(String[] args) 8. { 9. // z metodo showMessageDialog razreda JOptionPane izpišemo sporočilo v pogovornem oknu 10. JOptionPane.showMessageDialog(null, "Sporočilo v pogovornem oknu.\n 11. (Uporaba razreda JOptionPane.)", "Sporočilo", JOptionPane.INFORMATION_MESSAGE); 12. } // konec metode 13. } // konec razreda

Slika 40: Izpis sporočila

Vnos vrednosti Metodo showInputDialog uporabimo za vnos vrednosti v pogovornem oknu. JOptionPane.showInputDialog(String); Primer 1: 1. // najava uporabe razreda JOptionPane iz paketa javax.swing 2. import javax.swing.JOptionPane; 3. 4. public class P2_5Okna_2 { 5.


6. public static void main(String[] args) 7. { 8. //z metodo showInputDialog razreda JOptionPane v pogovornem oknu 9. //izvedemo vnos vrednosti oz. branje 10. String tIzpit = JOptionPane.showInputDialog("Vpišite predmet: "); 11. // v pogovornem oknu izpišemo vneseno informacijo 12. JOptionPane.showMessageDialog(null, "Naziv predmeta: " + tIzpit, 13. "Sporočilo", JOptionPane.INFORMATION_MESSAGE); 14. } // konec metode 15. } // konec razreda

Slika 41: Vno predmeta

Slika 42: Izpis predmeta

Primer 2: String ime_priimek; // ime in priimek ime_priimek = JOptionPane.showInputDialog("Ime in priimek"); String besedilo_stevilo; //vnos v besedilno spremenljivko int stevilo_studentov; // celoštevilčna spremenljivka //vnos in pretvorba v celo število besedilo_stevilo = JOptionPane.showInputDialog( "Število študentov" ); stevilo_studentov = Integer.parseInt( besedilo_stevilo );

13.1 WindowBuilder

Eclipsov vtičnik WindowBuilder podpira izdelavo GUI vmesnikov oz. aplikacij. Namestitev vtičnika 1. V meniju izberemo Help➪Install New Software. Odpre se pogovorno okno Install. 2. V pogovornem oknu Install kliknemo gumb Add. Odpre se pogovorno okno Add Repository. 3. V oknu Add Repository vpišemo ime npr. WindowsBuilder in URL naslov http://download.eclipse.org/windowbuilder/WB/release/R201406251200/4.4/ (na strani http://www.eclipse.org/windowbuilder/download.php poiščemo ustrezno povezavo za nameščeno verzijo Eclipse razvojnega okolja). Vnos potrdimo s klikom na gumb OK (V redu).


Slika 43: Določitev mesta prenosa

Prikaže se seznam elementov, ki so na voljo za namestitev.

Slika 44: Izbor elementov


Izberemo vse elemente s klikom na gumb (Select All) in nato kliknemo gumb . Izpiše se vsebina licenčnega besedila. Potrdimo strinjanje z licenco z izbiro radijskega gumba

.

Nastavitve namestitve potrdimo s klikom na gumb .

Vtičniki se prenesejo in samodejno namestijo. Po namestitvi izvedemo vnovični zagon programa Eclipse. Orodje je nameščeno za uporabo.


14 VAJE

14.1.1 Izpis obvestila

Izpis obvestila "To je prvi primer na vajah.".

To je prvi primer na vajah.

14.1.2 Izpis obvestila na zaslon

Ime: <Vaše ime npr. Marko> Priimek: <Vaš priimek npr. Koren> E-naslov: <Vaš elektronski naslov>

14.1.3 Izračun vsote dveh vnesenih celih števil

Vpiši dve celi števili: 45 78 Prvo število je: 45 Drugo število je: 78 Vsota števil je 123.

14.1.4 Ploščine in obsega pravokotnika

Podatki pravokotnika: Stranica a: 3.5 Stranica b: 2.45 ----------------------------------- Obseg pravokotnika je 11.9. Ploščina pravokotnika je 8.575.

14.1.5 Zamenjava vrednosti spremenljivk

Program prebere celoštevilčni vrednosti dveh spremenljivk x in y. Program zamenja vrednosti spremenljivk in izpiše nove vrednosti na zaslon.

Vpiši dve celi stevili: 45 56 Začetna vrednost spremenljivke x je 45. Začetna vrednost spremenljivke y je 56. Zamenjava vrednosti spremenljivk x <= => y. Nova vrednost spremenljivke x je 56. Nova vrednost spremenljivke y je 45.


14.1.6 Povprečna starost in povprečna teža

Program prebere starost in težo treh študentov in izpiše povprečno starost in povprečno težo.

Vpiši starost in težo 1. študenta: 20 75 Vpiši starost in težo 2. študenta: 22 73 Vpiši starost in težo 3. študenta: 22 80 Povprečna starost: 21.3333 Povprečna teza: 76

14.1.7 Vrednosti relacijskih izrazov

Program, ki za dve vneseni realni števili izpiše vrednosti relacijskih izrazov: >, >=, <, <=, !=, ==.

Vnesi dve števili: 5 5 5<=5: resnično 5<5: neresnično 5>5: neresnično 5>=5: resnično 5==5: resnično 5!=5: neresnično

14.1.8 Tranzitivnost števil

Program, ki za tri vnesena realna števila preveri, če velja tranzitivnost: x > y in y > z sledi (=>) x > z

Vnesi tri števila (x y z): 67 56 54 67>56 in 67>54 => 67>54: Pravilo tranzitivnosti velja.

14.1.9 Višine študentov

Uporabnik za tri študente vnese višino študentov. Program izpiše višine študentov po vrsti od največjega do najmanjšega.

Višina 1. študenta: 180 Višina 2. študenta: 185 Višina 3. študenta: 165 Urejene višine študentov: 185, 180, 165.

14.1.10 Program za telesno težo

Program za osebo izpiše ali ima premajhno telesno težo ali ima normalno telesno težo ali ima preveliko telesno težo. Uporabnik vnese višino v metrih in telesno težo v kilogramih. Glede na ta dva podatka se izračuna koeficient po formuli koeficient = teža / (višina * višina). Če je koeficient pod 18.5 => "premajhna teža", če je med 18.5 in 25.5 => "normalna teža", sicer pa je teža "prevelika teža".

Vnesi višino (metri) in težo osebe (kg): 1.72 64


Telesna teža je: normalna teža

14.1.11 Število pozitivnih in negativnih števil

Program za deset vnesenih celih števil izpiše število pozitivnih in število negativnih števil.

Vpiši 1. to število: 5 Vpiši 2. to število: -15 Vpiši 3. to število: 2.5 Vpiši 4. to število: 56 Vpiši 5. to število: 14 Vpiši 6. to število: -54 Vpiši 7. to število: -1.1 Vpiši 8. to število: 2 Vpiši 9. to število: -6 Vpiši 10. to število: 23 Število pozitivnih: 6 Število negativnih: 4

14.1.12 Izris pravokotnika

Program s pomočjo zvezdic izriše pravokotnik dimenzij a (število stolpcev) in b (število vrstic). Dimenzije vnese uporabnik.

Število stolpcev: 12 Število vrstic: 6 Lik: pravokotnik ************ ************ ************ ************ ************ ************

14.1.13 Izris pravokotnega trikotnika

Program s pomočjo zvezdic izriše pravokotni trikotnik. Uporabnik vnese višino trikotnika (število vrstic).

Višina trikotnika: 8 Lik: ******** ******* ****** ***** **** *** ** *


14.1.14 Izračun fakultete

Program za izračun fakultete vnesenega celega števila. Število vnese uporabnik. Izračun fakultete se izvaja dokler uporabnik na vprašanje "Želiš nadaljevati (D/N)?" ne odgovori z "N".

Vpiši celo število: 8 8! = 40320 Želiš nadaljevati (D/N): D Vpiši celo število: 4 4! = 24 Želiš nadaljevati (D/N): N

14.1.15 Tabela naključnih števil

Program v tabelo naključna ustvari 100 naključnih števil iz intervala od 50 do 500. Program iz tabele izpiše števila, ki so deljiva z 2 ali s 4 ali s 7 po 10 števil v posamezni vrstici. Na koncu izpiše še število teh števil.

180 232 240 456 498 126 54 208 92 60 62 441 490 214 152 66 184 310 392 88 166 164 92 413 316 464 150 312 308 116 192 474 266 390 278 490 222 436 268 210 208 236 110 142 392 315 316 368 306 208 175 290 390 Število naključnih števil, ki izpolnjujejo pogoj je 53.

14.1.16 Izračun obresti

Uporabnik vnese začetno stanje glavnice, obrestno mero (letno) in število let. Program po letih izpiše leto in stanje v tistem letu. Novo stanje za tekoče leto = začetno stanje * Math.pow(1.0 + obrestna mera, leto)

Začetno stanje glavnice: 500000 Obrestna mera: .06 Število let: 5 Leto Stanje na tekočem računu 1 530000.0000 2 561800.0000 3 595508.0000 4 631238.4800 5 669112.7888


14.1.17 Frekvenca pojavitev posameznih ocen študentov

Uporabnik vnaša ocene študentov dokler ne vnese 0. Program določi in izpiše frekvence pojavitev posameznih ocen.

Vpiši oceno med 6 in 10 (0 za konec): 7 Vpiši oceno med 6 in 10 (0 za konec): 8 Vpiši oceno med 6 in 10 (0 za konec): 7 Vpiši oceno med 6 in 10 (0 za konec): 9 Vpiši oceno med 6 in 10 (0 za konec): 7 Vpiši oceno med 6 in 10 (0 za konec): 3 Vnesena je bila napačna ocena. Vpiši oceno med 6 in 10 (0 za konec): 10 Vpiši oceno med 6 in 10 (0 za konec): 0 Frekvenca ocen: 6: 0 7: 3 8: 1 9: 1 10: 1

14.1.18 Izračun vsote členov zaporedja

Izračun vsote N členov zaporedja i * (i-1); i = 1 .. N Izpis vsebuje posamezne člene zaporedja. Uporaba zanke while.

Vpišite število členov zaporedja <N>: 6 1. člen zaporedja: 0 2. člen zaporedja: 2 3. člen zaporedja: 6 4. člen zaporedja: 12 5. člen zaporedja: 20 6. člen zaporedja: 30 Vsota je 70.

14.1.19 Praštevilo

Praštevilo je naravno število n > 1, če ima točno dva pozitivna delitelja (faktorja), število 1 in samega sebe kot edini prafaktor. Pri tem je 1 edini pravi delitelj tega števila. Po definiciji število 1 ni praštevilo. Število 2 je praštevilo. Množica prvih 25 pozitivnih praštevil: { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97 }. Uporabnik vpiše število, program izpiše ali je vpisano število praštevilo.

14.1.20 Števila iz območja, ki so deljiva s tri ali pet

Izpis števil iz območja odStevila do DoStevila, ki so deljiva s tri ali pet.

Primer izvajanja:


Od števila: 10 Do števila: 20 Deljiva števila so: 10, 12, 15, 18

14.1.21 Izris sinusne krivulje v besedilnem načinu

Izris krivulje sinusne funkcije v mejah med 0 in 360 stopinj (v navpični obliki). Uporabite konstante: final float pi = 3.14159; final char zvezdica = '*'; znak za izris krivulje final int skal_fakt = 20; faktor skaliranja final int min_kot = 0; začetni kot final int max_kot = 360; končni kot final int korak = 9; korak v stopinjah Uporabite metode za: 1. pretvorbo stopinj v radiane, 1. zaokroževanje realnega števila na N decimalnih mest. Primer izvajanja:

Kot Izris sinusne krivulje 0| * 0.0 9| * 0.16 18| * 0.31 27| * 0.45 36| * 0.59 45| * 0.71 54| * 0.81 63| * 0.89 72| * 0.95 81| * 0.99 90| * 1.0 99| * 0.99 108| * 0.95 117| * 0.89 126| * 0.81 135| * 0.71 144| * 0.59 153| * 0.45 162| * 0.31 171| * 0.16 180| * 2.5e-06 189| * -0.16 198| * -0.31 207| * -0.45 216| * -0.59 225| * -0.71 234| * -0.81 243| * -0.89 252| * -0.95


261| * -0.99 270| * -1.0 279| * -0.99 288| * -0.95 297| * -0.89 306| * -0.81 315| * -0.71 324| * -0.59 333| * -0.45 342| * -0.31 351| * -0.16 360| * -5.1e-06

14.1.22 Izris lika

izris lika iz primera izvajanja (besedilni način) z uporabo metod. Metoda: public static void izris_znak(int stevilo, char znak) - izris (izpis) določenega števila znakov na zaslon Primer izvajanja:

Vpiši dimenzijo lika <N>: 11 1. +++++*

2. ++++**

3. +++***

4. ++****

5. +*****

6. ***********

7. *+++++++++*

8. *+++++++++*

9. *+++++++++*

10. *+++++++++*

11. *+++++++++*

12. *+++++++++*

13. *+++++++++*

14. *+++++++++*

15. *+++++++++*

16. ***********

14.1.23 Prestopno leto

Metoda prestopnoLeto za leto določi, če je prestopno. Vhod: int leto Izhod: boolean (true - leto je prestopno, letno ni prestopno). Prestopno leto imenujemo leto s 366 dnevi, ki premore tudi 29. februar. Pravila za prestopno leto: 1. Leto je prestopno, če je deljivo s 4, razen ... 2. ... v primeru, da je leto deljivo s 100, leto ni prestopno, razen ...


3. ... v primeru, da je leto deljivo s 400, leto je prestopno. Npr. leto 2004 je prestopno (1. pravilo), leto 1900 ni prestopno (2. pravilo, navkljub 1. pravilu), leto 2000 je prestopno (3. pravilo).

14.1.24 Največji skupni delitelj

Metoda največjiSkupniDelitelj za dve celoštevilčni vrednosti vrne največji skupni delitelj teh dveh števil. Vhod: int stevilo1, int stevilo 2 Izhod: int (največji skupni delitelj).

14.1.25 Izpis trikotnika števil

Metoda izpisStevil za podano dimenzijo izpiše števila v obliki trikotnika (primer izpisa). Npr. izpisStevil(5): 1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1

14.1.26 Dan v tednu

Zellerjev algoritem za določitev dneva v tednu za kateri koli datum. Formula za gregorijanski koledar je: h = (q + ((m+1)*26 / 10) + K + K/4 + J/4 -2J ) ostanek po celoštevilčnem deljenju z 7 kjer je: h - dan v tednu (0 = sobota, 1 = nedelja, 2 = ponedeljek...) q - je dan v mesecu m - je mesec J - je stoletje (leto / 100) K - je leto v stoletju (leto ostanek po celoštevilčnem deljenju s 100) Januar in februar se štejeta kot 13. in 14. mesec prejšnjega leta. Metoda danVTednu Vhod: leto, mesec m (1 <= m <= 12) in dan d (1 <= d <= 31). Izhod: dan v tednu (0 .. 6).

14.1.27 Besedilni dokument

V preglednici ustvarite tabelo (10x10) naključnih števil iz območja med 100 in 10.000. Dokument shranite v CSV obliko besedilnega dokumenta z imenom "stevila.csv". Dokument stevila.csv odprite v beležnici in ga uredite tako, da bodo vsa števila v eni vrstici ločena s podpičjem in za zadnjim številom ni presledka ali prehoda v novo vrstico. Spremenjen dokument shranite v dokument "stevila.txt". Besedilni dokument "stevila.txt" predstavlja vir podatkov za metode: - vsotaStevil, - povprecjeStevil, - najvecjeStevilo, - najmanjseStevilo, - steviloSodihStevil, - izpisStevilTabela10x10.


14.1.28 Izpis lika

Metoda izpiše lik z določenim številom vrstic (slika).

štev

ec i

1 1 1 x x x x x x x 2 1 1 1 x x x x x x 3 x 1 1 1 x x x x x 4 x x 1 1 1 x x x x 5 x x x 1 1 1 x x x 6 x x x x 1 1 1 x x 7 x x x x x 1 1 1 x 8 x x x x x x 1 1 1 9 x x x x x x x 1 1

1 2 3 4 5 6 7 8 9 števec j

Metoda: izrisiLikX(int steviloVrstic) Klic metode: izrisiLikX(9)

14.1.29 Reverzni niz

Metoda vrne obrnjeno besedilo vhodnega parametra, ki je objekt razreda String. public static String obrniBesedilo (String besedilo) npr. klic obrniBesedilo ("besedilo") vrne vrednost "olideseb"

14.1.30 Število besed

Metoda vrne število besed vhodnega argumenta public static int steviloBesed (String besedilo) npr. klic steviloBesed ("dve besedi") vrne vrednost 2

14.1.31 Ločila

Metoda vrne število ločil vhodnega parametra public static int steviloLocil (String besedilo) npr. klic steviloLocil ("Stavek1. Stavek2? Stavek tri.") vrne vrednost 3

14.1.32 Meni

Ustvarite meni z možnostjo izbire in ponavljanja izvajanja zgornjih metod (reverzni niz, število besed, ločila).

14.1.33 Največja števka

Metoda vrne največjo števko oz. cifro celoštevilčnega vhodnega parametra. public static int najvecjaStevka (long stevilo) npr. klic najvecjaStevka (2831) vrne vrednost 8.


14.1.34 Binarna vrednost

Metoda vrne binarno vrednost celoštevilčnega parametra. public static String binarnaVrednost (int stevilo) npr. klic binarnaVrednost (10) vrne vrednost "1010"

14.1.35 Dolžina števila

Metoda vrne dolžino celoštevilčnega vhodnega parametra. public static int dolzinaStevila (long stevilo) npr. klic dolzinaStevila (156) vrne vrednost 3

14.1.36 Dan v tednu

Metoda glede na tabelo za številko dneva v tednu vrne besedilno vrednost dneva v tednu. public static String danTeden (int dan) npr. klic danTeden (2) vrne vrednost »torek«.

Dan v tednu (število) Dan v tednu (besedilo)

1 ponedeljek

2 torek

3 sreda

4 četrtek

5 petek

6 sobota

7 nedelja

14.1.37 Določitev ocene

Metoda glede na kriterij ocenjevanja in doseženo število točk vrne oceno. public static String ocenaIzpita (int tocke) npr. klic ocenaIzpita (60) vrne vrednost »db (7)«.

Točke od – do Ocena

0 - 49 nzd (5)

50-59 zd (6)

60-69 db (7)

70-79 pdb (8)

80-89 pdb (9)

90-100 odl (10)

14.1.38 Vsota števil deljivih s tri

Metoda vrne vsoto celih števil iz intervala odStevila do doStevila, ki so deljiva s 3. public static int vsotaOdDo1 (int odStevila, int doStevila) npr. klic vsotaOdDo1 (4,12) vrne vrednost 27


14.1.39 Vsota števil deljivih s pet ali sedem

Metoda vrne vsoto celih števil iz intervala odStevila do doStevila, ki so deljiva s 5 ali 7. public static int vsotaOdDo1 (int odStevila, int doStevila) npr. klic vsotaOdDo1 (4,12) vrne vrednost 22

14.1.40 Izpis angleške abecede v padajočem zaporedju

Metoda izpiše velike črke angleške abecede v padajočem vrstnem redu od Z do A. public static void izpisAngAbecede() npr. klic izpisAngAbecede() izpiše Z … C B A.

14.1.41 Izpis trikotnika števil

Metoda izpiše trikotnik z določenim številom vrstic (slika). public static void izpisTrikotnik1 (int steviloVrstic) npr. klic izpisTrikotnik1 (6) izpiše: 1 1 2 1 2 4 1 2 4 8 1 2 4 8 16 1 2 4 8 16 32

14.1.42 Izpis enakostraničnega trikotnika

Metoda izpiše trikotnik z določenim številom vrstic (slika). public static void izpisTrikotnik2 (int steviloVrstic) npr. klic izpisTrikotnik2 (6) izpiše: _X_X_X_X_X_X_ __X_X_X_X_X__ ___X_X_X_X___ ____X_X_X____ ______X_X____ _______X_____

14.1.43 Produkt lihih števil

Metoda vrne produkt lihih celih števil iz intervala odStevila do doStevila. public static int produktOdDo1 (int odStevila, int doStevila) npr. klic produktOdDo1 (8,11) vrne vrednost 99

14.1.44 Vsota inverznih števil

Metoda vrne vsoto inverznih vrednosti celih števil iz intervala odStevila do doStevila. 1 + 1/2 + 1/3 + 1/4 + 1/5 + 1/6 + 1/7 public static double vsotaInveznaOdDo1 (int odStevila, int doStevila) npr. klic vsotaInveznaOdDo1 (2,6) vrne vsoto 1/2 + 1/3 + 1/4 + 1/5 + 1/6


14.1.45 Vsota števil z enako prvo in zadnjo števko

Metoda vrne vsoto celih števil iz intervala odStevila do doStevila, ki imajo enako prvo in zadnjo cifro oz. števko. public static int vsotaOdDo2 (int odStevila, int doStevila) npr. klic vsotaOdDo2 (10,13) vrne vrednost 11

14.1.46 Polje realnih števil

Enodimenzionalna tabela realnih števil. Program naj vsebuje metode: za vnos realnih števil v enodimenzionalno tabelo (največ 100 števil), izpis elementov tabele, inicializacijo tabele, izračun povprečne vrednosti elementov v tabeli, indeks in vrednost največjega elementa v tabeli, meni. Primer izvajanja:

1 - inicializacija 2 - vnos 3 - izpis 4 - povprečje 5 - največje število 0 - konec

Število elementov tabele: 5 Vnos elementov Vnesi 1. element: 5 Vnesi 2. element: 7 Vnesi 3. element: 3 Vnesi 4. element: 8 Vnesi 5. element: 9 Povprečna vrednost je: 6.4 Največje število je: 9

14.1.47 Frekvenca pojavitev metov kocke

Program naključno ustvari N metov kocke. Meti se shranjujejo v enodimenzionalno tabelo (polje). Z uporabo dodatne tabele izračunajte frekvenco pojavitev posameznih metov. Primer izvajanja:

Število metov kocke: 100 Pike kocke Frekvenca 1 10 2 19 3 22 4 12 5 20 6 17


14.1.48 Ustvarjanje in izpis šahovnice

Program za izpis šahovnice z znakoma '_ ' in 'X' za vnešeno dimanzijo N. Šahovnico shranite v dvodimenzionalno tabelo in jo nato izpišite. Uporabite metodi: ustvari vrednosti tabele, izpis tabele. Primer izvajanja:

Vnesite velikost šahovnice: 8 _ X _ X _ X _ X X _ X _ X _ X _ _ X _ X _ X _ X X _ X _ X _ X _ _ X _ X _ X _ X X _ X _ X _ X _ _ X _ X _ X _ X X _ X _ X _ X _

14.1.49 Kocka naključnih števil

Program za delo s trodimenzionalno tabelo dimenzije N (predstava - kocka). Metode: inicializacija tabele z ničlami (vse podatke postavi na vrednost 0), inicializacija tabele z naključnimi vrednostmi (cela števila iz intervala od 10 do 100), vsota posameznih ploskev (plošč) kocke, postavitev števila ena (1) na diagonale vseh ploskev, postavitev števila ena (1) na zunanje robove kocke, izpis podatkov kocke (po posameznih površinah), meni. Primer izvajanja:

Primer izvajanja: 1 - inicializacija (0) 2 - inicializacija (naključna vrednosti med 10 in 100) 3 - izpis po površinah 4 - vsota posameznih površin 5 - postavi telesne diagonale ploskev na 1 6 - postavi zunanje robove ploskev na 1 0 - konec Izbor: 3 Ploskev 1: 52 70 50 28 81 25 80 66 32 53 38 19 19 97 90 79 51 68 55 18 17 87 29 38 15 Ploskev 2: 85 63 52 20 41 26 75 52 86 12 82 14 54 38 80 11 16 41 28 67


70 17 14 18 49 Ploskev 3: 37 34 18 66 35 19 67 79 16 62 81 59 34 70 46 14 41 17 86 99 84 38 27 87 78 Ploskev 4: 12 49 61 95 92 57 72 22 66 77 42 26 29 61 48 33 87 36 11 44 20 59 85 54 25 Ploskev 5: 57 71 37 72 34 69 91 55 56 35 32 92 43 47 40 58 54 90 55 28 42 28 78 31 46 Za nadaljevanje pritisni katerokoli znak ... Izbor: 6 Izbor: 3 Ploskev 1: 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 Ploskev 2: 1 1 1 1 1 1 75 52 86 1 1 14 54 38 1 1 16 41 28 1 1 1 1 1 1 Ploskev 3: 1 1 1 1 1 1 67 79 16 1 1 59 34 70 1 1 41 17 86 1 1 1 1 1 1 Ploskev 4: 1 1 1 1 1 1 72 22 66 1 1 26 29 61 1 1 87 36 11 1 1 1 1 1 1 Ploskev 5: 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 Za nadaljevanje pritisni katerokoli znak ... Izbor: 2 Izbor: 4


Vsota ploskve 1: 1343 Vsota ploskve 2: 1339 Vsota ploskve 3: 1447 Vsota ploskve 4: 1501 Vsota ploskve 5: 1476 Za nadaljevanje pritisni katerokoli znak ...

14.1.50 Evidenca študentov

Program za vnos in izpis podatkov za posameznega študenta: številka indeksa, ime, priimek, datum, mesec in leto rojstva Primer izvajanja

Vnos podatkov o študentu: Številka indeksa: 56487456 Ime: Tine Priimek: Kovač Datum rojstva - dan: 12 Datum rojstva - mesec: 6 Datum rojstva - leto: 1972 Izpis podatkov o študentu: Številka indeksa: 56487456 Ime: Tine Priimek: Kovač Datum rojstva - dan: 12 Datum rojstva - mesec: 6 Datum rojstva - leto: 1972

14.1.51 Evidenca višin oseb

Program naj omogoča: dodajanje osebe: vnos imena, priimka in višine osebe v enodimenzionalno tabelo, brisanje oseb iz tabele, ki izpolnjujejo vnesen kriterij (ime, priimek), izpis vsebine tabele na zaslon, izpis (filtriranje) tabele občanov glede na vnesen kriterij (ime, priimek), urejanje tabele, izbor možnosti v meniju. Primer izvajanja

1 - dodajanje osebe v tabelo 2 - brisanje po kriteriju


3 - izpis vseh oseb 4 - izpis oseb po kriteriju 5 - uredi osebe po višini (padajoče) 0 - Izbor: 1 Vnos podatkov o osebi: Ime: Tine Priimek: Kotnik Višina: 180 ------------------------------------------------ Izbor: 1 Vnos podatkov o osebi: Ime: Ana Priimek: Dovnik Višina: 165 ------------------------------------------------ Izbor: 1 Vnos podatkov o osebi: Ime: Jure Priimek: Naklov Višina: 190 ------------------------------------------------ Izbor: 5 ------------------------------------------------ Izbor: 2 Vnos kriterija za brisanje oseb: Ime: Jure Priimek: Naklov ------------------------------------------------ Izbor: 3 Podatki o 1. osebi: Izpis podatkov o osebi: Ime: Tine Priimek: Kotnik Višina: 190 ------------------------------------------------ Podatki o 2. osebi: Izpis podatkov o osebi: Ime: Ana Priimek: Dovnik Višina: 180 Izbor: 0

14.1.52 Urejenje števil v tabeli

Program za urejanje enodimenzionalne tabele realnih števil. Metode: urejanje z izborom najmanjšega elementa, urejanje z mehurčnim urejanjem, urejanje z vstavljanjem, binarno iskanje določenega elementa,


urejanje z binarnim vstavljanjem, meni za izbor.

15 LITERATURA

1. Deitel, Paul and Harvey. Java: How to Program, Ninth Edition. 2. Mahnič, Viljan, Fürst, Luka,Rožanc, Igor: Java skozi primere, Bi-tim, 2008. 3. Mesojedec, Uroš, Fabjan, Borut: Java 2: Temelji programiranja, Ljubljana : Pasadena, 2004. 4. Farrell J.: Java Programming, Third Edition, Thomson Course Technology, 2006. 5. Morelli R.: Java, Java, Java: Object-oriented problem solving, Prentice hall, 2000. 6. McLaughlin B. in Flanagan D.: Java 1.5 Tiger, O'Reilly Media, Inc., 2004. 7. Eckel B.: Thinking in Java, Prentice Hall PTR, 1998. 8. The Java Tutorial, http://java.sun.com/docs/books/tutorial/index.html (5. 2. 2015). 9. Tutorialspoint Java Tutorial, http://www.tutorialspoint.com/java (5. 2. 2015). 10. James L. Weaver ... [et al.] , Pro JavaFX 2 [Elektronski vir] : Definitive guide to rich clients with Java technology,

[New York : Apress], cop. 2012.

Documents

PROGRAMI RANJE (1. letnik) JAVA - scv.si · 2015. 3. 11. · 6.5 Break in continue stavek 56 6.5.1 Break stavek 56 6.5.2 Continue stavek 57 6.5.3 Primeri 57 7 METODE 60 7.1.1 Deklaracija