Capitolul V
5.3 Instrucţiuni

5.3.1 Blocuri de instrucţiuni

5.3.1.1 Declaraţii de variabile locale

5.3.2 Tipuri de instrucţiuni

5.3.2.1 Instrucţiuni de atribuire

5.3.2.1.1 Atribuire cu operaţie
5.3.2.1.2 Atribuiri implicite

5.3.2.2 Instrucţiuni etichetate
5.3.2.3 Instrucţiuni condiţionale

5.3.2.3.1 Instrucţiunea if
5.3.2.3.2 Instrucţiunea switch

5.3.2.4 Instrucţiuni de ciclare

5.3.2.4.1 Instrucţiunea while
5.3.2.4.2 Instrucţiunea do
5.3.2.4.3 Instrucţiunea for

5.3.2.5 Instrucţiuni de salt

5.3.2.5.1 Instrucţiunea break
5.3.2.5.2 Instrucţiunea continue
5.3.2.5.3 Instrucţiunea return
5.3.2.5.4 Instrucţiunea throw

5.3.2.6 Instrucţiuni de protecţie

5.3.2.6.1 Instrucţiunea try
5.3.2.6.2 Instrucţiunea synchronized

5.3.2.7 Instrucţiunea vidă

5.3.1 Blocuri de instrucţiuni

Un bloc de instrucţiuni este o secvenţă, eventual vidă, de instrucţiuni şi declaraţii de variabile locale. Aceste instrucţiuni se execută în ordinea în care apar în interiorul blocului. Sintactic, blocurile de instrucţiuni sunt delimitate în sursă de caracterele { şi }.

În limbajul Java, regula generală este aceea că oriunde putem pune o instrucţiune putem pune şi un bloc de instrucţiuni, cu câteva excepţii pe

care le vom sesiza la momentul potrivit, specificând în acest fel că instrucţiunile din interiorul blocului trebuiesc privite în mod unitar şi tratate ca o singură instrucţiune.

5.3.1.1 Declaraţii de variabile locale

O declaraţie de variabilă locală introduce o nouă variabilă care poate fi folosită doar în interiorul blocului în care a fost definită. Declaraţia trebuie să conţină un nume şi un tip. În plus, într-o declaraţie putem specifica o valoare iniţială în cazul în care valoarea implicită a tipului variabilei, definită standard de limbajul Java, nu ne satisface.

Numele variabilei este un identificator Java. Acest nume trebuie să fie diferit de numele celorlalte variabile locale definite în blocul respectiv şi de eventualii parametri ai metodei în interiorul căreia este declarat blocul.

De exemplu, este o eroare de compilare să declarăm cea de-a doua variabilă x în blocul:

{
int x = 3;
…
{
int x = 5;
…
}
}

Compilatorul va semnala faptul că deja există o variabilă cu acest nume în interiorul metodei. Eroarea de compilare apare indiferent dacă cele două variabile sunt de acelaşi tip sau nu.

Nu acelaşi lucru se întâmplă însă dacă variabilele sunt declarate în două blocuri de instrucţiuni complet disjuncte, care nu se includ unul pe celălalt. De exemplu, declaraţiile următoare sunt perfect valide:

{
{
int x = 3;
…
}
…
{
int x = 5;
…
}
}

Practic, fiecare bloc de instrucţiuni defineşte un domeniu de existenţă a variabilelor locale declarate în interior. Dacă un bloc are subblocuri declarate în interiorul lui, variabilele din aceste subblocuri trebuie să fie distincte ca nume faţă de variabilele din superbloc. Aceste domenii se pot reprezenta grafic ca în figura următoare:

Figura 5.4 Reprezentarea grafică a domeniilor de existenţă a variabilelor incluse unul într-altul.

Figura reprezintă situaţia din primul exemplu. Observaţi că domeniul blocului interior este complet inclus în domeniul blocului exterior. Din această cauză, x apare ca fiind definită de două ori. În cel de-al doilea exemplu, reprezentarea grafică este următoarea:

Figura 5.5 Reprezentarea grafică a domeniilor de existenţă a variabilelor disjuncte.

În acest caz, domeniile în care sunt definite cele două variabile sunt complet disjuncte şi compilatorul nu va avea nici o dificultate în a identifica la fiecare referire a unei variabile cu numele x despre care variabilă este vorba. Să mai observăm că, în cel de-al doilea exemplu, referirea variabilelor x în blocul mare, în afara celor două subblocuri este o eroare de compilare.

În cazul în care blocul mare este blocul de implementare al unei metode şi metoda respectivă are parametri, aceşti parametri sunt luaţi în considerare la fel ca nişte declaraţii de variabile care apar chiar la începutul blocului. Acest lucru face ca numele parametrilor să nu poată fi folosit în nici o declaraţie de variabilă locală din blocul de implementare sau subblocuri ale acestuia.

În realitate, o variabilă locală poate fi referită în interiorul unui bloc abia după declaraţia ei. Cu alte cuvinte, domeniul de existenţă al unei variabile locale începe din punctul de declaraţie şi continuă până la terminarea blocului.

Astfel, următoarea secvenţă de instrucţiuni:

{
x = 4;
int x = 3;
}

va determina o eroare de compilare, cu specificaţia că variabila x nu a fost încă definită în momentul primei atribuiri.

Acest mod de lucru cu variabilele face corectă următoarea secvenţă de instrucţiuni:

{
{
int x = 4;
}
int x = 3;
}

pentru că, în momentul declaraţiei din interiorul subblocului, variabila x din exterior nu este încă definită. La ieşirea din subbloc, prima declaraţie îşi termină domeniul, aşa că se poate defini fără probleme o nouă variabilă cu acelaşi nume.

5.3.2 Tipuri de instrucţiuni

5.3.2.1 Instrucţiuni de atribuire

O atribuire este o setare de valoare într-o locaţie de memorie. Forma generală a unei astfel de instrucţiuni este:

Locaţie = valoare ;

Specificarea locaţiei se poate face în mai multe feluri. Cel mai simplu este să specificăm un nume de variabilă locală. Alte alternative sunt acelea de a specifica un element dintr-un tablou de elemente sau o variabilă care nu este declarată finală din interiorul unei clase sau numele unui parametru al unei metode.

Valoarea care trebuie atribuită poate fi un literal sau rezultatul evaluării unei expresii.

Instrucţiunea de atribuire are ca rezultat chiar valoarea atribuită. Din această cauză, la partea de valoare a unei operaţii de atribuire putem avea chiar o altă operaţie de atribuire ca în exemplul următor:

int x = 5;
int y = 6;
x = ( y = y / 2 );

Valoarea finală a lui x va fi identică cu valoarea lui y şi va fi egală cu 3. Parantezele de mai sus sunt puse doar pentru claritatea codului, pentru a înţelege exact care este ordinea în care se execută atribuirile. În realitate, ele pot să lipsească pentru că, în mod implicit, Java va executa întâi atribuirea din dreapta. Deci, ultima linie se poate rescrie ca:

x = y = y / 2;

De altfel, gruparea inversă nici nu are sens:

( x = y ) = y / 2;

Această instrucţiune va genera o eroare de compilare pentru că, după executarea atribuirii din paranteze, rezultatul este valoarea 6 iar unei valori nu i se poate atribui o altă valoare.

În momentul atribuirii, dacă valoarea din partea dreaptă a operaţiei nu este de acelaşi tip cu locaţia din partea stângă, compilatorul va încerca conversia valorii la tipul locaţiei în modul pe care l-am discutat în paragraful referitor la conversii. Această conversie trebuie să fie posibilă, altfel compilatorul va semnala o eroare.

Pentru anumite conversii, eroarea s-ar putea să nu poată fi depistată decât în timpul execuţiei. În aceste cazuri, compilatorul nu va semnala eroare dar va fi semnalată o eroare în timpul execuţiei şi rularea programului va fi abandonată.

5.3.2.1.1 Atribuire cu operaţie

Se întâmplă deseori ca valoarea care se atribuie unei locaţii să depindă de vechea valoare care era memorată în locaţia respectivă. De exemplu, în instrucţiunea:

int x = 3;
x = x * 4;

vechea valoare a lui x este înmulţită cu 4 şi rezultatul înmulţirii este memorat înapoi în locaţia destinată lui x. Într-o astfel de instrucţiune, calculul adresei locaţiei lui x este efectuat de două ori, o dată pentru a lua vechea valoare şi încă o dată pentru a memora noua valoare. În realitate, acest calcul nu ar trebui executat de două ori pentru că locaţia variabilei x nu se schimbă în timpul instrucţiunii.

Pentru a ajuta compilatorul la generarea unui cod eficient, care să calculeze locaţia lui x o singură dată, în limbajul Java au fost introduse instrucţiuni mixte de calcul combinat cu atribuire. În cazul nostru, noua formă de scriere, mai eficientă, este:

int x = 3;
x *= 4;

Eficienţa acestei exprimări este cu atât mai mare cu cât calculul locaţiei este mai complicat. De exemplu, în secvenţa următoare:

int x = 3, y = 5;
double valori[] = new double[10];
valori[( x + y ) / 2] += 3.5;

calculul locaţiei de unde se va lua o valoare la care se va aduna 3.5 şi unde se va memora înapoi rezultatul acestei operaţii este efectuat o singură dată. În acest exemplu, calcului locaţiei presupune execuţia expresiei:

( x + y ) / 2

şi indexarea tabloului numit valori cu valoarea rezultată. Valoarea din partea dreaptă poate fi o expresie arbitrar de complicată, ca în:

valori[x] += 7.0 * ( y * 5 );

Iată toţi operatorii care pot fi mixaţi cu o atribuire:

*=, /=, %=, +=, -=, <<=, >>=, >>>=,   &=, |=, ^= ^

5.3.2.1.2 Atribuiri implicite

Să mai observăm că, în cazul folosirii operatorilor de incrementare şi decrementare se face şi o atribuire implicită pentru că pe lângă valoarea rezultată în urma operaţiei, se modifică şi valoarea memorată la locaţia pe care se aplică operatorul. La fel ca şi la operaţiile mixte de atribuire, calculul locaţiei asupra căreia se aplică operatorul se efectuează o singură dată.

5.3.2.2 Instrucţiuni etichetate

Unele dintre instrucţiunile din interiorul unui bloc de instrucţiuni trebuie referite din altă parte a programului pentru a se putea direcţiona execuţia spre aceste instrucţiuni. Pentru referirea acestor instrucţiuni, este necesar ca ele să aibă o etichetă asociată. O etichetă este deci un nume dat unei instrucţiuni din program prin care instrucţiunea respectivă poate fi referită din alte părţi ale programului.

Eticheta cea mai simplă este un simplu identificator urmat de caracterul : şi de instrucţiunea pe care dorim să o etichetăm:

Etichetă: Instrucţiune

ca în exemplul următor:

int a = 5;
Eticheta: a = 3;

Pentru instrucţiunea switch, descrisă mai jos, sunt definite două moduri diferite de etichetare. Acestea au forma:

case Valoare: Instrucţiune

default: Instrucţiune

Exemple pentru folosirea acestor forme sunt date la definirea instrucţiunii.

5.3.2.3 Instrucţiuni condiţionale

Instrucţiunile condiţionale sunt instrucţiuni care selectează pentru execuţie o instrucţiune dintr-un set de instrucţiuni în funcţie de o anumită condiţie.

5.3.2.3.1 Instrucţiunea if

Instrucţiunea if primeşte o expresie a cărei valoare este obligatoriu de tipul boolean. Evaluarea acestei expresii poate duce la doar două valori: adevărat sau fals. În funcţie de valoarea rezultată din această evaluare, se execută unul din două seturi de instrucţiuni distincte, specificate de instrucţiunea if.

Sintaxa acestei instrucţiuni este următoarea:

if( Expresie ) Instrucţiune1 [else Instrucţiune2]

După evaluarea expresiei booleene, dacă valoarea rezultată este true, se execută instrucţiunea 1.

Restul instrucţiunii este opţional, cu alte cuvinte partea care începe cu cuvântul rezervat else poate să lipsească. În cazul în care această parte nu lipseşte, dacă rezultatul evaluării expresiei este false se va executa instrucţiunea 2.

Indiferent de instrucţiunea care a fost executată în interiorul unui if, după terminarea acesteia execuţia continuă cu instrucţiunea de după instrucţiunea if, în afară de cazul în care instrucţiunile executate conţin în interior o instrucţiune de salt.

Să mai observăm că este posibil ca într-o instrucţiune if să nu se execute nici o instrucţiune în afară de evaluarea expresiei în cazul în care expresia este falsă iar partea else din instrucţiunea if lipseşte. Expresia booleană va fi întotdeauna evaluată.

Iată un exemplu de instrucţiune if în care partea else lipseşte:

int x = 3;
if( x == 3 )
x *= 7;

şi iată un exemplu în care sunt prezente ambele părţi:

int x = 5;
if( x % 2 == 0 )
x = 100;
else
x = 1000;

Instrucţiunea 1 nu poate lipsi niciodată. Dacă totuşi pe ramura de adevăr a instrucţiunii condiţionale nu dorim să executăm nimic, putem folosi o instrucţiune vidă, după cum este arătat puţin mai departe.

În cazul în care dorim să executăm mai multe instrucţiuni pe una dintre ramurile instrucţiunii if, putem să în locuim instrucţiunea 1 sau 2 sau pe amândouă cu blocuri de instrucţiuni, ca în exemplul următor:

int x = 5;
if( x == 0 ) {
x = 3;
y = x * 5;
} else {
x = 5;
y = x * 7;
}

Expresia booleană poate să fie şi o expresie compusă de forma:

int x = 3;
int y = 5;
if( y != 0 && x / y == 2 ) 
x = 4;

În acest caz, aşa cum deja s-a specificat la descrierea operatorului &&, evaluarea expresiei nu este terminată în toate situaţiile. În exemplul nostru, dacă y este egal cu 0, evaluarea expresiei este oprită şi rezultatul este fals. Această comportare este corectă pentru că, dacă un termen al unei operaţii logice de conjuncţie este fals, atunci întreaga conjuncţie este falsă.

În plus, acest mod de execuţie ne permite să evităm unele operaţii cu rezultat incert, în cazul nostru o împărţire prin 0. Pentru mai multe informaţii relative la operatorii && şi || citiţi secţiunea destinată operatorilor.

5.3.2.3.2 Instrucţiunea switch

Instrucţiunea switch ne permite saltul la o anumită instrucţiune etichetată în funcţie de valoarea unei expresii. Putem să specificăm câte o etichetă pentru fiecare valoare particulară a expresiei pe care dorim să o diferenţiem. În plus, putem specifica o etichetă la care să se facă saltul implicit, dacă expresia nu ia nici una dintre valorile particulare specificate.

Sintaxa instrucţiunii este:

switch( Expresie ) {

[case ValoareParticulară: Instrucţiuni;]*

[default: InstrucţiuniImplicite;]

}

Execuţia unei instrucţiuni switch începe întotdeauna prin evaluarea expresiei dintre parantezele rotunde. Această expresie trebuie să aibă tipul caracter, octet, întreg scurt sau întreg. După evaluarea expresiei se trece la compararea valorii rezultate cu valorile particulare specificate în etichetele case din interiorul blocului de instrucţiuni. Dacă una dintre valorile particulare este egală cu valoarea expresiei, se execută instrucţiunile începând de la eticheta case corespunzătoare acelei valori în jos, până la capătul blocului. Dacă nici una dintre valorile particulare specificate nu este egală cu valoarea expresiei, se execută instrucţiunile care încep cu eticheta default, dacă aceasta există.

Iată un exemplu de instrucţiune switch:

int x = 4;
…
int y = 0;
switch( x + 1 ) {
case 3:
x += 2;
y++;
case 5:
x = 11;
y++;
default:
x = 4;
y += 3;
}

Dacă valoarea lui x în timpul evaluării expresiei este 2 atunci expresia va avea valoarea 3 şi instrucţiunile vor fi executate una după alta începând cu cea etichetată cu case 3. În ordine, x va deveni 4, y va deveni 1, x va deveni 11, y va deveni 2, x va deveni 4 şi y va deveni 5.

Dacă valoarea lui x în timpul evaluării expresiei este 4 atunci expresia va avea valoarea 5 şi instrucţiunile vor fi executate pornind de la cea etichetată cu case 5. În ordine, x va deveni 11, y va deveni 1, x va deveni 4 şi y va deveni 4.

În fine, dacă valoarea lui x în timpul evaluării expresiei este diferită de 2 şi 4, se vor executa instrucţiunile începând cu cea etichetată cu default. În ordine, x va deveni 4 şi y va deveni 3.

Eticheta default poate lipsi, caz în care, dacă nici una dintre valorile particulare nu este egală cu valoarea expresiei, nu se va executa nici o instrucţiune din bloc.

În cele mai multe cazuri, această comportare a instrucţiunii switch nu ne convine, din cauza faptului că instrucţiunile de după cea etichetată cu case 5 se vor executa şi dacă valoarea este 3. La fel, instrucţiunile de după cea etichetată cu default se execută întotdeauna. Pentru a schimba această comportare trebuie să folosim una dintre instrucţiunile de salt care să oprească execuţia instrucţiunilor din bloc înainte de întâlnirea unei noi instrucţiuni etichetate.

Putem de exemplu folosi instrucţiunea de salt break care va opri execuţia instrucţiunilor din blocul switch. De exemplu:

char c = '\t';
…
String mesaj = "nimic";
switch( c ) {
case '\t':
mesaj = "tab";
break;
case '\n':
mesaj = "linie noua";
break;
case '\r':
mesaj = "retur";
default:
mesaj = mesaj + " de";
mesaj = mesaj + " car";
}

În acest caz, dacă c este egal cu caracterul tab, la terminarea instrucţiunii switch, mesaj va avea valoarea "tab". În cazul în care c are valoarea CR, mesaj va deveni mai întâi "retur" apoi "retur de" şi apoi "retur de car". Lipsa lui break după instrucţiunea

mesaj = "retur";

face ca în continuare să fie executate şi instrucţiunile de după cea etichetată cu default.

5.3.2.4 Instrucţiuni de ciclare

Instrucţiunile de ciclare (sau ciclurile, sau buclele) sunt necesare atunci când dorim să executăm de mai multe ori aceeaşi instrucţiune sau acelaşi bloc de instrucţiuni. Necesitatea acestui lucru este evidentă dacă ne gândim că programele trebuie să poată reprezenta acţiuni de forma: execută 10 întoarceri, execută 7 genoflexiuni, execută flotări până ai obosit, etc.

Desigur, sintaxa instrucţiunilor care se execută trebuie să fie aceeaşi, pentru că ele vor fi în realitate scrise în Java o singură dată. Totuşi, instrucţiunile nu sunt neapărat aceleaşi. De exemplu, dacă executăm în mod repetat instrucţiunea:

int tablou[] = new int[10];
int i = 0;
tablou[i++] = 0;

în realitate se va memora valoarea 0 în locaţii diferite pentru că variabila care participă la calculul locaţiei îşi modifică la fiecare iteraţie valoarea. La primul pas, se va face 0 primul element din tablou şi în acelaşi timp i va primi valoarea 1. La al doilea pas, se va face 0 al doilea element din tablou şi i va primi valoarea 2, şi aşa mai departe.

Lucrurile par şi mai clare dacă ne gândim că instrucţiunea executată în mod repetat poate fi o instrucţiune if. În acest caz, În funcţie de expresia condiţională din if se poate executa o ramură sau alta a instrucţiunii.

De exemplu instrucţiunea din buclă poate fi:

int i = 0;
if( i++ % 2 == 0 )
…
else
…

În acest caz, i este când par când impar şi se execută alternativ cele două ramuri din if. Desigur, comportarea descrisă este valabilă dacă valoarea lui i nu este modificată în interiorul uneia dintre ramuri.

5.3.2.4.1 Instrucţiunea while

Această instrucţiune de buclare se foloseşte atunci când vrem să executăm o instrucţiune atâta timp cât o anumită expresie condiţională rămâne adevărată. Expresia condiţională se evaluează şi testează înainte de execuţia instrucţiunii, astfel că, dacă expresia era de la început falsă, instrucţiunea nu se mai executa niciodată.

Sintaxa acestei instrucţiuni este:

while( Test ) Corp

Test este o expresie booleană iar Corp este o instrucţiune normală, eventual vidă. Dacă avem nevoie să repetăm mai multe instrucţiuni, putem înlocui corpul buclei cu un bloc de instrucţiuni.

Iată şi un exemplu:

int i = 0;
int tablou[] = new int[20];
while( i < 10 )
tablou[i++] = 1;

Bucla while de mai sus se execută de 10 ori primele 10 elemente din tablou fiind iniţializate cu 1. În treacăt fie spus, celelalte rămân la valoarea 0 care este valoarea implicită pentru întregi. După cei 10 paşi iterativi, i devine 10 şi testul devine fals (10 < 10).

În exemplul următor, corpul nu se execută nici măcar o dată:

int i = 3;
while( i < 3 )
i++;

Putem să creăm un ciclu infinit (care nu se termină niciodată) prin:

while( true )
;

Întreruperea execuţiei unui ciclu infinit se poate face introducând în corpul ciclului o instrucţiune de salt.

5.3.2.4.2 Instrucţiunea do

Buclele do se folosesc atunci când testul de terminare a buclei trebuie făcut după execuţia corpului buclei. Sintaxa de descriere a instrucţiuni do este:

do Corp while( Test ) ;

Test este o expresie booleană iar Corp este o instrucţiune sau un bloc de instrucţiuni. Execuţia acestei instrucţiuni înseamnă execuţia corpului în mod repetat atâta timp cât expresia Test are valoarea adevărat. Testul se evaluează după execuţia corpului, deci corpul se execută cel puţin o dată.

De exemplu, în instrucţiunea:

int i = 3;
do
i++;
while( false );

valoarea finală a lui i este 4, pentru că instrucţiunea i++ care formează corpul buclei se execută o dată chiar dacă testul este întotdeauna fals.

În instrucţiunea:

int i = 1;
do {
tablou[i] = 0;
i += 2;
} while( i < 5 );

sunt setate pe 0 elementele 1 şi 3 din tablou. După a doua iteraţie, i devine 5 şi testul eşuează cauzând terminarea iteraţiei.

5.3.2.4.3 Instrucţiunea for

Instrucţiunea for se foloseşte atunci când putem identifica foarte clar o parte de iniţializare a buclei, testul de terminare a buclei, o parte de reluare a buclei şi un corp pentru buclă. În acest caz, putem folosi sintaxa:

for( Iniţializare Test ; Reluare ) Corp

Corp şi Iniţializare sunt instrucţiuni normale. Test este o expresie booleană iar Reluare este o instrucţiune căreia îi lipseşte caracterul ; final.

Execuţia unei bucle for începe cu execuţia instrucţiunii de iniţializare. Această instrucţiune stabileşte de obicei nişte valori pentru variabilele care controlează bucla. Putem chiar declara aici noi variabile. Aceste variabile există doar în interiorul corpului buclei şi în instrucţiunile de test şi reluare ale buclei.

În partea de iniţializare nu putem scrie decât o singură instrucţiune fie ea declaraţie sau instrucţiune normală. În acest caz instrucţiunea nu se poate înlocui cu un bloc de instrucţiuni. Putem însă să declarăm două variabile cu o sintaxă de forma:

int i = 0, j = 1;

După execuţia părţii de iniţializare se porneşte bucla propriu-zisă. Aceasta constă din trei instrucţiuni diferite executate în mod repetat. Cele trei instrucţiuni sunt testul, corpul buclei şi instrucţiunea de reluare. Testul trebuie să fie o expresie booleană. Dacă aceasta este evaluată la valoarea adevărat, bucla continuă cu execuţia corpului, a instrucţiunii de reluare şi din nou a testului. În clipa în care testul are valoarea fals, bucla este oprită fără să mai fie executat corpul sau reluarea.

Iată un exemplu:

int x = 0;
for( int i = 3; i < 30; i += 10 )
x += i;

În această buclă se execută mai întâi crearea variabilei i şi iniţializarea acesteia cu 3. După aceea se testează variabila i dacă are o valoare mai mică decât 30. Testul are rezultat adevărat (i este 0 < 30) şi se trece la execuţia corpului unde x primeşte valoarea 3 (0 + 3). În continuare se execută partea de reluare în care i este crescut cu 10, devenind 13. Se termină astfel primul pas al buclei şi aceasta este reluată începând cu testul care este în continuare adevărat (13 < 30). Se execută corpul, x devenind 16 (3 + 13), şi reluarea, unde x devine 23 (13 + 10). Se reia bucla de la test care este în continuare adevărat (23 < 30). Se execută corpul unde x devine 39 (16 + 23) şi reluarea unde i devine 33 (23 + 10). Se reia testul care în acest caz devine fals (33 < 30) şi se părăseşte bucla, continuându-se execuţia cu prima instrucţiune de după buclă.

După ieşirea din buclă, variabila i nu mai există, deci nu se mai poate folosi şi nu putem vorbi despre valoarea cu care iese din buclă, iar variabila x rămâne cu valoarea 39.

Pentru a putea declara variabila i în instrucţiunea de iniţializare a buclei for este necesar ca în blocurile superioare instrucţiunii for să nu existe o altă variabilă i, să nu existe un parametru numit i şi nici o etichetă cu acest nume.

Dacă dorim un corp care să conţină mai multe instrucţiuni, putem folosi un bloc. Nu putem face acelaşi lucru în partea de iniţializare sau în partea de reluare.

Oricare dintre părţile buclei for în afară de iniţializare poate să lipsească. Dacă aceste părţi lipsesc, se consideră că ele sunt reprezentate de instrucţiunea vidă. Dacă nu dorim iniţializare trebuie totuşi să specificăm implicit instrucţiunea vidă. Putem de exemplu să scriem o buclă infinită prin:

int x;
for( ;; )
x = 0;

Putem specifica funcţionarea instrucţiunii for folosindu-ne de o instrucţiune while în felul următor:

Iniţializare

while( Test ) {

Corp

Reluare ;

}

În fine, schema următoare reprezintă funcţionarea unei bucle for:

Figura 5.6 Schema de funcţionare a buclei for.

5.3.2.5 Instrucţiuni de salt

Instrucţiunile de salt provoacă întreruperea forţată a unei bucle, a unui bloc de instrucţiuni sau ieşirea dintr-o metodă. Instrucţiunile de salt sunt destul de periculoase pentru că perturbă curgerea uniformă a programului ceea ce poate duce la o citire şi înţelegere eronată a codului rezultat.

5.3.2.5.1 Instrucţiunea break

Instrucţiunea break produce întreruperea unei bucle sau a unui bloc switch. Controlul este dat instrucţiunii care urmează imediat după bucla întreruptă sau după blocul instrucţiunii switch.

De exemplu în secvenţa:

int i = 1, j = 3;
int tablou[] = new int[10];
while( i < 10 ) {
tablou[i++] = 0;
if( i == j )
break;
}
i += 2;

sunt setate pe 0 elementele 1 şi 2 ale tabloului. După a doua iteraţie i devine 3 şi testul i == j are valoarea adevărat, producându-se execuţia instrucţiunii break.

Instrucţiunea break cauzează ieşirea forţată din buclă, chiar dacă testul buclei i < 10 este în continuare valid. La terminarea tuturor instrucţiunilor de mai sus, i are valoarea 5.

În exemplul următor:

int i, j = 3;
int tablou[] = new tablou[10];
do {
tablou[i] = 0;
if( i++ >= j )
break;
} while( i < 10 );

sunt setate pe 0 elementele 0, 1, 2 şi 3 din tablou. Dacă vă întrebaţi la ce mai foloseşte testul buclei, atunci să spunem că este o măsură suplimentară de siguranţă. Dacă cumva j intră cu o valoare greşită, testul ne asigură în continuare că nu vom încerca să setăm un element care nu există al tabloului. De fapt, pericolul există încă, dacă valoarea iniţială a lui i este greşită, deci testul ar trebui mutat la început şi bucla transformată într-un while, ca cel de mai sus.

În cazul buclelor for, să mai precizăm faptul că la o ieşire forţată nu se mai execută instrucţiunea de reluare.

Instrucţiunea break poate avea ca argument opţional o etichetă, ca în:

break Identificator;

În acest caz, identificatorul trebuie să fie eticheta unei instrucţiuni care să includă instrucţiunea break. Prin faptul că instrucţiunea include instrucţiunea break, înţelegem că instrucţiunea break apare în corpul instrucţiunii care o include sau în corpul unei instrucţiuni care se găseşte în interiorul corpului instrucţiunii care include instrucţiunea break. Controlul revine instrucţiunii de după instrucţiunea etichetată cu identificatorul specificat.

De exemplu, în instrucţiunile:

int i, j;
asta: while( i < 3 ) {
do {
i = j + 1;
if( i == 3 )
break asta;
} while( j++ < 3 );
}
j = 10;

instrucţiunea break termină bucla do şi bucla while controlul fiind dat instrucţiunii de după while, şi anume atribuirea:

j = 10; 

5.3.2.5.2 Instrucţiunea continue

Instrucţiunea continue permite reluarea unei bucle fără a mai termina execuţia corpului acesteia. Reluarea se face ca şi cum corpul buclei tocmai a fost terminat de executat. Bucla nu este părăsită.

De exemplu, în instrucţiunea:

int i;
while( i < 10 ) {
i++;
continue;
i++;
}

corpul buclei se execută de 10 ori, pentru că a doua incrementare a lui i nu se execută niciodată. Execuţia începe cu testul şi apoi urmează cu prima incrementare. După aceasta se execută instrucţiunea continue care duce la reluarea buclei, pornind de la test şi urmând cu incrementarea şi din nou instrucţiunea continue.

În exemplul următor:

int i;
do {
i++;
continue;
i++;
} while( i < 10 );

corpul se execută de 10 ori la fel ca şi mai sus. Instrucţiunea continue duce la evitarea celei de-a doua incrementări, dar nu şi la evitarea testului de sfârşit de buclă.

În sfârşit, în exemplul următor:

for( int i = 0; i < 10; i++ ) {
continue;
i++;
}

corpul se execută tot de 10 ori, ceea ce înseamnă că reluarea buclei duce la execuţia instrucţiunii de reluare a buclei for şi apoi a testului. Doar ceea ce este în interiorul corpului este evitat.

Instrucţiunea continue poate avea, la fel ca şi instrucţiunea break, un identificator opţional care specifică eticheta buclei care trebuie continuată. Dacă există mai multe bucle imbricate una în cealaltă buclele interioare celei referite de etichetă sunt abandonate.

De exemplu, în secvenţa:

asta: for( int i, j = 1; i < 10; i++ ) {
while( j < 5 ) {
j++;
if( j % 2 == 0 )
continue asta;
}
}

instrucţiunea continue provoacă abandonarea buclei while şi reluarea buclei for cu partea de reluare şi apoi testul.

5.3.2.5.3 Instrucţiunea return

Instrucţiunea return provoacă părăsirea corpului unei metode. În cazul în care return este urmată de o expresie, valoarea expresiei este folosită ca valoare de retur a metodei. Această valoare poate fi eventual convertită către tipul de valoare de retur declarat al metodei, dacă acest lucru este posibil. Dacă nu este posibil, va fi semnalată o eroare de compilare.

Este o eroare de compilare specificarea unei valori de retur într-o instrucţiune return din interiorul unei metode care este declarată void, cu alte cuvinte care nu întoarce nici o valoare.

Instrucţiunea return fără valoare de retur poate fi folosită şi pentru a părăsi execuţia unui iniţializator static.

Exemple de instrucţiuni return veţi găsi în secţiunea care tratează metodele unei clase de obiecte.

5.3.2.5.4 Instrucţiunea throw

Instrucţiunea throw este folosită pentru a semnaliza o excepţie de execuţie. Această instrucţiune trebuie să aibă un argument şi acesta trebuie să fie un tip obiect, de obicei dintr-o subclasă a clasei de obiecte Exception.

La execuţia instrucţiunii throw, fluxul normal de execuţie este părăsit şi se termină toate instrucţiunile în curs până la prima instrucţiune try care specifică într-o clauză catch un argument formal de acelaşi tip cu obiectul aruncat sau o superclasă a acestuia.

5.3.2.6 Instrucţiuni de protecţie

Aceste instrucţiuni sunt necesare pentru tratarea erorilor şi a excepţiilor precum şi pentru sincronizarea unor secvenţe de cod care nu pot rula în paralel.

5.3.2.6.1 Instrucţiunea try

Instrucţiunea try iniţiază un context de tratare a excepţiilor. În orice punct ulterior iniţializării acestui context şi înainte de terminarea acestuia, o excepţie semnalată prin execuţia unei instrucţiuni throw va returna controlul la nivelul instrucţiunii try, abandonându-se în totalitate restul instrucţiunilor din corpul acestuia.

La semnalarea unei excepţii aceasta poate fi prinsă de o clauză catch şi, în funcţie de tipul obiectului aruncat, se pot executa unele instrucţiuni care repun programul într-o stare stabilă. De obicei, o excepţie este generată atunci când s-a produs o eroare majoră şi continuarea instrucţiunilor din contextul curent nu mai are sens.

În finalul instrucţiunii, se poate specifica şi un bloc de instrucţiuni care se execută imediat după blocul try şi blocurile catch indiferent cum s-a terminat execuţia acestora. Pentru specificarea acestor instrucţiuni, trebuie folosită o clauză finally.

Iată sintaxa unei instrucţiuni try:

try Bloc1 [catch( Argument ) Bloc2]*[finally Bloc3]

Dacă, undeva în interiorul blocului 1 sau în metodele apelate din interiorul acestuia, pe oricâte nivele, este apelată o instrucţiune throw, execuţia blocului şi a metodelor în curs este abandonată şi se revine în instrucţiunea try. În continuare, obiectul aruncat de throw este comparat cu argumentele specificate în clauzele catch. Dacă unul dintre aceste argumente este instanţă a aceleiaşi clase sau a unei superclase a clasei obiectului aruncat, se execută blocul de instrucţiuni corespunzător clauzei catch respective. Dacă nici una dintre clauzele catch nu se potriveşte, obiectul este aruncat mai departe. Dacă excepţia nu este nicăieri prinsă în program, acesta se termină cu o eroare de execuţie.

Indiferent dacă a apărut o excepţie sau nu, indiferent dacă s-a executat blocul unei clauze catch sau nu, în finalul execuţiei instrucţiunii try se execută blocul specificat în clauza finally, dacă aceasta există.

Clauza finally se execută chiar şi dacă în interiorul blocului 1 s-a executat o instrucţiune throw care a aruncat un obiect care nu poate fi prins de clauzele catch ale acestei instrucţiuni try. În astfel de situaţii, execuţia instrucţiunii throw se opreşte temporar, se execută blocul finally şi apoi se aruncă mai departe excepţia.

Exemple de utilizare a instrucţiunii try găsiţi în paragraful 9.2

5.3.2.6.2 Instrucţiunea synchronized

Instrucţiunea synchronized introduce o secvenţă de instrucţiuni critică. O secvenţă critică de instrucţiuni trebuie executată în aşa fel încât nici o altă parte a programului să nu poată afecta obiectul cu care lucrează secvenţa dată. Secvenţele critice apar de obicei atunci când mai multe părţi ale programului încearcă să acceseze în acelaşi timp aceleaşi resurse.

Gândiţi-vă, de exemplu, ce s-ar întâmpla dacă mai multe părţi ale programului ar încerca să incrementeze în acelaşi timp valoarea unei variabile. Una dintre ele ar citi vechea valoare a variabilei, să spunem 5, ar incrementa-o la 6 şi, când să o scrie înapoi, să presupunem că ar fi întreruptă de o altă parte a programului care ar incrementa-o la 6. La revenirea în prima parte, aceasta ar termina prima incrementare prin scrierea valorii 6 înapoi în variabilă. Valoarea finală a variabilei ar fi 6 în loc să fie 7 aşa cum ne-am aştepta dacă cele două incrementări s-ar face pe rând.

Spunem că cele două regiuni în care se face incrementarea aceleiaşi variabile sunt regiuni critice. Înainte ca una dintre ele să se execute, ar trebui să ne asigurăm că cealaltă regiune critică nu rulează deja. Cea mai simplă cale de a face acest lucru este să punem o condiţie de blocare chiar pe variabila incrementată. Ori de câte ori o regiune critică va încerca să lucreze, va verifica dacă variabila noastră este liberă sau nu.

Instrucţiunea synchronized îşi blochează obiectul pe care îl primeşte ca parametru şi apoi execută secvenţa critică. La sfârşitul acesteia obiectul este deblocat înapoi. Dacă instrucţiunea nu poate bloca imediat obiectul pentru că acesta este blocat de o altă instrucţiune, aşteaptă până când obiectul este deblocat.

Mai mult despre această instrucţiune precum şi exemple de utilizare veţi găsi în partea a treia, capitolul 9. Până atunci, iată sintaxa generală a acestei instrucţiuni:

synchronized ( Expresie ) Instrucţiune

Expresia trebuie să aibă ca valoare o referinţă către un obiect sau un tablou care va servi drept dispozitiv de blocare. Instrucţiunea poate fi o instrucţiune simplă sau un bloc de instrucţiuni.

5.3.2.7 Instrucţiunea vidă

Instrucţiunea vidă este o instrucţiune care nu execută nimic. Ea este folosită uneori, atunci când este obligatoriu să avem o instrucţiune, dar nu dorim să executăm nimic în acea instrucţiune. De exemplu, în cazul unei instrucţiuni if, este obligatoriu să avem o instrucţiune pe ramura de adevăr. Dacă însă nu dorim să executăm nimic acolo, putem folosi un bloc vid sau o instrucţiune vidă.

Sintaxa pentru o instrucţiune vidă este următoarea:

;

Iată şi un exemplu:

int x = 3;
if( x == 5 ) ; else x = 5;

Caracterul ; care apare după condiţia din if reprezintă o instrucţiune vidă care specifică faptul că, în cazul în care x are valoarea 5 nu trebuie să se execute nimic.