Limbajele de programare utilizeaza instructiuni de control pentru a ajusta modul in care un program se desfasoara. Instructiunile de control din limbajul Java pot fi impartite in trei categorii:
• instructiuni conditionale;
• instructiuni iterative;
• instructiuni de salt.
Intructiuni conditionale
Instructiunile conditionale permit executia conditionata a unei instructiuni sau a unui bloc de instructiuni. Java suporta doua astfel de instructiuni: if si switch.
Instructiunea if poate fi utilizata pentru a indruma executia programului pe doua cai.
if (conditie) instructiune1; else instructiune2;
In acest caz instructiune poate reprezenta o singura instructiune sau un bloc de instructiuni. Daca conditia este adevarata, atunci se executa instructiune1; in caz contrar, se executa instructiune2. Ramura else nu este obligatorie intr-o astfel de instructiune conditionala.
Instructiunea if poate fi intalnita si in constructii imbricate de genul if – else – if.
if (conditie1) instructiune1; else if (conditie2) instructiune2; else …
Instructiunea switch este utilizata pentru evaluarea valorilor posibile ale unei expresii. Expresia evaluata trebuie sa fie un intreg, deci pot fi utilizate tipurile: byte, short, int, long sau char.
switch(expresie) { case valoare1: instructiune1; break; case valoare2: instructiune2; break; … case valoareN: instructiuneN; break; default: instructiuneDefault; break; }
Daca expresie are aceeasi valoare cu cea intalnita pe o ramura case, atunci controlul este transmis catre ramura respectiva. Vor fi rulate toate instructiunile care se gasesc inaintea primului break. Daca nici una din valorile intalnite nu corespunde, controlul este acordat etichetei default (daca aceasta exista).
class Conditie { | |
public static void main(String[] args) { | |
// instructiunea if | |
int min; | |
int a = 15, b = 3, c = 23; | |
if (a < b) { | |
if (a < c) | |
min = a; | |
else | |
min = c; | |
} else { | |
if (b < c) | |
min = b; | |
else | |
min = c; | |
} | |
System.out.println("minimul este " + min); | |
// instructiunea switch | |
int luna = 5; | |
switch (luna) { | |
case 1: | |
case 2: | |
case 12: | |
System.out.println("iarna"); | |
break; | |
case 3: | |
case 4: | |
case 5: | |
System.out.println("primavara"); | |
break; | |
case 6: | |
case 7: | |
case 8: | |
System.out.println("vara"); | |
break; | |
case 9: | |
case 10: | |
case 11: | |
System.out.println("toamna"); | |
break; | |
} | |
} | |
} |
minimul este 3 primavara
Instructiuni iterative
Instructiunile iterative utilizate in limbajul de programare Java sunt while, do-while si for. Aceste instructiuni au rolul de a executa repetitiv o instructiune sau un set de instructiuni, pana la indeplinirea unei conditii de iesire.
Instructiunea iterativa while se utilizeaza pentru a repeta o instructiune sau un bloc de instructiuni atata timp cat conditia este adevarata. Forma generala a instructiunii while este urmatoarea:
while(conditie) { instructiune; }
In momentul in care conditia devine falsa, controlul executiei este acordat urmatoarei linii de program de dupa bucla while. Instructiunea while mai poarta si denumirea de bucla cu test initial.
Daca se doreste testarea conditiei buclei la finalul acesteia, se poate utiliza instructiunea do-while. In acest caz corpul buclei se executa cel putin o data, deoarece conditia se testeaza la final. Sintaxa pentru do-while are forma:
do { instructiune; } while(conditie);
Cea de-a treia instructiune iterativa este for sau bucla cu numar fix de pasi. Sintaxa completa a unui instructiuni for este urmatoarea:
for(initializare; conditie; iteratie) { instructiune; }
Modul de executie pentru instructiunea for este urmatorul: se ruleaza mai intai initializare, apoi se testeaza conditie. Daca conditia este adevarata, se executa corpul ciclului si se trece la iteratie.
class Iteratie { | |
public static void main(String[] args) { | |
int i; | |
// instructiunea while | |
i = 0; | |
while (i < 10) { | |
System.out.print(i + " "); | |
i++; | |
} | |
System.out.print("\n"); | |
// instructiunea do-while | |
i = 0; | |
do { | |
System.out.print(i + " "); | |
i++; | |
} while (i < 10); | |
System.out.print("\n"); | |
// instructiune for | |
for (i = 0; i < 10; i++) | |
System.out.print(i + " "); | |
} | |
} |
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
Instructiuni de salt
Pe langa instructiunile conditionale si iterative, limbajul Java mai ofera trei tipuri de instructiuni de salt: break, continue si return. Instructiunile de salt sunt utilizate pentru a transfera controlul executiei unei alte zone a programului.
Instructiunea break poate fi utilizata in trei situatii: terminarea unei instructiuni switch, parasirea unei bucle si salt la o eticheta.
class InstrBreak { | |
public static void main(String[] args) { | |
int i; | |
i = 0; | |
while (i < 10) { | |
if (i == 5) | |
break; | |
System.out.print(i + " "); | |
i++; | |
} | |
System.out.print("\n"); | |
out: for (i = 0; i < 10; i++) { | |
if (i == 5) | |
break out; | |
System.out.print(i + " "); | |
} | |
} | |
} |
0 1 2 3 4 0 1 2 3 4
O instructiune continue poate aparea numai in interiorul unui bloc de instructiuni subordonat unei instructiuni iterative. Instructiunea continue opreste executia restului de instructiuni din bloc si face un salt la urmatoarea iteratie. Şi in cazul instructiunii continue poate fi definita o eticheta pentru salt.
class InstrContinue { | |
public static void main(String[] args) { | |
int i; | |
for (i = 0; i < 10; i++) { | |
System.out.print(i + " "); | |
if (i % 2 == 0) | |
continue; | |
System.out.print("\n"); | |
} | |
} | |
} |
0 1 2 3 4 5 6 7 8 9
Instructiunea return ofera controlul executiei apelantului metodei care o contine. De asemenea, instructiunea return va determina finalizarea metodei in care este executata.