Qual é a diferença entre Step Into e Step Over no depurador do Eclipse?

Eu quero depurar todo o stream de um programa em Java. Qual é a diferença entre F5 (passo em) e F6 (passo por cima) no eclipse?

Considere o seguinte código com seu ponteiro de instrução atual (a linha que será executada em seguida) no f(x); linha em g() , tendo sido chamada pela linha g(2) em main() :

 public class testprog { static void f (int x) { System.out.println ("num is " + (x+0)); // <- step into } static void g (int x) { -> f(x); // <----------------------------------- current location f(1); // <----------------------------------- step over } public static void main (String args[]) { g(2); g(3); // <----------------------------------- step out of } } 

Se você entrar nesse ponto, você irá para a linha println() em f() , entrando na chamada de function.

Se você fosse pisar naquele ponto, você passaria para o f(1); linha em g() , passando por cima da chamada de function.

Outro recurso útil dos depuradores é a saída ou a etapa de retorno . Nesse caso, um retorno por etapas basicamente fará com que você percorra a function atual até voltar um nível acima. Em outras palavras, ele percorrerá f(x) f(1) , depois retornará à function de chamada para terminar em g(3); em main() .

Eclipse (pelo menos Europa, que é o único que eu tenho à mão no momento) usa F5 para step into , F6 para stepover e F7 para step return .

Ao depurar linhas de código, veja os cenários usuais:

  • ( Step Into ) Um método está prestes a ser invocado, e você quer depurar o código desse método, então o próximo passo é entrar nesse método e continuar a debugging passo-a-passo.
  • ( Step Over ) Um método está prestes a ser chamado, mas você não está interessado em depurar esta invocação específica, então você quer que o debugger execute esse método completamente como uma etapa inteira.
  • ( Etapa Retornar ) Você acabou de depurar este método passo a passo, e deseja que o depurador execute todo o método até que ele retorne como uma etapa inteira.
  • ( Continuar ) Você deseja que o depurador retome a execução “normal” em vez de passo a passo
  • ( Line Breakpoint ) Você não se importa como chegou lá, mas se a execução atingir uma determinada linha de código, você quer que o debugger pause temporariamente a execução para que você possa decidir o que fazer.

O Eclipse possui outros resources de debugging avançados, mas esses são os fundamentos básicos.

Veja também

  • Tutorial em vídeo grátis: Eclipse e Java: usando o depurador
  • IBM / DeveloperWorks / Depurando com a Plataforma Eclipse
  • IBM / DeveloperWorks / Aprenda os fundamentos da debugging

entrar vai cavar em chamadas de método
passo acabou de executar a linha e ir para o próximo

Você não pode passar pelos detalhes do método usando o passo acima. Se você quiser pular a linha atual, você pode usar o step over, então você só precisa pressionar o F6 por apenas uma vez para ir para a próxima linha. E se você acha que há algo errado no método, use F5 para examinar os detalhes.

Step Into A próxima expressão na linha atualmente selecionada a ser executada é invocada e a execução é suspensa na próxima linha executável no método invocado.

Step Over A linha atualmente selecionada é executada e suspende na próxima linha executável.