Debug no IntelliJ IDEA

1. Bug

Os programadores têm o seu próprio jargão. E a primeira palavra que você conhecerá a fundo será bug (do inglês bug — inseto). Esta palavra designa um erro no programa que faz com que ele se comporte de forma inesperada, trave ou produza um resultado estranho.

Se um programa funciona de maneira estranha, mas o programador garante que foi planejado assim, geralmente diz-se: "Isso não é um bug, é uma feature". A internet está cheia de memes sobre esse tema.

Contexto histórico

Diz a lenda que, em setembro de 1947, cientistas de Harvard estavam testando o computador Mark II. Ele apresentava falhas. Ao verificar todos os contatos, encontraram uma mariposa real presa entre os relés. O inseto foi colado no registro com a legenda "First actual case of bug being found" (Primeiro caso real de um inseto encontrado).

Desde então, o processo de busca e correção de erros é chamado de debug ou depuração.

---

2. Modo de Debug

Para encontrar um erro, os programadores usam o Debugger. É uma ferramenta especial dentro do IntelliJ IDEA que permite colocar a execução do programa em pausa e dar uma olhada "debaixo do capô".

O IntelliJ IDEA pode executar seu programa em dois modos:

No modo de depuração, você pode executar o programa linha por linha, observando como os valores das variáveis mudam.

3. Breakpoints

Para que o Debugger entenda onde parar, você deve colocar um Breakpoint. Sem ele, o programa simplesmente passará direto até o fim, como de costume.

Vamos praticar com um exemplo prático. Extraímos a lógica da multiplicação para um método separado para mostrar todo o poder do debugger. Copie este código para o seu IDEA:

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            int result = calculateMultiply(i);  // <--- Queremos parar aqui
            sum += result;
            System.out.println("Step: " + i + ", Result: " + result + ", Sum: " + sum);
        }
        System.out.println("Final Sum: " + sum);
    }

    public static int calculateMultiply(int number) {
        return number * 2;
    }
}

Tarefa. Queremos ver como as variáveis mudam dentro do loop e entrar dentro do nosso método.

Ação. Clique com o mouse na margem cinza estreita à esquerda da linha int result = calculateMultiply(i);. Um círculo vermelho aparecerá.

Agora, inicie o programa através do Debug (ícone do inseto). O programa iniciará e "congelará" instantaneamente antes de executar essa linha.

4. Controle: F8, F7, F9

Quando o programa está em pausa, você tem um painel de controle na parte superior da janela Debugger.

F8 — Step Over

Pressione F8. O programa executará a linha atual (chamará o método, obterá o resultado) e avançará para a próxima sum += result;.

Pressione F8 novamente. O programa somará os números. Você verá como os valores das variáveis mudaram.

Pressione F8 mais uma vez. Você verá a saída no console.

Esta é a principal forma de se mover: linha por linha, sem se aprofundar nos detalhes internos dos métodos.

F9 — Resume Program

Temos um loop de 1 a 5. Pressionar F8 cinco vezes para passar por uma rodada do loop é entediante. E se o loop tiver 1000 iterações?

Pressione F9. O programa "desgrudará", executará todo o restante do código na iteração atual, seguirá para a segunda rodada e... parará novamente no Breakpoint.

Assim, com a ajuda do F9, você pode percorrer loops rapidamente: um clique — uma iteração.

F7 — Step Into

Se no código você encontrar uma chamada de um método seu (no nosso caso calculateMultiply(i)) e pressionar F8, o Debugger simplesmente o executará e seguirá em frente. Mas se você quiser ver como o código funciona dentro desse método — pressione F7.

Tente pressionar F7 quando o programa parar na linha int result = calculateMultiply(i);. O Debugger o levará para dentro do método calculateMultiply, e você verá como o valor é passado para o parâmetro number.

Shift + F8 — Step Out

O que fazer se você pressionou F7 por acidente na linha System.out.println(...) e caiu nas profundezas do código de sistema do Java? Ler milhares de linhas de código alheio é chato e confuso.

Pressione Shift + F8. O programa executará rapidamente tudo o que resta no método atual e o trará de volta para onde você veio (o seu método main).

5. Onde ver os valores?

Voltemos ao nosso exemplo com o loop.

Modo 1: Inline Debugging

Observe diretamente no editor de código. À direita das linhas, o IDEA escreve os valores atuais em cinza.

Modo 2: Painel Variables

Na parte inferior da janela Debugger, existe a aba Variables. Lá são mostradas todas as variáveis atuais.

Esclarecimento importante para Java: Tipos primitivos (por exemplo, int) mostram seus valores imediatamente. Já objetos e arrays (por exemplo, String[]) armazenam muitos dados dentro de si. Para ver o conteúdo, é necessário clicar na pequena seta à esquerda da variável para "expandir" o objeto.

Modo 3: Painel Frames

À esquerda das variáveis há uma lista chamada Frames (Stack Trace). Ela mostra em que passo o programa se encontra atualmente.

Por exemplo, o texto main:6, Main significa:

• Você está no método main da classe Main.
• Você parou na linha número 6.

Este é o seu endereço exato no código. Se você entrar em outro método (pressionar F7 em calculateMultiply), uma nova entrada aparecerá no topo desta lista: calculateMultiply:13, Main, indicando que o novo método foi chamado a partir do anterior.

6. Evaluate Expression

Às vezes, apenas olhar para as variáveis não é suficiente. Você quer perguntar: "O que acontece se..."

Pressione Alt + F8 (Windows/Linux) ou Option + F8 (macOS). Uma janela "Evaluate" será aberta. Você também pode digitar expressões diretamente na linha abaixo do painel Variables.

Aqui você pode escrever qualquer código usando as variáveis atuais. Por exemplo, em nosso loop, escreva:

sum + 100

Pressione Enter e o IDEA calculará o resultado sem alterar o programa real. É o seu rascunho para experimentos.

7. Conditional Breakpoints

Imagine que você tem um loop de 10.000 iterações, mas o erro ocorre apenas no passo 5.000. Pressionar F9 cinco mil vezes é uma má ideia.

Clique com o botão direito do mouse no círculo vermelho do Breakpoint. Uma janela pop-up aparecerá. No campo Condition, escreva uma condição em Java, por exemplo: i == 5. Pressione Done.

Agora, se você iniciar o Debugger, o programa ignorará as primeiras 4.999 rodadas e parará apenas quando a condição se tornar true. Isso economizará horas de trabalho!

8. Gerenciamento de todos os Breakpoints

Às vezes, iniciantes colocam tantos Breakpoints em diferentes arquivos do projeto que o programa fica constantemente parando em lugares inesperados. Procurar círculos vermelhos por todos os arquivos manualmente é demorado.

Pressione Ctrl + Shift + F8 (Windows/Linux) ou Cmd + Shift + F8 (macOS). A janela Breakpoints será aberta.

Aqui você vê uma lista de todos os pontos de parada no seu projeto. Você pode desmarcá-los (desabilitar temporariamente) ou excluí-los com a tecla Delete.

9. Conclusão

Analisamos o arsenal principal do desenvolvedor Java para encontrar erros. O Debugger é o que transforma a escrita de código de "adivinhação" em um trabalho de engenharia preciso.

A habilidade de encontrar rapidamente a causa de um erro é uma competência que é valorizada no desenvolvimento comercial, até mais do que a habilidade de escrever código rapidamente. Pratique com breakpoints condicionais e Evaluation, e nenhum bug escapará de você.