0Pricing
Java Academy · Leçon

Champs statiques et constantes

Utilisez des champs statiques pour l’état partagé, des constantes avec static final et des initialiseurs statiques.

Champs statiques et constantes est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Champs statiques et constantes

Les champs statiques appartiennent à la classe, et non aux instances. Ils sont partagés par tous les objets de la classe. Les constantes combinent static et final pour créer des valeurs immuables au niveau de la classe.

Champs statiques et champs d'instance

Un champ d'instance possède une copie distincte pour chaque objet. Un champ statique possède une seule copie partagée par tous les objets de la classe.

class Counter {
    private static int totalCount = 0;  // shared across all instances
    private int instanceId;              // unique per instance

    Counter() {
        totalCount++;
        instanceId = totalCount;
    }

    static int getTotalCount() { return totalCount; }
    int getInstanceId()        { return instanceId; }
}

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

System.out.println(Counter.getTotalCount()); // 3
System.out.println(c1.getInstanceId());       // 1
System.out.println(c3.getInstanceId());       // 3

Constantes avec static final

Déclarez les constantes avec public static final. Par convention, leur nom utilise la notation SCREAMING_SNAKE_CASE.

class MathConstants {
    public static final double PI      = 3.141592653589793;
    public static final double E       = 2.718281828459045;
    public static final double GOLDEN  = 1.618033988749895;
    public static final int    PRIMES[] = {2, 3, 5, 7, 11, 13};
}

// Access without an instance
System.out.println(MathConstants.PI);

// Constants on domain classes
class HttpStatus {
    public static final int OK        = 200;
    public static final int NOT_FOUND = 404;
    public static final int SERVER_ERR = 500;
}

Blocs d'initialisation statique

Lorsqu'une constante nécessite une initialisation complexe, utilisez un bloc d'initialisation statique, exécuté une seule fois au chargement de la classe.

import java.util.*;

class Config {
    public static final Map<String, String> DEFAULTS;

    static {
        Map<String, String> map = new HashMap<>();
        map.put("timeout",  "30");
        map.put("maxRetry", "3");
        map.put("logLevel", "INFO");
        DEFAULTS = Collections.unmodifiableMap(map);
    }
}

System.out.println(Config.DEFAULTS.get("timeout")); // 30

Schéma du compteur statique

Les champs statiques sont couramment utilisés pour générer des ID, compter des métriques ou stocker des caches partagés.

import java.util.concurrent.atomic.AtomicLong;

class Order {
    private static final AtomicLong ID_SEQUENCE = new AtomicLong(1000);

    private final long id;
    private final String item;

    Order(String item) {
        this.id   = ID_SEQUENCE.getAndIncrement();
        this.item = item;
    }

    long getId()   { return id; }
    String getItem() { return item; }
}

Order o1 = new Order("Laptop");
Order o2 = new Order("Mouse");
System.out.println(o1.getId()); // 1000
System.out.println(o2.getId()); // 1001

Singleton avec un champ statique

Dans un singleton, un champ statique contient l'unique instance. Utilisez l'initialisation différée pour les classes qui ne sont pas toujours nécessaires.

class DatabasePool {
    private static volatile DatabasePool instance;
    private final int maxConnections;

    private DatabasePool() { this.maxConnections = 20; }

    public static DatabasePool getInstance() {
        if (instance == null) {
            synchronized (DatabasePool.class) {
                if (instance == null)
                    instance = new DatabasePool();
            }
        }
        return instance;
    }

    public int getMaxConnections() { return maxConnections; }
}

System.out.println(DatabasePool.getInstance().getMaxConnections()); // 20

Importation statique

import static permet d'utiliser des membres statiques sans le préfixe du nom de classe, ce qui est pratique pour les constantes et les méthodes utilitaires.

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;
import static java.lang.Math.pow;

// Without import static: Math.PI * Math.pow(r, 2)
double radius = 5.0;
double area = PI * pow(radius, 2);
System.out.printf("Area: %.2f%n", area); // 78.54

// Caution: overuse of static imports hurts readability
// Acceptable for: Math.*, Assert.* in tests, TimeUnit

Sûreté des champs statiques vis-à-vis des threads

Les champs statiques partagés entre plusieurs threads nécessitent une synchronisation ou des types atomiques pour éviter les conditions de concurrence.

import java.util.concurrent.atomic.*;

class RequestMetrics {
    private static final AtomicLong requestCount  = new AtomicLong(0);
    private static final AtomicLong totalLatencyMs = new AtomicLong(0);

    public static void record(long latencyMs) {
        requestCount.incrementAndGet();
        totalLatencyMs.addAndGet(latencyMs);
    }

    public static double averageLatency() {
        long count = requestCount.get();
        return count == 0 ? 0 : (double) totalLatencyMs.get() / count;
    }
}
RequestMetrics.record(45);
RequestMetrics.record(120);
System.out.println(RequestMetrics.averageLatency()); // 82.5

Champs statiques modifiables : pièges à éviter

Les champs statiques modifiables sont dangereux : un état global modifiable est difficile à tester, n'est pas sûr vis-à-vis des threads sans précautions et crée un couplage caché entre les classes.

// BAD: mutable static state
class GlobalConfig {
    public static String environment = "dev"; // mutable global!
}
// Any code anywhere can change GlobalConfig.environment
// Very hard to test, unexpected interactions

// BETTER: immutable constant
class GlobalConfig2 {
    public static final String ENVIRONMENT =
        System.getenv().getOrDefault("APP_ENV", "dev");
}

// BEST: inject via constructor (dependency injection)
class Service {
    private final String environment;
    Service(String environment) { this.environment = environment; }
}

Anti-pattern de l'interface de constantes

Il est déconseillé d'utiliser une interface pour stocker des constantes (l'anti-pattern « Constant Interface »). Utilisez plutôt une classe dotée d'un constructeur privé.

// BAD: constant interface — pollutes the namespace of implementing classes
interface FinancialConstants {
    double TAX_RATE = 0.08;  // implicitly public static final
}

// GOOD: utility class for constants
final class FinancialConstants2 {
    private FinancialConstants2() {} // prevent instantiation

    public static final double TAX_RATE  = 0.08;
    public static final double VAT_RATE  = 0.20;
    public static final int    MAX_ITEMS = 100;
}
System.out.println(FinancialConstants2.TAX_RATE); // 0.08

Pratique : indicateurs de fonctionnalités avec des constantes

Utilisation de constantes booléennes static final comme indicateurs de fonctionnalités évalués à la compilation : le compilateur JIT élimine les branches mortes.

class Features {
    public static final boolean ENABLE_ANALYTICS   = true;
    public static final boolean ENABLE_AI_SEARCH    = false;
    public static final boolean DEBUG_MODE          =
        "true".equals(System.getenv("DEBUG"));
}

// The JIT eliminates this if-block when ENABLE_AI_SEARCH is false:
if (Features.ENABLE_AI_SEARCH) {
    System.out.println("Running AI search...");
}

if (Features.DEBUG_MODE) {
    System.out.println("[DEBUG] Request received");
}

Vérification rapide

Quelle est la différence entre un champ statique et un champ d'instance ?

Récapitulatif : champs statiques et constantes

Points essentiels :

  • Les champs statiques appartiennent à la classe : une seule copie partagée par toutes les instances
  • Constantes : public static final UPPER_SNAKE_CASE
  • Utilisez des blocs d'initialisation statique pour les constantes nécessitant une initialisation complexe
  • Préférez AtomicLong/AtomicInteger pour les champs statiques modifiables dans du code concurrent
  • Évitez les champs statiques modifiables : ils créent un état global caché, difficile à tester
  • Utilisez une classe non instanciable (constructeur privé) pour les constantes plutôt qu'une interface

Questions Fréquemment Posées

La leçon « Champs statiques et constantes » est-elle gratuite ?

Oui — le texte complet de « Champs statiques et constantes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Champs statiques et constantes » ?

Utilisez des champs statiques pour l’état partagé, des constantes avec static final et des initialiseurs statiques. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Champs statiques et constantes » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Règles de surcharge des méthodes
  2. Paramètres varargs
  3. Champs statiques et constantes
  4. Classes utilitaires et méthodes de fabrique statiques
← Retour à Java Academy