Java Academy · Lektion

Faser vid klassinläsning: Load, Link, Initialize

Gå igenom hur klasser läses in, verifieras, förbereds, länkas och initieras.

Lektion 1 av 413 steg

Faser vid klassinläsning: Load, Link, Initialize är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Livscykeln för klassinläsning

En Java-klass genomgår tre faser innan den kan användas: inläsning (hitta och läsa bytekoden), länkning (verifiera, förbereda och lösa) samt initiering (köra statiska initialiserare).

Fas 1: Inläsning

ClassLoader läser .class-filen (från filsystemet, en JAR-fil, nätverket eller genererad bytekod) och skapar ett Class<?>-objekt på heapen som representerar den.

// Trigger loading explicitly:
Class<?> c = Class.forName("com.example.MyService");
// The JVM delegates to the appropriate ClassLoader to find and load MyService.class

Fas 2a: Verifiering

Bytekodverifieraren kontrollerar att den inlästa bytekoden är strukturellt giltig, typsäker och följer JVM-specifikationens regler. Ogiltig bytekod (till exempel bytekod som har manipulerats felaktigt med ASM) orsakar VerifyError.

Fas 2b: Förberedelse

JVM allokerar minne för statiska fält och sätter dem till deras standardvärden (0, false, null). Statiska initialiserare har ännu INTE körts i detta steg.

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
}

Fas 2c: Lösning

Symboliska referenser (klassnamn och metodsignaturer) i konstantpoolen ersätts med direkta referenser (pekare) till de faktiska klasserna och metoderna. Detta kan skjutas upp (långsam lösning).

Fas 3: Initiering

Statiska initialiserare (static {}-block) och tilldelningar av statiska fält körs i textordning. Det är då timeout = 30 och host = "db" faktiskt körs.

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

Utlösare för klassinitialisering

Initialisering körs första gången: (1) en instans skapas, (2) ett statiskt fält används (om det inte är en konstant), (3) en statisk metod anropas, (4) reflektion används via Class.forName() (med initialize=true), (5) en underklass initialiseras.

// forName with initialize=false skips static initializers:
Class<?> c = Class.forName("com.example.MyService", false, loader);

Metoden <clinit>

JVM genererar en metod <clinit> (klassinitialiserare) utifrån alla statiska initialiserare och tilldelningar till statiska fält. Den körs exakt en gång och är trådsäker – JVM garanterar ömsesidig uteslutning.

ExceptionInInitializerError

Om en statisk initialiserare kastar ett undantag kapslar JVM in det i ExceptionInInitializerError. Efterföljande försök att använda klassen kastar NoClassDefFoundError.

static {
    if (System.getenv("DB_URL") == null)
        throw new RuntimeException("DB_URL not set"); // wrapped in ExceptionInInitializerError
}

Ordning för statisk initialisering

Statiska initialiserare körs i den ordning de står i källtexten. Cirkulära klassberoenden under initialiseringen kan leda till delvis initialiserade klasser – en välkänd fallgrop med mönstret 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!
}

Observera klassinläsning

Aktivera loggutdata för klassinläsning med -Xlog:class+load=info (JVM 9+) för att se vilka klasser som läses in, varifrån de läses in och av vilken 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.jar

Snabbkontroll

Under vilken fas körs statiska initialiserare?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Laddning: läs bytekod. Länkning: verifiera → förbered (nollstandardvärden) → lös upp (symboliska referenser). Initialisering: kör <clinit>. Initialisering utlöses vid första användningen och är trådsäker. Cirkulära beroenden under initialiseringen orsakar subtila buggar.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Faser vid klassinläsning: Load, Link, Initialize” gratis?

Ja – hela texten till ”Faser vid klassinläsning: Load, Link, Initialize” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Faser vid klassinläsning: Load, Link, Initialize”?

Gå igenom hur klasser läses in, verifieras, förbereds, länkas och initieras. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Faser vid klassinläsning: Load, Link, Initialize”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Faser vid klassinläsning: Load, Link, Initialize
ClassLoader-hierarki och egna laddare
Inspektera bytekod med javap
JIT-kompilering och nivåindelad kompilering

← Tillbaka till Java Academy