Cosa significano le parole chiave static e final?

Question

Accepted Answer

**`static`** significa "appartiene alla classe stessa, non alle istanze." **`final`** significa "non può essere modificato/esteso." Sono parole chiave indipendenti spesso confuse, ma affrontano preoccupazioni diverse — e si combinano per creare costanti. ## static — a livello di classe, condiviso tra tutte le istanze ```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` ``` I membri `static` appartengono alla classe, non a singoli oggetti — esiste una sola copia condivisa da tutte le istanze, accessibile tramite il nome della classe. I metodi static non possono usare `this` o campi di istanza (nessuna istanza esiste). ## final — non può essere riassegnato / sovrascritto / esteso ```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` ha tre usi: una **variabile** final non può essere riassegnata (una costante), un **metodo** final non può essere sovrascritto, e una **classe** final non può essere estesa. ## Un punto sottile: riferimenti final ```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 ``` Per un riferimento `final`, il *riferimento* non può essere riassegnato, ma l'*oggetto a cui punta* può comunque essere mutato — un punto di confusione comune. ## Combinato: static final = una costante ```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` insieme creano vere costanti — un valore condiviso, immutabile per l'intera classe, il modo standard per definire costanti in Java. ## Perché è importante `static` e `final` sono parole chiave Java fondamentali con significati distinti e importanti: `static` abilita lo stato a livello di classe e metodi di utilità (contatori condivisi, factory method, `Math.PI`, il metodo `main` stesso), mentre `final` impone immutabilità e previene l'ereditarietà/sovrascrizione (costanti, classi immutabili come String, sigillamento di metodi critici). Comprenderli — incluso il comportamento sottile dei riferimenti final (riferimento fisso, oggetto mutabile) e la loro combinazione in costanti — è essenziale per progettare correttamente le classi, definire costanti in modo appropriato, controllare l'estensibilità, e ragionare su stato condiviso rispetto a stato per istanza. Sono pervasivi nel codice Java e argomenti frequenti nei colloqui.