
Diferența dintre static și non-static în Java ține de cui aparține un membru. Un atribut sau o metodă static aparține clasei, există într-un singur exemplar și se folosește fără obiect (Math.max(3, 7)). Un membru non-static aparține fiecărui obiect în parte, iar ca să îl folosești ai nevoie de un obiect creat cu new.
În lecția asta vezi ce înseamnă concret cuvântul static, de ce main e static, de unde vine eroarea „non-static variable cannot be referenced from a static context” și cum alegi corect între cele două variante.
Pentru exerciții pe fiecare concept, cursul Java pentru începători are primele 15 lecții gratuite, cu cod rulat direct în browser.
Ce înseamnă static în Java?
Cuvântul static marchează un membru care ține de clasă, nu de obiecte. Un atribut static există o singură dată în memorie, oricâte obiecte ai crea, iar toate obiectele îl văd și îl modifică pe același.
Exemplul de mai jos numără câți utilizatori s-au înregistrat pe o platformă:
public class Utilizator {
private static int numarUtilizatori = 0; // unul singur, comun
private String nume; // câte unul pentru fiecare obiect
public Utilizator(String nume) {
this.nume = nume;
numarUtilizatori++;
}
public String salut() { // non-static
return "Salut, " + nume + "!";
}
public static int getNumarUtilizatori() { // static
return numarUtilizatori;
}
}
Utilizator a = new Utilizator("Ana");
Utilizator b = new Utilizator("Mihai");
System.out.println(a.salut()); // Salut, Ana!
System.out.println(Utilizator.getNumarUtilizatori()); // 2 Fiecare utilizator are numele lui, dar contorul e unul singur. Observă și cum se apelează: metoda non-statică prin obiect (a.salut()), cea statică prin numele clasei (Utilizator.getNumarUtilizatori()).
Care e diferența dintre static și non-static?
Un membru static descrie ceva comun tuturor obiectelor sau ceva care nu depinde de vreun obiect, iar unul non-static descrie starea și comportamentul unui obiect anume. Tabelul rezumă diferențele practice:
| Criteriu | Static | Non-static (de instanță) |
|---|---|---|
| Aparține de | clasă | fiecare obiect |
| Câte copii există | una singură | câte una pentru fiecare obiect |
| Cum îl apelezi | Clasa.membru | obiect.membru |
Are nevoie de new? | nu | da |
Poate folosi this? | nu | da |
| Poate accesa direct membri non-statici? | nu | da, și pe cei statici |
| Exemple | Math.sqrt(), Integer.parseInt(), constante | lista.add(), text.length(), cont.depune() |
Atributele non-statice se mai numesc variabile de instanță, pentru că fiecare instanță (obiect) le are pe ale ei. Ele țin starea obiectului: soldul unui cont, stocul unui produs, numele unui cursant.
De ce metoda main este statică?
Metoda main e statică pentru că JVM-ul trebuie să o poată porni înainte să existe vreun obiect. Când rulezi programul, nu există nimic creat încă. Dacă main ar fi non-statică, JVM-ul ar trebui întâi să construiască un obiect din clasa ta, fără să știe ce constructor să folosească.
Asta explică și de ce, în primele lecții, toate metodele tale aveau static: le apelai direct din main, fără obiecte. Din momentul în care lucrezi cu clase și obiecte, majoritatea metodelor devin non-statice.
De ce apare eroarea „non-static variable cannot be referenced from a static context”?
Eroarea apare când încerci să folosești un atribut sau o metodă de obiect dintr-o metodă statică, fără să spui despre care obiect e vorba. E probabil cea mai frecventă eroare de compilare din primele săptămâni de OOP.
public class Main {
int contor = 0;
public static void main(String[] args) {
contor++; // eroare de compilare
}
} Compilatorul are dreptate: contor există doar în interiorul unui obiect Main, iar main rulează fără niciun obiect. Întrebarea pe care ți-o pune e „contorul cui?”. Ai două reparații corecte:
- creezi un obiect și lucrezi prin el:
Main m = new Main(); m.contor++;; - dacă valoarea chiar trebuie să fie una singură pentru tot programul, o declari
static int contor.
Varianta greșită, din păcate des întâlnită, e să pui static peste tot până dispare eroarea. Codul compilează, dar toate obiectele ajung să împartă aceleași date. Dacă ai zece cursanți și nume e static, toți zece se vor numi ca ultimul înscris.
În sens invers nu există nicio restricție. O metodă non-statică poate folosi liniștit membrii statici, așa cum constructorul lui Utilizator crește numarUtilizatori.
Când folosești static în Java?
Folosești static pentru lucruri care nu țin de un obiect anume: constante, metode utilitare care lucrează doar cu parametrii lor și contoare comune. În rest, alegerea implicită e non-static.
Constante
O constantă e o valoare fixă, comună întregului program, declarată static final. Nu are sens ca fiecare obiect să aibă propria copie a cotei de TVA:
public static final double COTA_TVA = 0.21; Constantele și cuvântul final au o lecție separată, mai încolo în serie.
Clase utilitare
O clasă utilitară grupează metode statice care primesc tot ce au nevoie prin parametri și nu țin stare. Math din Java e exemplul clasic. Una a ta ar putea arăta așa:
public final class CalculTva {
public static final double COTA_TVA = 0.21; // cota standard din 2025
private CalculTva() { } // nimeni nu creează obiecte din ea
public static double cuTva(double pretFaraTva) {
return pretFaraTva * (1 + COTA_TVA);
}
}
System.out.println(CalculTva.cuTva(100)); // 121.0 Constructorul privat împiedică new CalculTva(), care n-ar avea niciun rost. Testul simplu pentru o metodă statică: dacă metoda nu folosește niciun atribut de obiect și rezultatul depinde doar de parametri, poate fi statică.
Blocuri statice
Un bloc static { ... } rulează o singură dată, când clasa e încărcată prima oară, și e util pentru a inițializa date statice mai complicate decât o simplă atribuire:
static final Map<String, String> SETARI = new HashMap<>();
static {
SETARI.put("moneda", "RON");
SETARI.put("limba", "ro");
} Când folosești non-static?
Folosești non-static ori de câte ori datele sau comportamentul diferă de la un obiect la altul. Soldul contului, coșul unui client, progresul unui cursant la un curs: toate sunt stare de obiect și trebuie să fie variabile de instanță, cu metode non-statice care lucrează pe ele.
Și metodele care par „de serviciu” sunt de obicei mai bune non-statice. Un ServiciuEmail are nevoie de un server și de setări. Dacă îl faci obiect, poți avea unul real în aplicație și unul fals în teste. Dacă îl faci static, ești legat de el peste tot în cod.
De ce starea statică poate fi periculoasă?
Un atribut static modificabil este, practic, o variabilă globală: oricine din program îl poate schimba, oricând. În proiecte mici nu se vede problema. În proiecte mari, apar trei efecte neplăcute.
- Bug-uri greu de urmărit. Dacă o valoare statică e greșită, oricare dintre zecile de clase care o ating poate fi vinovată.
- Teste care se influențează. Un test lasă o valoare statică modificată, iar următorul test pică fără niciun motiv aparent.
- Probleme cu thread-urile. O aplicație web servește mai mulți utilizatori în paralel. Un contor static incrementat cu
++din mai multe thread-uri poate pierde incrementări; pentru asta există clase caAtomicInteger.
Regula practică: static final pentru valori care nu se schimbă e în regulă oricând. Un static modificabil îl folosești doar când ai un motiv clar.
Metodele statice se pot suprascrie?
Nu. O metodă statică poate fi redeclarată într-o clasă copil, dar asta se numește ascundere (hiding), nu suprascriere. Java alege metoda după tipul variabilei, nu după obiectul real:
class Parinte { static String cine() { return "Parinte"; } }
class Copil extends Parinte { static String cine() { return "Copil"; } }
Parinte p = new Copil();
System.out.println(p.cine()); // Parinte Cu o metodă non-statică, rezultatul ar fi fost „Copil”. Diferența contează la polimorfism și e explicată pe larg în lecția despre overloading vs overriding. Detaliul tehnic e descris în tutorialul Oracle despre suprascriere și ascundere.
Tot de aici vine și sfatul: apelează membrii statici prin numele clasei (Utilizator.getNumarUtilizatori()), nu printr-un obiect. Java permite a.getNumarUtilizatori(), dar codul sugerează greșit că rezultatul depinde de a.
Ce greșeli fac începătorii cu static?
Majoritatea greșelilor cu static vin din tentația de a scăpa repede de o eroare de compilare.
- Pui
staticca să dispară eroarea. Repară cauza: creează obiectul și lucrează prin el. - Atribute statice pentru date individuale. Numele, emailul sau soldul sunt ale fiecărui obiect, nu ale clasei.
- Folosești
thisîntr-o metodă statică. Nu există un obiect curent, deci compilatorul refuză. - Crezi că
static finalface un obiect neschimbabil. O listăstatic finalnu poate fi înlocuită cu alta, dar poți adăuga și scoate elemente din ea. - Transformi orice clasă în clasă utilitară. Un serviciu care lucrează cu baze de date sau emailuri e mai ușor de testat ca obiect.
Alte erori tipice din primele luni de Java sunt adunate în articolul despre greșelile frecvente ale începătorilor în Java.
Exercițiu: catalogul de produse
Scrie clasa Produs cu atributele de instanță nume și pret și un atribut static numarProduse, care crește în constructor. Adaugă metoda de instanță pretCuTva(), care folosește CalculTva.cuTva(), și metoda statică getNumarProduse().
În main, creează trei produse, afișează prețul cu TVA al fiecăruia și numărul total de produse. Apoi încearcă să apelezi pretCuTva() fără obiect și citește cu atenție mesajul compilatorului.
Întrebări frecvente
Ce înseamnă static în Java?
Înseamnă că membrul aparține clasei, nu obiectelor. Există într-un singur exemplar și se folosește prin numele clasei, fără să creezi un obiect.
Pot apela o metodă non-statică fără obiect?
Nu. O metodă non-statică lucrează cu datele unui obiect anume, deci ai nevoie de un obiect pe care să o apelezi. Din main, creezi întâi obiectul cu new.
De ce nu pot folosi this într-o metodă statică?
Pentru că this înseamnă „obiectul curent”, iar o metodă statică rulează fără niciun obiect. Compilatorul nu are la ce să lege referința.
Este static mai rapid decât non-static?
Diferența de viteză e neglijabilă în aplicațiile obișnuite. Alegerea se face după design: dacă membrul ține de un obiect sau de clasă, nu după performanță.
Este static rău în Java?
Nu, dar se folosește des greșit. Constantele, metodele utilitare fără stare și main sunt utilizări corecte. Starea statică modificabilă e cea care creează probleme.
Primul pas: caută static-urile din codul tău
Deschide ultimele exerciții scrise și ia fiecare static la rând. Pentru fiecare, întreabă-te: ține de clasă sau de un obiect? Dacă e o dată care diferă de la un obiect la altul, scoate-l și creează obiecte.
În cursul de Java exersezi diferența dintre static și non-static pe exerciții verificate automat, iar primele 15 lecții sunt gratuite. Când eroarea de context static nu are sens pentru tine, Profu’, tutorele AI din lecții, ți-o explică pe codul tău. Pentru drumul complet spre un post de junior, vezi traseul de Java Developer.
Lecția anterioară: constructorul în Java. Lecția următoare: compoziția în Java.
Curs Java
Programare Java pentru începători: de la sintaxă la OOP și colecții
Începe gratuit
