Többször beszéltem már a függvények használatának fontosságáról (többek között Programok működésének felépítése és Függvény és Változó nevek). De még nem beszéltem arról, hogy pontosan, hogyan is kell létrehozni illetve használni a függvényeket. Ez az egyik alapvető része a programozásnak, ezért következzen most egy rövid gyakorlati bemutatás.

Ez a bemutató érvényes mind a Java, mind pedig a C nyelvre, minthogy a függvények használata mind a két nyelvben ugyanúgy történik, de én most mégis egy rövid Java programban fogom végigvenni a lényeget.

Mielőtt rátérnék a gyakorlati részre, gyorsan nézzük meg, hogy elméletben mit is jelent egy függvény a programozásban?
Egy függvény nem más mint egy végrehajtható kódhalmaz, ami mindig ugyanazt csinálja, éppen attól függően, hogy milyen céllal hozták létre az adott függvényt. Tekintsünk a függvényre úgy mint egy fekete doboz, nem kell feltétlen ismernünk a tartalmát, van valamilyen bemenete és abból valamilyen módon előállítja a kimenetét. Ezt a dobozt (a függvényt) bárhonnan fel lehet használni, meg lehet hívni. Egy ilyen függvényhívás során, a függvényben lévő kódhalmaz végrehajtódik. A függvények célja nem más, mint a program egyes részeinek feldarabolása. Mintha egy könyv tartalmát fejezetekbe osztanánk fel, úgy osztjuk fel a programot különböző függvényekbe. Illetve mivel egy függvényt többször is meghívhatunk, ezért a program egy fontos részegységét elég egyszer lekódolni és azt utána tetszőlegesen sokszor felhasználhatjuk. Minden függvényhívás során ugyanaz a kód fog végrehajtódni, függetlenül attól, hogy a függvényt honnan hívták. Attól, hogy a függvény végrehajtása befejeződött, attól még maga program nem ér véget, hanem onnan folytatódik tovább ahonnan a függvény meg lett hívva. Két fontos lépés van:

1. A függvényhívás helye
2. A függvény tartalma

Először is nézzük meg, hogy hogyan lehet létrehozni egy függvényt. Minden függvénynek három része van:

1. A függvény visszatérési értéke -> A függvény által kiszámolt érték
2. A függvény neve
3. A függvény bemenete -> Azok a bemeneti adatok, amiket minden függvényhívás során kötelezően meg kell adni

(A dolog kicsit tud bonyolódni, ugyanis nem biztos, hogy egy függvénynek van visszatérési értéke vagy paramétere, de most a könnyebb megértés miatt ettől tekintsünk el. Neve mindig kell, hogy legyen, ezzel tehát nem lesz problémánk)

Ahhoz, hogy függvényekről tudjunk beszélni, ismernünk kell a változókat is, de ezen bloggcikknek nem célja mind a két terület bemutatása, ezért az egyszerűsítés érdekében, fogadjuk el az alábbi tényeket:

• Egy változó nem más, mint egy átmeneti tárolója egy bizonyos értéknek
• A változó értékét tetszőlegesen lehet írni és olvasni
• Minden változónak van típusa, például:
  
  • int: egész szám típus
  • double: nem egész szám típus

Hogyan is néz ki akkor egy függvény létrehozása?
Deklaráljuk az összeadó függvényt, ami összead egy egész és egy nem egész számot, aminek az eredménye egy nem egész szám. Íme:

Elkészült az összeadó függvényünk deklarációja. A függvény az alábbi kóddal rendelkezik:

double sumOfTwoNumbers(int number1, double number2)
{

return (number1 + number2);

}

Most már nincs más teendőnk, csupán a megfelelő bemenetekkel (paraméterekkel), meg kell hívni a függvényünket. Íme:

Egy nagyon fontos dologra felhívnám a figyelmet. A függvényen belül már nem látjuk azokat a dolgokat amik a függvényhívás helyén történtek. Hogyan is láthatnánk, hiszen a függvényeknek pont az az előnye, hogy bárhonnan meg tudjuk őket hívni. Az egyetlen pont ahol összekapcsolódnak az a bemenete és a kimenete a függvénynek. De itt is csak típusok szinten van összekapcsolódás, a változók elnevezésében például már lehetnek eltérések.

A fenti példaprogramban tehát először létrehozunk két számot a megfelelő típusokkal (sumOfNumber2, sumOfNumber1), majd azokat a számokat átadjuk a függvénynek (ezek lesznek a függvény bemenetei, a paraméterek). Ezután nem kell feltétlen tudnunk, hogy pontosan mi történik (most az egyértelműség miatt a függvény működését zölddel bekereteztem, összeadjuk a két számot) a függvény visszaadja az eredményt, amit a függvényhívás helyén fel is használunk, azáltal, hogy letároljuk a függvény eredményét (visszatérési értékét) egy harmadik változóba (result). Amit nagyon fontos megérteni, hogy mi a különbség a függvény létrehozása (deklarálása) és a felhasználása között.

A deklarációkor adjuk meg a

1. Függvény nevét
2. Visszatérési értékének típusát
3. Paramétereinek típusát és nevét

A függvényen belül már csak ezeket a paramétereket fogjuk tudni felhasználni, mint kívülről származó információ.

A függvény használatakor már csak a megfelelő módon meghívjuk a függvényt, átadjuk neki a kötelező paramétereket és ha akarjuk felhasználjuk a függvény kimenetét (de ez nem kötelező).

Ez volt a függvények legalapvetőbb felhasználásának módja. Ha megértjük a függvények célját, illetve az összefüggéseket a függvények létrehozása és felhasználása között, akkor már a nehezén túl vagyunk. Remélem tudtam segíteni a megértésben.

A teljes példaprogramot itt eléritek.

Ha további részletekre vagytok kíváncsiak, jobban meg szeretnétek érteni a függvényeket és a belőlük felépülő programokat, akkor itt a helyetek! A függvényeket részletesen átbeszéljük a Java Tanfolyamon is, sőt még ennél is többet!