Java Academy · Aula

Fases de Carregamento de Classes: Carregar, Vincular e Inicializar

Percorra o carregamento, a verificação, a preparação, a resolução e a inicialização de classes.

Fases de Carregamento de Classes: Carregar, Vincular e Inicializar é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

O ciclo de carregamento de classes

Uma classe Java passa por três fases antes de poder ser usada: carregamento (localizar e ler o bytecode), vinculação (verificar, preparar e resolver) e inicialização (executar os inicializadores estáticos).

Fase 1: carregamento

O ClassLoader lê o arquivo .class (do sistema de arquivos, de um JAR, da rede ou de bytecode gerado) e cria na memória heap um objeto Class<?> que o representa.

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

Fase 2a: verificação

O verificador de bytecode verifica se o bytecode carregado é estruturalmente válido, seguro quanto aos tipos e compatível com as regras da especificação da JVM. Bytecode inválido (por exemplo, manipulado incorretamente com ASM) causa VerifyError.

Fase 2b: preparação

A JVM aloca memória para campos estáticos e atribui a eles seus valores padrão (0, false, null). Os inicializadores estáticos AINDA NÃO foram executados nesta etapa.

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: resolução

As referências simbólicas (nomes de classes e assinaturas de métodos) no conjunto de constantes são substituídas por referências diretas (ponteiros) para as classes e os métodos reais. Isso pode ser adiado (resolução tardia).

Fase 3: inicialização

Os inicializadores estáticos (blocos static {}) e as atribuições de campos estáticos são executados na ordem textual. É nesse momento que timeout = 30 e host = "db" são realmente executados.

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

Gatilhos da inicialização de classes

A inicialização é executada pela primeira vez em: (1) criação de uma instância, (2) acesso a um campo estático (não constante), (3) chamada de um método estático, (4) reflexão por meio de Class.forName() (com initialize=true) e (5) inicialização de uma subclasse.

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

O método <clinit>

A JVM gera um método <clinit> (inicializador de classe) a partir de todos os inicializadores estáticos e das atribuições a campos estáticos. Ele é executado exatamente uma vez e é seguro para uso por várias threads — a JVM garante a exclusão mútua.

ExceptionInInitializerError

Se um inicializador estático lançar uma exceção, a JVM a encapsula em ExceptionInInitializerError. As tentativas posteriores de usar a classe lançam NoClassDefFoundError.

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

Ordem da inicialização estática

Os inicializadores estáticos são executados na ordem textual. Dependências circulares entre classes durante a inicialização podem causar classes parcialmente inicializadas — uma armadilha conhecida do padrão 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!
}

Observando o carregamento de classes

Ative a saída de registro do carregamento de classes com -Xlog:class+load=info (JVM 9 ou posterior) para ver quais classes são carregadas, de onde vêm e por qual 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

Verificação rápida

Durante qual fase os inicializadores estáticos são executados?

Recapitulação

Carregar: ler o bytecode. Vincular: verificar → preparar (valores padrão zero) → resolver (referências simbólicas). Inicializar: executar <clinit>. A inicialização é acionada pelo primeiro uso e é segura para uso por várias threads. Dependências circulares durante a inicialização causam erros sutis.

Perguntas Frequentes

A aula “Fases de Carregamento de Classes: Carregar, Vincular e Inicializar” é grátis?

Sim — o texto completo de “Fases de Carregamento de Classes: Carregar, Vincular e Inicializar” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Fases de Carregamento de Classes: Carregar, Vincular e Inicializar”?

Percorra o carregamento, a verificação, a preparação, a resolução e a inicialização de classes. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Fases de Carregamento de Classes: Carregar, Vincular e Inicializar”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Fases de Carregamento de Classes: Carregar, Vincular e Inicializar
Hierarquia de ClassLoader e Carregadores Personalizados
Inspecionando bytecode com javap
Compilação JIT e compilação em camadas

← Voltar para Java Academy