Ce semnificație au cuvintele-cheie static și final?

Question

Accepted Answer

**`static`** semnifică "aparține clasei în sine, nu instanțelor." **`final`** semnifică "nu poate fi schimbat/extins." Sunt cuvinte-cheie independente adesea confundate, dar ele abordează preocupări diferite — și se combină pentru a face constante. ## static — la nivel de clasă, partajat între toate instanțele ```java public class Counter { static int count = 0; // ONE shared variable for the whole class int id; // each instance has its OWN id Counter() { count++; // increments the shared counter id = count; } static void reset() { // static method — called on the class count = 0; } } Counter.count; // access via the CLASS name, no instance needed Counter.reset(); // call a static method on the class new Counter(); // each new instance shares `count` ``` `static` membrii aparțin clasei, nu obiectelor individuale — există o copie partajată de toate instanțele, accesată prin numele clasei. Metodele statice nu pot folosi `this` sau câmpuri de instanță (nu există instanță). ## final — nu poate fi reasignat / suprascris / extins ```java final int MAX = 100; // a constant — can't be reassigned MAX = 200; // ❌ compile error final class Util { } // a final CLASS can't be subclassed (e.g. String is final) class Base { final void critical() { } // a final METHOD can't be overridden } ``` `final` are trei utilizări: o **variabilă** finală nu poate fi reasignată (o constantă), o **metodă** finală nu poate fi suprascrisă, și o **clasă** finală nu poate fi extinsă. ## Un punct subtil: referințe finale ```java final List list = new ArrayList<>(); list.add("a"); // ✅ ALLOWED — modifying the OBJECT, not the reference list = new ArrayList<>(); // ❌ ERROR — can't REASSIGN the reference ``` Pentru o referință `final`, **referința** nu poate fi reasignată, dar **obiectul la care aceasta indică** poate încă fi mutat — un punct comun de confuzie. ## Combinat: static final = o constantă ```java public static final double PI = 3.14159; // class-level, unchangeable constant public static final String APP_NAME = "MyApp"; // convention: UPPER_SNAKE_CASE for static final constants ``` `static final` împreună creează adevărate constante — o valoare partajată, neschimbabilă pentru întreaga clasă, modul standard de a defini constante în Java. ## De ce este important `static` și `final` sunt cuvinte-cheie Java fundamentale cu semnificații distincte și importante: `static` activează starea la nivel de clasă și metodele utilitare (contoare partajate, metode factory, `Math.PI`, metoda `main` în sine), în timp ce `final` impune imutabilitate și previne moștenirea/suprascrierea (constante, clase imutabile cum ar fi String, sigilarea metodelor critice). Înțelegerea lor — inclusiv comportamentul subtil al referințelor finale (referință fixă, obiect mutabil) și combinația lor în constante — este esențială pentru proiectarea corectă a claselor, definirea corectă a constantelor, controlul extensibilității și raționamentul asupra stării partajate versus per-instanță. Sunt omniprezente în codul Java și subiecte frecvente la interviuri.