0Pricing
Java Academy · Aula

Inspecionando bytecode com javap

Descompile arquivos de classe com javap -c para entender como as construções de Java são traduzidas para bytecode.

Inspecionando bytecode com javap é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 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.

Por que inspecionar o bytecode?

Entender o bytecode revela como a JVM realmente executa seu código Java. Isso ajuda a depurar problemas de desempenho, entender as otimizações do compilador e verificar se o código sintético (expressões lambda, classes internas) funciona como esperado.

Uso básico de javap

javap ClassName exibe a API pública da classe (assinaturas de métodos e declarações de campos). Ele lê o arquivo .class do diretório atual ou do caminho de classes.

# Compile first:
javac User.java
# Display public API:
javap User
# Output:
# public class User {
#   public java.lang.String getName();
#   public int getAge();
# }

Desmontando bytecode com -c

javap -c User mostra o conjunto de instruções da JVM (códigos de operação) para cada método. Esta é a visão principal para entender o fluxo de execução.

# javap -c User
# public java.lang.String getName();
#   Code:
#      0: aload_0
#      1: getfield      #2  // Field name:Ljava/lang/String;
#      4: areturn

Saída detalhada com -v

javap -v User adiciona o conjunto de constantes, as sinalizações de acesso, os tamanhos da pilha e a tabela de exceções — elementos essenciais para análises aprofundadas e para depurar ClassCastException.

# javap -v User
# Constant pool:
#    #1 = Methodref  #5.#22  // java/lang/Object."<init>":()V
#    #2 = Fieldref   #4.#23  // User.name:Ljava/lang/String;
# ...

Instruções comuns de bytecode

Conheça os códigos de operação mais frequentes: aload_0 (carrega this), getfield, putfield, invokevirtual, invokespecial (construtores/privados), invokestatic, invokedynamic (expressões lambda), return, areturn.

Expressões lambda e invokedynamic

As expressões lambda são compiladas para instruções invokedynamic. A primeira invocação usa LambdaMetafactory para gerar uma classe; as chamadas seguintes a reutilizam. javap -v mostra a tabela de métodos de bootstrap.

// Java:
list.forEach(s -> System.out.println(s));
// Compiles to invokedynamic — javap shows:
// invokedynamic #4,0  // InvokeDynamic #0:accept:()Ljava/util/function/Consumer;

Otimização da concatenação de strings

O javac moderno usa invokedynamic para "Hello " + name em vez de StringBuilder. javap -v mostra o método de bootstrap StringConcatFactory.

// Java 9+ string concat:
String s = "Hello " + name;
// Compiles to:
// invokedynamic #5,0  // InvokeDynamic #1:makeConcatWithConstants

Observando o acesso a classes internas

Quando uma classe externa acessa um campo privado de uma classe interna (ou vice-versa), o compilador gera métodos sintéticos access$000. javap -p (membros privados) os revela.

# javap -p OuterClass
# static int access$000(OuterClass);
# -- synthetic bridge method generated by the compiler

Verificando o custo do autoboxing

O autoboxing é compilado para chamadas a Integer.valueOf() ou int.intValue(). Use javap -c para confirmar que o boxing ocorre e decidir se deve usar tipos primitivos.

// Java:
List<Integer> list = new ArrayList<>();
list.add(42); // autoboxing
// Bytecode:
// bipush 42
// invokestatic java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

Lendo try-catch do bytecode

Os manipuladores de exceções aparecem como entradas na tabela de exceções, visível com javap -v. Cada entrada mostra o início do try, o fim do try, o manipulador e o tipo capturado.

# Exception table:
# from    to  target  type
#    2    10      15  Class java/io/IOException
# -- means: if IOException in bytes 2-10, jump to handler at byte 15

Cabeçalho do arquivo de classe

O cabeçalho do arquivo de classe contém o número mágico (CAFEBABE), a versão principal/secundária e as sinalizações de acesso. javap -v mostra a versão principal, que corresponde à versão do Java que compilou a classe.

# javap -v User
# minor version: 0
# major version: 61   <- Java 17
# flags: ACC_PUBLIC, ACC_SUPER

Verificação rápida

Qual sinalização do javap mostra os códigos de operação da JVM para cada método?

Recapitulação

Use javap -c para ver os códigos de operação e javap -v para ver todos os detalhes. Conheça os principais códigos: invokevirtual, invokespecial, invokedynamic, getfield. Inspecione expressões lambda, boxing e concatenação de strings para entender a saída do compilador.

Perguntas Frequentes

A aula “Inspecionando bytecode com javap” é grátis?

Sim — o texto completo de “Inspecionando bytecode com javap” é 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 “Inspecionando bytecode com javap”?

Descompile arquivos de classe com javap -c para entender como as construções de Java são traduzidas para bytecode. 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 3 de 4.

Quanto tempo leva a aula “Inspecionando bytecode com javap”?

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

  1. Fases de Carregamento de Classes: Carregar, Vincular e Inicializar
  2. Hierarquia de ClassLoader e Carregadores Personalizados
  3. Inspecionando bytecode com javap
  4. Compilação JIT e compilação em camadas
← Voltar para Java Academy