Newsgroup: it.comp.java
Titolo: gerarchia classi

VI PREGO AIUTATEMI!
Devo sostenere l'esami di informatica a giorni.Il prof mi ha dato un
programmino da realizzare.
In pratica devo inserire in un'applet la lettura da più file(riuscendo a
capire a che gerarchia appartengono),  e poi visualizzare la gerarchia
delle classi
Il testo del progetto è il seguente:
-Rappresentazione grafica della gerarchia delle classi in base alla
derivazione e ai package.
 studiare il problema se trattare il sorgente java o piuttosto l'output di
javadoc.-
Vi prego aiutatemi sono  a dir poco disperata.
Grazie Barbara
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 delle classi
Se ho capito bene a te serve visualizzare graficamente l'alberatura
delle classi in un'applet.
Bene per fare questo ti viene in aiuto la Reflection che ti permette a
partire dal nome della classe di avere a disposizione tutte le sue
informazioni. Dai quindi un'occhiata al package java.lang.reflect,
tieni conto che il punto di partenza è la classe java.lang.Class, una
volta ottenuta questa classe hai tutto quello che ti serve, ovviamente
dovrai gestire l'interfaccia grafica.
Spero di essere stato di aiuto, se hai bisogno posta di nuovo.
G.M.

 delle classi
Se ho capito bene la tua applet deve leggere dei file .java quindi non puo'
contare sull'avere a disposizione i .class e quindi la reflection è
inattuabile.
(Ma siamo sicuri che una applet puo' leggere dal filesystem? Sinceramente
non lo so...)
Il testo del progetto non è chiaro. Non si capisce se l'albero delle classi
deve contenere anche quelle non definite nei file che devi esaminare ma che
sono parte dell'API di Java.
Se le deve considerare allora la cosa è decisamente piu' complicata.
Ora provo ad abbozzare una soluzione che non prevede il parsing del file.
Vediamo prima il caso piu' semplice, devi costruire l'albero delle classi
contenute nei file da esaminare:
Se le classi dichiarate nel file devono stare in un package (e non nel
package senza nome) la dichiarazione del package è all'inizio del file. La
riconosci per via della parola chiave "package". Quindi questa informazione
è facile da ottenere. 
Poi devi scorrere il file a caccia di dichiarazioni di classi.
L'identificatore di una classe è la prima parola dopo la parola chiave
"class" quindi anche questo non è difficile. 
Guarda se la prima parola dopo l'identificatore è "extends". In questo caso
devi tenere conto anche del "padre".
Resta da capire se devi considerare anche le classi annidate. E qui si
porrebbe il problema di capire se una classe è annidata o meno. Questo
perché se scorri il file alla ricerca della parola "class" non sai a che
livello di annidamento ti trovi. Allora puoi contare le parentesi graffe.
Ad ogni graffa aperta incrementi una variabile che conta l'attuale livello
di annidamento. Ad ogni graffa chiusa la decrementi (per ogni parentesi
aperta ce n'é una chiusa, assumiamo di trattare file Java corretti). Quindi
se trovi una parola "class" con livello di annidamento 1 sei all'interno
dell'ultima classe riconosciuta. E così via per i livelli successivi.
Appena riconosci una classe la aggiungi ad un albero.
Come fare?
Cerchi nell'albero il padre. Se lo trovi attacchi la tua classe come figlia
di questo. Altrimenti i casi sono due: 
1_Il padre è una classe dell'API di Java. La ignori (l'ipotesi di questa
soluzione era che venivano ignorate) ed attacchi la tua classe alla radice
(Object, object ti serve perché l'albero deve avere una radice).
2_ Il padre non è una classe dell'API. Allora, poiché non è presente
nell'albero (altrimenti ce l'avresti attaccata prima senza farti tanti
problemi) vuol dire che la sua dichiarazione deve essere ancora analizzata.
Questo ti fa capire che ti serve un albero autoristrutturante.
MOMENTANEAMEMTE la attacchi alla radice, ma salvi nel nodo l'informazione
che quella classe doveva avere un altro padre.
Così, ogni volta che inserisci una classe nell'albero scansioni tutti i nodi
al livello 2 (subito sotto la radice) e guardi se qualcuno voleva la classe
che stai aggiungendo come padre. In questo caso attacchi tutto il sotto
albero che ha quella classe come radice sotto alla nuova arrivata.
Questo meccanismo non pone dei vincoli all'ordine in cui i file devono
essere analizzati.
Alla fine ti ritrovi con un albero che rappresenta la gerarchia delle classi
riconosciute.
Se invece devi considerare anche le classi dell'API di java allora devi per
forza ricorrere all'analisi del javadoc (per questo penso che non sia il
tuo caso, altrimenti il testo non avrebbe proprio parlato dei file).
Valuta comunque la possibilità di usare il javadoc al posto dei sorgenti
perché all'inizio c'é proprio disegnato il ramo dell'albero a cui è
attaccata la classe da analizzare.
Guarda il sorgente HTML e vedrai che puoi riconoscere dai tag il punto del
file in cui si trova il ramo.
Per il progetto di linguaggi e traduttori ho fatto un programma che analizza
un insieme di file, ricostruisce in memoria l'albero delle classi (ed il
grafo delle interfacce) e di ogni classe (o interfaccia) tiene traccia
anche dei metodi e dei campi. Risponde quindi a domande dell'utente sulla
struttura e su quali metodi o campi vendono ereditati e da chi. Stampa
anche l'albero ed una rappresentazione del grafo.
L'albero che tentavo di descriverti l'ho realizzato in questa occasione (è
una idea mia, per quanto possa sembrarvi banale a me sembrava buona ;)
Quell'aplicazione però effettuava un parsing parziale (senza entrare nel
corpo dei metodi) dei file, quindi non puoi fare copia e incolla ;)
Dato che l'ho fatto da solo il professore mi ha permesso di non considerare
le classi annidate, un'altro motivo per non fare copia-incolla.
Però se pensi che il codice e la documentazione possano esserti utili
(soprattutto per le strutture di dati), o anche il programma stesso,
mandami una e-mail in privato e te li do.
Ciao
Matteo