Kazalo
Zgradba programa
Prevajanje
Napake
Spremenljivke
Deklaracija, definicija
Prireditveni stavek
Izrazi in operatorji
Stavki
Prazen stavek
Običajen stavek
Sestavljeni stavek
Java Application
Izpisovanje na zaslon
Branje s tipkovnice
Java Applet
Risanje
Cela števila
Znaki
Osnovne operacije nad celimi števili
Primeri
Realna števila
Osnovne operacije nad realnimi števili
Logične vrednosti
Osnovne operacije nad logičnimi
vrednostmi
Operacije, katerih rezultat so logične
vrednosti
Primer: Pozdrav
Primer: Racun
Primer: Simbol
Primer: Risanje
Primer: Obrat
Primer: Matematika
Primer: Deljenje
Primer: Delez
Primer: Yard
Primer: Prestopno
Odlocitve
Pogojni izraz
Pogojni stavek
Primer: Premici
Primer: Pravokotnik
Primer: Kompleksno
Zanke
Zanka while
Primer: deljitelj
Vaje: zanke
Zgradba programa
Program, napisan v programskem jeziku Java, je sestavljen iz definicij enega ali več razredov. Podrobnosti o razredih trenutno niso pomembne, omenimo samo naslednje:
- Razred je zaključen del programa, ki vsebuje podatke in metode.
- Razred je lahko javen, privaten ali zaščiten.
- Razred mora imeti svoje ime.
Prazen javen razred z imenom Razred bi definirali takole:
public class Razred
{
}
Definicije razredov zapišemo na eno ali več datotek s končnico java. Na eni datoteki lahko definiramo več razredov, definicije posameznega razreda pa ne smemo razbiti na več datotek. Če imamo na eni datoteki več razredov, je največ eden izmed njih je lahko javen. Če imamo na datoteki javen razred, mora biti ime datoteke enako imenu javnega razreda. Pri tem so pomembne tudi male in velike črke. Definicijo javnega razreda z imenom Razred moramo torej shraniti na datoteko z imenom Razred.java.
Ime razreda je lahko sestavljeno iz poljubnih črk, števk in nekaterih posebnih znakov, pri čemer prvi znak ne sme biti števka. Priporočljivo je, da ime razreda nakazuje, čemu je ta razred namenjen (kaj naj bi program počel). Ime razreda običajno pričnemo z veliko začetnico, če pa je sestavljeno iz več besed, jih napišemo skupaj (ime ne sme vsebovati presledka) in vsako besedo pričnemo z veliko začetnico.
Prevajanje
Prevajanje programa je v bistvu prevajanje definicij razredov v računalniku bolj razumljivo obliko. Prevajanje sprožimo iz ukazne vrstice z ukazom javac, ki mu damo za parametre imena tistih datotek, ki jih je potrebno prevesti (te datoteke imajo vse končnico java). Zgornji program, sestavljen iz definicije razreda Razred, ki je zapisana na datoteki Razred.java, bi torej prevedli z ukazom
> javac Razred.java
Če pa bi želeli prevesti vse datoteke s končnico java v trenutni mapi, bi to storili takole
> javac *.java
Če prevajalnik v programu najde kakšno sintaktično (slovnično) napako, nas nanjo opozori. Ko napake odpravimo, moramo program prevesti znova. Ko prevajalnik v programu ne najde več nobenih napak, dobimo za vsak definiran razred novo datoteko z imenom razreda in končnico class. Te datoteke vsebujejo prevedene definicije razredov. V našem primeru bi torej dobili datoteko Razred.class.
Napake
Recimo, da smo pretipkali in shranili zgornji program, le ime razreda smo po pomoti napisali z malo začetnico, tako da se ne ujema z imenom datoteke. Prevajalnik nas na napako opozori tako, da izpiše ime datoteke, dvopičje, številko vrstice, v kateri je prišlo do napake, ter še eno dvopičje, ki mu sledi opis napake. V drugi vrstici izpiše celotno vrstico, v kateri je prišlo do napake, v tretji vrstici pa z znakom ^ označi mesto v vrstici, kjer je odkril napako.
> javac Razred.java
Razred.java:1: class razred is public, should be declared in a file named razred.java
public class razred
^
1 error
Če bi v programu pozabili zaviti zaklepaj na koncu, bi se prevajalnik pritožil takole:
> javac Razred.java
Razred.java:2: '}' expected
{
^
1 error
Nekatere napake imajo lahko za posledico še več drugih napak. Zato so včasih seznami napak tudi precej dolgi. Napake je vedno priporočljivo odpravljati po vrsti, saj se pogosto zgodi, da ko odpravimo prvo napako, avtomatsko odpravimo še nekatere druge.
Ko se nam program prevede brez napak, pa to še ne pomeni, da bo deloval pravilno. Pri programiranju namreč pogosto delamo tudi semantične (logične) napake, ki pa jih prevajalnik ne more odkriti.
Spremenljivke
Vrednosti, ki jih izračunamo med izvajanjem programa, in jih bomo kasneje v programu še potrebovali, shranjujemo v spremenljivke. Vsaka spremenljivka v Javi ima tip, ime in vrednost.
Ime spremenljivke je lahko sestavljeno iz poljubnih črk, števk, ter nekaterih posebnih znakov (podčrtaj, dolar, ...), pri čemer prvi znak imena ne sme biti števka. Java ločuje med malimi in velikimi črkami, zato so imena stevec, Stevec in STEVEC imena treh različnih spremenljivk. Običajno pišemo imena spremenljivk z malimi črkami, če pa je ime sestavljeno iz več besed, jih napišemo skupaj (ime spremenljivke ne sme vsebovati presledka) in vsako besedo (razen prve) napišemo z veliko začetnico, na primer leviSosed, barvaOzadja ali steviloModrihKock. Imena spremenljivk so lahko poljubno dolga, a pretiravati ni priporočljivo (20 znakov je običajno več kot dovolj). Izbrano ime za spremenljivko naj bo smiselno, tako da lahko že iz imena sklepamo, kakšna je vloga spremenljivke v programu.
Tip spremenljivke določa, kakšne vrste vrednosti bomo hranili v njej (cela števila, realna števila, logične vrednosti, ...). Tipe delimo na:
- osnovni tipi
- sklicni tipi
V spremenljivki osnovnega tipa lahko hranimo samo eno vrednost. Obstaja več tipov celih števil. Najpogosteje bomo uporabljali tipa int in char (slednji je namenjen za shranjevanje znakov). Prav tako obstaja več tipov realnih števil. Uporabljali bomo predvsem tip double. Tip za shranjevanje logičnih vrednosti se imenuje boolean.
V spremenljivki sklicnega tipa lahko hranimo več vrednosti. V tabelah hranimo vrednosti enakega tipa, v objektih pa vrednosti, ki so lahko različnih tipov.
Deklaracija, definicija
Vsako spremenljivko, ki jo uporabimo v programu, moramo najprej napovedati (deklarirati). Pri deklaraciji ji določimo tip in ime, lahko pa ji predpišemo tudi začetno vrednost. Deklaraciji, kjer spremenljivki predpišemo začetno vrednost, rečemo tudi definicija.
int ocena; // deklaracija celoštevilske spremenljivke ocena
double polmer = 14.631; // definicija realne spremenljivke polmer
Z eno samo deklaracijo lahko napovemo tudi več spremenljivk, pri čemer lahko vsem, samo nekaterim ali pa nobeni določimo začetno vrednost. Kot začetno vrednost spremenljivke lahko napišemo poljuben izraz, katerega vrednost je ustreznega tipa. V takem izrazu lahko uporabimo tudi druge spremenljivke, ki že imajo vrednost.
int x, y, z;
int dolzina = 5, sirina = 7, visina = 2 + 6;
int prostornina = dolzina * sirina * visina
Prireditveni stavek
Ko je znan tip spremenljivke, ji lahko dodelimo vrednost. To je sicer možno storiti že pri deklaraciji, lahko pa to storimo tudi kasneje (spremenljivki je tako možno vrednost tudi spremeniti). Stavku, s katerim spremenljivki dodelimo ali spremenimo vrednost, rečemo prireditveni stavek. Zapišemo ga tako kot definicijo spremenljivke, le brez tipa na začetku (ker je tip znan že od prej).
dolzina = 2;
sirina = dolzina + 3
Prej smo vrednost spremenljivke prostornina definirali kot produkt vrednosti spremenljivk dolzina, sirina in visina. Čeprav smo zdaj spremenljivkama dolzina in sirina spremenili vrednost, se vrednost spremenljivke prostornina s tem ni spremenila. Ob dodelitvi vrednosti spremenljivki namreč ta ne ve, kako je bila vrednost izračunana in od katerih spremenljivk je bila odvisna. Če želimo, da bo prostornina spet vsebovala pravilno prostornino, jo moramo ponovno izračunati.
Poglejmo si še en primer:
int x = 1;
x = x + 1
Pri definiciji spremenljivke x smo ji dodelili vrednost 1. V prireditvenem stavku v drugi vrstici pa smo vzeli vrednost spremenljivke x, jo povečali za 1 in dobljeno vrednost zapisali nazaj v spremenljivko x. Povedano krajše: vrednost spremenljivke x smo povečali za 1. Takšni in podobni prireditveni stavki so v Javi tako pogosti, da so Javi dodali posebne operatorje, s pomočjo katerih jih lahko krajše zapišemo (spoznali jih bomo kasneje).
Izrazi in operatorji
Med programiranjem moramo večkrat zapisati stavek, ki dano spremenljivko poveča ali zmanjša za neko vrednost, ali pa jo pomnoži ali deli z neko vrednostjo. Vse to lahko naredimo z običajnim prireditvenim stavkom, lahko pa uporabimo posebne prireditvene operatorje, ki nam to omogočajo zapisati malo krajše.
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 |
Pogostokrat je potrebno vrednost neke spremenljivke povečati za 1. Poznamo že dva načina, kako to storiti (navaden ali poseben prireditveni operator), lahko pa uporabimo operator ++, ki ga lahko napišemo pred ali za imenom spremenljivke. Naslednji štirje stavki so torej ekvivalentni.
x = x + 1;
x += 1;
x++;
++x
Podobno velja tudi za zmanjševanje vrednosti spremenljivke za 1.
x = x - 1;
x -= 1;
x--;
--x
Če smo čisto natančni, ni vedno vseeno, ali operator ++ ali -- napišemo pred ali za imenom spremenljivke. Učinek na spremenljivko je vedno enak (povečanje ali zmanjšanje vrednosti za 1). Razlika je v vrednosti tega izraza, ki je zelo pomembna, kadar ga uporabimo kot del nekega večjega izraza. Če operator napišemo pred imenom spremenljivke, je vrednost izraza enaka novi vrednosti spremenljivke, če pa operator napišemo za imenom spremenljivke, je vrednost izraza enaka prvotni vrednosti spremenljivke.
int x = 1;
int a = x++; // a = 1, x = 2
int b = ++x; // b = 3, x = 3
Vsak izraz ima vrednost. Tudi prireditveni stavek je pravzaprav samo izraz, v katerem uporabimo prireditveni operator. Zato ima tudi prireditveni stavek svojo vrednost, in sicer vrednost, ki jo priredimo spremenljivki. To lahko izkoristimo in prireditveni stavek uporabimo kot del večjega izraza. Nekaj primerov:
x = y = z = 0; // x = 0, y = 0, z = 0
a = (b += 2) + 1; // b povecamo za 2, a = b + 1
Stavki
Videli smo že, da je program v Javi sestavljen iz definicij enega ali več razredov, vsak razred je sestavljen iz definicij njegovih komponent in metod, vsaka metoda pa je sestavljena iz zaporedja programskih stavkov.
Prazen stavek
Prazen stavek je stavek, ki ga ni. Največrat ga uporabljamo pri zankah, kadar je telo zanke prazno. Prazen stavek mora biti zaključen s podpičjem.
;
Običajen stavek
Stavek vedno zaključimo s podpičjem.
stavek
Sestavljeni stavek
Sestavljeni stavek ali blok je zaporedje več stavkov, ki jih zapišemo v zavitih oklepajih. Sestavljeni stavek največkrat uporabljamo kot telo pogojnega stavka ali zanke. Za zavitim zaklepajem ne pišemo podpičja.
{
stavek1;
stavek2;
stavek3;
}
Java Application
Java Application je običajen program, napisan v programskem jeziku Java. Povsod v nadaljevanju bomo takšnemu programu rekli preprosto program. Tak program sam od sebe ne stori skoraj ničesar. Uporabniku ob zagonu ponudi možnost uporabe znakovnega okna, kamor lahko vnaša podatke in izpisuje rezultate. Za vse drugo (uporaba grafičnih oken in podobno) se mora programer posebej potruditi in to sprogramirati.
Ogrodje programa je zelo preprosto. Sestaviti moramo definicijo javnega razreda in v njem definirati javno statično metodo z imenom main.
public class JavaApplication
{
public static void main(String[] args)
{
}
}
Poglejmo si podrobnosti. Program, zapisan na datoteki JavaApplication.java, je sestavljen iz javnega (public) razreda (class) z imenom JavaApplication, ki vsebuje javno (public) statično (static) metodo z imenom main. Ta dobi za parameter tabelo nizov (String[]) z imenom args in ne vrača nobenega rezultata (void). Metoda main običajno vsebuje stavke, ki se izvedejo, ko poženemo program. V zgornjem primeru takih stavkov ni, torej program ne bo naredil ničesar.
Ko se program prevede brez napak, ga lahko poženemo. To storimo spet iz ukazne vrstice z ukazom java, ki mu damo za parameter ime tistega razreda, ki vsebuje metodo main (v našem primeru je to razred JavaApplication).
> javac JavaApplication.java
> java JavaApplication
Zapomnimo si osnovni postopek izdelave programa v Javi:
- Napišemo program in ga shranimo v datoteke s končnico java
- Program prevedemo s prevajalnikom javac, ki izdela datoteke s končnico class
- Program poženemo s tolmačem java
Izpisovanje na zaslon
Na standardni izhod (znakovno okno) izpisujemo s pomočjo metode print objekta out iz razreda System. Izpisujemo lahko števila, znake, nize (zaporedja znakov), logične vrednosti in objekte.
System.out.print(153); // izpis celega števila
System.out.print(-12.345); // izpis realnega števila
System.out.print("Pozdrav"); // izpis niza
System.out.print('A'); // izpis znaka
Metoda print izpiše podatek, ki ga dobi za parameter, na tisto mesto na zaslonu, kjer se trenutno nahaja kurzor. Stranski učinek izpisovanja je premik kurzorja za toliko mest naprej, kolikor znakov je metoda izpisala. Naslednja metoda print bo torej pričela izpisovati tam, kjer je prejšnja končala.
Poleg metode print pozna Java še metodo println, ki tudi izpiše podatek, ki ga dobi za parameter, ima pa še dodaten učinek: po izpisu zadnjega znaka izpiše še znak za skok v novo vrsto. Tako lahko izpis vsaj malo oblikujemo. Metoda println ima še posebno obliko brez parametra. Ta izpiše samo znak za skok v novo vrsto. Pravila lepega programiranja pravijo, da se spodobi zadnjo izpisano vrstico vedno zaključiti s skokom v novo vrsto.
System.out.println(153); // izpis celega števila + skok v novo vrsto
System.out.println(-12.345); // izpis realnega števila + skok v novo vrsto
System.out.println("Pozdrav"); // izpis niza + skok v novo vrsto
System.out.println('A'); // izpis znaka + skok v novo vrsto
System.out.println(); // skok v novo vrsto
Poleg konkretnih podatkov lahko metodama print in println damo za parameter poljuben izraz, katerega vrednost je število, znak, niz, logična vrednost ali objekt. Metodi izpišeta vrednost izraza. Razlika med spodnjima klicema je torej precejšnja.
System.out.print("1 + 2"); // izpis niza
System.out.print(1 + 2); // izpis vrednosti izraza
Omenimo še eno možnost, ki nam lahko precej skrajša programe. Z enim samim klicem metode print ali println lahko izpišemo tudi več podatkov enega za drugim. Našteti jih moramo v takem vrstnem redu, kot jih želimo izpisati, ločiti pa jih moramo s plusom (operator za seštevanje). Edina omejitev je, da mora biti prvi ali drugi sumand niz.
System.out.println(dan + "." + mesec + '.' + leto); // izpis datuma
System.out.println("1 + 2 = " + (1 + 2)); // izpis izraza z vrednostjo
Operator + deluje kot stik nizov, pri čemer vsak podatek, ki ni niz, naprej pretvori v niz. Tako pri izpisu datuma številko dneva najprej pretvori v niz in doda piko, nato doda številko meseca, še eno piko in na koncu še številko leta. Vse skupaj izpiše kot niz.
Pri izpisu vrednosti izraza je bilo potrebno postaviti oklepaje okoli izraza, sicer bi k nizu najprej dodal prvi sumand in nato še drugega (tako bi nizu dodal števki 1 in 2 eno za drugo). Če postavimo oklepaje, bo najprej izračunal vrednost izraza in rezultat 3 dodal k nizu.
Branje s tipkovnice
Nikoli ni lepo pisati programov, ki delujejo samo za neke konkretne podatke. Če bi želeli program preizkusiti pri drugačnih podatkih, bi morali podatke spremeniti v programu, morda celo spremeniti postopek delovanja, program ponovno prevesti in pognati. Primer takega programa smo videli v poglavju o spremenljivkah (primer Zamenjava).
Veliko uporabnejši so bolj splošni programi, ki delujejo pri poljubnih vhodnih podatkih, seveda pa moramo na začetku programa nekako priskrbeti konkretne podatke. Možnosti je več, zaenkrat si bomo ogledali način, kako podatke vnesemo preko standardnega vhoda (vtipkamo med izvajanjem programa). Programa tako ne bo treba ponovno prevajati pri vsakem novem preizkusu na drugih podatkih.
Da bi med izvajanjem programa lahko brali podatke s standardnega vhoda, bo v ogrodju programa potrebnih nekaj dopolnitev. Te dopolnitve so skupaj s primeroma, kako preberemo celo in realno število, prikazane na spodnjem primeru.
import java.io.*;
public class JavaApplicationVhod
{
public static void main(String[] args) throws IOException
{
BufferedReader vhod = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Vnesi celo stevilo: ");
int celo = Integer.parseInt(vhod.readLine());
System.out.print("Vnesi realno stevilo: ");
double realno = Double.parseDouble(vhod.readLine());
}
}
Podrobnosti o tem ogrodju nas zaenkrat ne bodo zanimale, vseeno pa na kratko razložimo pomen posameznih novosti. Na vrhu programa smo s stavkom import napovedali, da bomo v programu uporabljali nekatere razrede iz paketa java.io (io je kratica za Input/Output). V programu smo uporabili tri razrede iz tega paketa: IOException, BufferedReader in InputStreamReader. Razredi System, String, Integer in Double so del paketa java.lang, ki pa ga prevajalnik vključi avtomatsko.
Pri vnosu podatkov lahko pride do raznih napak, na primer vnos podatka, ki ni pravilnega tipa (program pričakuje celo število, uporabnik pa vpiše realno ...). Ker se s takimi napakami zaenkrat ne želimo ukvarjati, smo pri deklaraciji metode main pripisali besedi throws IOException. S tem smo označili, da metoda main ne poskrbi za obnašanje programa v primeru takih napak.
Prvi stavek v metodi main je definicija objekta vhod, ki bo programu služil kot vir podatkov, ki jih bomo vnašali. Podrobnosti o tej definiciji pustimo za kdaj kasneje.
Sledita še dva para stavkov. S prvim preberemo vrednost celoštevilske, z drugim pa vrednost realne spremenljivke. V obeh primerih najprej na zaslon izpišemo navodilo uporabniku, kaj mora vpisati. Ker smo uporabili metodo print, bo kurzor počakal v isti vrstici. Za dvopičjem smo izpisali še en presledek, da podatek, ki ga bomo vpisali, ne bo staknjen z njim. Ob klicu metode readLine program počaka, da vnesemo podatek in pritisnemo tipko Enter, nato pa ga pretvori v celo oziroma realno število.
Java Applet
Java Applet je posebne vrste program, napisan v programskem jeziku Java. Povsod v nadaljevanju mu bomo rekli preprosto applet. Applet moramo vgraditi na spletno stran (v datoteko HTML), kjer se potem izvaja oziroma riše znotraj dodeljenega grafičnega področja. Applet ima tudi možnost izpisa v znakovno okno, ki pa ga uporabnik ne vidi, dokler v brskalniku ne zahteva njegovega prikaza.
Ogrodje appleta je malo bolj zapleteno, kot je bilo ogrodje programa. Spet moramo sestaviti definicijo javnega razreda, v njem pa definirati javno metodo z imenom paint.
import java.applet.*;
import java.awt.*;
public class JavaApplet extends Applet
{
public void paint(Graphics g)
{
}
}
Applet, zapisan na datoteki JavaApplet.java, je sestavljen iz javnega (public) razreda (class) z imenom JavaApplet, 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. V zgornjem primeru takih stavkov ni, torej applet ne naredi ničesar.
Razreda Applet in Graphics sta že definirana. Java namreč vsebuje preko 2500 razredov, ki jih lahko uporabljamo v svojih programih. Da ob tako velikem številu razredov ne bi bilo prevelike zmede, so razredi razporejeni v nekaj skupin oziroma paketov. Tako razred Applet pripada paketu java.applet, razred Graphics pa paketu java.awt. Vsak uporabljen vgrajen razred moramo na vrhu datoteke vključiti z ukazom import. Izjema so samo razredi iz paketa java.lang, ki so že avtomatsko vključeni. Ker pa bomo pri pisanju programa verjetno potrebovali še kakšen drug razred, vključimo kar vse razrede iz teh dveh paketov (namesto imena razreda za imenom paketa napišemo zvezdico).
Ko se program prevede brez napak, moramo sestaviti še datoteko HTML, kamor bomo ta applet vključili. Značka za vključitev appleta v HTML se imenuje applet in ima tri obvezne parametre. S parametroma width in height določimo velikost pravokotnega področja, ki bo na volju appletu, s parametrom code pa določimo, na kateri datoteki je prevod razreda, ki je podrazred razreda Applet (v našem primeru je to datoteka JavaApplet.class).
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN">
<html>
<head>
<title>JavaApplet</title>
</head>
<body>
<applet width="600" height="400" code="JavaApplet.class">
</applet>
</body>
</html>
Izdelano datoteko HTML si lahko ogledamo s poljubnim brskalnikom, ki ima vgrajeno podporo za Javo (takšni so zdaj že skoraj vsi brskalniki). Lahko pa applet poženemo tudi iz ukazne vrstice z ukazom appletviewer, ki mu damo za parameter ime datoteke HTML, kamor smo applet vključili (v našem primeru je to datoteka JavaApplet.html).
> javac JavaApplet.java
> appletviewer JavaApplet.html
Zapomnimo si osnovni postopek izdelave appleta v Javi:
- Napišemo applet in ga shranimo v datoteke s končnico java
- Napišemo datoteko HTML, kamor vključimo applet
- Applet prevedemo s prevajalnikom javac, ki izdela datoteke s končnico class
- Datoteko HTML si ogledamo s poljubnim brskalnikom ali pa s pregledovalnikom appletviewer
Risanje
V appletu imamo znotraj metode paint na razpolago grafični objekt g, ki nam omogoča osnovno risanje v grafično okno. Vse metode za risanje uporabljajo koordinatni sistem, kjer je izhodišče v vogalu levo zgoraj. Koordinate x naraščajo proti levi, koordinate y pa navzdol. Poglejmo si nekaj osnovnih metod za risanje, druge podrobnosti pa so zbrane v dokumentaciji razreda Graphics.
g.drawString(besedilo, x, y)
Metoda drawString nariše besedilo besedilo. Položaj besedila je določen s koordinatama x in y. Ta točka določa, kje se prične vodoravna črta (osnovnica), nad katero bo izpisano besedilo. Na sliki je beseda "abcdefghij" izpisana na mesto (5, 15).
g.drawLine(x1, y1, x2, y2)
Metoda drawLine nariše ravno črto od točke (x1, y1) do točke (x2, y2). Na sliki je prikazana črta med točkama (10, 70) in (110, 20).
g.drawRect(x, y, širina, višina)
g.fillRect(x, y, širina, višina)
Metoda drawRect nariše rob, metoda fillRect pa notranjost pravokotnika. Pravokotnik je podan z levim zgornjim ogliščem (x, y), širino širina in višino višina. Stranice pravokotnika so vzporedne s koordinatnima osema. Na sliki je pravokotnik s podatki (10, 10, 30, 20) in pobarvani pravokotnik s podatki (60, 10, 30, 20).
g.drawOval(x, y, širina, višina)
g.fillOval(x, y, širina, višina)
Metoda drawOval nariše elipso, metoda fillOval pa njeno notranjost. Elipsa je podana s podatki o pravokotniku, v katerega je včrtana, torej z levim zgornjim ogliščem (x, y), širino širina in višino višina. Stranice očrtanega pravokotnika in osi elipse so vzporedne s koordinatnima osema. Na sliki je elipsa s podatki (10, 10, 30, 20) in pobarvana elipsa s podatki (60, 10, 30, 20).
g.drawRoundRect(x, y, širina, višina, rx, ry)
g.fillRoundRect(x, y, širina, višina, rx, ry)
Metoda drawRoundRect nariše rob, metoda fillRoundRect pa notranjost pravokotnika z zaobljenimi vogali. Pravokotnik je podan z levim zgornjim ogliščem (x, y), širino širina in višino višina. Stranice pravokotnika so vzporedne s koordinatnima osema. Parametra rx in ry sta premera elipse, s katero dosežemo učinek zaobljenosti. Na sliki je pravokotnik z zaobljeni vogali s podatki (10, 10, 30, 20, 20, 10) in pobarvani pravokotnik z zaobljenimi vogali s podatki (60, 10, 30, 20, 20, 10).
g.drawArc(x, y, širina, višina, kot, dolžina)
g.fillArc(x, y, širina, višina, kot, dolžina)
Metoda drawArc nariše eliptični lok, metoda fillArc pa eliptični izsek. Lok in izsek sta podana s podatki o elipsi oz. pravokotniku, v katerega je ta elipsa včrtana, torej z levim zgornjim ogliščem (x, y), širino širina in višino višina. Stranice očrtanega pravokotnika in osi elipse so vzporedne s koordinatnima osema. Parameter kot določa začetni kot loka v stopinjah, parameter dolžina pa dolžino loka (spet v stopinjah). Na sliki je eliptični lok s podatki (10, 10, 50, 40, 45, 225) in eliptični izsek s podatki (80, 10, 50, 40, 45, 225).
g.setColor(barva)
Metoda setColor nastavi barvo, s katero rišejo druge grafične metode. Barva ostane nastavljena, dokler je ne spremenimo z naslednjim klicem te metode. Če barve pred risanjem ne nastavimo, bodo liki narisani v črni barvi. Za barvo lahko vpišemo njeno ime (glej spodnjo tabelo) ali pa sestavimo mešanico različnih deležev rdeče, zelene in modre barve (RGB). To storimo z new Color(rdeča, zelena, modra), kjer so rdeča, zelena in modra cela števila med 0 in 255.
setBackground(barva)
Metoda setBackground nastavi barvo ozadja. Barvo ozadja običajno nastavimo na začetku metode paint, preden karkoli narišemo. Če tega ne storimo, bomo imeli ozadje privzete barve, kakšna je ta barva, pa je odvisno od tega, kako poženemo applet. V večini brskalnikov je privzeta barva ozadja za applet svetlo siva, če pa applet poženemo z appletviewer-jem, bo privzeta barva ozadja bela. Barvo določimo na enak način, kot pri metodi setColor.
Color.BLACK |
|
Color.DARK_GRAY |
|
Color.GRAY |
|
Color.LIGHT_GRAY |
|
Color.WHITE |
|
Color.RED |
|
Color.GREEN |
|
Color.BLUE |
|
Color.CYAN |
|
Color.MAGENTA |
|
Color.YELLOW |
|
Color.ORANGE |
|
Color.PINK |
Cela števila
Java pozna več tipov celih števil. Razlikujejo se po velikosti (številu zlogov, ki jih potrebujemo, da število zapišemo v pomnilnik) in s tem tudi po obsegu (katera števila lahko predstavimo).
tip |
velikost |
min |
max |
byte |
1 zlog |
-128 |
127 |
short |
2 zloga |
-32768 |
32767 |
int |
4 zlogi |
-2147483648 |
2147483647 |
long |
8 zlogov |
-9223372036854775808 |
9223372036854775807 |
char |
2 zloga |
0 |
65535 |
Najpogosteje bomo uporabljali tip int. Manjša tipa byte in short uporabljamo samo, kadar želimo varčevati s pomnilnikom, večji tip long pa v primeru, ko res potrebujemo tako velika cela števila.
Znaki
Celoštevilski tip char je nekaj posebnega. Je edini, ki ne dopušča negativnih vrednosti. V spremenljivkah tega tipa običajno hranimo znake (vrednost je koda znaka v tabeli Unicode). Temu ustrezno sta prilagojeni metodi print in println, ki namesto številske vrednosti izpišeta ustrezen znak.
Ker si je kode posameznih znakov težko zapomniti, lahko namesto kode v programu napišemo kar ustrezen znak, obdan z enojnimi narekovaji, npr. namesto vrednosti 65 lahko napišemo tudi 'A'.
Osnovne operacije nad celimi števili
Nad celimi števili lahko izvajamo vse običajne operacije (seštevanje, odštevanje, množenje in deljenje). Vsota, razlika in produkt dveh celih števil so definirani na običajen način, deljenje pa je nekaj posebnega. Pri deljenju dveh celih števil Java zanemari vsa decimalna mesta (tako je kvocient dveh celih števil vedno celo število). Poleg takega deljenja pa pozna Java še en operator (%), ki vrne ostanek pri deljenju (spet celo število).
a + b |
vsota |
a - b |
razlika |
a * b |
produkt |
a / b |
celi del kvocienta |
a % b |
ostanek pri deljenju |
Predznak ostanka pri deljenju je vedno enak predznaku števca. Predznak celoštevilskega kvocienta pa je vedno enak predznaku pravega kvocienta. Če pride do deljenja z ničlo, se izvajanje programa prekine (dobimo obvestilo o napaki).
a |
b |
a / b |
a % b |
13 |
5 |
2 |
3 |
13 |
-5 |
-2 |
3 |
-13 |
5 |
-2 |
-3 |
-13 |
-5 |
2 |
-3 |
Primeri
Realna števila
Java pozna več tipov realnih števil. Razlikujejo se po velikosti (številu zlogov, ki jih potrebujemo, da število zapišemo v pomnilnik) in s tem tudi po obsegu (katera števila lahko predstavimo). Za realna števila je značilna njihova nenatančnost. Ker je realnih števil na intervalu [min, max] neskončno mnogo, računalnik pa ima omejen pomnilnik, lahko predstavimo samo končno podmnožico množice realnih števil. Vsa druga realna števila predstavimo z najbližjim predstavljivim realnim številom. Poleg predstavljivih realnih števil z intervala [min, max], lahko v Javi predstavimo tudi njihove negativne vrednosti ter pet posebnih števil: negativno in pozitivno ničlo, negativno in pozitivno neskončnost ter vrednost NaN (Not-a-Number).
tip |
velikost |
min |
max |
natančnost |
float |
4 zlogi |
1.4 · 10-45 |
3.4028235 · 1038 |
7 mest |
double |
8 zlogov |
4.9 · 10-324 |
1.7976931348623157 · 10308 |
15 mest |
Najpogosteje bomo uporabljali tip double. Manjši tip float uporabljamo samo, kadar želimo varčevati s pomnilnikom.
Osnovne operacije nad realnimi števili
Tudi nad realnimi števili lahko izvajamo vse običajne operacije (seštevanje, odštevanje, množenje in deljenje). Vsota, razlika, produkt in kvocient dveh realnih števil so definirani na običajen način, tudi deljenje ni nič posebnega. Java poleg običajnega deljenja pozna tudi ostanek pri deljenju dveh realnih števil.
a + b |
vsota |
a - b |
razlika |
a * b |
produkt |
a / b |
kvocient |
a % b |
ostanek pri deljenju |
Kadar bi dve celi števili radi delili na običajen način (da dobimo realni kvocient), je pred deljenjem potrebno vsaj enega od operandov pretvoriti v realno število.
Logične vrednosti
Java pozna tudi poseben tip za shranjevanje logičnih vrednosti. Imenuje se boolean. Poznamo samo dve vrednosti tega tipa, to sta true in false.
Osnovne operacije nad logičnimi vrednostmi
Java pozna običajne operacije nad logičnimi vrednostmi (negacija, in, ali).
!a |
logična negacija |
a && b |
logični in |
a || b |
logični ali |
Opozoriti velja, da se izrazi, v katerih uporabljamo operatorja && in ||, vrednotijo vedno od leve proti desni in sicer tako dolgo, da je vrednost celotnega izraza določena. Naj bosta a in b dva logična izraza. Če ima izraz a vrednost false, potem vemo, da ima tudi izraz a && b vrednost false. Podobno: če ima izraz a vrednost true, potem ima tudi izraz a || b vrednost true. Izraza b Java v teh dveh primerih sploh ne ovrednosti.
Operacije, katerih rezultat so logične vrednosti
a == b |
enako |
a != b |
različno |
a < b |
manjše |
a <= b |
manjše ali enako |
a > b |
večje |
a >= b |
večje ali enako |
Primer: Pozdrav
Sestavi program, ki nas bo pozdravil (izpisal bo besedo "Pozdravljeni!").
Besedo (zaporedje znakov) izpišemo s pomočjo metode println objekta out iz razreda System.
public class Pozdrav
{
public static void main(String[] args)
{
System.out.println("Pozdravljeni!");
}
}
> javac Pozdrav.java
> java Pozdrav
Pozdravljeni!
Primer: Racun
Sestavi program, ki bo izračunal in izpisal, koliko je 423 + 65 * 52. Najprej naj izpiše celoten izraz, nato pa še enačaj in vrednost izraza.
Vse delo bomo opravili z metodama print in println.
public class Racun
{
public static void main(String[] args)
{
System.out.print("423 + 65 * 52 = ");
System.out.println(423 + 65 * 52);
}
}
Z metodo print izpišemo niz, v katerem je zapisan izraz, vključno z enačajem. Java ga izpiše znak za znakom, takšnega kot je. Z metodo println bomo izpis nadaljevali v isti vrstici, izpisali pa bomo vrednost izraza (torej celo število), ki smo jo podali kot parameter. Na koncu izpišemo še znak za novo vrsto.
> javac Racun.java
> java Racun
423 + 65 * 52 = 3803
Primer: Simbol
Sestavi program, ki na zaslon izpiše preprost simbol, sestavljen iz dveh trikotnikov. Oba naj imata vodoravno osnovnico, postavljena naj bosta eden ob drugem, prvi naj bo obrnjen navzgor, drugi pa navzdol. Za "risanje" trikotnikov uporabi malo črko o.
Ker lahko v Javi izpisujemo samo od leve proti desni in od zgoraj navzdol, bomo trikotnika izrisali po vrsticah s pomočjo metode println.
public class Simbol
{
public static void main(String[] args)
{
System.out.println(" o");
System.out.println(" o o");
System.out.println(" o o");
System.out.println("ooooooooooooo");
System.out.println(" o o");
System.out.println(" o o");
System.out.println(" o");
}
}
Simbol je sestavljen iz sedmih vrstic, zato smo uporabili sedem klicev metode println. Vsaka od njih izpiše dani niz (vključno z vsemi presledki, ki nastopajo v njem) in znak za novo vrsto. Čeprav se zdi nepotrebno, znak za novo vrsto izpišemo tudi na koncu zadnje vrstice.
> javac Simbol.java
> java Simbol
o
o o
o o
ooooooooooooo
o o
o o
o
Primer: Risanje
Sestavi applet, ki bo narisal takšno sliko.
import java.applet.*;
import java.awt.*;
public class Risanje extends Applet
{
public void paint(Graphics g)
{
setBackground(new Color(255, 255, 200));
// obraz
g.setColor(Color.WHITE);
g.fillOval(10, 10, 151, 171);
g.setColor(Color.BLACK);
g.drawOval(10, 10, 150, 170);
// oči
g.drawOval(40, 50, 30, 30);
g.drawOval(100, 50, 30, 30);
g.fillOval(55, 58, 15, 15);
g.fillOval(100, 58, 15, 15);
// nos
g.setColor(Color.PINK);
g.fillOval(70, 85, 31, 36);
g.setColor(Color.BLACK);
g.drawOval(70, 85, 30, 35);
// usta
g.drawArc(55, 130, 60, 30, 0, 180);
}
}
<html>
<body>
<applet width="170" height="190" code="Risanje.class">
</applet>
</body>
</html>
> javac Risanje.java
> appletviewer Risanje.html
Primer: Obrat
Sestavi program, ki bo obrnil dano štirimestno naravno število. Iz števila 1234 mora sestaviti število 4321.
Podatek (štirimestno naravno število) bomo prebrali in shranili v celoštevilsko spremenljivko. Število bomo razdrobili na posamezne števke, nato pa sestavili nazaj v obratnem vrstnem redu.
import java.io.*;
public class Obrat
{
public static void main(String[] args) throws IOException
{
BufferedReader vhod = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Vnesi stirimestno celo stevilo: ");
int stevilo = Integer.parseInt(vhod.readLine());
int e = stevilo % 10;
int d = stevilo / 10 % 10;
int s = stevilo / 100 % 10;
int t = stevilo / 1000;
int obrat = 1000 * e + 100 * d + 10 * s + t;
System.out.println("Obrnjeno stevilo je " + obrat);
}
}
Vhodni podatek smo shranili v celoštevilsko spremenljivko stevilo. Nato smo v štiri (prav tako celoštevilske) spremenljivke e, d, s in t naračunali enice, desetice, stotice in tisočice tega števila. Vsaka od teh štirih spremenljivk torej hrani eno števko (vrednost je celo število med 0 in 9) prvotnega števila. Na koncu iz posameznih števk sestavimo obrnjeno število ter ga izpišemo.
Pri računanju posameznih števk smo uporabljali operatorja / in %. Enice dobimo kot ostanek pri deljenju prvotnega števila z 10, tisočice pa kot celi del kvocienta, ko število delimo s 1000 (predpostavili smo, da je število štirimestno). Pri deseticah in stoticah smo se morali bolj potruditi. Najprej uporabimo celoštevilsko deljenje z 10 oziroma s 100, nato pa pogledamo, kakšne so enice dobljenega rezultata.
> javac Obrat.java
> java Obrat
Vnesi stirimestno celo stevilo: 1234
Obrnjeno stevilo je 4321
Rezultat pa ni nujno štirimestno število. Če se vhodni podatek konča z eno ali več ničlami, so te ničle na začetku obrnjenega števila in se ne izpišejo.
> java Obrat
Vnesi stirimestno celo stevilo: 1230
Obrnjeno stevilo je 321
Kaj pa če vhodni podatek ni štirimestno naravno število? Poskusite razložiti naslednje rezultate.
> java Obrat
Vnesi stirimestno celo stevilo: 123
Obrnjeno stevilo je 3210
> java Obrat
Vnesi stirimestno celo stevilo: 12345
Obrnjeno stevilo je 5442
> java Obrat
Vnesi stirimestno celo stevilo: -1234
Obrnjeno stevilo je -4321
> java Obrat
Vnesi stirimestno celo stevilo: -1230
Obrnjeno stevilo je -321
> java Obrat
Vnesi stirimestno celo stevilo: -123
Obrnjeno stevilo je -3210
> java Obrat
Vnesi stirimestno celo stevilo: -12345
Obrnjeno stevilo je -5442
Primer: Matematika
Sestavi program, ki izračuna in izpiše vrednosti izrazov sin(π/6), √1225 in ln(e).
Matematične konstante, kot sta π in e, ter matematične funkcije, kot so sinus, kvadratni koren, logaritem, ... so v Javi definirane kot statične konstante in metode razreda Math, zato moramo pred imenom matematične konstante ali funkcije vedno napisati ime tega razreda in piko. Popoln seznam vgrajenih matematičnih funkcij si oglejte v dokumentaciji razreda Math.
public class Matematika
{
public static void main(String[] args)
{
System.out.println(Math.sin(Math.PI / 6));
System.out.println(Math.sqrt(1225));
System.out.println(Math.log(Math.E));
}
}
Program izpiše vrednosti treh matematičnih izrazov, vsako vrednost v svojo vrstico.
> javac Matematika.java
> java Matematika
0.49999999999999994
35.0
1.0
Ob pogledu na izpisane vrednosti se nam postavi nekaj vprašanj. Že v srednji šoli smo se učili, da je sin(π/6) enako 0.5, naš program pa je izpisal 0.49999999999999994, kar je sicer zelo blizu, ni pa točno. Treba se bo privaditi, da računalniki z realnimi števili ne znajo računati točno, vse delajo s približki. Opazimo tudi na videz nepotrebno decimalno ničlo v drugi in tretji vrstici. S tem Java opozarja, da je izpisana vrednost v resnici realna, torej moramo dopuščati možnost napak.
Primer: Deljenje
Sestavi program, ki bo prebral dve realni števili in izpisal njun kvocient.
Deljenec in delitelj bomo shranili v dve realni spremenljivki. Rezultat bo tudi realno število.
import java.io.*;
public class Deljenje
{
public static void main(String[] args) throws IOException
{
BufferedReader vhod = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Deljenec: ");
double a = Double.parseDouble(vhod.readLine());
System.out.print("Delitelj: ");
double b = Double.parseDouble(vhod.readLine());
System.out.println(a + " / " + b + " = " + a / b);
}
}
Pred rezultatom smo še izpisali celoten izraz. Tu še enkrat opazimo, da pri izpisu realnih števil, ki so v resnici cela, Java doda na videz nepotrebno decimalno ničlo.
> javac Deljenje.java
> java Deljenje
Deljenec: 3
Delitelj: 5
3.0 / 5.0 = 0.6
Preverimo še, kako program deli neobičajna števila:
> java Deljenje
Deljenec: 1
Delitelj: 0
1.0 / 0.0 = Infinity
> java Deljenje
Deljenec: -1
Delitelj: 0
-1.0 / 0.0 = -Infinity
> java Deljenje
Deljenec: 0
Delitelj: 0
0.0 / 0.0 = NaN
> java Deljenje
Deljenec: -1
Delitelj: Infinity
-1.0 / Infinity = -0.0
Primer: Delez
Sestavi program, ki bo prebral dve celi števili (osnovo in procente) ter izračunal in izpisal ustrezen delež.
Ker sta osnova in procenti obe celi števili, ju bomo shranili v celoštevilski spremenljivki. Rezultat je lahko realno število.
import java.io.*;
public class Delez
{
public static void main(String[] args) throws IOException
{
BufferedReader vhod = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Vnesi osnovo: ");
int osnova = Integer.parseInt(vhod.readLine());
System.out.print("Vnesi procente: ");
int procent = Integer.parseInt(vhod.readLine());
double delez = osnova * procent / 100.0;
System.out.println(procent + "% od " + osnova + " je " + delez);
}
}
V celoštevilski spremenljivki osnova in procent smo shranili prebrana podatka. Rezultat mora biti realno število, izračunamo pa ga tako, da zmnožimo vrednosti spremenljivk osnova in procent ter dobljeni produkt delimo s 100. Število 100 smo zapisali kot realno število, tako da pri deljenju dobimo realen rezultat. Na koncu izpišemo rezultat v obliki smiselnega stavka.
> javac Delez.java
> java Delez
Vnesi osnovo: 176
Vnesi procente: 13
13% od 176 je 22.88
Primer: Yard
Sestavi program, ki bo dano dolžino (realno število) iz yardov pretvoril v metre, decimetre in centimetre. En yard meri 0.9144 metra.
Ker vhodna dolžina in razmerje med yardi in metri nista celi števili, bomo v računih uporabili spremenljivke tipa double. Končni rezultat bo seveda celoštevilski. Dobili ga bomo z rezanjem decimalk, morebitne milimetre, ki ostanejo, pa bomo zanemarili.
import java.io.*;
public class Yard
{
public static void main(String[] args) throws IOException
{
BufferedReader vhod = new BufferedReader(new InputStreamReader(System.in));
double yard = 0.9144;
System.out.print("Vnesi dolzino v yardih: ");
double dolzinaY = Double.parseDouble(vhod.readLine());
double dolzina = dolzinaY * yard;
int m = (int)dolzina;
dolzina = 10 * (dolzina - m);
int dm = (int)dolzina;
dolzina = 10 * (dolzina - dm);
int cm = (int)dolzina;
System.out.print(dolzinaY + " yardov = ");
System.out.println(m + "m " + dm + "dm " + cm + "cm");
}
}
V spremenljivko yard smo zapisali, koliko metrov meri en yard, v spremenljivko dolzinaY pa dolžino v yardih, ki jo moramo pretvoriti v metre, decimetre in centimetre.
Dolžino najprej iz yardov pretvorimo v metre. Dobimo realno število, ki ga shranimo v spremenljivko dolzina. Vrednost te spremenljivke pretvorimo v celo število (odrežemo decimalke) in tako dobimo metre (spremenljivka m).
Če metre odštejemo od celotne dolžine, ostane nenegativno realno število manjše od 1, iz katerega moramo dobiti še decimetre in centimetre. Decimetre dobimo tako, da razliko pomnožimo z 10, shranimo nazaj v spremenljivko dolzina, nato pa odrežemo decimalke in shranimo v spremenljivko dm. Na podoben način dobimo tudi centimetre.
Na koncu še izpišemo rezultat: najprej dolžino v yardih, nato pa še metre, decimetre in centimetre.
> javac Yard.java
> java Yard
Vnesi dolzino v yardih: 524.7
524.7 yardov = 479m 7dm 8cm
Morebitne milimetre (pravzaprav vse, kar je krajše od enega centimetra) smo zanemarili. Zato izpisan rezultat morda ni najbolj natančen. Bolj natančen rezultat bi dobili, če bi v izračunu upoštevali tudi milimetre. Če nam ostane vsaj 5 milimetrov, bi povečali centimetre za 1. Če dobimo 10 centimetrov, jih pretvorimo v en decimeter. Če dobimo 10 decimetrov, pa še te pretvorimo v en meter.
V resnici postopek ni tako zapleten. Ko dolžino pretvarjamo iz yardov v metre, je dovolj prišteti še 5 milimetrov, oziroma 0.005 metra. Postopek nato nadaljujemo brez sprememb in dopolnitev. V programu torej popravimo samo definicijo spremenljivke dolzina.
double dolzina = dolzinaY * yard + 0.005
Ko ponovno prevedemo in poženemo program, opazimo razliko v izpisu. Če ročno (ali s kalkulatorjem) preračunamo 524.7 yardov v metre, dobimo 479.78568 metrov. Torej je popravljen rezultat bolj natančen.
> javac Yard.java
> java Yard
Vnesi dolzino v yardih: 524.7
524.7 yardov = 479m 7dm 9cm
Primer: Prestopno
Sestavi program, ki bo za dano letnico preveril, ali predstavlja prestopno leto.
Leto je prestopno, če je letnica deljiva s 4, ni pa deljiva s 100. Obstajajo pa tudi izjeme. Če je letnica deljiva s 400, je leto prestopno. Neko število je deljivo z drugim številom, če je ostanek pri deljenju enak 0.
import java.io.*;
public class Prestopno
{
public static void main(String[] args) throws IOException
{
BufferedReader vhod = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Vnesi leto: ");
int leto = Integer.parseInt(vhod.readLine());
boolean prestopno = leto % 4 == 0 && leto % 100 != 0 || leto % 400 == 0;
System.out.println(prestopno);
}
}
Vhodni podatek smo shranili v celoštevilsko spremenljivko leto, v logično spremenljivko prestopno pa smo zapisali, ali je leto prestopno. Leto je prestopno, če pri deljenju s 4 dobimo ostanek 0, pri deljenju s 100 pa neničelen ostanek, ali pa če pri deljenju s 400 dobimo ostanek 0. Na koncu izpišemo vrednost logične spremenljivke prestopno.
> javac Prestopno.java
> java Prestopno
Vnesi leto: 2004
true
> java Prestopno
Vnesi leto: 2002
false
> java Prestopno
Vnesi leto: 2000
true
> java Prestopno
Vnesi leto: 1900
false
Vhodni podatek smo shranili v celo
Odlocitve
Problemov, ki se jih da rešiti s preprostimi programi, kjer se stavki izvajajo lepo po vrsti, eden za drugim, je bolj malo. Skoraj v vsakem programu se moramo odlociti med vec moznostmi, oziroma izvšiti dolocene stavke samo, ce je izpolnjen nek pogoj. Take odlocitvene probleme rešujemo na spodaj opisane nacine.
Pogojni izraz
Pogojni izraz je edini izraz v Javi, ki ima tri operande. Prvi je pogoj, druga dva pa sta poljubna izraza. Vrednost pogojnega izraza je odvisna od prvega operanda (pogoja). Ce je izpolnjen (ce je njegova vrednost true), dobi izraz vrednost drugega, sicer pa vrednost tretjega operanda.
(pogoj) ? izraz1 : izraz2
Ce ima pogoj vrednost true, dobi pogojni izraz vrednost izraza izraz1, sicer pa vrednost izraza izraz2. Pogoj obicajno napišemo v navadnih oklepajih. Izraza izraz1 in izraz2 morata imeti vrednost enakega tipa.
Recimo, da sta a in b celoštevilski spremenljivki s poljubnima vrednostma. V spodnjem primeru v spremenljivko min zapišemo manjšo, v spremenljivko max pa vecjo od njunih vrednosti. V spremenljivko abs izracunamo še absolutno vrednost spremenljivke a.
int min = (a < b) ? a : b;
int max = (a > b) ? a : b;
int abs = (a < 0) ? -a : a
Poglejmo si še stavek, ki izpiše cas (uro in minute) v obicajni obliki (ura, dvopicje, minute z morebitno vodilno niclo). Recimo, da je ura (celo število med 0 in 23) zapisana v spremenljivki ura, minute (celo število med 0 in 59) pa v spremenljivki min. Izpis casa bo sestavljen iz štirih delov: najprej vrednost spremenljivke ura, nato dvopicje, temu sledi številka 0, ce je minut manj kot 10 (ce so minute enomestno število), na koncu pa še vrednost spremenljivke min.
System.out.println(ura + ":" + ((min < 10) ? "0" : "") + min);
Pogojni stavek
Pogojni stavek uporabimo, kadar zelimo izvesti dolocen stavek samo v primeru, ko je izpolnjen nek pogoj. Pogojni stavek zapišemo z besedo if, ki ji sledi pogoj (izraz z vrednostjo true ali false, zapisan v oklepajih), temu pa stavek, ki ga zelimo izvesti, ce je pogoj izpolnjen (ce ima vrednost true).
if (pogoj) stavek
Poglejmo si primer, kako lahko izracunamo absolutno vrednost danega števila. Recimo, da je število zapisano v spremenljivki x. Ce je negativno, mu moramo spremeniti predznak.
if (x < 0) x = -x
Prejšnji problem izpisa casa bi s pogojnim stavkom rešili takole:
System.out.print(ura + ":");
if (min < 10) System.out.print('0');
System.out.println(min);
Ce zelimo v primeru, ko pogoj ni izpolnjen (ko ima vrednost false), izvesti kakšen drug stavek, na koncu (obicajno v novi vrsti) napišemo še besedo else ter stavek, ki ga zelimo izvesti.
if (pogoj) stavek1; else stavek2
Stavek, ki ga zelimo izvesti, ce je nek pogoj izpolnjen, je lahko sestavljen tudi iz vec stavkov. V tem primeru stavke zapišemo enega za drugim in jih obdamo z zavitimi oklepaji, kot je to prikazano na primeru. Takemu stavku recemu tudi sestavljeni stavek ali blok.
if (pogoj) {
stavek1;
stavek2;
stavek3;
}
else {
stavek4;
stavek5;
}
Tudi pogojni stavek je cisto navaden stavek, torej ga lahko uporabimo kot enega od stavkov znotraj drugega pogojnega stavka (gnezdenje pogojnih stavkov). Pri tem pa lahko nastopijo nekatere tezave. Ce napišemo dva pogojna stavka (enega v drugem) in samo en else, vcasih nastopijo dvomi, kateremu pogojnemu stavku ta else pripada. Pravila prevajalnika so sicer jasna (else pripada zadnjemu pogojnemu stavku brez njega), programerji pa vcasih z zamikanjem nakazejo ravno drugace. Poglejmo si primer:
if (pogoj1) if (pogoj2) stavek1; else stavek2
Stavki so zamaknjeni tako, da se zdi, kot da else pripada prvemu pogojnemu stavku, v resnici pa pripada drugemu. Ce bi zeleli, da else pripada prvemu pogojnemu stavku, bi morali uporabiti zavite oklepaje:
if (pogoj1) {
if (pogoj2) stavek1;
}
else stavek2
S pogojnim stavkom se lahko odlocimo za eno izmed dveh moznosti. Vcasih pa je moznosti vec. V takih primerih lahko uporabimo posebno varianto gnezdenih pogojnih stavkov.
if (pogoj1) stavek1; else if (pogoj2) stavek2; else if (pogoj3) stavek3; else if (pogoj4) stavek4; else stavek5
Opomba: Vse deklaracije znotraj bloka so veljavne samo do konca tega bloka. Ce torej spremenljivko deklariramo znotraj bloka, jo lahko uporabljamo samo v tem bloku, izven tega bloka pa ta spremenljivka ni vidna (kot da ne obstaja).
Primer: Premici
Sestavi program, ki ugotovi, ali se dani dve premici v ravnini y = k1x + n1 in y = k2x + n2 seceta ali ne. Ce se seceta, doloci še koordinate preseka (tri moznosti: se ne seceta, seceta se v natanko eni tocki, seceta se v neskoncno mnogo tockah).
Ce imata premici enaka smerna koeficienta, sta vzporedni. Ce imata enaka tudi prosta clena, se celo pokrivata. Ce pa sta smerna koeficienta razlicna, se premici seceta v natanko eni tocki.
import java.io.*;
public class Premici
{
public static void main(String[] args) throws IOException
{
BufferedReader vhod = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Prva premica:");
System.out.print(" smerni koeficient: ");
double k1 = Double.parseDouble(vhod.readLine());
System.out.print(" prosti clen: ");
double n1 = Double.parseDouble(vhod.readLine());
System.out.println();
System.out.println("Druga premica:");
System.out.print(" smerni koeficient: ");
double k2 = Double.parseDouble(vhod.readLine());
System.out.print(" prosti clen: ");
double n2 = Double.parseDouble(vhod.readLine());
System.out.println();
if (k1 == k2) {
if (n1 == n2) System.out.println("Premici sta enaki.");
else System.out.println("Premici sta vzporedni.");
}
else {
double x = (n2 - n1) / (k1 - k2);
double y = k1 * x + n1;
System.out.print("Premici se seceta v tocki ");
System.out.println("(" + x + ", " + y + ").");
}
}
}
Primer: Pravokotnik
Doloci, ali lezi tocka, katere koordinati prebereš, znotraj, zunaj ali na robu pravokotnika. Pravokotnik je podan s parom nasprotnih oglišc in ima stranice vzporedne koordinatnima osema.
Paziti moramo na to, kateri nasprotni oglišci pravokotnika sta podani. To sta lahko levo spodnje in desno zgornje ali pa levo zgornje in desno spodnje oglišce. V obeh primerih imamo še dve podmoznosti: najprej levo in nato desno oglišce ali pa obratno.
import java.io.*;
public class Pravokotnik
{
public static void main(String[] args) throws IOException
{
BufferedReader vhod = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Podatki o pravokotniku:");
System.out.println(" Prvo oglisce: ");
System.out.print(" koordinata x: ");
int x1 = Integer.parseInt(vhod.readLine());
System.out.print(" koordinata y: ");
int y1 = Integer.parseInt(vhod.readLine());
System.out.println(" Drugo oglisce: ");
System.out.print(" koordinata x: ");
int x2 = Integer.parseInt(vhod.readLine());
System.out.print(" koordinata y: ");
int y2 = Integer.parseInt(vhod.readLine());
System.out.println();
System.out.println("Podatki o tocki:");
System.out.print(" koordinata x: ");
int x = Integer.parseInt(vhod.readLine());
System.out.print(" koordinata y: ");
int y = Integer.parseInt(vhod.readLine());
System.out.println();
if (x1 > x2) { int t = x1; x1 = x2; x2 = t; }
if (y1 > y2) { int t = y1; y1 = y2; y2 = t; }
System.out.print("Tocka (" + x + ", " + y + ") lezi ");
if (x1 < x && x < x2 && y1 < y && y < y2)
System.out.print("v pravokotniku");
else if (x < x1 || x2 < x || y < y1 || y2 < y)
System.out.print("zunaj pravokotnika");
else
System.out.print("na robu pravokotnika");
System.out.println(" [" + x1 + ", " + x2 + "] x [" + y1 + ", " + y2 + "].");
}
}
Primer: Kompleksno
Sestavi program, ki bo cimlepše izpisal dano kompleksno število s celimi komponentami, na primer: 0, 4, i, -i, 4i, -2+i, 1+3i, 2-i ali -3-2i.
Kompleksno število bomo izpisovali po delih. Najprej realni del, potem predznak, imaginarni del in na koncu imaginarno konstanto i.
import java.io.*;
public class Kompleksno
{
public static void main(String[] args) throws IOException
{
BufferedReader vhod = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Vnesi kompleksno stevilo:");
System.out.print(" realni clen: ");
int re = Integer.parseInt(vhod.readLine());
System.out.print(" imaginarni clen: ");
int im = Integer.parseInt(vhod.readLine());
System.out.println();
if (im == 0) System.out.println(re);
else {
if (re != 0) {
System.out.print(re);
if (im > 0) System.out.print('+');
}
if (im == -1) System.out.print('-');
else if (im != 1) System.out.print(im);
System.out.println('i');
}
}
}
Vaje: Odlocitve
1. Polje na šahovnici podamo z dvema koordinatama 1 ? x, y ? 8. Sestavi program Sah, ki bo za dani dve polji na šahovnici preveril:
- ali sta polji enake barve
- ali trdnjava na prvem polju napada drugo polje
- ali lovec na prvem polju napada drugo polje
- ali kraljica na prvem polju napada drugo polje
- ali konj na prvem polju napada drugo polje
- ali kralj na prvem polju napada drugo polje
2. Sestavi program Interval, ki prebere dve celi števili a in b ter realno število x, nato pa preveri, ali x lezi na zaprtem intervalu, ki ga dolocata števili a in b. Pri tem je spodnja meja intervala enaka manjši izmed njunih vrednosti, zgornja meja pa je enaka vecji vrednosti.
3. Sestavi program Trikotnik1, ki bo prebral koordinate treh tock v ravnini. Ce ne lezijo na isti premici, naj program izracuna obseg in plošcino trikotnika, ki ga dolocajo te tri tocke.
4. Program za prebrano stevilo ugotovi ali je vecje od 100.
5. Program preveri ali lezi tocka znotraj kroga. Razdalja od tocke do sredisca mora biti < od polmera.
6. Program preveri ali pri razcepu na prafaktorje nastopajo st. 3, 5, 7.
7. Program ugotavlja ali je vsota enic in desetic < ali > od vsote stotic in tisocic.
8. Program prebere dve stevili in izpise manjse nato vecje.
9. Program ugotovi katera od treh tock je najblizja izhodiscu.
10. Program prebere tri stevila in jih zapise po velikosti.
11. Program prebere trimestno stevilo in ga preoblikuje v maximalno.
12. Realna periodicna funkcija s periodo 10 je na intervalu [0, 10) podana z naslednjim predpisom:
x + sin(x), 0 ? x < 2
f(x) = |x - 3|, 2 ? x ? 4
(x - 5)2, 4 < x < 7
12 - 5 x, 7 ? x < 10
Zanke
Zanko v programu uporabljamo takrat, ko zelimo enega ali vec stavkov izvršiti veckrat zaporedoma. Java pozna tri vrste zank: while, for in do.
Zanka while
Zanka while je najpreprostejša zanka. Osnovna oblika te zanke se glasi:
while (pogoj) stavek
To pomeni: "dokler je izpolnjen pogoj, ponavljaj stavek". Poglejmo podrobneje. Program najprej preveri pogoj, ki ga moramo vedno napisati v oklepajih. Ce pogoj ni izpolnjen (ce ima vrednost false), se ne zgodi nicesar, sicer pa se izvede telo zanke. To je stavek, ki sledi pogoju. Potem se spet preveri pravilnost pogoja. Ce je še vedno izpolnjen, se telo zanke izvede še enkrat. To se ponavlja, dokler je pogoj izpoljen. Ko pogoj ni vec izpolnjen, se zanka konca. Nepazljiv programer lahko sestavi pogoj, ki bo vedno izpolnjen. V takem primeru se zanka ne bo nikoli koncala. Pri programiranju zank moramo torej zelo paziti, da ne sestavimo neskoncne zanke.
Verjetno ni treba dodajati, da lahko za telo zanke namesto preprostega stavka uporabimo tudi sestavljeni stavek (blok). Manj znano pa je, da je lahko telo zanke tudi prazno (še vedno moramo napisati podpicje). Taki primeri so sicer redki, vendar pa dovoljeni, zato prevajalnik tega ne obravnava kot napako, ceprav se velikokrat izkaze, da gre za napako (odvecno podpicje med pogojem in stavkom).
Pri sestavljanju zank velikokrat uporabimo posebno kontrolno spremenljivko, s pomocjo katere se odlocamo, kdaj je potrebno zanko koncati. Najveckrat je to števec, ki šteje kolikokrat se mora zanka še ponoviti ali pa kolikokrat se je ze izvršila. Zacetno vrednost te spremenljivke nastavimo pred zanko, njeno trenutno vrednost preverjamo v pogoju, spreminjamo pa jo v telesu zanke (najveckrat tik pred koncem). Za števce lahko uporabljamo poljubne spremenljivke, najveckrat pa izberemo kratka imena, kot so i, j ali k.
Poglejmo si primer zanke, ki izpiše vsa naravna števila med 1 in 10.
int i = 1;
while (i <= 10) {
System.out.println(i);
++i;
}
Pred zanko števcu i dodelimo zacetno vrednost 1. Dokler je i manjši ali enak 10, izpisujemo njegovo vrednost, po vsakem izpisu pa mu vrednost še povecamo za 1. Ko števec i dobi vrednost 11, se zanka konca.
Opomba: Enak ucinek bi dosegli tudi z desetimi zaporednimi stavki za izpis števil od 1 do 10, vendar pa tak nacin odpove, ce bi morali izpisati vsa naravna števila od 1 do 10000, ali pa vsa naravna števila od 1 do n.
Primer: Delitelji
Sestavi program, ki bo za dano naravno število izpisal vse njegove delitelje.
Po vrsti bomo pregledali vse kandidate za delitelje (vsa naravna števila, ki so manjša od danega števila). Ce kandidat deli dano število, ga bomo izpisali.
import java.io.*;
public class Delitelji
{
public static void main(String[] args) throws IOException
{
BufferedReader vhod = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Vnesi naravno stevilo: ");
int n = Integer.parseInt(vhod.readLine());
System.out.print("Delitelji stevila " + n + " so:");
int i = 1;
while (i <= n) {
if (n % i == 0) System.out.print(" " + i);
++i;
}
System.out.println();
}
}
Vaje: Zanke
Sestavi program Produkt, ki bo prebral naravno število in izracunal produkt njegovih nenicelnih števk.
> java Produkt
Vnesi naravno stevilo: 2304701
Produkt nenicelnih stevk: 168
Sestavi program Kvocient, ki bo izpisal prvih n decimalk kvocienta a/b. Delaj samo s celimi števili.
> java Kvocient
Vnesi a: 10
Vnesi b: 761
Vnesi n: 40
0.0131406044678055190538764783180026281208
Sestavi program Ulomek, ki bo prebral pozitivno realno število in izpisal ulomek z imenovalcem manjšim od 1000, ki je temu številu najblizji. Izpiše naj tudi njuno absolutno razliko.
> java Ulomek
Vnesi pozitivno realno stevilo: 3.7326546
Najblizji ulomek je 1829 / 490
Razlika je 1.5387755101237133E-6
Zanka for
Zanka for je izpopolnjena oblika zanke while, ki nam omogoca bolj strnjen zapis stavkov, s katerimi kontroliramo potek zanke. Osnovna oblika je:
for (start; pogoj; korak) stavek
Pri tem je start stavek, ki se izvrši samo enkrat, preden se zanka sploh pricne. Obicajno s tem stavkom nastavimo zacetno vrednost kontrolne spremenljivke (števec ali kaj podobnega), ki jo uporabljamo v zanki. Takoj zatem se preveri pogoj. Ce je izpolnjen (ce ima vrednost true), se izvede telo zanke (stavek, ki sledi), nato pa še stavek korak, s katerim spremenimo vrednost kontrolne spremenljivke. Potem se spet preveri pogoj. Dokler je izpolnjen, se izvajata telo zanke in stavek korak. Ko pogoj ni vec izpolnjen, se zanka konca.
Ce je stavek start definicija nove spremenljivke, potem lahko to spremenljivko uporabljamo samo znotraj zanke. Izven zanke je ne moremo uporabljati. Ce nas po izteku zanke zanima njena koncna vrednost, jo moramo deklarirati ze pred zanko.
Izpis prvih desetih naravnih števil bi z zanko for naredili takole:
for (int i = 1; i <= 10; ++i) System.out.println(i);
Zanka for je torej samo krajši zapis naslednje oblike zanke while:
{
start;
while (pogoj) {
stavek;
korak;
}
}
Zunanji zaviti oklepaji so potrebni, da omejimo vidnost števca, definiranega v stavku start (kadar gre za definicijo nove spremenljivke).
Vaje Program izpise vsa cela stevila od a do b.
Program izpise prvih deset veckratnikov stevila k.
Program ugotovi koliko stevk ima stevilo.
Zanka do
Zanka do je v primerjavi s prejšnjima dvema zankama nekaj posebnega. Pri zankah while in for se veljavnost pogoja preverja pred vsako ponovitvijo telesa zanke, pri zanki do pa se najprej izvede telo zanke in šele nato preveri veljavnost pogoja. Zanka do se torej v vsakem primeru izvede vsaj enkrat. Zapišemo jo takole:
do stavek; while (pogoj);
Zanko do torej uporabimo takrat, kadar se mora telo zanke izvršiti vsaj enkrat. Tipicen primer uporabe je preverjanje smiselnosti vnešenih podatkov. Od uporabnika zahtevamo vnos podatka tako dolgo, da vnese smiselno vrednost.
int stevilo;
do {
System.out.println("Vnesi stirimestno naravno stevilo: ");
stevilo = Integer.parseInt(vhod.readLine());
} while (stevilo < 1000 || stevilo > 9999);
Uporabnik mora število vnesti vsaj enkrat. Ce ne vnese štirimestnega števila, se zanka ponovi. Deklaracija spremenljivke stevilo stoji pred zanko. Ce bi jo napisali znotraj zanke, ne bi bila vidna v pogoju, tako da ne bi mogli preveriti smiselnosti njene vrednosti.
Stavek break
Stavek break uporabljamo znotraj zank, kadar zelimo izvajanje zanke predcasno prekiniti. Program se nadaljuje s stavkom, ki sledi zanki.
Sestavi program, ki bo za dano naravno število n preveril, ali je praštevilo.
Nalogo bi lahko rešili na vec nacinov. Najpreprosteje bi bilo prešteti, koliko deliteljev ima število n. Ce ima natanko 2 delitelja, potem je praštevilo, sicer pa ne. A videli smo ze, da je iskanje vseh deliteljev lahko casovno precej zahteven postopek, zato se bomo temu izognili.
Namesto da kot kandidate za delitelje pregledamo vsa števila od 1 do n, je dovolj pregledati samo kandidate od 2 do √n (teh je bistveno manj). Za 1 in n vemo, da sta delitelja, zato nam ju sploh ni treba preverjati. Ce pa od 2 do √n ni nobenega delitelja, potem tudi ne bo nobenega vecjega od √n in manjšega od n. Takoj, ko najdemo kakšnega delitelja, lahko zanko prekinemo, saj ze vemo, da n ni praštevilo.
import java.io.*;
public class Prastevilo
{
public static void main(String[] args) throws IOException
{
BufferedReader vhod = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Vnesi naravno stevilo: ");
int n = Integer.parseInt(vhod.readLine());
int i = 2;
while (i <= Math.sqrt(n)) {
if (n % i == 0) break;
++i;
}
if (i > Math.sqrt(n)) System.out.println(n + " je prastevilo.");
else System.out.println(n + " ni prastevilo.");
}
}
Gnezdenje
Tudi zanke so cisto obicajni stavki, zato jih lahko uporabljamo znotraj drugih zank. Temu recemo gnezdenje zank. Pri tem je zelo pomembno, da ne pomešamo števcev posameznih zank (vec zank bi naceloma lahko uporabljalo isti števec, a taki primeri so zelo redki). Ce bi na primer zeleli na zaslon izpisati n vrstic zvezdic, pri cemer bi v prvi vrstici imeli eno zvezdico, v drugi dve, v tretji tri, itn., bi zanki sestavili takole:
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= i; ++j) System.out.print("*");
System.out.println();
}
Števec i v zunanji zanki šteje vrstice. V i-ti vrstici moramo izpisati i zvezdic, kar storimo v notranji zanki, ki i-krat izpiše po eno zvezdico. Ko je notranje zanke konec, skocimo v novo vrstico, in ponovimo zunanjo zanko (ce je pogoj še vedno izpolnjen).