JDB - Stepping

Questo capitolo spiega come utilizzare il concetto di Stepping nel debug di un programma. Stepping è la funzionalità del debugger che consente di eseguire il codice scorrendo riga per riga. Usando questo, puoi esaminare ogni riga del codice per assicurarti che si comportino come previsto.

I seguenti comandi vengono utilizzati nel processo di stepping:

• passo: passa alla riga di esecuzione successiva
• list: esamina dove ti trovi nel codice
• cont: continua l'esecuzione rimanente

Esempio

L'esempio seguente utilizza la classe Add che abbiamo utilizzato nel capitolo precedente:

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);
   }
}

Salva il file sopra come Add.java. Compila questo file utilizzando il seguente comando:

\>javac Add.java

Supponiamo che il punto di interruzione sia impostato sul metodo main () della classe Add. I passaggi seguenti mostrano come applicare lo stepping nella classe Add.

Passaggio 1: eseguire il lavoro

Il comando seguente avvia l'esecuzione della classe denominata Add.

> run Add

Se esegui questo comando, vedrai il seguente output. In questo output, puoi scoprire che l'esecuzione si ferma alla posizione del breakpoint, cioè al metodo main ().

L'esecuzione si ferma alla prima riga del metodo principale, cioè a "int a = 5, b = 6;" o Riga n .: 11 nel codice. È possibile osservare queste informazioni nell'output.

Passaggio 2: scorrere il codice

Il comando seguente fa passare l'esecuzione alla riga successiva.

main[1] step

Ora l'esecuzione passa alla riga no: 12. Si arriva a vedere il seguente output.

Passaggio 3: elenca il codice

Il comando seguente elenca il codice:

main[1] list

Ottieni il seguente output. Il comando List viene utilizzato per farti conoscere la riga nel codice fino alla quale è arrivato il controllo del programma. Notare il segno di freccia => nella schermata seguente che mostra la posizione corrente del controllo del programma.

Passaggio 4: continuare l'esecuzione

Il seguente comando continua a eseguire il codice:

main[1] cont

Questo comando continua a eseguire le restanti righe del codice. L'output è come mostrato di seguito:

> Add:11
The application exited
\>

In generale, ci sono tre tipi di stepping:

• Entra
• Scavalcare
• Uscire

Entra

Usando questo comando, puoi passare alla riga successiva del codice. Se la riga successiva del codice è una chiamata di funzione, entra nella funzione guidando il controllo nella riga superiore della funzione.

Nel codice seguente, il segno di freccia definisce il controller nel codice.

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 usi l'estensione step intocomando, il controller si sposta alla riga successiva, ovvero "int c = ob.addition (a, b);". A questa riga, c'è una chiamata di funzioneaddition(int, int) quindi il controller si sposta sulla riga più in alto della funzione di aggiunta con il segno di freccia come mostrato di seguito:

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);
   }
}

Scavalcare

Step Over esegue anche la riga successiva. Ma se la riga successiva è una chiamata di funzione, esegue quella funzione in background e restituisce il risultato.

Facciamo un esempio. Nel codice seguente, il segno di freccia definisce il controllo nel codice.

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 usi l'estensione step overcomando, il controllo si sposta alla riga successiva, ovvero "int c = ob.addition (a, b);". In questa riga, c'è una chiamata di funzioneaddition(int, int) quindi l'esecuzione della funzione viene eseguita in background e il risultato viene restituito alla riga corrente con il segno di freccia come mostrato di seguito:

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);
   }
}

Uscire

Step Out esegue la riga successiva. Se la riga successiva è una chiamata di funzione, la salta e l'esecuzione della funzione continua con le righe rimanenti del codice.

Facciamo un esempio. Nel codice seguente, il segno di freccia definisce il controller nel codice.

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 usi l'estensione step outcomando, il controller si sposta alla riga successiva, ovvero "int c = ob.addition (a, b);". In questa riga, c'è una chiamata di funzioneaddition(int, int) quindi l'esecuzione della funzione viene saltata e l'esecuzione rimanente continua con il segno di freccia come mostrato di seguito:

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);
   }
}