...
← Blog Lecții programare java

Operatorii în Java: aritmetici, logici și de comparație

Sigla Java, ilustrație pentru lecția despre operatorii în Java

Operatorii în Java sunt simbolurile cu care faci calcule, compari valori și combini condiții: + - * / % pentru aritmetică, == != < > pentru comparații, && || ! pentru logică, = += ++ pentru atribuire și incrementare. Fiecare operator lucrează pe una sau mai multe valori, numite operanzi, și produce un rezultat.

Aici găsești toate categoriile de operatori într-un tabel, exemple din viața de zi cu zi (casa de marcat, minute transformate în ore, anii bisecți), ordinea în care Java evaluează expresiile și capcanele care dau rezultate greșite fără nicio eroare.

Ce este un operator în Java?

Un operator este un simbol care spune ce operație să facă Java cu valorile din jurul lui. În int suma = 10 + 5;, operatorul + adună operanzii 10 și 5, iar operatorul = pune rezultatul, 15, în variabila suma.

Combinația de operatori și operanzi se numește expresie. Orice expresie are un rezultat de un anumit tip: 10 + 5 dă un int, 10 > 5 dă un boolean. Să înțelegi ce tip produce fiecare expresie e jumătate din lecția asta.

Ce categorii de operatori există?

Pentru un începător contează cinci categorii: aritmetici, de atribuire, de comparație, logici și de incrementare. Tabelul de mai jos le adună pe toate.

CategorieOperatoriExempluRezultat
Aritmetici+ - * / %17 % 52 (restul)
Atribuire= += -= *= /= %=scor += 10scor crește cu 10
Comparație== != > < >= <=varsta >= 18true sau false
Logici&& || !esteLogat && arePlatatrue doar dacă ambele sunt adevărate
Incrementare / decrementare++ --vizite++vizite crește cu 1

Mai există operatorul ternar (? :), care are o lecție separată în serie, și operatorii pe biți (& | ^ << >>), pe care îi vei folosi rar la început. Lista completă e în tutorialul Oracle despre operatori.

Cum folosești operatorii aritmetici?

Operatorii aritmetici fac calculele: adunare (+), scădere (-), înmulțire (*), împărțire (/) și restul împărțirii (%, numit modulo). Primele patru funcționează ca la matematică, cu o singură surpriză, la împărțire.

Să zicem că scrii casa de marcat a unui magazin de cartier. Clientul ia 4 sticle de apă, 2 pâini și 6 iaurturi:

double pretApa = 4.5;
double pretPaine = 3.2;
double pretIaurt = 5.8;

double total = pretApa * 4 + pretPaine * 2 + pretIaurt * 6;
System.out.println(total);  // 59.199999999999996

Înmulțirile se fac primele, apoi adunările, la fel ca la școală. Rezultatul ar trebui să fie 59,20 lei, dar double nu reprezintă exact zecimalele, așa că apare acel „…99996”. La afișare rotunjești cu printf("%.2f", total); în aplicațiile cu bani adevărați se folosește BigDecimal.

Împărțirea întreagă și operatorul modulo

Când ambii operanzi sunt numere întregi, / face împărțire întreagă și taie zecimalele, iar % îți dă restul. Împreună sunt foarte utile:

System.out.println(17 / 5);    // 3
System.out.println(17 % 5);    // 2
System.out.println(17.0 / 5);  // 3.4

int minute = 135;
System.out.println(minute / 60 + " h " + minute % 60 + " min");  // 2 h 15 min

Cu / și % transformi minute în ore, secunde în minute, bani în bancnote. Cu % 2 afli dacă un număr e par (numar % 2 == 0), iar cu % 10 iei ultima cifră a unui număr. Vei folosi operatorul modulo constant în exercițiile cu bucle.

Cum funcționează operatorii de atribuire?

Operatorul = pune valoarea din dreapta în variabila din stânga; nu verifică egalitatea. Formele compuse (+=, -=, *=, /=, %=) sunt prescurtări: salariu += 500 înseamnă salariu = salariu + 500.

int puncte = 100;
puncte += 50;   // 150
puncte -= 30;   // 120
puncte *= 2;    // 240
puncte /= 3;    // 80
puncte %= 7;    // 3

Un detaliu care surprinde: formele compuse fac conversie automată de tip. int x = 10; x += 2.7; compilează și lasă în x valoarea 12, pentru că rezultatul 12,7 e convertit înapoi la int. Varianta lungă, x = x + 2.7;, nu compilează deloc.

Care e diferența dintre x++ și ++x?

Ambele cresc variabila cu 1. Diferența apare doar când folosești rezultatul în aceeași expresie: x++ întoarce valoarea veche, apoi crește, iar ++x crește întâi și apoi întoarce valoarea nouă.

int i = 5;
int a = i++;   // a primește 5, apoi i devine 6

int j = 5;
int b = ++j;   // j devine 6, apoi b primește 6

La fel funcționează --, pentru scădere cu 1. Când scrii i++ singur pe un rând, ca în bucla for, cele două forme sunt identice. Recomandarea: nu combina ++ cu alte operații în aceeași expresie. int rezultat = i++ + ++i; e corect sintactic, dar nimeni nu vrea să citească așa ceva.

Cum compari două valori?

Operatorii de comparație (==, !=, >, <, >=, <=) întorc întotdeauna un boolean: true sau false. Îi folosești în condițiile din if și din bucle.

int varsta = 21;
System.out.println(varsta >= 18);  // true
System.out.println(varsta == 25);  // false
System.out.println(varsta != 25);  // true

Reține diferența dintre = și ==: primul înseamnă „primește valoarea”, al doilea înseamnă „este egal cu?”. Și încă o regulă care te scapă de multe bug-uri: texte (String) nu le compari cu ==, ci cu nume.equals("Ana"). Operatorul == la obiecte verifică dacă e același obiect în memorie, nu același conținut.

Cum combini condiții cu operatorii logici?

Operatorii logici leagă mai multe condiții: && (ȘI) e adevărat doar dacă toate condițiile sunt adevărate, || (SAU) e adevărat dacă măcar una este, iar ! (NU) inversează o valoare.

ABA && BA || B!A
truetruetruetruefalse
truefalsefalsetruefalse
falsetruefalsetruetrue
falsefalsefalsefalsetrue

Un magazin online dă 10% reducere doar dacă clientul e autentificat, are cont Premium și coșul depășește 500 de lei. Regula se scrie într-un singur rând:

boolean esteLogat = true;
boolean estePremium = true;
double valoareCos = 650;

if (esteLogat && estePremium && valoareCos >= 500) {
    System.out.println("Reducere acordată!");
}

Evaluarea scurtcircuitată

&& și || se opresc imediat ce știu rezultatul. La &&, dacă prima condiție e falsă, a doua nici nu se mai verifică. Te folosești de asta ca să eviți erori:

String nume = null;

if (nume != null && nume.length() > 3) {
    System.out.println("Nume lung");
}

Dacă nume e null, Java nu mai apelează nume.length(), care ar fi oprit programul cu NullPointerException. Ordinea condițiilor contează: verificarea de siguranță vine prima.

În ce ordine evaluează Java operatorii?

Java respectă o ordine de prioritate, la fel ca matematica: înmulțirea și împărțirea înaintea adunării, comparațiile după calcule, iar && înaintea lui ||. Parantezele schimbă ordinea și fac intenția clară.

  1. parantezele ( );
  2. incrementarea, decrementarea și negația: ++ -- !;
  3. înmulțirea, împărțirea și restul: * / %;
  4. adunarea și scăderea: + -;
  5. comparațiile de mărime: < > <= >=;
  6. egalitatea: == !=;
  7. ȘI logic: &&;
  8. SAU logic: ||;
  9. atribuirile: = += -= și celelalte.

5 + 3 * 2 dă 11, iar (5 + 3) * 2 dă 16. Un exemplu mai realist e regula anilor bisecți: un an e bisect dacă se împarte la 4 și nu la 100, sau dacă se împarte la 400.

int an = 2028;
boolean bisect = (an % 4 == 0 && an % 100 != 0) || an % 400 == 0;
System.out.println(bisect);  // true

Parantezele de aici nu sunt obligatorii, pentru că && are oricum prioritate față de ||. Le pui ca cine citește codul să nu trebuiască să-și amintească tabelul de prioritate.

Ce greșeli fac începătorii cu operatorii?

Aproape toate greșelile cu operatori compilează fără probleme și dau un rezultat greșit, așa că sunt greu de observat. Iată-le pe cele pe care le vezi cel mai des.

Împărțirea întreagă la medii

int suma = 27; int nr = 4; double media = suma / nr; dă 6.0, nu 6.75. Împărțirea s-a făcut între două int-uri, iar zecimalele s-au pierdut înainte de atribuire. Corect: double media = (double) suma / nr;.

Concatenarea care „adună” greșit

System.out.println("Total: " + 2 + 3);    // Total: 23
System.out.println("Total: " + (2 + 3));  // Total: 5
System.out.println(2 + 3 + " lei");        // 5 lei

Operatorul + lipește texte când unul dintre operanzi e String. Java citește de la stânga la dreapta: odată ce a apărut un text, tot ce urmează se lipește. Pune calculele în paranteze.

Comparații între texte cu ==

if (parola == "secret123") poate da false chiar dacă utilizatorul a scris exact parola, mai ales când textul vine de la tastatură. Folosește parola.equals("secret123").

Restul unui număr negativ

-7 % 3 dă -1, nu 2, pentru că în Java restul păstrează semnul primului operand. Dacă verifici numere impare cu n % 2 == 1, un număr negativ impar nu trece testul. Varianta sigură e n % 2 != 0.

Exercițiu: bancomatul

Scrie un program care primește o sumă în lei (de exemplu 1.380) și afișează câte bancnote de 200, 100, 50 și 10 lei dă bancomatul, folosind cât mai puține bancnote. Ai nevoie doar de / și %: împarți la 200 ca să afli câte bancnote de 200 încap, iar restul îl împarți mai departe la 100 și așa mai departe.

Pentru 1.380 lei, rezultatul corect este 6 × 200, 1 × 100, 1 × 50 și 3 × 10. Apoi adaugă o verificare cu operatori logici: dacă suma nu se împarte exact la 10 sau e mai mare de 3.000 de lei, afișează un mesaj de eroare.

Întrebări frecvente

Care este diferența dintre = și == în Java?

= este operatorul de atribuire și pune o valoare într-o variabilă. == este operatorul de comparație și verifică dacă două valori sunt egale, întorcând true sau false.

La ce folosește operatorul % (modulo)?

Întoarce restul împărțirii a două numere: 10 % 3 dă 1. Îl folosești ca să verifici dacă un număr e par, să iei ultima cifră a unui număr sau să transformi unități de timp, de exemplu minute în ore și minute.

De ce 5 / 2 dă 2 în Java?

Pentru că ambii operanzi sunt int, iar împărțirea a două numere întregi dă tot un număr întreg; partea zecimală se taie. Ca să obții 2,5, scrie 5.0 / 2 sau convertește unul dintre operanzi cu (double).

Ce înseamnă && și || în Java?

&& este ȘI logic: rezultatul e adevărat doar dacă ambele condiții sunt adevărate. || este SAU logic: rezultatul e adevărat dacă cel puțin o condiție e adevărată. Ambii se opresc din evaluare imediat ce știu rezultatul.

Care e diferența dintre i++ și ++i?

Ambele cresc variabila cu 1. i++ întoarce valoarea dinainte de creștere, iar ++i întoarce valoarea de după. Diferența contează doar când folosești rezultatul în aceeași expresie.

Primul pas: rulează capcanele

Copiază exemplele din secțiunea cu greșeli într-un editor și rulează-le pe rând. Înainte de fiecare, scrie pe o foaie ce crezi că va afișa. Unde ai greșit, ai găsit exact ce trebuie să recapitulezi. Apoi rezolvă exercițiul cu bancomatul.

Operatorii și conversiile sunt în primul modul din cursul de Java, inclus în primele 15 lecții gratuite, cu exerciții verificate automat direct în browser. Profu’, tutorele AI din lecții, îți explică de ce un rezultat nu e cel așteptat. Dacă vrei să vezi ce urmează după fundamente, ai traseul complet de Java Developer, iar pentru erorile tipice din primele săptămâni citește articolul despre greșelile frecvente în Java.

Lecția anterioară: variabile în Java. Lecția următoare: Scanner în Java.

Logo Curs Java Interactiv · 15 lecții gratuite

Curs Java

Programare Java pentru începători: de la sintaxă la OOP și colecții

Începe gratuit

Citește și

Primul tău program e la 5 minute distanță.

Creează-ți contul gratuit și începe primele 15 lecții. Fără card, fără instalări.

Începe gratuit