Fala, pessoal! Hoje nós vamos ter uma visão geral de como usar o Debug no Eclipse.
Mas primeiramente, o que é Debug? Basicamente é o modo de depuração de código.
Depuração significa executar o código passo a passo em uma ferramenta, como o Eclipse, com intenção de localizar o ponto exato em que você cometeu um erro de programação.
Ou seja, você acompanha a própria execução do código, vendo o que está acontecendo e todos os valores ali contidos, além de poder validar expressões e replicar cenários.
E afinal, quem nunca passou por um bug de dar dor de cabeça, né? Então, agora você verá que isso facilita e muito a correção de bugs.
Breakpoint
O que é o Breakpoint? Ele nada mais é que um ponto de parada.
Note que, quando tiver um pontinho no Eclipse da seguinte forma, ele é o Breakpoint.
Confere na imagem abaixo o famoso Breakpoint:
Lembrando que, para você colocar um Breakpoint no Eclipse, você precisa clicar duas vezes com o botão esquerdo do mouse ao lado da linha desejada como na imagem acima, e também é necessário que seja em uma linha de código que faça algo.
Ou seja, não tem como eu colocar um Breakpoint em uma linha vazia, ou até mesmo em uma linha que não tem lógica.
Vamos conferir a seguir a imagem de onde consigo colocar uma parada e onde não consigo, elas serão representados por pontos verdes e vermelhos respectivamente.
Executando em Debug
Para nós conseguirmos usar o Debug, nós devemos executar em modo Debug, segue a imagem de como fazer a execução dessa forma:
Basta clicar na área marcada em vermelho que irá executar o código, mas é necessário que esteja em modo Debug (e sim, o ícone é um inseto haha).
Uma curiosidade: para quem não conhece a história, o termo bug surgiu quando um inseto ficou preso em um computador e causou um mal funcionamento. Desde então passou-se a usar o termo bug para quando algo dá errado, e que significa “inseto” em inglês.
Mas voltando ao assunto. Depois que rodarmos em Debug e a execução chegar a algum Breakpoint, ele irá parar e nesse momento você vai ter diversos recursos disponíveis!
E é aí que a “mágica” acontece.
Conhecendo o Modo Debug
No momento que a execução do seu código chegar no Breakpoint, você pode ter acesso a vários benefícios do Debug como por exemplo verificar variáveis, validar expressões, ver valores e acompanhar passo a passo da execução.
A nossa tela de Debug vai ser essa:
Fique tranquilo se não aparecer dessa forma pra você! Basta ir na lupa do Eclipse e pesquisar pelo nome do que você quer abrir que irá aparecer, tal como as ferramentas e utilitários para fazer o Debug. Exemplo: pesquisar por “Variables” e “Expressions“.
O lugar onde vamos monitorar as variáveis está na cor verde, também temos acessos a todos os Breakpoints e as expressões que podemos realizar;
Em vermelho está o nosso código que está sendo executado;
E na parte azul da nossa tela, está a stack/pilha do programa que é algo interno que o Eclipse nos mostra, que não é o nosso foco no momento.
Também temos algumas abas abertas que vão nos ajudas, como as que estão na área em verde: “Variables”, “Breakpoints”, “Expressions” e “Outline”.
Elas são…
Variables: Estarão as variáveis globais e locais. Breakpoints: Estarão todos os Breakpoints que temos no nosso código.
Expressions: Nós podemos adicionar expressões e verificar elas no contexto que você está testando, podemos até mesmo verificar expressões que estão acontecendo no nosso código para verificar se elas estão de acordo com o desejado.
Outline: Que é onde o código executado está. Ele é útil principalmente pra quando você tem um projeto maior e você precisa debugar algo que passa por muitas classes.
Já em execução temos alguns botões para avançar com o Debug e verificar linha por linha, são eles:
Por ordem, vamos verificar o que cada um deles faz, exceto os que estão em cinza escuro:
Resume (F8): Pula para o próximo Breakpoint.
Terminate (CTRL + F2): Terminar a execução.
Step Into (F5): Pular para a próxima etapa verificando cada método chamado. Por exemplo, se você passar com Debug por um System.out.println() o debug irá entrar dentro do método println, ao contrário do Step Over mencionado abaixo.
Step Over (F6): Pular para a próxima etapa ignorando as pilhas de métodos.
Step Return (F7): Voltar na execução do código.
Geralmente nós usamos apenas alguns deles no nosso dia a dia, os que realmente são mais relevantes para o Debug, porém ainda possuem alguns botões e funcionalidades, mas, não vamos entrar a fundo nesses detalhes. Os mais usados são Resume, Step Into e Step Over.
Como Devemos Debugar o Código?
Agora que nós conhecemos muitos recursos que o Debug do Eclipse nos oferece, vamos verificar como realmente devemos Debugar.
Realmente depende muito do contexto onde estamos e com o que estamos lidando, são realmente infinitas possibilidades, mas o caminho é: a sua lógica está “certa” mas tem algo de errado?
Coloque essa expressão nas “Expressions” e verifique se ela realmente está retornando o que deveria.
Exemplo:
Aqui estou verificando algumas expressões no canto superior direito marcado em verde.
Se você notar eu fiz o código com um bug propositalmente numero % 2 != 0 .
Essa expressão será falsa se o número for par, eu “me confundi” e estou passando por esse problema de o resultado ser o inverso do que eu desejo. Vamos perceber que ao Debugar. conseguimos especificamente validar essa expressão passando a própria variável numero(somente se ele estiver no escopo de onde está a execução no momento!), ou até mesmo um outro número qualquer.
Assim, portanto, conseguimos descobrir vários comportamentos indesejados.
E aqui vai uma dica que está marcada em vermelho: se você quiser saber o valor de uma variável, também pode passar o mouse por cima dela e isso fará aparecer o valor como mostrado na imagem.
Tenho certeza que apenas com isso vocês conseguirão descobrir os bugs de uma forma muito mais fácil a partir de agora, mas vamos fazer uma última verificação para finalizarmos.
Nessa imagem note que todas as expressões que fizemos anteriormente não estão conseguindo serem avaliadas, você sabe por que? Porque a variável que estamos tentando verificar está dentro do escopo do método verificarNumeroParOuImpar, portanto, não temos acesso à ela quando estamos no método main.
Agora note também destacado em verde que meu código está gerando um NullPointerException, por que? Nas próprias expressões está mostrando que ele vai gerar NullPointerException e logo abaixo da expressão ela me diz que irá gerar isso, e um pouco mais abaixo eu verifiquei o conteúdo da variável que estamos tentando usar que seria b.toString, verificamos a variável b e ela está null, por isso o NullPointerException.
Conclusão
Eu realmente espero ter feito vocês entender ao menos um pouco do modo Debug no Eclipse, um recurso essencial para todos os programadores! Um grande abraço a todos, e bons estudos!
