...
← Blog Lecții programare java

Constante și final în Java: static final, metode și clase final

Sigla Java, ilustrație pentru lecția despre constante și final în Java

Constantele în Java se declară cu static final: valoarea se setează o singură dată și nu mai poate fi schimbată, iar numele se scrie cu majuscule, de exemplu COTA_TVA. Cuvântul-cheie final are trei utilizări: la variabile interzice o nouă atribuire, la metode interzice suprascrierea, iar la clase interzice moștenirea.

În lecția asta vezi fiecare utilizare a lui final, cum declari corect constantele, de ce o listă final se poate totuși modifica, când alegi un enum în loc de constante și ce greșeli apar cel mai des.

Ce este keywordul final în Java?

final este un modificator care spune „asta nu se mai schimbă după ce a primit o formă”. Ce anume nu se schimbă depinde de locul în care îl pui:

Unde pui finalCe interziceExemplu
variabilă locală sau parametruo nouă atribuirefinal int lectiiPeZi = 3;
atribut de instanțăschimbarea după constructorprivate final String iban;
atribut staticorice schimbare: e o constantăstatic final double COTA_TVA = 0.21;
metodăsuprascrierea în subclasepublic final String semnatura()
clasămoștenireapublic final class String

În toate cazurile, regula e verificată de compilator. Dacă încerci lectiiPeZi = 4; după declarație, primești eroarea „cannot assign a value to final variable lectiiPeZi”, iar programul nici nu pornește.

Cum declari constante cu static final în Java?

O constantă în Java este un atribut static final, cu o valoare fixă cunoscută dinainte, comună întregului program. static înseamnă că există o singură copie, legată de clasă, iar final că nu se schimbă.

public final class Limite {
    public static final int NOTA_MINIMA_PROMOVARE = 5;
    public static final double COTA_TVA = 0.21;
    public static final int MAX_PRODUSE_IN_COS = 50;

    private Limite() { }   // nu se creează obiecte din ea
}

int nota = 7;
System.out.println(nota >= Limite.NOTA_MINIMA_PROMOVARE ? "Promovat" : "Restanță");
// Promovat

Convenția de denumire e strictă: majuscule, cu cuvintele despărțite prin underscore (MAX_PRODUSE_IN_COS). Oricine citește codul vede imediat că valoarea e fixă. Dacă diferența dintre membrii statici și cei de instanță nu îți e încă limpede, recitește lecția despre static vs non-static în Java.

De ce folosești constante în loc de numere scrise direct?

Constantele dau nume valorilor și le țin într-un singur loc, așa că o schimbare se face o dată, nu în 30 de fișiere. Un număr scris direct în cod, fără explicație, se numește „magic number” și e unul dintre primele lucruri pe care le semnalează un code review.

// greu de înțeles: ce e 0.21? ce e 50?
double total = subtotal * 1.21;
if (produse.size() > 50) { ... }

// clar
double total = subtotal * (1 + Limite.COTA_TVA);
if (produse.size() > Limite.MAX_PRODUSE_IN_COS) { ... }

Când cota de TVA s-a schimbat în România, de la 19% la 21% în august 2025, aplicațiile cu o constantă au modificat o singură linie. Cele cu 1.19 scris prin tot codul au avut de căutat fiecare apariție și de verificat dacă acel 1.19 era chiar TVA sau altceva.

O nuanță: o valoare care se schimbă des sau diferă între medii (adresa serverului, parola bazei de date, o promoție) nu e constantă, ci configurare. Locul ei e într-un fișier de configurare sau într-o variabilă de mediu, nu în cod.

Cum folosești final la variabile și atribute?

O variabilă final trebuie să primească valoare exact o dată, dar nu neapărat la declarare. Compilatorul verifică doar ca, pe orice drum prin cod, să fie atribuită o singură dată:

final String mesaj;
if (premium) {
    mesaj = "Acces complet";
} else {
    mesaj = "Acces gratuit";
}
// aici mesaj are sigur o valoare și nu mai poate fi schimbat

La atribute, final e cel mai util pentru datele care identifică un obiect și nu au voie să se schimbe: IBAN-ul unui cont, CNP-ul unei persoane, numărul unei comenzi. Un atribut final de instanță trebuie inițializat la declarare sau în fiecare constructor, altfel codul nu compilează. Avantajul: nimeni, nici tu peste trei luni, nu poate schimba IBAN-ul unui cont din greșeală.

La parametri, final te împiedică să reatribui parametrul în interiorul metodei. Unele echipe îl pun peste tot, altele deloc. Nu e o regulă de limbaj, ci de stil, așa că urmează convenția proiectului în care lucrezi.

O listă final poate fi modificată?

Da. final blochează referința, nu obiectul spre care arată. Aceasta e cea mai frecventă confuzie legată de final, și apare des la interviuri.

final List<String> cos = new ArrayList<>();
cos.add("Carte Java");          // permis: modifici lista
cos.add("Cană");                // permis
cos = new ArrayList<>();        // eroare: nu poți schimba referința

Variabila cos va arăta mereu spre aceeași listă, dar conținutul listei se schimbă liber. Dacă vrei o listă care nu poate fi modificată deloc, folosești o colecție imuabilă:

public static final List<String> ORASE_LIVRARE = List.of("București", "Cluj-Napoca", "Iași");

ORASE_LIVRARE.add("Timișoara");   // UnsupportedOperationException la rulare

List.of() creează o listă imuabilă (din Java 9). Combinat cu static final, obții o constantă adevărată: nici referința, nici conținutul nu se pot schimba. Același lucru e valabil pentru Set.of() și Map.of().

Cum faci un obiect complet imuabil?

Un obiect imuabil este un obiect a cărui stare nu se mai schimbă după creare. Îl obții combinând mai multe reguli, nu doar final:

  1. clasa e final, ca nimeni să nu o extindă cu o subclasă modificabilă;
  2. toate atributele sunt private final;
  3. nu există setteri;
  4. metodele care „modifică” returnează un obiect nou;
  5. atributele care sunt colecții sau obiecte modificabile se copiază la intrare și la ieșire.
public final class Pret {
    private final long bani;      // 4999 înseamnă 49,99
    private final String moneda;

    public Pret(long bani, String moneda) {
        this.bani = bani;
        this.moneda = moneda;
    }

    public Pret plus(Pret altul) {
        return new Pret(bani + altul.bani, moneda);   // obiect nou
    }

    @Override
    public String toString() {
        return bani / 100 + "," + String.format("%02d", bani % 100) + " " + moneda;
    }
}

Pret total = new Pret(4999, "lei").plus(new Pret(1500, "lei"));
System.out.println(total);   // 64,99 lei

String, Integer și LocalDate din Java sunt construite exact așa. Obiectele imuabile sunt sigure de împărțit între părți diferite ale programului și între thread-uri, pentru că nimeni nu le poate strica starea.

Ce fac metodele și clasele final?

O metodă final nu poate fi suprascrisă, iar o clasă final nu poate fi extinsă deloc. Le folosești când un comportament trebuie să rămână exact cum l-ai scris, indiferent cine extinde codul.

public class Document {
    public final String semnatura() {
        return "semnat digital";
    }
}

final class A { }
class B extends A { }   // eroare: cannot inherit from final A

Exemplul cel mai cunoscut e String, care e final. Dacă ar putea fi extinsă, cineva ar putea crea un „String” care își schimbă conținutul după ce a fost verificat, iar o mare parte din siguranța limbajului s-ar pierde. Pentru clasele tale, nu e nevoie să pui final peste tot. Pune-l când știi sigur că o subclasă ar strica regulile clasei.

Constante sau enum?

Când ai un set închis de valori înrudite, ca stările unei comenzi sau zilele săptămânii, un enum e mai bun decât un grup de constante int sau String.

// fragil: orice int trece, inclusiv 42
public static final int STATUS_PLASATA = 0;
public static final int STATUS_PLATITA = 1;

// sigur: doar aceste valori există
public enum StatusComanda {
    PLASATA, PLATITA, EXPEDIATA, LIVRATA, ANULATA
}

StatusComanda status = StatusComanda.EXPEDIATA;

Cu enum, compilatorul refuză orice valoare care nu e în listă, iar switch-ul pe un enum poate verifica dacă ai tratat toate cazurile. Păstrează constantele static final pentru valori numerice sau texte izolate, ca COTA_TVA. Detaliile despre final la atribute sunt în specificația limbajului Java, secțiunea despre câmpurile final.

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

Majoritatea greșelilor cu final vin din ideea că ar face orice neschimbabil.

  1. Crezi că final face obiectul imuabil. Blochează doar referința. Pentru liste, folosește List.of().
  2. Expui o listă public static final modificabilă. Oricine poate adăuga sau șterge elemente din „constanta” ta.
  3. Pui în constante valori care se schimbă. Adrese de server, parole, prețuri promoționale: acestea țin de configurare.
  4. Lași magic numbers în cod. Orice număr cu un sens de business merită un nume.
  5. Constante int în loc de enum. Pierzi verificarea compilatorului pentru valorile permise.
  6. Uiți să inițializezi un atribut final într-unul dintre constructori. Compilatorul refuză codul, iar mesajul („variable might not have been initialized”) te trimite exact la constructorul cu problema.

Exercițiu: refactorizează magic numbers

Ia codul de mai jos și înlocuiește fiecare număr cu o constantă bine numită, într-o clasă Reguli care nu poate fi instanțiată:

double pretFinal(double subtotal, int produse) {
    double total = subtotal * 1.21;
    if (subtotal > 200) {
        return total;               // livrare gratuită
    }
    return total + (produse > 5 ? 25 : 15);
}

Apoi transformă două dintre ele în configurare: care valori crezi că s-ar schimba la o promoție de Black Friday și ar trebui citite din afara codului?

Întrebări frecvente

Ce înseamnă final în Java?

Înseamnă că elementul marcat nu se mai poate schimba: o variabilă nu poate fi reatribuită, o metodă nu poate fi suprascrisă, iar o clasă nu poate fi extinsă.

Care este diferența dintre final și static final?

Un atribut final are câte o valoare fixă pentru fiecare obiect, setată în constructor. Un atribut static final are o singură valoare pentru toată clasa și e ceea ce numim constantă.

O variabilă finală trebuie inițializată imediat?

Nu. Poate primi valoarea mai târziu, de exemplu pe ramurile unui if sau în constructor, cu condiția să fie atribuită exact o dată pe orice drum prin cod.

O listă finală este imuabilă?

Nu. Poți adăuga și șterge elemente, doar nu poți face variabila să arate spre altă listă. Pentru o listă imuabilă folosești List.of() sau Collections.unmodifiableList().

Este final același lucru cu const?

Nu chiar. const e un cuvânt rezervat în Java, dar nu se folosește. Echivalentul unei constante din alte limbaje e static final.

Primul pas: caută numerele magice din codul tău

Deschide ultimele trei exerciții și caută orice număr, în afară de 0 și 1, scris direct în cod. Dă-i un nume și mută-l într-o constantă. Apoi caută atributele care nu se schimbă după constructor și fă-le final.

În cursul de Java exersezi constantele, final și obiectele imuabile pe exerciții verificate automat, direct în browser, iar primele 15 lecții sunt gratuite. Profu’, tutorele AI din lecții, îți explică de ce o listă final s-a modificat totuși. Pentru drumul complet spre primul job, vezi traseul de Java Developer.

Lecția anterioară: overloading vs overriding în Java. Lecția următoare: pachete în Java și organizarea unui proiect.

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