Tutorial su Eclipse and Java……
+
Che cos’è un Debug?
Debugging (o semplicemente debug) è un'attività che consiste nella individuazione della porzione di
software affetta da errore (bug) rilevati nei software a seguito dell'utilizzo del programma.
Donato Tarantino. All rights reserved 2008.
1
Strumenti utilizzati:
Eclipse 3.x.x, debugger_tutorial_archive.zip da sourceforge.net.
(http://sourceforge.net/project/showfiles.php?group_id=200662&package_id=251688)
Obiettivi di questa lezione:
Approfondimento della sezione di Debug (vista nella 1°lezione)
- Uso dei tasti Step Over, Step Into e Step Return;
- Esplorare il contenuto delle variabili di programma a run-time..
OBIETTIVO PRINCIPALE: Acquisire familiarita’ con l’ambiente di Debug di Eclipse
3
4
Agli utenti piu’ esperti sara’ utile soltanto guardare un po’ il codice contenuto nelle classi
Book, Person, MyLibrary e MyUtilities per capire le funzioni e i metodi del progetto. Per
chi invece si avvicina ora al linguaggio, l’autore ci fornisce oltre alle lezioni anche un pdf
nel quale ci illustra le sue idee e le scelte da lui operate (e’ buona norma realizzare
sempre e comunque un minimo di documentazione)
Il file in questione e’ Debugger-Tutorial-Companion-Document.pdf, anch’esso disponibile
su Sourceforge.net.
5
Una volta importato nel workbench il debugger_tutorial_archive.zip, selezioniamo con un
click del mouse la classe Mylibrary.java, in src, org.debugger.tutorial…
6
Inseriamo un break point sulla riga 158 (abbiamo già visto cm impostarlo..)
Chiediamo ad Eclipse di switchare nella modalita’ Debug. Esso ci proporra’ una vista del nostro
ambiente di lavoro in cui sara’ possibile controllare l’evoluzione del nostro codice secondo la
modalita’ line by line.
7
8
Ci ritroviamo posizionati sulla riga 160:
160:
MyLibrary testLibrary = new MyLibrary("Test Drive Library");
Fatto cio’, scendiamo giu per il codice con il tasto Step Over (o semplicemente premendo F6
sulla nostra tastiera)
Passeremo quindi alla riga 161:
161: Book b1 = new Book("War and Peace");
9
Giunti alla riga 161, mandiamo in errore il debug di Eclipse premendo il bottone Step Into (o
semplicemente F5 dalla tastiera)…..
Ci aspettavamo di entrare direttamente nella classe chiamata Book.java, invece Eclipse ci
restituisce a video una serie di stack frames di output che ci “rivelano” la mancata
inizializzazione del costruttore Book della classe Book.java.
La separazione di Book.java da Mylibrary.java non consente al JRE di passare comodamente da
uno scenario all altro. (piu’ avanti vedremo come bypassare i warnings…)
Per ora rimuoviamo manualmente tramite il tasto Step Return (F7 da tastiera), i stack frames…
Stiamo istruendo Eclipse sul dove andare a prendere Book.java.
(Basta uscire e rientrare e i warnings sono scomparsi)
10
Eclipse ha fatto i compiti per casa???
La risposta e’ si, infatti sulla riga 163:
Book b2 = new Book("Great Expectations");
Nel dare il comando Step Into, Eclipse ricorda il path della classe Book.java e fa quello che ci
aspettavamo alla prima call..
11
Bypassiamo ora il problema emerso nella prima call a classi esterne alla nostra classe attuale
(MyLibrary.java)…
Clicchiamo col tasto dx su MyLibrary.main (nella finestrella di Debug) e scegliamo nel menù
appena aperto, la voce Edit Step Filters..
Spuntiamo la casella di controllo corrispondente alla voce Use Step Filters e selezioniamo nella
casella di riepilogo il package java.*, importando tutte le classi e i metodi contenuti nel path
java/, alcuni dei quali permettono a Eclipse di cambiare scenario chiamando altre classi che
siano diverse da MyLibrary.java, senza che sia il progettista che manualmente debba farlo come
gia’ visto in precedenza.
12
13
Possiamo da subito verificare la bonta’ della nostra scelta, semplicemente scorrendo il nostro
codice fino alla riga 166:
Person jim = new Person();
Ecco una nuova chiamata ad una classe esterna a MyLibrary: la classe Person.java e,
precisamente, al suo costruttore.
Premendo Step Into, tutto andra’ come un progettista alle prime armi avrebbe previsto..
Siamo dentro il costruttore.
14
STEP INTO
Ci permette di saltare nei metodi e nei costruttori della classe puntata del metodo main()
del nostro programma (a patto che esistano).
Altrimenti si comportera’ come lo Step Over.
STEP OVER
Ci permette di scorrere le linee di codice della classe sullo schermo.
STEP RETURN
Ci permette di tornare alla classe chiamante: in genere al metodo main() della nostra classe principale.
15
L’analisi che il debug compie sul codice (puramente sintattica, non concettuale), puo’ essere
agevolata, come gia’ visto, mediante l’uso di breakpoint (punti di rottura), grazie ai quali il
debug “salta” ad una linea di codice specifica.
Metodo Alternativo di settaggio di un breakpoint: nella vista di Debug, a debug attivo, entriamo
nel menu’ Run ,selezioniamo la voce Run to line. (CTRL+R)
16
Addentriamoci nel debugger degli Ide (in particolare qll di Eclipse)….
LE VARIABILI DEL PROGRAMMA:
Evoluzione dinamica (a run-time…)
“Il Programma lavora sotto i nostri occhi”
(Mark Dexter)
17
Posizioniamoci in corrispondenza della linea 166 del nostro codice, premiamo il tasto Step Into:
siamo nella classe Persona.
Rivolgiamo particolare attenzione ai stack frames….
18
Il primo stack frames e’ il costruttore Persona chiamato da main() di MyLibrary, rappresentato
dal secondo stack frames.
19
Gli stack frames seguono la struttura Lifo…
Ogni qualvolta chiamiamo un metodo o un costruttore, scendiamo di livello nel programma in
questione…
20
Ciascun frame della pila ha al suo interno delle variabili “in scope”, che possono essere
visibili al chiamante o meno. Ecco quindi che tocchiamo un punto cruciale del
linguaggio Java..esso consente l’Information Hiding nel momento in cui nn fa trasparire
metodi o attributi di una classe ad un’altra che la invoca.
21
Tornando ad Eclipse, a destra sono visualizzate le variabili di contesto della classe
Queste sono gli attributi del costruttore Person().
this: parola chiave di Java che richiama l’oggetto corrente all’interno del suo costruttore
22
Le variabili hanno un valore di default (il che implica che sono state correttamente inizializzate),
in quanto il costruttore non e’ stato ancora eseguito.
Scorrendo con lo Step Over, scorriamo il codice non facendo altro che simulare la sua regolare
esecuzione, infatti le variabili cambieranno valore (maximumbooks diventera’ 3 ad esempio). La
transizione verra’ inoltre evidenziata in giallo. Esauriti i metodi, lo stack frames Person verra’
deallocato e torneremo a lavorare sul main(). Abbiamo creato quindi una nuova persona (jim)
(visibile sul lato dx, nello spazio dedicato alle variabili), invochiamo il metodo setName
(implementato nella linea 47di Person.java) di jim passandogli come parametro “Jim”.
Inoltre, Eclipse ci da’ la possibilita’ di avere una vista sulla classe chiamata selezionando il codice
a dx dell’uguale(new Person(Jim)) e cliccando col tasto destro del mouse, nel menu appena
apparso, scegliendo poi Inspect.
23
Inoltre, nell’area Variables, vi e’ una piccola area (Detail Pane) che ci mostra il valore assunto
dalle variabili a run-time
24
Notiamo inoltre la freccetta in alto a destra: essa ci permette di disporre la vista delle aree a
nostro piacimento, modificando il layout del workbench in ambiente di debug..
25
Riassunto delle slides:
Abbiamo imparato molto su come scorrere linee di codice, spostarci tra chiamato e
chiamante, abbiamo visto il contenuto di variabili, locali e non, ai fini di prevedere il
vero funzionamento del programma finale.
26
