Operații aritmetice

Majoritatea operațiilor din Java sunt similare cu cele folosite în alte limbaje de tip C. Există operații unare (efectuate asupra unui operand), binare - asupra a doi operanzi, și terțiare - efectuate asupra a trei operanzi. Operandul poate fi o variabilă sau o valoare (de exemplu, un număr) implicată în operație. Să examinăm toate tipurile de operații.

În operațiile aritmetice sunt implicate numere. În Java există operații aritmetice binare (efectuate asupra a doi operanzi) și unare (efectuate asupra unui singur operand). Operațiile binare includ următoarele:

• + operația de adunare a două numere:

int a = 10;
int b = 7;
int c = a + b;  // 17
int d = 4 + b;  // 11

• - operația de scădere a două numere:

int a = 10;
int b = 7;
int c = a - b;  // 3
int d = 4 - a;  // -6

• * operația de înmulțire a două numere:

int a = 10;
int b = 7;
int c = a * b;  // 70
int d = b * 5;  // 35

• / operația de împărțire a două numere:

int a = 20;
int b = 5;
int c = a / b;  // 4
double d = 22.5 / 4.5;  // 5.0

La împărțire, trebuie să ținem cont că dacă în operație sunt implicate două numere întregi, rezultatul împărțirii va fi rotunjit la un număr întreg, chiar dacă rezultatul este atribuit unei variabile de tip float sau double:

double k = 10 / 4;     // 2
System.out.println(k);

Pentru ca rezultatul să fie un număr cu virgulă mobilă, unul dintre operanzi trebuie să fie un număr cu virgulă mobilă:

double k = 10.0 / 4;     // 2.5
System.out.println(k);

• % obținerea restului împărțirii a două numere:

int a = 33;
int b = 5;
int c = a % b;  // 3
int d = 22 % 4; // 2 (22 - 4*5 = 2)

De asemenea, există două operații aritmetice unare care se efectuează asupra unui singur număr: ++ (incrementare) și -- (decrementare). Fiecare dintre aceste operații are două forme: prefixată și postfixată:

• ++ (incrementare prefixată) Presupune creșterea variabilei cu unul, de exemplu, z=++y (mai întâi valoarea variabilei y crește cu 1, iar apoi această valoare este atribuită variabilei z)

int a = 8;
int b = ++a;
System.out.println(a);  // 9
System.out.println(b);  // 9

• ++ (incrementare postfixată) Reprezintă, de asemenea, creșterea variabilei cu unul, de exemplu, z=y++ (mai întâi valoarea variabilei y este atribuită variabilei z, iar apoi valoarea variabilei y crește cu 1)

int a = 8;
int b = a++;
System.out.println(a);  // 9
System.out.println(b);  // 8

• -- (decrementare prefixată) Scăderea variabilei cu unul, de exemplu, z=--y (mai întâi valoarea variabilei y scade cu 1, iar apoi această valoare este atribuită variabilei z)

int a = 8;
int b = --a;
System.out.println(a);  // 7
System.out.println(b);  // 7

• -- (decrementare postfixată) z=y-- (mai întâi valoarea variabilei y este atribuită variabilei z, iar apoi valoarea variabilei y scade cu 1)

int a = 8;
int b = a--;
System.out.println(a);  // 7
System.out.println(b);  // 8

Prioritatea operațiilor aritmetice

Unele operații au o prioritate mai mare decât altele și, prin urmare, sunt efectuate mai întâi. Operațiile în ordinea descrescătoare a priorității:

• ++ (incrementare postfixată), -- (decrementare postfixată)
• ++ (incrementare prefixată), -- (decrementare prefixată)
• * (înmulțire), / (împărțire), % (restul împărțirii)
• + (adunare), - (scădere)

Prioritatea operațiilor trebuie avută în vedere atunci când executăm un set de expresii aritmetice:

int a = 8;
int b = 7;
int c = a + 5 * ++b;      
System.out.println(c);  // 48

Mai întâi se va executa operația de incrementare ++b, care are o prioritate mai mare - va crește valoarea variabilei b și o va returna ca rezultat. Apoi se va executa înmulțirea 5 * ++b, iar abia la sfârșit se va executa adunarea a + 5 * ++b.

Parantezele permit redefinirea ordinii de calcul:

int a = 8;
int b = 7;
int c = (a + 5) * ++b;    
System.out.println(c);  // 104

Deși operația de adunare are o prioritate mai mică, aceasta se va efectua mai întâi, deoarece operația de adunare este închisă între paranteze.

Asociativitatea operațiilor

Pe lângă prioritate, operațiile diferă și prin asociativitate. Când operațiile au aceeași prioritate, ordinea calculului este determinată de asociativitatea operatorilor. În funcție de asociativitate, există două tipuri de operatori:

• Operatori stânga-asociativi, care se execută de la stânga la dreapta
• Operatori dreapta-asociativi, care se execută de la dreapta la stânga

De exemplu, unele operații, cum ar fi operațiile de înmulțire și împărțire, au aceeași prioritate. Care va fi atunci rezultatul în expresia:

int x = 10 / 5 * 2;

Ar trebui să interpretăm această expresie ca (10 / 5) * 2 sau ca 10 / (5 * 2)? Deoarece interpretarea va produce rezultate diferite.

Toți operatorii aritmetici (cu excepția incrementării și decrementării prefixate) sunt stânga-asociativi, adică se execută de la stânga la dreapta. Prin urmare, expresia 10 / 5 * 2 trebuie interpretată ca (10 / 5) * 2, rezultatul fiind 4.

Operații cu numere în virgulă mobilă

Trebuie remarcat că numerele cu virgulă mobilă nu sunt potrivite pentru calcule financiare sau alte calcule în care erorile de rotunjire pot fi critice. De exemplu:

double d = 2.0 - 1.1;
System.out.println(d);

În acest caz, variabila d nu va fi egală cu 0.9, așa cum s-ar putea presupune inițial, ci cu 0.8999999999999999.

Astfel de erori de precizie apar din cauza faptului că, la nivel scăzut, pentru reprezentarea numerelor cu virgulă mobilă se folosește sistemul binar, însă pentru numărul 0.1 nu există o reprezentare binară, la fel cum nu există și pentru alte valori zecimale. De aceea, în astfel de cazuri se folosește, de obicei, clasa BigDecimal, care permite evitarea unor astfel de situații.