Debug in IntelliJ IDEA

1. Bug

I programmatori hanno il loro gergo. E la prima parola che imparerai bene sarà bug (dall'inglese bug — insetto). Questa parola indica un errore nel programma a causa del quale esso fa qualcosa di sbagliato, crasha o produce un risultato strano.

Se un programma si comporta in modo strano, ma il programmatore giura che fosse intenzionale, di solito si dice: "Non è un bug, è una feature". Internet è pieno di meme su questo argomento.

Nota storica

La leggenda narra che nel settembre 1947, gli scienziati di Harvard stavano testando il computer Mark II. Aveva dei malfunzionamenti. Controllando tutti i contatti, trovarono una vera falena bloccata tra i relè. L'insetto fu incollato nel registro con la didascalia "First actual case of bug being found" (Primo caso reale di bug trovato).

Da allora, il processo di ricerca e correzione degli errori viene chiamato debug o correzione degli errori.

---

2. Debug Mode

Per trovare un errore, i programmatori usano il Debugger. È uno strumento speciale all'interno di IntelliJ IDEA che permette di mettere in pausa l'esecuzione del programma e dare un'occhiata "sotto il cofano".

IntelliJ IDEA può avviare il tuo programma in due modalità:

In modalità Debug, puoi eseguire il programma riga per riga, osservando come cambiano i valori delle variabili.

3. Breakpoint

Affinché il Debugger capisca dove fermarsi, devi impostare un Break Point. Senza di esso, il programma volerà semplicemente fino alla fine, come al solito.

Facciamo pratica con un esempio reale. Abbiamo estratto la logica della moltiplicazione in un metodo separato per mostrare tutta la potenza del debugger. Copia questo codice in IDEA:

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            int result = calculateMultiply(i);  // <--- Vogliamo fermarci qui
            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;
    }
}

Compito. Vogliamo vedere come cambiano le variabili all'interno del ciclo e dare un'occhiata dentro il nostro metodo.

Azione. Clicca con il mouse sulla stretta striscia grigia a sinistra della riga int result = calculateMultiply(i);. Apparirà un cerchio rosso.

Ora avvia il programma tramite Debug (l'icona dell'insetto). Il programma si avvierà e si "congelerà" istantaneamente prima dell'esecuzione di questa riga.

4. Controllo: F8, F7, F9

Quando il programma è in pausa, hai un pannello di controllo nella parte superiore del Debugger.

F8 — Step Over

Premi F8. Il programma eseguirà la riga corrente (chiamerà il metodo, otterrà il risultato) e passerà alla successiva sum += result;.

Premi F8 di nuovo. Il programma sommerà i numeri. Vedrai come cambiano i valori delle variabili.

Premi F8 ancora una volta. Vedrai l'output nella console.

Questo è il metodo principale di spostamento: riga per riga, senza scendere nei dettagli interni dei metodi.

F9 — Resume Program

Abbiamo un ciclo da 1 a 5. Premere F8 cinque volte per completare un ciclo è lungo. E se il ciclo fosse di 1000 iterazioni?

Premi F9. Il programma si "sbloccherà", eseguirà tutto il resto del codice nell'iterazione corrente, passerà al secondo giro e... si fermerà di nuovo al Breakpoint.

Quindi, con F9 puoi scorrere rapidamente i cicli: una pressione, un'iterazione.

F7 — Step Into

Se nel codice incontri una chiamata al tuo metodo (nel nostro caso calculateMultiply(i)) e premi F8, il Debugger lo eseguirà semplicemente e andrà avanti. Ma se vuoi vedere come funziona il codice all'interno di questo metodo, premi F7.

Prova a premere F7 quando il programma si ferma sulla riga int result = calculateMultiply(i);. Il Debugger ti porterà dentro il metodo calculateMultiply e vedrai come il valore viene passato al parametro number.

Shift + F8 — Step Out

Cosa fare se hai premuto F7 per errore sulla riga System.out.println(...) e sei finito nei meandri del codice di sistema Java? Leggere migliaia di righe di codice altrui è noioso e incomprensibile.

Premi Shift + F8. Il programma eseguirà rapidamente tutto ciò che resta nel metodo corrente e ti riporterà dove sei partito (nel tuo metodo main).

5. Dove guardare i valori?

Torniamo al nostro esempio con il ciclo.

Metodo 1: Inline Debugging

Guarda direttamente nell'editor di codice. A destra delle righe, in grigio, IDEA scrive i valori correnti.

Metodo 2: Pannello Variables

In basso nella finestra Debugger c'è la scheda Variables. Lì sono mostrate tutte le variabili correnti.

Una precisazione importante per Java: I tipi primitivi (ad esempio, int) mostrano il loro valore immediatamente. Invece, oggetti e array (ad esempio, String[]) contengono molti dati al loro interno. Per vedere il loro contenuto, devi cliccare sulla piccola freccia a sinistra della variabile per "espandere" l'oggetto.

Metodo 3: Pannello Frames

A sinistra delle variabili c'è una lista chiamata Frames (Stack delle chiamate). Mostra a che punto si trova il programma.

Ad esempio, la scritta main:6, Main significa:

• Ti trovi nel metodo main della classe Main.
• Sei fermo alla riga numero 6.

Questo è il tuo indirizzo esatto nel codice. Se entri in un altro metodo (premi F7 su calculateMultiply), in questa lista in alto apparirà una nuova voce calculateMultiply:13, Main, che indica che il nuovo metodo è stato chiamato dal precedente.

6. Evaluate Expression

A volte guardare le variabili non basta. Vuoi chiederti: "Cosa succederebbe se..."

Premi Alt + F8 (Windows/Linux) o Option + F8 (macOS). Si aprirà la finestra "Evaluate". Puoi anche inserire espressioni direttamente nella riga sotto il pannello Variables.

Qui puoi scrivere qualsiasi codice utilizzando le variabili correnti. Ad esempio, nel nostro ciclo scrivi:

sum + 100

Premi Enter e IDEA calcolerà il risultato senza modificare il programma reale. È la tua bozza per gli esperimenti.

7. Conditional Breakpoints

Immagina di avere un ciclo di 10.000 iterazioni, e l'errore si verifica solo al 5000° passo. Premere F9 cinquemila volte è una cattiva idea.

Clicca con il tasto destro del mouse sul cerchio rosso Breakpoint. Apparirà una finestra pop-up. Nel campo Condition scrivi una condizione in Java, ad esempio: i == 5. Premi Done.

Ora, se avvii il Debugger, il programma ignorerà i primi 4999 giri e si fermerà solo quando la condizione diventerà true. Questo ti farà risparmiare ore di lavoro!

8. Gestione di tutti i breakpoint

A volte i principianti inseriscono così tanti Breakpoint in file diversi del progetto che il programma si ferma continuamente in punti inaspettati. Cercare i cerchi rossi manualmente in tutti i file è lungo.

Premi Ctrl + Shift + F8 (Windows/Linux) o Cmd + Shift + F8 (macOS). Si aprirà la finestra Breakpoints.

Qui vedi l'elenco di tutti i breakpoint nel tuo progetto. Puoi deselezionarli (disabilitarli temporaneamente) o eliminarli con il tasto Delete.

9. Riepilogo

Abbiamo esaminato l'arsenale principale dello sviluppatore Java per la ricerca di errori. Il Debugger è ciò che trasforma la scrittura del codice da "indovinare con la sfera di cristallo" a un preciso lavoro ingegneristico.

La capacità di trovare rapidamente la causa di un errore è una competenza valutata nello sviluppo commerciale anche più della capacità di scrivere codice velocemente. Fai pratica con i breakpoint condizionali e l'Evaluation, e nessun bug ti sfuggirà.