Java — `static` & Évolutions (Java 11 → 25)

Le mot-clé static est fondamental en Java. Il est souvent utilisé mais parfois mal compris, surtout dans des contextes réels (performance, mémoire, design).

1. Idée simple

static signifie :

appartient à la classe et non aux instances

➡️ une seule copie partagée en mémoire

2. Variable `static`

class Counter {
    static int count = 0;
}

Ici :

count est partagé par tous les objets
une seule valeur en mémoire

Exemple

Counter c1 = new Counter();
Counter c2 = new Counter();

c1.count++;
System.out.println(c2.count); // 1

même variable partagée

3. Méthode `static`

class MathUtils {
    static int add(int a, int b) {
        return a + b;
    }
}

Appel :

MathUtils.add(2, 3);

pas besoin d’objet

Règles importantes

une méthode static ne peut pas accéder directement aux variables non static
elle n’a pas accès à this

4. Bloc `static`

class Config {
    static {
        System.out.println("Initialisation");
    }
}

exécuté une seule fois au chargement de la classe

5. Cas courant : constantes

public static final int MAX = 100;

combinaison fréquente :

static → partagé
final → immuable

Pièges fréquents

croire que static = global (ce n’est pas exactement ça)
utiliser trop de static → code difficile à tester
oublier que c’est partagé → bugs en concurrence

6. `static` et concurrence

une variable static est :

partagée entre threads
donc potentiellement dangereuse

➡️ nécessite synchronisation si modifiée

7. Évolutions Java 11 → 25

Le comportement de static n’a pas changé fondamentalement

MAIS l’environnement autour a évolué :

Java 11

version LTS stable
utilisation classique de static

Java 17 (LTS)

amélioration des performances JVM
sealed classes (impact design, pas static)

Java 21 (LTS)

virtual threads (Project Loom) impact indirect :
static partagé → attention en concurrence massive

Java 25 (récent)

optimisations JVM
amélioration GC et performance
pas de changement direct sur static

8. Impact réel aujourd’hui

avec les virtual threads :

plus de threads → plus d’accès concurrent
les variables static deviennent encore plus critiques

➡️ attention aux race conditions

9. Questions classiques

Q1

static signifie quoi ? partagé au niveau classe

Q2

une méthode static peut utiliser this ? non

Q3

combien d’instances d’une variable static ? une seule

Q4

danger principal ? concurrence

10. À retenir

static = partagé entre toutes les instances
utile pour utilitaires, constantes
dangereux si mal utilisé en multi-thread
pas de changement majeur entre Java 11 et 25

🧾 En résumé

static appartient à la classe
une seule copie en mémoire
souvent utilisé avec final
nécessite attention en concurrence

C’est un concept simple mais critique pour comprendre la mémoire et la performance en Java.

Java — static & Évolutions (Java 11 → 25)