JDB - Stepping
Este capítulo explica como usar o conceito de Stepping na depuração de um programa. A revisão é o recurso do depurador que permite executar o código percorrendo linha por linha. Usando isso, você pode examinar cada linha do código para garantir que estão se comportando conforme o esperado.
Os seguintes comandos são usados no processo de revisão:
- etapa: etapas para a próxima linha de execução
- lista: examina onde você está no código
- cont: continua a execução restante
Exemplo
O exemplo a seguir usa a classe Add que usamos no capítulo anterior:
public class Add
{
public int addition( int x, int y)
{
int z = x + y;
return z;
}
public static void main( String ar[ ] )
{
int a = 5, b = 6;
Add ob = new Add();
int c = ob.addition(a,b);
System.out.println("Add: " + c);
}
}
Salve o arquivo acima como Add.java. Compile este arquivo usando o seguinte comando:
\>javac Add.java
Vamos supor que o ponto de interrupção seja definido no método main () da classe Add. As etapas a seguir mostram como aplicar a revisão na classe Adicionar.
Etapa 1: execute o trabalho
O comando a seguir começa a executar a classe chamada Add.
> run Add
Se você executar este comando, verá a seguinte saída. Nesta saída, você pode descobrir que a execução para na posição do ponto de interrupção, ou seja, no método main ().
A execução pára na primeira linha do método principal, ou seja, em "int a = 5, b = 6;" ou Linha nº: 11 no código. Você pode observar essas informações na saída.
Etapa 2: percorrer o código
O comando a seguir leva a execução para a próxima linha.
main[1] step
Agora, as etapas de execução para a linha nº: 12. Você verá a seguinte saída.
Etapa 3: liste o código
O seguinte comando lista o código:
main[1] list
Você obtém a seguinte saída. O comando List é usado para permitir que você saiba a linha no código até a qual o controle do programa atingiu. Observe a marca de seta => na captura de tela a seguir que mostra a posição atual do controle do programa.
Etapa 4: continuar a execução
O seguinte comando continua a executar o código:
main[1] cont
Este comando continua executando as linhas restantes do código. A saída é mostrada abaixo:
> Add:11
The application exited
\>
Geralmente, existem três tipos de revisão:
- Entrar
- Passar por cima
- Sair
Entrar
Usando este comando, você pode ir para a próxima linha do código. Se a próxima linha do código for uma chamada de função, ela entrará na função acionando o controle na linha superior da função.
No código a seguir, a marca de seta define o controlador no código.
public class Add
{
public int addition( int x, int y)
{
int z = x + y;
return z;
}
public static void main( String ar[ ] )
{
int a = 5, b = 6;
-> Add ob = new Add();
int c = ob.addition(a,b);
System.out.println("Add: " + c);
}
}
Se você usar o step intocomando, o controlador se move para a próxima linha, ou seja, "int c = ob.addition (a, b);". Nesta linha, há uma chamada de funçãoaddition(int, int) portanto, o controlador se move para a linha superior da função de adição com a marca de seta, conforme mostrado abaixo:
public class Add
{
public int addition( int x, int y)
-> {
int z = x + y;
return z;
}
public static void main( String ar[ ] )
{
int a = 5, b = 6;
Add ob = new Add();
int c = ob.addition(a,b);
System.out.println("Add: " + c);
}
}
Passar por cima
Step Over também executa a próxima linha. Mas se a próxima linha for uma chamada de função, ela executa essa função em segundo plano e retorna o resultado.
Vamos dar um exemplo. No código a seguir, a marca de seta define o controle no código.
public class Add
{
public int addition( int x, int y)
{
int z = x + y;
return z;
}
public static void main( String ar[ ] )
{
int a = 5, b = 6;
-> Add ob = new Add();
int c = ob.addition(a,b);
System.out.println("Add: " + c);
}
}
Se você usar o step overcomando, o controle se move para a próxima linha, ou seja, "int c = ob.addition (a, b);". Nesta linha, há uma chamada de funçãoaddition(int, int) portanto, a execução da função é feita em segundo plano e o resultado é retornado para a linha atual com a marca de seta, conforme mostrado abaixo:
public class Add
{
public int addition( int x, int y)
{
int z = x + y;
return z;
}
public static void main( String ar[ ] )
{
int a = 5, b = 6;
Add ob = new Add();
-> int c = ob.addition(a,b);
System.out.println("Add: " + c);
}
}
Sair
Step Out executa a próxima linha. Se a próxima linha for uma chamada de função, ela a ignora e a execução da função continua com as linhas restantes do código.
Vamos dar um exemplo. No código a seguir, a marca de seta define o controlador no código.
public class Add
{
public int addition( int x, int y)
{
int z = x + y;
return z;
}
public static void main( String ar[ ] )
{
int a = 5, b = 6;
-> Add ob = new Add();
int c = ob.addition(a,b);
System.out.println("Add: " + c);
}
}
Se você usar o step outcomando, o controlador se move para a próxima linha, ou seja, "int c = ob.addition (a, b);". Nesta linha, há uma chamada de funçãoaddition(int, int) portanto, a execução da função é ignorada e a execução restante continua com a marca de seta, conforme mostrado abaixo:
public class Add
{
public int addition( int x, int y)
{
int z = x + y;
return z;
}
public static void main( String ar[ ] )
{
int a = 5, b = 6;
Add ob = new Add();
-> int c = ob.addition(a,b);
System.out.println("Add: " + c);
}
}