Fasi del caricamento delle classi: load, link, initialize
Segua le fasi di caricamento, verifica, preparazione, risoluzione e inizializzazione delle classi.
Fasi del caricamento delle classi: load, link, initialize è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 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.
Il ciclo di vita del caricamento delle classi
Una classe Java attraversa tre fasi prima di poter essere utilizzata: caricamento (individuazione e lettura del bytecode), collegamento (verifica, preparazione e risoluzione) e inizializzazione (esecuzione degli inizializzatori statici).
Fase 1: caricamento
Il ClassLoader legge il file .class (dal file system, da un JAR, dalla rete o dal bytecode generato) e crea nell'heap un oggetto Class<?> che lo rappresenta.
// Trigger loading explicitly:
Class<?> c = Class.forName("com.example.MyService");
// The JVM delegates to the appropriate ClassLoader to find and load MyService.classFase 2a: verifica
Il verificatore del bytecode controlla che il bytecode caricato sia strutturalmente valido, sicuro rispetto ai tipi e conforme alle regole della specifica JVM. Un bytecode non valido (ad esempio manipolato in modo errato con ASM) causa VerifyError.
Fase 2b: preparazione
La JVM alloca memoria per i campi statici e li imposta sui rispettivi valori predefiniti (0, false, null). In questa fase gli inizializzatori statici NON sono ancora stati eseguiti.
public class Config {
static int timeout = 30; // after preparation: timeout = 0 (default)
static String host = "db"; // after preparation: host = null
// Both get their real values only after Initialization
}Fase 2c: risoluzione
I riferimenti simbolici (nomi di classi, firme dei metodi) nel constant pool vengono sostituiti con riferimenti diretti (puntatori) alle classi e ai metodi effettivi. La risoluzione può essere posticipata (risoluzione lazy).
Fase 3: inizializzazione
Gli inizializzatori statici (blocchi static {}) e le assegnazioni ai campi statici vengono eseguiti nell'ordine testuale. È in questa fase che vengono effettivamente eseguite le istruzioni timeout = 30 e host = "db".
public class Config {
static int timeout;
static String host;
static {
timeout = Integer.parseInt(System.getenv("TIMEOUT"));
host = System.getenv("DB_HOST");
System.out.println("Config initialized");
}
}Trigger dell'inizializzazione delle classi
L'inizializzazione viene eseguita per la prima volta durante: (1) la creazione di un'istanza, (2) l'accesso a un campo statico (non costante), (3) la chiamata a un metodo statico, (4) la reflection tramite Class.forName() (con initialize=true), (5) l'inizializzazione di una sottoclasse.
// forName with initialize=false skips static initializers:
Class<?> c = Class.forName("com.example.MyService", false, loader);Il metodo <clinit>
La JVM genera un metodo <clinit> (inizializzatore della classe) a partire da tutti gli inizializzatori statici e dalle assegnazioni ai campi statici. Viene eseguito esattamente una volta ed è thread-safe: la JVM garantisce la mutua esclusione.
ExceptionInInitializerError
Se un inizializzatore statico genera un'eccezione, la JVM la incapsula in ExceptionInInitializerError. I tentativi successivi di utilizzare la classe generano NoClassDefFoundError.
static {
if (System.getenv("DB_URL") == null)
throw new RuntimeException("DB_URL not set"); // wrapped in ExceptionInInitializerError
}Ordine di inizializzazione statica
Gli inizializzatori statici vengono eseguiti nell'ordine testuale. Le dipendenze circolari tra classi durante l'inizializzazione possono causare classi inizializzate solo parzialmente: un'insidia nota del pattern Initialization-on-Demand Holder.
class A {
static final int X = B.Y + 1; // accesses B before B is initialized!
}
class B {
static final int Y = A.X + 1; // circular!
}Osservare il caricamento delle classi
Abiliti l'output del log del caricamento delle classi con -Xlog:class+load=info (JVM 9+) per vedere quali classi vengono caricate, da dove e da quale ClassLoader.
// JVM flag:
// java -Xlog:class+load=info:file=classload.log MyApp
// Output lines like:
// [info][class,load] com.example.MyService source: file:///app/app.jarVerifica rapida
Durante quale fase vengono eseguiti gli inizializzatori statici?
Riepilogo
Caricamento: lettura del bytecode. Collegamento: verifica → preparazione (valori predefiniti a zero) → risoluzione (riferimenti simbolici). Inizializzazione: esecuzione di <clinit>. L'inizializzazione viene attivata al primo utilizzo ed è thread-safe. Le dipendenze circolari durante l'inizializzazione causano bug difficili da individuare.
Domande Frequenti
La lezione «Fasi del caricamento delle classi: load, link, initialize» è gratuita?
Sì — il testo completo di «Fasi del caricamento delle classi: load, link, initialize» è 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 «Fasi del caricamento delle classi: load, link, initialize»?
Segua le fasi di caricamento, verifica, preparazione, risoluzione e inizializzazione delle classi. 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 1 di 4.
Quanto tempo richiede la lezione «Fasi del caricamento delle classi: load, link, initialize»?
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
- Fasi del caricamento delle classi: load, link, initialize
- Gerarchia dei ClassLoader e loader personalizzati
- Ispezionare il bytecode con javap
- Compilazione JIT e compilazione a livelli