În cadrul acestui modul vor fi tratate controlul fluxului, buclele și

ramificarea limbajului de programare Java.

Controlul fluxului se reflectă în posibilitatea de a executa diferite

blocuri de cod în condiții diferite. Buclele au posibilitatea de a executa
același cod (cu valori diferite) de mai multe ori, până când o anumită
condiție este îndeplinită. Ramificarea presupune existența mai multor
fluxuri de programe care pot fi executate sau nu, în funcție de
îndeplinirea condițiilor.

În cadrul metodelor, executarea codului se realizează liniar, linie cu

linie, de sus în jos. Programele pe care le-am creat până acum nu au
avut prea mari posibilităţi de încălcare a acestei reguli, respectiv
neliniaritatea. Acesta este şi motivul pentru care nu am putut să facem
operaţii mai serioase. Pentru a depăşi această problemă, se folosesc
diferite tehnici de control al fluxului programului. Una dintre ele este
construcția if.

Drept control de flux pot fi considerate şi blocurile try/catch pentru

procesarea excepţiilor. Mai multe despre acest lucru vom afla în
modulul referitor la procesarea excepțiilor. Să vedem acum controlul
fluxului prin intermediul construcţiei if.

Construcţia if/else

În forma de bază, această construcţie are următoarea formă:

if (condition) {
statement1
}
else {
statement2
}
 Imaginea 11.1 Controlul fluxului - if else

Vedem că în codul de mai sus, între parantezele condiției if, există

expresia condiției (condition). Expresiile condiționale în Java pot avea
valoarea true sau false. În funcție de valorile pe care expresia
condițională le are în structura de mai sus, se va ajunge la executarea
unuia sau a celuilalt bloc de cod. Dacă condiția este îndeplinită, se va
executa codul blocului if (statement1), după care se va trece la
executarea codului din afara construcțiilor condiționale. În cazul în care
condiția nu este îndeplinită, se va executa blocul de cod else
(statement2), după care se continuă executarea codului definit sub
construcțiile condiționale. În imagine este ilustrat cursul de executare a
unui program care conține o construcţie condițională if-else.

Un exemplu de o astfel de construcţie este următorul:

int x = 0;

if (x != 0) {
System.out.println("x is different from zero");
}
else
{
System.out.println("x is equal to zero");
}

În exemplul de mai sus, am declarat și inițializat o variabilă de tip int

cu valoarea 0. După aceea, am definit o structură condițională. La
ieșire va fi afișat:

x is equal to zero

else if

În forma de bază a construcţiei if pe care tocmai am văzut-o, se

verifică exactitatea doar a unei condiții. Dacă aţi dori să verificăm mai
multe condiții și să avem mai multe blocuri condiționale, putem
extinde construcția if utilizând blocurile else if. Atunci, această
construcţie ar arăta aşa:
 if (condition) {
statement1
}
else if (condition2) {
statement2
}
...
else {
statement3
}

Puteți observa în construcţia de mai de sus că, spre deosebire de

exemplul anterior, aici avem două condiții pe care le executăm. Cele
trei puncte care se află în construcţia de mai sus înseamnă că putem
avea definit mai mult de un bloc else/if.

Când programul ajunge la comanda if, el verifică prima condiție

(condition). În cazul în care condiția este corectă, se execută primul
grup de expresii (statement1), după care programul trece la
executarea codului care este în afara structurii if/else.

În cazul în care prima condiție nu este corectă, se verifică condiţia din

cadrul expresiei else if (dacă există). Dacă această condiție este
corectă, se execută al doilea grup de expresii, în cazul nostru
statement2, după care executarea părăseşte structura if.

Dacă şi această condiție este incorectă, se execută grupul de expresii

din cadrul blocului else. Acest lucru înseamnă că blocul else se va
executa în cazul în care nicio condiție definită nu este îndeplinită.

În cadrul unei structuri if/else pot fi mai multe blocuri else if. Dacă mai
multe condiții sunt adevărate, se va executa doar prima dintre ele.

Este evident că mecanismul pentru controlul fluxului este de tip

boolean, respectiv tipul boolean este cel ce se pune între paranteze
(condition). Atunci este logic ca în exemplul de mai sus, în locurile în
care apare condition şi condition 2, să fie aşteptată valoarea boolean.
Este foarte important să reţinem că expresia else nu are niciodată o
condiţie între paranteze.

În următorul exemplu avem ilustrarea practică a utilizării construcţiei if

– else if. A fost efectuată iniţializarea variabilei num cu valoarea 15.
Apoi se vor efectua trei verificări pentru a vedea dacă num este mai
mic, mai mare sau egal cu 10 și, în funcţie de fiecare rezultat, se va
afişa mesajul corespunzător:

int num = 15;

if (num < 10) {
System.out.println("Number is less than 10");
} else if (num > 10) {
System.out.println("The number is greater than 10");
} else if (num == 10) {
System.out.println("The number is equal to the number of 10");
}

Exemplul va emite la ieșire mesajul: "The number is greater than 10"

(numărul este mai mare decât 10). Dacă vom modifica variabila num,
se va produce o schimbare în ieșire, respectiv va fi activată o altă linie
de cod, cauzată de o altă condiție.

Construcţia if poate conţine doar blocul if, ca în exemplul următor:

int x = 110;

if (x != 0) {
System.out.println("x is different from zero");
}

Dacă valoarea variabilei x este diferită de zero, la ieşire se va afişa

mesajul definit.
Blocurile if se pot specifica unul după altul. În acest caz, se va executa
fiecare dintre aceste blocuri, dacă condiția este îndeplinită. De fapt,
fiecare bloc if astfel definit reprezintă o construcţie de sine stătătoare.

int x = 110;

if (x != 0) {
System.out.println("x is different from zero");
}
if (x < 100)
{
System.out.println("x is less than 100");
}
else
{
System.out.println("x is larger than 100");
}

După executarea construcţiei de mai sus, la ieşire vom obţine:

x is different from zero

x is larger than 100

De fapt, în codul de mai sus există două construcţii condiţionale. Prima

conține doar un bloc if cu condiţia x != 0, în timp ce cealaltă
construcţie condițională conține, pe lângă blocul if, și blocul else.
Blocul else din codul de sus se referă la cea de-a doua expresie
condițională.

Condițiile if-else pot fi imbricate. Acest lucru înseamnă că se poate

stabili o condiție în cadrul unei alte condiţii.

De exemplu:

if(true)
if(true)
 System.out.println("This works!");

Acest exemplu complet funcțional, în afara faptului că ilustrează

utilizarea condițiilor introduse în alte condiţii, prezintă de asemenea o
altă modalitate de utilizare a acestei construcţii. Aceasta este corpul
fără paranteze acolade. Această abordare este posibilă numai în cazul
în care corpul conţine o singură linie de cod. Dacă există mai multe
linii, cel puțin două, parantezele acolade sunt obligatorii, altfel, se
poate ajunge la nereguli logice în funcţionarea aplicaţiei.

Să vedem acum următorul exemplu:

if(false)
System.out.println("conditional execution");
System.out.println("this part is outside of condition");

Dacă executăm codul de sus, la ieşire vom avea următorul mesaj:

this part is outside of condition

Putem vedea în acest exemplu că interpreter-ul a luat doar prima

expresie drept corp al condiției if. În cazul în care scriem acest
exemplu astfel:

if(false)
{
System.out.println("conditional execution ");
System.out.println("this is now part of condition");
}

la ieşire nu am obține nimic scris, deoarece ambele comenzi fac parte

din blocul condițional care nu se poate executa din pricina valorii
boolean false din parantezele blocului.

Atâta timp cât respectaţi regula "o linie per bloc condițional", puteți
scrie câte condiții doriţi, una după alta.

if(true)
else if(true)
else if(true)

Veţi întâlni modul de scriere a blocurilor condiționale fără paranteze

acolade şi la alte structuri pentru controlul fluxului, dar nu şi în cazul
funcțiilor sau claselor. În plus, de obicei se întâmplă ca ceea ce v-aţi
imaginat că va fi o singură linie (condițională) de cod să crească la mai
multe linii, prin urmare, cel mai bine este să folosiţi parantezele
acolade atunci când aveţi de-a face cu manipularea fluxului.

Există o problemă în folosirea concretă a structurii if/else pentru

controlul fluxului. Şi anume, faptul că vizibilitatea codului se pierde
foarte repede (după doar câteva condiţii). De exemplu:

int a=0;
if(a==1)
System.out.println("a je jedan");
if(a==2)
System.out.println("a je dva");
if(a==3)
System.out.println("a je tri");

De aceea, este mai bine să se utilizeze construcția Switch când avem

mai multe condiţii. Pe aceasta o vom explica în lecția următoare.

Uneori, pentru definirea condițiilor se utilizează și operatorul ternar.

Acest operator a fost tratat în detaliu în cadrul lecției "Operatori logici
(condiționali)". În continuare vom ilustra aceeași problemă rezolvată în
două moduri, primul cu ajutorul structurii if-else, iar al doilea folosind
operatorul ternar.
boolean isHappy = true;
String mood = "";
if (isHappy == true)
{
mood = "I'm Happy!";
}
else
{
mood = "I'm Sad!";
}

În codul de mai sus este definită variabila de tip boolean numită

isHappy și valoarea true. Sub ea este declarată încă o variabilă de tip
String. Acesta este aşa-numitul string gol, respectiv un string care nu
are valoare, deoarece valoarea a fost inițializată după cum urmează:

String mood = "";

Valoarea boolean isHappy se utilizează pentru controlul fluxului.

Deoarece valoarea variabilei este true, este clar că dacă blocul se va
executa, variabila mood va obţine valoarea I'm Happy!

Haideţi să vedem cum putem face acelaşi lucru şi cu operatorul ternar.

boolean isHappy = true;

String mood = (isHappy == true)?"I'm Happy!":"I'm Sad!";

O greşeală frecventă care apare atunci când sunt create blocurile

condiţionale este utilizarea operatorului de atribuire (=) în locul
operatorului de comparaţie (==).

Desigur, mediul de dezvoltare integrat (precum NetBeans) nu va

permite niciodată acest lucru:
 Imaginea 11.2 Utilizarea incorectă a opratorului de atribuire în locul
operatorului de comparaţie

În exemplul de mai sus, vedem că editorul a precizat clar faptul că

există o eroare, afişând un mesaj care ne anunţă că tipul int nu poate fi
convertit în tip boolean.

Următorul exemplu calculează două numere în raport cu operatorul

definit:

char op = '/';
double a=5;
double b=3;
if(op=='+')
{
System.out.println(a+b);
}
if(op=='-')
{
System.out.println(a-b);
}
if(op=='/')
{
System.out.println(a/b);
}
if(op=='*')
{
System.out.println(a*b);
}

La construirea condiţiei, se pot folosi combinaţii de expresii, atâta timp

cât întreaga combinaţie dă tipul boolean ca rezultat. Să presupunem că
vrem o valoare care să fie mai mare decât unu, dar mai mică decât
cinci. Acest lucru nu se poate scrie într-o singură expresie, dar putem
uni aceste două expresii prin operatorul logic && (ŞI):

int x = 3;
if(x>1 && x<5)
System.out.println("x is between 1 and 5");
else
System.out.println("x is not between 1 and 5");

În acelaşi mod putem să facem o condiţie şi mai complexă.

Să presupunem că dorim să verificăm dacă un număr este mai mare

decât 1 și mai mic decât 25, dar în același timp să nu fie 10 sau
valoarea numărului să fie exact 35.

Acest lucru îl putem realiza în felul următor:

int x = 15;
if((x>1 && x<25 && x!=10) || (x==35))
System.out.println("Condition is fulfilled");
else
System.out.println("Condition is not fulfilled");