În cadrul episodului anterior am văzut cum putem crea și apela funcții. Dar acestea erau foarte simple; practic, erau o înșiruire de instrucțiuni care, eventual, ar putea fi apelate de mai multe ori. Vom vedea acum că putem face mai multe.
Să considerăm următoarea secvență:
|
1 2 3 4 5 6 |
int nr = 2457; if (nr % 2 == 0) { System.out.println("Număr par"); } else { System.out.println("Număr impar"); } |
Verificăm dacă un număr este par și afișăm un mesaj corespunzător, după caz. Verificarea se face simplu: numerele pare se împart exact la 2 (restul împărțirii la doi este zero), iar cele impare nu.
În urma executării acestei secvențe, s-ar afișa mesajul Număr impar. Dacă am vrea să verificăm paritatea altui număr am mofica prima linie, inițializând variabila nr cu o altă valoare.
Am putea pune acest cod într-o funcție. Am văzut că uneori e mai bine așa... Funcția noastră ar putea arăta astfel:
|
1 2 3 4 5 6 7 8 |
private static void verificareParitate() { int nr = 2457; if (nr % 2 == 0) { System.out.println("Număr par"); } else { System.out.println("Număr impar"); } } |
Acum putem să o apelăm de mai multe ori; dar, nu facem decât să verificăm de câte ori vrem paritatea aceluiași număr ( 2457 dacă nu-l schimbăm). Nu pare foarte util...
Dar, cum ar fi dacă am putea să verificăm paritatea oricărui număr am dori. Nu ar fi frumos ca atunci când apelăm funcția să putem preciza și care este numărul a cărui paritate vrem să o verificăm?
Din fericire este posibil. Vă amintiți de acele ciudate parenteze care trebuie adăugate și când definim și când apelăm funcția? Vom vedea acum la ce sunt bune... În momentul în care apelăm funcția, putem să precizăm anumite valori sau variabile, pe care le punem între acele paranteze; dacă sunt mai multe, le separăm prin virgule. Ele poartă denumirea de argumente ale apelului.
În situația noastră, am vrea să verificăm paritatea anumitor numere: apelurile noastre ar putea arăta așa:
|
1 2 3 4 |
verificareParitate(2457); verificareParitate(47); verificareParitate(0); verificareParitate(a); |
Avem patru apeluri. În urma executării primelor două s-ar afișa textul Număr impar, pentru al treilea s-ar afișa textul Număr par, iar textul afișat pentru ultimul depinde de valoarea curentă a variabilei a.
Dar, așa cum arată funcția noastră acum, ea nu ia în seamă nicio eventuală valoare care însoțește apelul. Dar, are și ea acele paranteze care par inutile. Probabil ați ghicit, putem pune aici ceva. Practic, putem face în așa fel încât valorile argumentelor apelului să fie disponibile. Pentru aceasta avem așa-numiții parametri ai funcției. Ei seamănă cu niște variabile: au tip și denumire. Putem modifica foarte ușor funcția noastră astfel încât ea să aibă un parametru:
|
1 2 3 4 5 6 7 |
private static void verificareParitate(int nr) { if (nr % 2 == 0) { System.out.println("Număr par"); } else { System.out.println("Număr impar"); } } |
Dacă funcția are mai mulți parametri, sunt separați și ei prin virgule.
De multe ori denumirile de argument și parametru nu sunt folosite corect. Veți auzi sau vedea de multe ori spunându-se că apelul are parametri sau funcția are argumente. Noțiunile au ajuns să fie aproape interschimbabile. De fapt, nici nu ar prea au de ce să fie diferite. Dar, strict vorbind, funcțiile au parametri și apelurile au argumente.
În Java, tipurile și numărul argumentelor trebuie să se potrivească. Așadar, pentru noua versiune a funcției, următoarea apeluri nu sunt corecte:
|
1 2 3 |
verificareParitate(2, 3); verificareParitate("text"); verificareParitate(); |
Când apelăm funcția, putem avea orice argument care este compatibil cu tipul argumentului; am văzut că putem folosi valori sau variabile; dar, putem avea și expresii, atâta timp cât tipul rezultatului este compatibil. Următoarea secvență este corectă:
|
1 2 3 4 5 |
verificareParitate(2 + 3); int nr = 2457; verificareParitate(nr + 47); bool exista = true; verificareParitate(exista ? nr : 13); |
Dacă privim cu atenție, ne dăm seama că foloseam apeluri cu argumente încă de la primul episod. Să revenim la primul program pe care l-am scris în Java:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
/* package whatever; // don't place package name! */ import java.util.*; import java.lang.*; import java.io.*; /* Name of the class has to be "Main" only if the class is public. */ class Ideone { public static void main (String[] args) throws java.lang.Exception { System.out.println("Gazeta de Informatică"); } } |
În linia 12 vedeți ceva ce seamănă foarte mult cu un apel de funcție; aceasta ar fi System.out.println, iar argumentul ar fi "Gazeta de Informatică". Este într-adevăr un apel de funcție; nu apelăm o funcție pe care am creat-o noi, ci una care există deja în Java. Această funcție afișează la ieșire un mesaj pe care îl primește ca parametru.
Mai trebuie precizat faptul că denumirea funcției este doar println (nu pot fi folosite puncte în denumirile funcțiilor); System și out sunt altceva și nu vom intra în detalii acum fiindcă nu sunt relevante (cel puțin nu în acest moment).
Va urma
Deocamdată am transmis funcției informații din exterior. În episodul următor vom vedea cum putem comunica și în sens invers; funcțiile pot și ele genera anumite valori pe care să le comunice apelantului.
