
Cele mai frecvente greșeli ale începătorilor în Java sunt compararea textelor cu ==, împărțirea între numere întregi care taie zecimalele, capcana Scanner cu nextInt() și nextLine(), NullPointerException și calculele cu bani în double. Toate au o cauză clară și o reparație de un rând, odată ce știi ce să cauți.
Dacă vrei să înveți practic, curs Java pentru începători are primele lecții gratuite, cu exerciții verificate direct în browser.
Mai jos găsești 12 greșeli pe care le vezi mereu la exercițiile din primele luni, fiecare cu codul greșit, ce se întâmplă și varianta corectă. Exemplele sunt testate pe Java 25.
Care sunt greșelile frecvente ale începătorilor în Java?
Tabelul te ajută să găsești repede greșeala după simptom, apoi citești explicația ei mai jos.
| Simptomul | Cauza probabilă | Greșeala nr. |
|---|---|---|
| Două texte identice „nu sunt egale” | ai comparat cu == | 1 |
| Media iese 13 în loc de 13,5 | împărțire între int-uri | 2 |
| Programul „sare” peste o citire | nextInt() urmat de nextLine() | 3 |
NullPointerException | obiect care nu a fost creat | 4 |
| Switch-ul afișează mai multe cazuri | lipsește break | 5 |
| Totalul coșului are cifre ciudate la final | bani calculați în double | 6 |
| „should be declared in a file named…” | numele clasei diferă de fișier | 7 |
ConcurrentModificationException | ștergi din listă în timp ce o parcurgi | 8 |
1. Compari String-uri cu == în loc de equals()
Operatorul == verifică dacă două variabile arată spre același obiect în memorie, nu dacă textul e același. La un String citit de la tastatură sau construit în program, == poate da false chiar dacă literele sunt identice.
String a = "Ion";
String b = new String("Ion");
System.out.println(a == b); // false
System.out.println(a.equals(b)); // true Regula e simplă: pentru texte folosești mereu equals(), iar dacă nu contează literele mari și mici, equalsIgnoreCase(). == rămâne pentru numere, caractere și boolean.
2. Împarți două numere întregi și pierzi zecimalele
În Java, împărțirea a două valori int dă tot un int, iar partea zecimală se taie, fără rotunjire și fără niciun avertisment.
int suma = 9 + 10 + 8;
int nrNote = 2;
System.out.println(suma / nrNote); // 13
System.out.println((double) suma / nrNote); // 13.5 Conversia (double) se pune pe unul dintre operanzi, înainte de împărțire. Dacă scrii (double) (suma / nrNote), împărțirea s-a făcut deja între întregi și obții 13.0.
3. Folosești nextLine() imediat după nextInt()
nextInt() citește numărul, dar lasă în buffer apăsarea de Enter. Următorul nextLine() găsește acel Enter și întoarce imediat un text gol, așa că programul pare să sară peste întrebare.
Scanner sc = new Scanner(System.in);
System.out.print("Vârsta: ");
int varsta = sc.nextInt();
System.out.print("Orașul: ");
String oras = sc.nextLine(); // primește "" și nu mai așteaptă Reparația e un sc.nextLine(); în plus după nextInt(), care „consumă” Enter-ul rămas. O altă variantă e să citești totul cu nextLine() și să convertești cu Integer.parseInt(). Toate detaliile sunt în lecția despre Scanner în Java.
4. Folosești un obiect care e null
NullPointerException apare când apelezi o metodă pe o variabilă care nu arată spre niciun obiect. E probabil cea mai întâlnită excepție din Java.
String oras = null;
System.out.println(oras.length());
// Cannot invoke "String.length()" because "oras" is null Versiunile noi de Java îți spun exact ce variabilă era null, deci citește mesajul până la capăt. Ca să eviți eroarea, verifică înainte (if (oras != null)) sau, la comparații, pune textul cunoscut în față: "Cluj".equals(oras) întoarce false în loc să arunce excepția.
5. Uiți break în switch
În forma clasică a lui switch, după ce un case se potrivește, Java execută și toate cazurile de dedesubt, până la primul break.
int zi = 2;
switch (zi) {
case 1: System.out.println("Luni");
case 2: System.out.println("Marți");
case 3: System.out.println("Miercuri");
}
// Marți
// Miercuri Pui break; la finalul fiecărui caz sau, mai simplu, folosești sintaxa cu săgeată, disponibilă din Java 14, care nu are această problemă:
String nume = switch (zi) {
case 1 -> "Luni";
case 2 -> "Marți";
default -> "Altă zi";
}; Ambele forme sunt explicate în lecția despre switch în Java.
6. Calculezi bani cu double
Tipul double păstrează numerele în binar, iar multe zecimale obișnuite, cum e 0,1, nu pot fi reprezentate exact. Pentru o notă medie nu contează. Pentru o factură în lei, da.
System.out.println(0.1 + 0.2); // 0.30000000000000004
BigDecimal pret = new BigDecimal("19.99");
BigDecimal total = pret.multiply(new BigDecimal("3"));
System.out.println(total); // 59.97 Pentru sume de bani folosești BigDecimal, creat din text ("19.99"), nu din double. E mai lung de scris, dar e ce vei găsi în orice aplicație de plăți sau facturare.
7. Numele clasei nu se potrivește cu numele fișierului
O clasă public trebuie să stea într-un fișier cu exact același nume, inclusiv literele mari. Dacă fișierul se numește Salut.java și scrii public class Main, compilatorul refuză:
Salut.java:1: error: class Main is public, should be declared in a file named Main.java Redenumești fie clasa, fie fișierul. Și ține minte că Java face diferența între main și Main, între string și String.
8. Ștergi elemente dintr-o listă în timp ce o parcurgi
Dacă elimini elemente dintr-un ArrayList în interiorul unui for-each, Java aruncă ConcurrentModificationException, pentru că lista s-a schimbat sub bucla care o citea.
List<Integer> stoc = new ArrayList<>(List.of(12, 0, 5, 0, 8));
for (Integer s : stoc) {
if (s == 0) stoc.remove(s); // ConcurrentModificationException
}
stoc.removeIf(s -> s == 0); // corect: [12, 5, 8] removeIf face exact ce voiai, într-un singur rând. Despre liste găsești mai multe în lecția despre ArrayList în Java.
9. Citești un element din afara vectorului
Un vector cu trei elemente are indecșii 0, 1 și 2. Orice încercare de a citi note[3] oprește programul cu ArrayIndexOutOfBoundsException.
int[] note = {9, 10, 8};
System.out.println(note[3]);
// Index 3 out of bounds for length 3 Cel mai des apare într-o buclă scrisă cu i <= note.length în loc de i < note.length. Greșeala și reparația sunt explicate pe larg în lecția despre bucla for în Java.
10. Ascunzi excepțiile cu un catch gol
Un catch gol face ca eroarea să dispară din consolă, dar nu și din program. Codul merge mai departe cu date greșite, iar tu nu mai ai niciun indiciu despre ce s-a întâmplat.
try {
int cantitate = Integer.parseInt(text);
} catch (NumberFormatException e) {
// nimic aici: greșit
} Măcar afișează mesajul (System.out.println("Cantitate invalidă: " + text)) sau tratează cazul explicit, de exemplu cerând din nou valoarea. Un catch trebuie să facă ceva util cu eroarea.
11. Scrii tot programul în main
La început, totul încape în main. După 200 de rânduri, nu mai găsești nimic și repeți același cod în trei locuri. Semnul clar e când copiezi un bloc de cod ca să-l folosești din nou.
Soluția e să împarți programul în metode cu nume clare (calculeazaMedia, afiseazaMeniul), iar mai târziu în clase. Începe cu lecția despre metode în Java: e primul pas spre cod pe care îl poți citi și peste o lună.
12. Nu citești mesajul de eroare
Multe ore pierdute la început vin din faptul că vezi text roșu și te sperii, în loc să-l citești. Un mesaj de eroare Java îți spune ce s-a întâmplat, în ce fișier și pe ce rând.
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
at E.main(E.java:4) Citește-l de sus în jos: tipul erorii (ArrayIndexOutOfBoundsException), explicația (indexul 3, lungimea 3), apoi locul (E.java, rândul 4). În cele mai multe cazuri, primele două rânduri sunt suficiente ca să repari problema singur.
Cum eviți aceste greșeli din primele săptămâni?
Majoritatea greșelilor de mai sus dispar dacă rulezi codul des și îl strici intenționat. Câteva obiceiuri care ajută:
- rulează programul după fiecare 5–10 rânduri, nu după 100;
- când apare o eroare, citește primele două rânduri ale mesajului înainte să cauți pe internet;
- după ce un exercițiu merge, strică-l cu bună știință (scoate un
break, pune==la texte) și vezi ce se întâmplă; - nu copia cod pe care nu îl poți explica rând cu rând;
- urmează o singură sursă structurată până la capăt, în loc să sari între zece tutoriale.
Întrebări frecvente
De ce == funcționează uneori la String-uri?
Pentru că Java refolosește textele scrise direct în cod, deci "Ion" == "Ion" poate da true. Pe textele citite de la tastatură sau construite în program, comparația eșuează. Nu te baza pe noroc: folosește mereu equals().
Care e cea mai frecventă eroare în Java?
La începători, NullPointerException și erorile de compilare de tip „cannot find symbol”, care apar când scrii greșit un nume de variabilă sau uiți să o declari. Ambele se repară citind atent mesajul.
E normal să fac aceleași greșeli de mai multe ori?
Da. Primele săptămâni sunt pline de aceleași cinci-șase greșeli, iar fiecare repetare te face să le recunoști mai repede. După câteva luni, le vezi înainte să rulezi codul.
Ajută un IDE să evit greșelile?
Da. Un IDE precum IntelliJ IDEA subliniază multe dintre ele înainte de rulare, de exemplu comparația de String-uri cu ==. Totuși, la început e util să înțelegi singur de ce e greșit, nu doar să accepți sugestia.
Primul pas: exersează cu verificare automată
Cel mai rapid repari o greșeală când afli imediat că ai făcut-o. În cursul de Java, fiecare exercițiu e verificat automat, iar Profu’, tutorele AI din lecții, îți explică ce ai greșit și îți dă un indiciu, fără să-ți dea direct soluția. Primele lecții sunt gratuite și le faci în browser, fără să instalezi nimic. Dacă vrei să știi ce urmează după bazele limbajului, uită-te pe traseul de Java Developer.
Curs Java
Programare Java pentru începători: de la sintaxă la OOP și colecții
Începe gratuit
