...
← Blog Lecții programare java

Static vs non-static în Java: diferența explicată cu exemple

Sigla Java, ilustrație pentru lecția despre static vs non-static în Java

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.

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:

CriteriuStaticNon-static (de instanță)
Aparține declasăfiecare obiect
Câte copii existăuna singurăcâte una pentru fiecare obiect
Cum îl apeleziClasa.membruobiect.membru
Are nevoie de new?nuda
Poate folosi this?nuda
Poate accesa direct membri non-statici?nuda, și pe cei statici
ExempleMath.sqrt(), Integer.parseInt(), constantelista.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:

  1. creezi un obiect și lucrezi prin el: Main m = new Main(); m.contor++;;
  2. 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 ca AtomicInteger.

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.

  1. Pui static ca să dispară eroarea. Repară cauza: creează obiectul și lucrează prin el.
  2. Atribute statice pentru date individuale. Numele, emailul sau soldul sunt ale fiecărui obiect, nu ale clasei.
  3. Folosești this într-o metodă statică. Nu există un obiect curent, deci compilatorul refuză.
  4. Crezi că static final face un obiect neschimbabil. O listă static final nu poate fi înlocuită cu alta, dar poți adăuga și scoate elemente din ea.
  5. 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.

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