ITI0011-2015:praktikum 02

Üldine

See lehekülg sisaldab 2. praktikumi materjali.

Teemad

• Eclipse
• git?
• Java keel
  • muutujad
  • põhilised operaatorid
  • funktsioonid
• Harjutusülesanne

Eclipse

Eclipse on IDE (Integrated Development Environment), mida kasutame Java tundides ülesannete lahendamiseks. Kes tahab, võib kasutada mõnda muud, näiteks:

• NetBeans [[1]]
• IntelliJ IDEA [[2]]

Eclipse'i käivitamine

Eclipse'i saab alla tõmmata järgmiselt lehelt: http://eclipse.org/
Sealt paremalt nupp "DOWNLOAD" -> Eclipse IDE for Java Developers. Võit eelnevalt valida opsüsteemi, kui see pole automaatselt õigesti määratud.

Kui olete zip-faili alla tõmmanud, tuleb see lahti pakkida näiteks kodukausta (windowsis c:\users\ago\eclipse). Mingit installeerimist ei toimu. Programmi käivitate vastavast kaustast, näiteks c:\users\ago\eclipse\eclipse.exe .

Programm küsib käivitamisel teilt workspace'i asukohta. Vaikimsi pakutud asukoht (kodukasutas workspace kaust) on täitesti sobiv. Kes tahab, võib selle kuhugi mujale paigutada. Kõik teie loodud failid hakkavad selles kataloogis (ja alamkataloogides) olema.

Eclipse'i tööaken

Kui panete Eclipse'i esimest korda käima, näidatakse teile "Welcome" lehte. Selle saate ülevalt paremalt "Workbench" kinni panna.

Eclipse'i tööaken on jagatud mitmeks erinevaks osaks. Igas osas saate hoida teile sobivaid paneele. Vaikimisi seadustuses paikneb vasakul "Package explorer", all asuvad "Problems", "Javadoc", "Declarations" ja "Console" paneelid. Paremal on näha "Task list" ja "Outline" paneelid. Keskmine osa on eraldatud aktiivsele koodifailile - ehk siis sinna ossa kirjutate koodi. Kõiki paneele saate ümber paigutada (näiteks tõsta mõne paneeli alt paremale jne), ära peita või siis ekraanilt üldse eemaldada. Paneeli saate "ära peita" paneeli üleval paremal servas oleva "-" nupukesega. Peitmise korral ei paista paneel vaikimisi ekraanil välja, küll aga on paremal ääres riba, mille peal see paneel (või paneelide grupp) on nähtav ikoonina. Sealt saab selle jälle nähtavale tuua. "x" kaotab konkreetse paneeli ekraanilt täielikult. Kui võtate paneeli päisest kinni, saate seda lohistada ekraanil teise kohta. Paigutus salvestatakse automaatselt - järgmisel korral, kui Eclipse'i avate, taastatakse see seis, mis teil viimati oli.

Kõik paneelid on kättesaadavad Window -> Show view -> Other... Sealt saate nime ja/või struktuuri järgi otsida. Ehk siis kui kogemata olete midagi ära kaotanud, saate sealt selle taastada.

Näiteks üks võimalus, kuidas tööaken seadistada on nii, et paremal on "Package explorer", vasakul on "Outline" (kui te seda kasutada oskate). Alumises osas on "Problems", "Javadoc", "Console". Kõik sõltub sellest, milliseid vaateid programmeerija oskab ja on harjunud jälgima.

Eclipse'i seadistamine

Eclipse'i seaded on nähtavat Window -> Preferences. Avaneb eraldi dialoog, kus saate seadeid otsida nime ja/või struktuuri järgi. Näiteks üks muudatus, mida õppejõud tavaliselt teeb, on fondi suurendamine. Selleks piisab, kui kirjutada otsingulahtrisse "font". Otsingutulemusena kuvatakse vaid see seadete menüü, kus nimetatud otsisõna leidus. Antud juhul General -> Appearance -> Colors and Fonts. Sealt valin Java -> Java Editor Text Font. Muudan suuruseks näiteks 20.

Otseselt teil mingit vajadust seadistuste muutmiseks pole. Küll aga mõnes olukorras võib see vajalik olla. Eks me kursuse käigus viitame, kui mingeid seadeid oleks vaja muuta.

Eclipse'ile Checkstyle lisa (plugin)

Üks kuruse eesmärke on õpetada teid kirjutama "ilusat" koodi. Selle tarvis on meil kasutusel üks Eclipse'i lisa, mis aitab koodiilu jälgida: Checkstyle. Selleks, et see lisa peale panna, toimige järgmiselt:

• Help -> Eclipse Marketplace
• otsingusse "Checkstyle"
• tulemustest "Checkstyle Plug-in 6.2.0" (peaks olema teine) juurest "install"
• näitab dialoogi, kus on nimekirjas kaks komponenti, mõlemal peaks "linnuke" juures olema (ehk siis mõlemad on märgistatud automaatselt). Vajutada "Confirm >".
• "I accept..." (muidugi tekst tuleks läbi ka lugeda...), "Finish"
• Installeerimise ajal küsib Eclipse kinnitust, kas tahad installeerida tarkvara, mis pole signeeritud. Security Warning, you are installing software that contains unsigned content. Vajuta "OK".
• Peale installeerimist küsib Eclipse restarti teha, võimaldage see (vajutades "Yes").

Kui Eclipse uuesti käima läheb (ta võib teilt küsida uuest workspace'i asukohta, mis võiks olla täidetud selle asukohaga, mis te eelnevalt määrasite), peaks Checkstyle plugin peal olema.

Järgmiseks tuleb Checkstyle'i jaoks seadistused paika panna. Selleks tuleb alla laadida seadistuste fail: Meedia:ITI0011-Checkstyle iti0011.xml. Fail on olemas ka materjalide repositooriumis stuff/checkstyle-iti0011.xml . Võimalik, et kursuse jooksul me uuendame seda faili, kui mõni seadistus tundub liiga leebe või range. Selleks, et seadistused failist rakenduda saaksid, tuleb see fail Eclipse'i plugin'ile külge panna. Selleks:

• Window -> Preferences
• otsingusse "Checkstyle" (tegelikult selline menüü on kohe vasakul nimekirjas ka olemas)
• "Checkstyle" menüüst valides, on näha paremal pool nimekirja "Global Check Configurations", kus peaks olema üks Google'i ja kaks Sun'i seadistust. Meie lisame sinna oma seadistuse.
• nimekirjast paremal on nupp "New..."
• avaneb dialoog
• Type: External Configuration File
• Name: ITI0011
• Location: otsite arvutist alla laetud XML-faili üles.
• "OK"
• nimekirja peaks ilmuma ITI0011. Märkida see hiirega ära ja vajutada paremalt nuppu "Set as Default"

Nüüd peaks sobiv konfiguratsioon olema peale pandud. Huvi korral võite sealtsamast seadistuste alt vaadata, millised piirangud on selle konfiguratsiooniga peale pandud (nimekirjas aktiivseks teha ja "Configure...").

Automaatselt Checkstyle plugin ei aktiveeru. Selleks, et antud lisast kasu oleks, tuleb see iga projekti puhul käsitsi aktiveerida. Aga enne, kui seda teha saame, peame mõne projekti looma.

Uus projekt

Projekt võib koosneda mitmest Java failist. Üldiselt projekt on üks terviklik programm. Näiteks iga teie koduülesanne võiks olla üks projekt. Samamoodi harjutusülesanded võiksid olla eraldi projektid. Kuigi tunniülesandeid võib ka kokku kõik ühte projekti panna.

Meie loome käesoleva praktikumi jaoks uue projekti. Selleks:

• File -> New -> Java Project
• Project name: näiteks "praktikum02´"
• ülejäänud seadistused võib paika jätta.
• "Finish"

Vasakule package exploreri paneeli peaks ilmuma kaust (projekt) nimega "praktikum02". Kui te projekti nime ees oleval kolmnurgal klikite, avatakse projekti sisu. Kogu projekti struktuur on näha n-ö kataloogipuuna (analoogiline vaade on ka näiteks Windows Exploreris olemas). Kui te arvutist oma workspace'i üles otsite, siis iga projekt on tegelikult lihtsalt üks kaust. Projekti all on kaust "src" (see on ka päriselt kõvakettal olemas). Esialgu on see kaust tühi.

Lisame esimese koodifaili. Selleks:

• parem klikk "src" kaustal
• avanevast menüüst New -> Class
• avaneb dialoog
• Name: TereMaailm
• märgistada ära "public static void main(String[] args)"
• kustuta praegu "package" sisu ära
• "Finish"

Vasakul package explorer vaates peaks "src" kaustas olema üks alamkaus nimega "(default package)". Üldiselt lähtekoodi kaust ("src") jaguneb pakettideks. Iga pakett on tegelikult kaust kõvakettal. Kuna ma selle faili puhul lihtsuse mõttes paketti ei lisanud, on see fail tegelikult otse "src" kausta all (kuigi ta nagu näitas, et vahepeal on üks "(default package)" nimeline kaust). Kui me oleks paketi nimeks pannud "tere", siis oleks lähtefail läinud "tere" kausta all jne. Esialgu meil pakette pole vaja väga uurida. Seega siinkohal otseselt vahet pole, kas ja mis nimega paketi alla see sai lisatud.

Tööakna keskmises osas peaks avanema loodud klassi (mis tegelikult on lihtsalt üks fail nimega TereMaailm.java) lähtekood.

Kood peaks välja nägema umbes selline: <source lang="java"> public class TereMaailm {

public static void main(String[] args) { // TODO Auto-generated method stub

}

} </source>

Esimene programm, mille me teeme, prindib käivitamisel teksti ekraanile.

Osa sellest lähtekoodist, mis teil failis algselt on, jääb meil seletamata (õigemini seletame me seda mõne nädala pärast, kui oleme muud põhiasjad läbi käinud). Lühidalt öeldes:

• 1. rida "public class TereMaailm" näitab klassi nimetuse "TereMaailm". Javas peab üldiselt failinimi ühtima selle sees oleva klassinimega. Kogu klassi sisu jääb {} märkide vahele. Ehk siis sellel real klassi definitsioon hakkab ning viimasel real lõppeb.
• 3. rida "public static void main(String[] args)" defineerib ära ühe meetodi/funktsiooni, mille nimi on "main". See on eriline meetod, kuna sellest meetodist pannakse käesolev fail/klass käima. Kui sellist meetodit pole, siis seda klassi/faili ei saa otse käivitada. Sulgudes antakse funktsioonile kaasa mingid argumendid.
• 4. rida " // ..." on kommentaar. See on programmeerijale - arvuti ignoreerib kommentaare. Teil on soovitatav oma koodis kommentaare kasutada, et kirjeldada mingeid tegevusi
• 6. rida "}" lõpetab main-meetodi
• 8. rida "}" lõpetab TereMaailm klassi

Meie ülesanne on main-meetodisse kirjutada koodi juurde. See kood pannakse käima siis, kui me selle faili käivitame. Kirjutame main-meetodisse ühe rea juurde: <source lang="java"> public class TereMaailm {

public static void main(String[] args) { // TODO Auto-generated method stub System.out.println("Tere maailm!")

}

} </source>

Kui te täpselt sellise rea lisate faili, peaks teil tekkima 5. rea algusesse punane ristike. See annab märku, et teie koodis on sellel real mingi viga. Enne, kui hakkame seda viga parandama, vaatame natuke, kuidas Eclipse'is vigu saab jälgida.

Tööakna alumises osas peaks teil olema tääb või paneel nimega "Problems". Kui te selle aktiivseks teete, peaksite nägema seal umbes sellist rida "Errors (1 item)". Kui selle rea ees olevale kolmnurgale vajutada, peaks avanema/sulguma vigade nimekiri. Seal on see meie tekitatud viga. Kui teete topeltkliki selle rea peal, avaneb teil koodis see koht, kus mainitud viga on tekkinud. Antud juhul on probleem selles, et Javas kõik käsud lõppevad semikooloniga (Pythonis see polnud vajalik).

Seega, töötav kood võiks olla selline:<source lang="java"> public class TereMaailm {

public static void main(String[] args) { // TODO Auto-generated method stub System.out.println("Tere maailm!");

}

} </source>

Kui tahame näha, mida meie programm teeb, saame ülevalt menüüst võtta Run -> Run As -> Java Application. Sama saab ka klahvikombinatsiooniga ctrl + F11. Kui olete programmi käivitanud, siis peaks automaatselt aktiivseks minema alumine Console paneel, kuhu peaks ilmuma tekst "Tere maailm!". Sellega oleme esimese programmi Javas valmis kirjutanud, kuigi me väga palju ei rääkinud, mida miski rida teeb. Jätkame nüüd Java keele teemadel.

git

TODO

Muutujad

Muutuja (ik variable) on nimeline viide mingile väärtusele, mis paikneb kuskil mälus. Näiteks võib muutuja nimi olla x ja see viitab väärtusele 5. Pseudokoodina võib kirjutada, et x = 5 (tegelikult samamoodi saab matemaatikas muutuja väärtust määrata). Kui edaspidi kuskil kasutatakse x'i, siis on selle väärtus 5. Näiteks x + 3 on väärtuse poolest sama mis 5 + 3. Analoogselt võib mõelda näiteks Exceli lahtritele. Kui te seal kirjutate mingeid valemeid, siis teete seda selliselt: =A1 + B2. A1 ja B2 oleksid nagu muutujad, mille väärtus on vastavates lahtrites.

Javas on igal muutujal lisaks nimele ka andmetüüp. Kui näiteks Pythonis võib kirjutada x = 'tere' ja seejärel kohe x = 3, siis Javas tuleb kõigepealt muutuja tüüp määrata. Edaspidi tohib see muutuja ainult seda tüüpi andmeid hoida. Näiteks täisarvuline andmetüüp on int: int x = 3;. Edaspidi koodis, kui ma olen juba x-ile andmetüübi määranud, saan ma kasutada lihtsalt muutujat (ilma andmetüübita): x = 4;. Viimane näide oli selline, kus deklareeriti muutuja x ning sellele anti kohe väärtuseks 3. Seejärel muudeti x'i väärtus 4-ks.

Sama nimega muutujaid tohib olla vaid üks. Kui koodis on deklareeritud muutuja x, siis rohkem selles koodiosas ei tohis x-nimelist muutujat olla.

Andmetüübid

Andmetüübid Javas jagunevad kahte suuremasse klassi: primitiivsed andmetüübid ja objektid. Esialgu vaatleme primitiivseid andmetüüpe. Primitiivsete andmetüüpide korral kehtib reegel, et muutujal on konkreetne väärtus. Hiljem objektide puhul näeme, mismoodi see on erinev.

All tabelis on välja toodud erinevad primitiivsed andmetüübid Javas:

Tüübi nimi	Suurus	Väärtused	Näide
byte	1 bait (8 bitti)	-128..127	byte b = 42;
short	2 baiti (16 bitti)	-32768..32767	short s = -12345;
int	4 baiti (32 bitti)	-2 147 483 648 (-2^31).. 2 147 483 647 (2^31 - 1)	int i = 10;
long	8 baiti (64 bitti)	-2^63 .. (2^63 - 1)	long l = -100;
float	32-big floating point	*	float f = 3.14f;
double	64-bit floating point	*	double d = 1.2345;
boolean	1 bitt	true, false	boolean b = true;
char	16-bit character	'a', 'b', ...	char c = 'a';

Muutuja deklareerimine, väärtustamine

Muutuja deklareerimine ehk muutuja tutvustamine programmile käib selliselt:

[andmetüüp] [muutujanimi];

või

[andmetüüp] [muutujanimi] = [algväärtus];

Näiteks:

int y; int x = 10;

Edaspidi igal ajal koodis võib muutuja väärtust muuta:

y = 1; x = 3;

Muutujate nimetamine

Java keeles lubatud muutuja nimed: N, n, x15, a_long_name, time_is_$, HelloWorld. Muutuja nimi on tõstutundlik, ehk siis kõik järgmised on erinevad muutujad: HelloWorld, helloWorld, helloworld, HELLOWORLD, HeLLoWoRLd. Keelekonstruktsioonide nimetused on reserveeritud, seetõttu nimed nagu class, public, static, if, else jne ei ole lubatud.

Kuigi Javas on lubatud väga erinevad nimekujud, on soovitatav järgida neid reegleid:

• muutuja nimi peaks olema mõistlik (temperature, speed mitte a, b)
• nimi peaks algama väikese tähega
• kasutada tuleks täisnimetusi (temperature, mitte temp)
• kui nimi koosneb ühest sõnast, siis kasutada läbivat väiketähte: weight, speed.
• kui nimi koosneb kahest või rohkemast sõnast, siis kirjutatakse sõnad kokku ning alates teisest sõnast iga sõna esimene täht peaks olema suur: playAgain, currentSpeed.

Kuna keelekonstruktsioonid on kõik inglisekeelsed (if, while, class jne), siis on soovitatav kasutada inglisekeelseid muutujanimesid (speed, mitte kiirus). Igal juhul võiks loogika olla läbi koodi sama: kui alustasite eestikeelsete muutujanimedega, siis peaks sama loogika kehtima lõpuni. See, kus mõned muutujad on eestikeelsed ja mõned inglisekeelsed, on väga halb komme.

Konstandid

Konstandid on erilisttüüpi muutujad. Nad on samamoodi andmetüübiga ja nimega viited mingile väärtusele. Erinevus tavalisest muutujast on see, et konstandi väärtust ei saa hiljem enam muuta. Konstandi nimetamise reelgid on mõnevõrra erinevad tavamuutujast:

• kõik tähed nimes on suurtähed: PI, SPEED.
• sõnad on eristatud alakriipsuga (_): SPEED_OF_LIGHT, NUMBER_OF_GEARS.

Konstandi saab luua klassi päises (enne meetodeid/funktsioone): public static final double PI = 3.14;

Aga konstantidest räägime täpsemalt mõnevõrra hiljem. Praeguses tekstis on konstandid mainitud nimetamise tõttu.

Operatsioonid, tehted

Muutuja suurendamine/vähendamine ühe võrra:

• y = x++ (x suurendatakse peale omistamist)
  • y = x
  • x = x + 1
• y = ++x (x suurendatakse enne omistamist)
  • x = x + 1
  • y = x

• x += y
  • x = x + y

Tehete järjekord (mis vastus on?):

• x = 2 + 3 * 6;
• x = (2 + 3) * 6;

= Jagamine, jääk

Kui argumendid on täisarvud, on ka tulemus täisarv (võetakse täisosa, mitte ei ümardata):

• 6 / 5 = 1
• 3 / 5 = 0
• 10 / 5 = 2

Kui vähemalt üks argumentidest on komaga arv, on tulemus ka komaga arv:

• 6.0 / 5 = 1.2
• 3 / 5.0 = 0.6
• 10.0 / 5.0 = 2.0

Jääk jagamisel (%):

• 22 % 5 = 2 (22 / 5 on 4, jääk on 2)
• 5 % 5 = 0
• 3 % 5 = 3

Jäägist võib mõelda nii, et kui meil on 22 õuna ja peame need 5 inimese vahel jagama (õunu katki ei tohi teha), siis mitu õuna jääb üle. Või kui meil on 3 õuna, siis 5-le inimesele jagatuna saab igaüks 0, 3 jääb üle.

Cast'imine

Kui muutujat on vaja kasutada teise andmetüübina, võib kasutada cast'imist. Näiteks täisarvude puhul saab kasutada, et saada "normaalne" tulemus.

• x = 8; y = 5; x / y = 1 (aga tahaksime saada 1.6)

Cast'imine ei muuda muutuja väärtust.

Cast'imise süntaks:

([uus-tüüp])[muutuja-nimi-või-väärtus];

Näide: <source lang="java"> (double)8/5; // => 1.6 x = 5; y = 2; x / y; // => 5 / 2 = 2 (double)x / y // => 5.0 / 2 = 2.5 x / y; // => 5 / 2 = 2 (int)5.5 / 3 // => 5 / 3 = 1 </source>

Funktsioonid

Lühike sissejuhatus funktsioonidesse. Täpsemalt räägime järgmistes praktikumides.

Programmi koodi saab jagada osadeks. Osa koosneb grupeeritud käskudest, millele antakse nimetus. Kui kuskil programmis on vastavaid käske vaja kasutada, saab välja kutsuda nimeliselt eelnevalt grupeeritud koodiosa.

Funktsioonid jagunevad kaheks:

• ühed, mis tagastavad mingi väärtuse (neid nimetatakse funktsioonideks)
• teised, mis ei tagasta väärtust (neid nimetatakse vahel protseduurideks)

Tegelikult võib mõlemat tüüpi funktsiooni kohta öelda lihtsalt "funktsioon" või Javas ka "meetod". Seega, neid termineid kasutatakse segamini. Pigem sisu järgi saab vahet teha, mistüüpi funktsiooni/meetodiga tegemist on.

Mõned näited matemaatilistest funktsioonidest:

• Math.sqrt(x); - tagastab etteantud argumendi ruutjuure
• Math.random(); - tagastab juhusliku arvu vahemikus [0..1)

Funktsiooni defineerimine:

[laiendid] [tagastus-tüüp] [funktsiooni-nimi] ([parameetrite nimekiri]) {
	[käsud]
}

Laiendeid võib olla mitu või võivad üldse puududa. Need on peamiselt olulised siis, kui hakkame objekt-orienteeritud koodi kirjutama.

Parameetrite nimekiri on komaga eraldatud argumentide nimed koos tüübiga. Kui funktsioon välja kutsutakse, tuleb sellised argumendid kaasa anda. Oluline on, et kaasaantud argumentide tüübid oleksid täpselt samad, nagu funktsioon eeldab. Funktsiooni sees on parameetrid nagu deklareeritud muutujad. Alloleva näite puhul deklareeritakse double-tüüpi muutuja x ja y, mille väärtus määratakse sellel hetkel, kui funktsioon väja kutsutakse. Kogu funktsiooni ulatuses {} märkide vahel on need funktsioonid kättesaadavad.

Funktsioon, millel on määratud tagastusväärtus (allpool olev funktsioon tagastab boolean väärtuse), saab seda teha käsuga: return [avaldis];

Funktsioon lõpetab oma töö ära peale "return" käsku.

Näiteks: <source lang="java"> public static boolean lessThan(double x, double y) { return x < y; } </source>

Hiljem koodis saab sellise koodi asemel:

<source lang="java"> // ...

boolean b1 = 5.0 > 6.0;

boolean b2 = 10.0 < 5.0; </source>

kirjutada nii:

<source lang="java"> boolean b1 = lessThan(6.0, 5.0); boolean b2 = lessThan(10.0, 5.0); </source>

Return käske võib funktsioonis olla mitu. See võib esineda ükskõik kus (ei pea funktsiooni lõpus olema). Täpselt üks return käsk käivitatakse, et funktsiooni väärtus tagastada (kuna peale esimese käivitamist lõpetab funktsioon oma töö, teise käsuni ei jõuta).

Näiteks: <source lang="java"> static intnextN(int currentN) { if(currentN % 2 == 1) // test if current N is odd return 3 * currentN + 1; // if so, return this value else return currentN/ 2; // if not, return this instead } </source>

Funktsioonide dokumenteerimine (JavaDoc)

JavaDoc on dokumentatsiooni genereerimise tööriist, mis kasutab kommentaare koodist, et genereerida dokumentatsioon ehk "juhend".

Näiteks funktsiooni JavaDoc:

<source lang="java"> /**

* Calculates the length of the hypotenuse for the right triangle
* with the side lengths a and b.
* @param a The length of one side
* @param b The length of other side
* @return The length of the hypotenuse
*/

double pythagoras(double a, double b) { ... </source>

JavaDoc funktsioonidele:

• algab /** sümbolitega
• iga järgmie rida algab *-ga
• esimene lause on lühike kokkuvõte.
• seejärel võib tulla mitu lauset (või isegi mitu lõiku) kirjeldust
• parameetrid kirjeldatakse ära @param sildiga: @param [muutuja-nimi] [kirjeldus]
• tagastusväärtus (kui see on olemas) kirjeldatakse @return sildiga: @return [kirjeldus]
• silte on palju erinevaid lisaks nendele kahele mainitule
• lõppeb */ sümbolitega eraldi real

Rohkem informatsiooni: http://www.oracle.com/technetwork/java/javase/documentation/index-137868.html

Näide 3N funktsioonist:

<source lang="java"> static void print3NSequence(int startingValue) {

   int N = startingValue; 
   int count = 1; 
   System.out.println("The 3N+1 sequence starting from " + N);
   System.out.println();
   System.out.println(N); 

   while (N > 1) {
       if (N % 2 == 1)          // is N odd?
           N = 3 * N + 1;
       else
           N = N / 2;
       count++;                 // count this term
       System.out.println (N);  // print this term
   } 
   System.out.println ();
   System.out.println (
       "There were " + count + " terms in the sequence."); 

} // -print3NSequence()

</source>

Kui nüüd seda funktsiooni on vaja koodis välja kutsuda, tehakse seda järgnevalt:

print3NSequence(17);

mis kutsub eelkirjeldatud funktsiooni välja algväärtusega 17 (ehk siis funktsioonis startingValue = 17).

Samamoodi võib funktsiooni välja kutsuda muutujaga:

print3NSequence(k);

k peab olema int-tüüpi muutuja. Funktsioon kutsutakse välja k väärtusega. k väärtust ei muudeta.

Veel näide funktsiooni parameetritest ja väljakutsumisest: <source lang="java"> static void doTask(int N, double x, boolean test) { // statements to perform the task go here } </source>

Sellise funktsiooni võib välja kutsuda nii:

<source lang="java"> doTask(17, Math.sqrt(z + 1), z >= 10); </source>

See väljakutse teeb umbes sama välja, kui enne doTask sisu käivitada järgmine koodilõik: <source lang="java"> // declare an int named N with initial value 17 int N = 17;

// compute Math.sqrt(z + 1), use it to initialize // a new variable x of type double double x = Math.sqrt(z + 1);

// evaluate "z >= 10" and use the resulting true/false // value to initialize a new variable boolean test = (z >= 10); </source>