Que signifient les mots-clés static et final ?

Question

Accepted Answer

**`static`** signifie « appartient à la classe elle-même, non aux instances ». **`final`** signifie « ne peut pas être modifié/étendu ». Ce sont des mots-clés indépendants souvent confondus, mais ils abordent des préoccupations différentes — et se combinent pour créer des constantes. ## static — au niveau de la classe, partagé entre toutes les instances ```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` Les membres appartiennent à la classe, non aux objets individuels — il existe une seule copie partagée par toutes les instances, accessible via le nom de la classe. Les méthodes statiques ne peuvent pas utiliser `this` ou les champs d'instance (aucune instance n'existe). ## final — ne peut pas être réassigné / surchargé / étendu ```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` a trois usages : une **variable** finale ne peut pas être réassignée (une constante), une **méthode** finale ne peut pas être surchargée, et une **classe** finale ne peut pas être étendue. ## Un point subtil : les références finales ```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 ``` Pour une référence `final`, la *référence* ne peut pas être réassignée, mais l'*objet vers lequel elle pointe* peut toujours être muté — un point source de confusion fréquent. ## Combiné : static final = une constante ```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` ensemble créent de véritables constantes — une valeur partagée, immuable pour toute la classe, la façon standard de définir les constantes en Java. ## Pourquoi c'est important `static` et `final` sont des mots-clés Java fondamentaux avec des significations distinctes et importantes : `static` permet l'état au niveau de la classe et les méthodes utilitaires (compteurs partagés, méthodes factory, `Math.PI`, la méthode `main` elle-même), tandis que `final` impose l'immuabilité et prévient l'héritage/la surcharge (constantes, classes immuables comme String, verrouillage des méthodes critiques). Les comprendre — y compris le comportement subtil des références finales (référence fixe, objet muable) et leur combinaison en constantes — est essentiel pour concevoir correctement les classes, définir correctement les constantes, contrôler l'extensibilité et raisonner sur l'état partagé par rapport à l'état par instance. Ils sont omniprésents dans le code Java et des sujets d'entretien fréquents.