Java Academy · Lezione

Campi statici e costanti

Utilizzi campi statici per lo stato condiviso, costanti con static final e inizializzatori statici.

Campi statici e costanti è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Campi statici e costanti

I campi statici appartengono alla classe, non alle istanze. Sono condivisi da tutti gli oggetti della classe. Le costanti combinano static e final per creare valori immutabili a livello di classe.

Campi statici e campi di istanza

Un campo di istanza ha una copia separata per ogni oggetto. Un campo statico ha una sola copia condivisa da tutti gli oggetti della 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

Costanti con static final

Dichiari le costanti come public static final. Per convenzione, utilizzano 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;
}

Blocchi di inizializzazione statici

Quando una costante richiede un'inizializzazione complessa, utilizzi un blocco di inizializzazione statico che viene eseguito una sola volta quando la classe viene caricata.

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

Pattern del contatore statico

I campi statici vengono comunemente usati per generare ID, contare metriche o gestire cache condivise.

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 tramite campo statico

Un campo statico contiene l'unica istanza di un Singleton. Utilizzi l'inizializzazione lazy per le classi che potrebbero non essere sempre necessarie.

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

Import statico

import static consente di utilizzare i membri statici senza il prefisso del nome della classe: è utile per costanti e metodi di utilità.

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

Sicurezza dei thread nei campi statici

I campi statici condivisi tra i thread richiedono la sincronizzazione o tipi atomici per evitare condizioni di race.

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

Campi statici mutabili: problemi

I campi statici mutabili sono pericolosi: lo stato globale mutabile è difficile da testare, non è sicuro per i thread se non viene gestito con attenzione e crea accoppiamenti nascosti tra le classi.

// 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 dell'interfaccia per le costanti

È sconsigliato utilizzare un'interfaccia per contenere costanti (l'anti-pattern "Constant Interface"). Utilizzi invece una classe con un costruttore privato.

// 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

Pratica: flag delle funzionalità tramite costanti

Utilizzo di costanti static final boolean per i flag delle funzionalità in fase di compilazione: il compilatore JIT elimina i rami di codice inutilizzati.

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");
}

Verifica rapida

Qual è la differenza tra un campo statico e un campo di istanza?

Riepilogo: campi statici e costanti

Punti chiave:

I campi statici appartengono alla classe: una sola copia condivisa da tutte le istanze
Costanti: public static final UPPER_SNAKE_CASE
Utilizzi blocchi di inizializzazione statici per le costanti che richiedono un'inizializzazione complessa
Preferisca AtomicLong/AtomicInteger per i campi statici mutabili nel codice concorrente
Eviti i campi statici mutabili: creano uno stato globale nascosto difficile da testare
Utilizzi una classe non istanziabile (con costruttore privato) per le costanti invece di un'interfaccia

Domande Frequenti

La lezione «Campi statici e costanti» è gratuita?

Sì — il testo completo di «Campi statici e costanti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Campi statici e costanti»?

Utilizzi campi statici per lo stato condiviso, costanti con static final e inizializzatori statici. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Campi statici e costanti»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Regole dell'overloading dei metodi
Parametri varargs
Campi statici e costanti
Classi di utilità e metodi factory statici

← Torna a Java Academy