Newsgroup: it.comp.java
Titolo: Help

Salve, ho comprato il libro della mc graw hill per imparare java.
Il libro è fatto molto bene, l'unica cosa che manca è un bel cd con
l'ambiente di sviluppo.
Ho scaricato l'SDK 1.3
ho installato il tutto ..
ed ora ?
chi ha la pazienza di insegnarmi a fare i primi passi ?
Grazie anticipatamente
Giovanna

 chi ha la pazienza di insegnarmi a fare i primi passi ?
Visto che hai già installato il JDK, direi che sei a buon punto! Immagino
che il libro che hai comprato non cominci proprio da zero, quindi ti posto
un tutorial che ho scritto qualche tempo fa. Dovrebbe aiutarti ad iniziare.
Buon lavoro!
---[ TUTORIAL ]---
JAVA: SCRITTURA DEL CODICE, COMPILAZIONE, ESECUZIONE di
Marco Ghislanzoni basato sul JDK 1.3 di Sun
1. Introduzione
Questo tutorial contiene una breve introduzione alla
scrittura del codice, alla compilazione ed alla esecuzione
di semplici applicazioni ed applet scritte in linguaggio
Java. E' stato pensato per quanti si avvicinano a Java
avendo poca o nessuna esperienza di programmazione alle
spalle e per questo cerca di essere il più chiaro e semplice
possibile, privilegiando un approccio "amichevole" e
rinunciando ad usare un linguaggio troppo tecnico.
Per seguire questo tutorial è necessario aver installato il
JDK 1.3 (Java Development Kit 1.3 = Kit di Sviluppo Java
versione 1.3), disponibile gratuitamente sul sito della Sun
all'indirizzo 
http://java.sun.com
. Sullo stesso sito sono
disponibili istruzioni dettagliate su come installare il
JDK. (Magari questo sarà argomento di un prossimo tutorial.)
Questo tutorial presuppone che si stiano usando i sistemi
operativi Windows 95 o 98 di Microsoft (dato che sono questi
i più diffusi in assoluto ed in particolare fra i non
professionisti) e che si sappia utilizzarli ad un
ragionevole livello. In particolare, bisogna saper avviare
una sessione MS-DOS ed essere in grado di muoversi fra le
directory utilizzando il comando "cd". Se non si sapesse
come fare, è possibile trovare spiegazioni consultando la
guida in linea di Windows.
So che coloro che usano altri sistemi operativi su cui è
stato implementato Java (Linux, Solaris, Macintosh) avranno
storto il naso, ma la scelta di privilegiare Windows è stata
dettata principalmente da ragioni pratiche. Ho comunque
ragione di credere che anche gli utenti non Windows potranno
comunque trovare utile, fatti i dovuti aggiustamenti, questi
tutorial.
2. Bbreve nota introduttiva sugli IDE
Gli IDE (Integrated Development Environment = Ambienti di
Sviluppo Integrati) sono particolari applicazioni che
aiutano nello sviluppo di... altre applicazioni! In pratica
mettono a disposizione una serie di strumenti che rendono
più veloce lo sviluppo di applicazioni in un determinato
linguaggio di programmazione.
Esistono svariati IDE per Java (JBuilder, Forte, VisualAge,
ecc.), ciascuno con i propri punti deboli ed i propri punti
di forza. Per chi è agli inizi con la programmazione Java è
meglio cercare di fare a meno di un ambiente di sviluppo
integrato (IDE). E' vero che gli IDE possono dare
l'impressione di semplificare le cose, ma si rischia di
perdersi nei dettagli dell'ambiente stesso invece che
concentrarsi sul linguaggio Java. Talvolta la sola
installazione di un IDE richiede di affrontare una serie
aggiuntiva di problemi che può non essere facile risolvere
per chi è alle prime armi. Meglio allora iniziare con un
approccio più spartano per passare ad un ambiente integrato
solo più avanti, quando saremo in grado di scegliere quello
che più si adatta alle nostre esigenze e fronteggiarne
l'installazione.
3. Scrittura del codice
Dopo tutte queste premesse, è finalmente ora di "sporcarci
le mani" con Java! Lo scopo di ogni programmatore è ottenere
una applicazione o una applet (vedi la nota seguente) in
grado di svolgere un certo compito o risolvere un dato
problema. Per poter svolgere il proprio compito una
applicazione o una applet deve prima essere creata e quindi
eseguita. La creazione di una applicazione richiede la
conoscenza di un linguaggio di programmazione (come Java)
tramite il quale scriverla. Una volta realizzata e resa in
grado di funzionare, l'applicazione può essere eseguita per
svolgere il proprio compito. Per arrivare a poter eseguire
una applicazione o una applet occorre compiere, come
vedremo, alcune operazioni.
Nota: una applicazione è un programma autonomo in grado di
essere esguito sul nostro PC come una qualsiasi altra
applicazione, tipo Word o Excel. Una applet invece è un
particolare programma che non può essere eseguito
autonomamente, ma funziona solo se ospitato all'interno di
un browser tipo Internet Explorer o Netscape. Navigando in
Internet sarà capitato di imbattersi in pagine web che
ospitano delle applet scritte per eseguire un certo compito
(magari per mostrare una animazione, creare delle scritte
scorrevoli o chiederci i nostri dati anagrafici.)
Il primo passo per ottenere una applicazione o applet in
grado di essere eseguita consiste nella scrittura del codice
"sorgente" java. Questo codice viene detto "sorgente"
perché, dopo i passaggi che vedremo, da esso scaturirà
l'applicazione o l'applet funzionante. Dato che ancora non
conosciamo il linguaggio Java e quindi non siamo in grado di
scrivere del codice sorgente di nostra invenzione, per
cominciare utilizzeremo un esempio ormai classico (fin
troppo!), riportato in tutti i libri per programmatori
principianti: il programma "Hello, World!" (riportato
sotto).
Il codice sorgente di ogni applicazione o applet java deve
essere contenuto in un file ascii con estensione ".java",
salvato da qualche parte sul disco fisso del computer su cui
è installato il JDK. Per creare tale file si può usare un
qualsiasi editor di testi capace di salvare i files in
formato ascii, come ad esempio notepad (blocco note) di
Windows. Altri programmi di videoscrittura tipo Word o
Wordpad invece non vanno bene perché, a meno che non si
specifichi diversamente, salvano i propri documenti in un
formato che non è ascii. Progredendo come programmatori sarà
utile procurarsi poi un editor più evoluto (es. UltraEdit)
se non, come accennavamo, passare ad un IDE.
Una volta aperto blocco note (Avvio -> Programmi ->
Accessori -> Blocco Note) si può iniziare a scrivere il
codice copiandolo fedelmente dall'esempio riportato sotto.
Nello scrivere il codice, occorre fare attenzione in
particolare alle parentesi (attenzione a non confondere le
graffe con le tonde!), ai punto e virgola ed ai nomi delle
parole chiave (tipo class, public, main, ecc.) Gli spazi
invece contano poco, così come gli "a capo". E' meglio però
fare attenzione a scrivere il codice in modo ordinato dato
che così è più facile da leggere, capire ed eventualmente
correggere (le macchine non faticano a leggere del codice
disordinato, gli uomini sì!)
Nota: Sfortunatamente le tastiere italiane non mettono a
disposizione dei programmatori nostrani le parentesi graffe,
che invece sono molto utilizzate quando si programma in
Java. Si può ugualmente ottenerle con una tastiera italiana
tenendo premuto il tasto ALT (non ALT Gr che non ha effetto)
e digitando i numeri 123, per la graffa aprta "{", e 125,
per la graffa chiusa "}", sul tastierino numerico posto a
destra della tastiera (i numeri posti in alto invece non
funzionano, bisogna per forza usare quelli del tastierino
numerico.) Per chi utilizza Windows 98 c'è un altro modo:
tenere premuto ALT Gr + SHIFT premendo le parentesi quadre
aperta e chiusa per ottenere le corrispondenti graffe (serve
un tocco da pianista, soprattuto per farlo con una mano
sola.)
Finito di digitare il codice, occorre salvarlo in un file
(File -> Salva o Salva con nome), meglio se all'interno di
una directory appositamente creata. Nel caso di java il nome
del file in cui si salva il codice sorgente è molto
importante e deve seguire regole ben precise. Esso deve
coincidere, carattere per carattere, maiuscole e minuscole
comprese, con il nome che segue la parola chiave class che
compare all'inizio del codice immesso. L'estensione del file
dove invece essere ".java". Nel caso dell'esempio
"HelloWorld", il cui codice è il seguente:
class HelloWorld
{
 public static void main(String[] args)
 {
  System.out.println("Hello, World!");
 }
}
il nome del file in cui va salvato dove essere
"HelloWorld.java" (doppi apici esclusi).
3. Compilazione del codice
Una volta scritto e salvato il codice sorgente nel file
".java", occorre compilarlo. La compilazione trasforma il
codice Java in "byte-code" (che potremmo tradurre come
"codice costituito da byte"). Il byte-code è il "linguaggio"
comprensibile alla Java Virtual Machine (JVM per gli amici).
La JVM è l'esecutore del'applicazione ed è contenuta nel JRE
(Java Runtime Environment = Ambiente di Esecuzione Java),
distribuito assieme al JDK (gli informatici amano le sigle,
ve ne siete accorti?) La JVM in grado di interpretare il
codice sorgente Java trasformato in byte-code dal
compilatore ed eseguirlo dando vita all'applicazione
corrispondente.
Nota: Uno dei punti di forza di Java sta nel fatto che il
byte-code prodotto dal compilatore sotto un determinato
sistema operativo può essere fatto funzionare, senza alcun
cambiamento, sotto un diverso sistema operativo per il quale
sia disponibile una Java Virtual Machine capace di
interpretarlo. Questa caratteristica molto importante viene
definita, in linguaggio informatico, "portabilità".
Per compilare il codice sorgente Java in byte-code occorre
usare il comando javac (che sta per JAVA Compiler =
compilatore java) fornito col JDK. Per compilare un file
sorgente Java contenuto in un file con estensione ".java",
la sintassi del comando javac deve essere la seguente:
javac <nomefile>.java
dove <nomefile> va sostituito col nome del file in cui si è
salvato il codice java.
Per poter immettere il comando javac è necessario, sotto
Windows, aprire una sessione MS-DOS e spostarsi, con il
comando DOS "cd", nella directory in cui si trova il file
".java" che si intende compilare. (Trucco sperimentato sotto
Windows 98: aprire la cartella corrispondente usando Risorse
del Computer e, con la cartella in primo piano, dare il
comando Start -> Esegui, digitare "command" e premere OK.)
Si aprirà una sessione MS-DOS direttamente nella directory
corrispondente.)
Ad esempio, per compilare il file HelloWorld.java, bisogna
aprire una sessione MS-DOS (Avvio -> Programmi -> Prompt di
MSDOS), spostarsi nella directory in cui si trova il file
HelloWorld.java e quindi digitare il comando:
javac HelloWorld.java
seguito dalla pressione del tasto INVIO. Se il comando va a
buon fine, non compare alcun messaggio, ma nella stessa
directory in cui è contenuto il file "HelloWorld.java", il
compilatore crea il file "HelloWorld.class" che contiene il
byte-code. Se invece comparissero messaggi di errore,
bisogna prestare attenzione al tipo di messaggio:
a) Se compare il messaggio "comando o nome file non valido",
significa che il sistema operativo non è in grado di trovare
il comando javac (che dovrebbe essere nella PATH o percorso
di ricerca e quindi direttamente accessibile da qualunque
directory.) Probabilmente il JDK è stato installato male.
Occorre ripetere l'installazione del JDK o chiedere aiuto a
qualcuno più esperto perché il problema potrebbe non essere
facilmente risolvibile.
b) Se invece compare un messaggio del tipo
error: cannot read: HelloWordl.java
(attenzione al testo del messaggio di errore!), la
situazione è meno grave. Il compilatore javac è stato
trovato ed ha funzionato quindi, con tutto probabilità, il
JDK è stato installato correttamente. Tuttavia il
compilatore javac non riesce a trovare il file ".java" che
gli abbiamo chiesto di compilare. Probabilmente non siamo
nella directory in cui è contenuto il file da compilare,
oppure abbiamo sbagliato a scrivere il nome del file dopo
javac, oppure abbiamo salvato il file java con un nome
sbagliato o diverso da quello che intendevamo dare. In
questo caso abbiamo scritto sulla riga di comando
HelloWordl.java invece di HelloWorld.java (invertendo fra
loro le ultime due lettere del nome del file.) Occorre
correggere il problema e rilanciare la compilazione. Spesso
capita di dimenticare l'estensione .java dopo il nome del
file. In questo caso il compilatore dà un messaggio del
tipo:
javac: invalid argument: HelloWorld
seguito dalle istruzioni d'uso del compilatore. La mancanza
dell'estensione java ha ingannato il compilatore facendogli
credere che il nome del file che intendevamo compilare fosse
invece un argomento (una sorta di comando aggiuntivo) per il
compilatore javac stesso. Aggiungendo l'estensione .java al
nome del file il problema si risolve.
c) Compaiono messaggi di errore in cui vengono riportate
parti del codice contenuto nel file ".java", talvolta
indicate con un '^'. Spesso significa che il codice che si è
scritto contiene degli errori sintattici (parentesi mancanti
o non bilanciate, parole chiave mal scritte, ecc.) Occorre
riaprire il file ".java", individuare e correggere gli
errori, quindi ricompilare. Ad esempio, un
messaggio del tipo:
HelloWorld.java:1: '{' expected
class HelloWorld
           ^
1 error
significa che vicino al codice "class HelloWorld" il
compilatore si aspettava di trovare una parentesi graffa che
invece manca (oppure, modo in cui si è prodotto l'errore
precedente, la parentesi graffa è stata erroneamente
scambiata con una tonda.)
d) Compaiono messaggi di altro tipo. Probabilmente il
compilatore non trova alcuni file di cui ha bisogno o la
nostra applicazione contiene degli errori formali pur
essendo sintatticamente corretta. Nel caso degli esempi
proposti in questo tutorial difficilmente dovrebbero
verificarsi errori di questo tipo.
Esercizio: una volta che l'applicazione "HelloWorld" è stata
compilata correttamente, può essere didattico provare ad
introdurre degli errori sintattici nel codice sorgente per
vedere quali messaggi d'errore vengono prodotti in
conseguenza dal compilatore. Prova ad esempio ad eliminare
una parentesi graffa od un punto e virgola finale, oppure a
storpiare una parola chiave come public o main.
4. Esecuzione del codice (applicazione)
In questo paragrafo ci occupiamo dell'esecuzione delle
applicazioni. L'esecuzione delle applet è invece descritta
nel paragrafo 5.
Una volta compilato il codice sorgente Java
dell'applicazione "HelloWorld" e prodotto il relativo byte-
code, contenuto nel file ".class", siamo pronti per
eseguirla. Per eseguire una applicazione occorre dare il
comando:
java <nomefile>
dove <nomefile> è il nome del file ".class" prodotto dal
compilatore. Il comando java richiama la Java Virtual
Machine e le chiede di eseguire il file <nomefile>
interpretando il byte-code contenuto nel file
<nomefile>.class. Attenzione! Nel caso del comando java non
va però aggiunta l'estensione ".class" al nome del file.
Infatti il comando java dà per scontato di dover cercare un
file contenente byte-code e quindi con estensione ".class".
Ad esempio, per eseguire il programma "HelloWorld" il cui
byte-code, frutto della compilazione, è contenuto nel file
"HelloWorld.class", occorre dare il comando:
java HelloWorld
Come per la compilazione con javac, anche per poter
immettere il comando java occorre aver aperto una sessione
MS-DOS ed essersi posizionati nella directory in cui si
trova il file ".class". Se abbiamo appena eseguito la
compilazione e abbiamo avuto l'accortezza di lasciare aperta
la finestra con la sessione MS- DOS, ci troveremo già nella
directory giusta.
Dopo aver immesso il comando java ed aver premuto INVIO,
verrà eseguita la Java Virtual Machine che, a sua volta,
inizierà l'esecuzione del nostro programma. Se il programma
che abbiamo eseguito produce dell'output (messaggi) di tipo
testuale, questo comparirà nella finestra della sessione MS-
DOS. Nel caso del nostro esempio "HelloWorld", nella
finestra MS-DOS, subito dopo il comando appena dato,
comparirà il messaggio:
Hello, World!
prodotto dall'applicazione "HelloWorld" stessa. Dato che
l'applicazione non fa altro che visualizzare questo
messaggio, la JVM capisce che "HelloWorld" ha terminato il
suo compito e quindi ne sospende l'esecuzione. Poiché
l'applicazione "HelloWorld" era l'unica di cui la JVM si
stava occupando, anche la JVM, non avendo altre applicazioni
da gestire, ha terminato il proprio lavoro e quindi si
ferma. Ricompare allora il prompt di MS-DOS ed il sistema
operativo è pronto a ricevere nuovi comandi.
Se il comando di compilazione javac ha funzionato, con molto
probabilità funzionerà anche il comando java. C'è però la
possibilità che la nostra applicazione, per essendo stata
compilata senza problemi, produca invece un qualche errore
durante il proprio funzionamento. Questi tipi di errori sono
detti "runtime error" (errori durante l'esecuzione), perché
si verificano, appunto, nel corso dell'esecuzione. Questi
errori vanno distinti dagli errori di compilazione, che
invece si verificano quando si compila un sorgente Java.
Quando si verificano errori di compilazione, non sarà
possibile eseguire l'applicazione finché gli errori non
saranno stati corretti ed il sorgente ricompilato.
Se si verificano errori runtime, l'esecuzione
dell'applicazione si interrompe e compare un messaggio di
errore prodotto dalla JVM. Questo messaggio, spesso molto
lungo, viene detto "stacktrace" (traccia dello stack) e
contiene informazioni preziose su dove mettere le mani per
correggere ciò che è andato storto. Guardando lo stacktrace
è possibile comprendere l'errore e correggere il codice, ma
questo è decisamente un argomento per programmatori un po'
più esperti. Dopo aver corretto il codice sorgente, occorre
ricompilarlo con javac e quindi eseguire la versione
corretta con il comando java.
Utilizzando il comando java si possono però commettere anche
errori più banali. Ad esempio, se nel lanciare "HelloWorld"
si aggiunge inavvertitamente l'estensione ".class", si
ottiene il messaggio di errore seguente:
C:\JavaDev>java HelloWorld.class Exception in thread "main"
java.lang.NoClassDefFoundError: HelloWorld/class
Il messaggio indica che la JVM ha cercato la classe
HelloWorld/class mentre la quella che abbiamo creato noi si
chiama semplicemente HelloWorld. Omettendo l'estensione
".class" dalla riga di comando l'errore scompare. Ancora,
può capitare di imbattersi nell'errore:
C:\JavaDev>java HelloWorld Exception in thread "main"
java.lang.NoSuchMethodError: main
col quale la JVM si lamenta di non riuscire a trovare il
metodo main dell' applicazione. Questo errore si verifica
avendo scritto male la parola chiave "main" nel codice
oppure avendo dimenticato le parole chiave "public static"
che la precedono.
Esercizio: prova a modificare l'applicazione "HelloWorld" in
modo che scriva il suo messaggio in italiano. Nota: dopo
aver modificato il sorgente Java ed avere salvato le
modifiche nel file ".java", per vedere gli effetti di
cambiamenti apportati dovrai prima ricompilarlo (con javac)
e poi eseguirlo (con java.)
5. Esecuzione del codice (applet)
In questo paragrafo ci occupiamo dell'esecuzione delle
applet. L'esecuzione delle applicazioni è invece stata
descritta nel paragrafo 4.
Una applet, a differenza di una applicazione, è fatta per
funzionare all'interno di una pagina HTML. La pagina HTML
viene solitamente visualizzata da parte di un browser. Sarà
compito del browser avviare l'esecuzione della applet
seguendo le istruzioni contenute nel file HTML tra le parole
chiave <APPLET>... </APPLET>.
Una applet semplice, da utilizzare come esempio in questo
paragrafo, può essere la seguente (che infatti costituisce
la versione applet dell'applicazione "HelloWorld"):
import java.applet.Applet ;
import java.awt.Graphics ;
public class HelloWorld extends Applet
{
    public void paint(Graphics g)
    {
        g.drawString("Hello, World!", 10, 10);
    }
}
Una applet viene compilata utilizzando lo stesso comando
javac utilizzato per le applicazioni, producendo il relativo
byte-code contenuto nel file ".class". A differenza di una
applicazione, per essere eseguita una applet avrà invece
bisogno di un file HTML che la richiami. Infatti la applet
viene eseguita da un browser che è in grado di "comprendere"
solo file di tipo HTML. Il file HTML che richiama una applet
può anch'esso essere scritto con un editor semplice come
notepad (blocco note di Windows) e salvato in formato ascii
con estensione ".htm" o ".html".
Il contenuto minimo di un file HTML capace di lanciare,
all'interno di un browser, l'applet precedente è mostrato di
seguito:
<HTML>
 <HEAD>
 </HEAD>
 <BODY>
  <APPLET CODE="HelloWorld.class" WIDTH=100 HEIGHT=100>
  </APPLET>
 </BODY>
</HTML>
dove HelloWorld.class è il nome del file byte-code
corrispondente alla applet prodotto dal compilatore javac e
WIDTH e HEIGHT indicano lo spazio che la applet ha a
disposizione, all'interno della finestra del browser, per
visualizzare il proprio output. Attenzione! Mentre il
comando java non vuole l'estensione .class dopo il nome
dell'applicazione da eseguire, nel caso delle applet
l'estensione .class deve essere specificata nella porzione
CODE="..." all'interno del file HTML.
Il file HTML capace di lanciare la applet deve essere
contenuto, per semplificare le cose, nella stessa directory
della applet e può avere un nome qualsiasi, anche se di
solito è meglio dargli lo stesso nome del file dell'applet
(in questo caso lo chiameremo perciò "HelloWorld.htm" o
"HelloWorld.html".) Aprendo il file HTML (di solito con un
doppio clic su di esso) con un browser tipo Internet
Explorer o Netscape verrà avviata automaticamente anche la
applet. Una volta avviata, l'applet di esempio visualizzerà
il messaggio "Hello, World!" nello spazio a propria
disposizione all'interno della finestra del browser. Fatto
questo, anche se non ce ne accorgiamo, l'applet termina, ma
è pronta a ripartire dietro richiesta del browser. Per
fermare l'applet, nel caso fosse necessario modificarne il
codice, occorre chiudere il browser. Una volta modificato il
sorgente della applet occorre ricompilarla e quindi
rilanciare il browser aprendo il file HTML (in questo modo
saremo sicuri che il browser caricherà la versione
aggiornata della nostra applet.)
Nel caso in cui, aprendo il file HTML con il browser,
quest'ultimo dovesse lamentarsi che l'applet non può essere
trovata, occore ricontrollare il nome del file .class nella
porzione CODE="..." del file HTML. Questo deve coincidere
col nome del file .class così come prodotto dal compilatore
java nella stessa directory.
Il JDK mette a disposizione un altro strumento per eseguire
le applet detto appletviewer (visualizzatore di applet.) In
questo modo si possono testare le proprie applet in modo
tutto sommato più semplice e senza aver bisogno di
utilizzare un browser. Per eseguire una applet mediante
appletviewer è comunque necessario compilare l' applet e
creare un file HTML identico a quello utilizzato con i
browser. Una volta completati i passi precedenti, per
esguire una applet con appletviewer occorre aprire una
sessione MS-DOS, posizionandosi nella directory in cui si
trovano il file class ed il file HTML, e dare il comando:
appletviewer <nomefile>.htm
dove <nomefile> è il nome del file htm contenente il codice
per lanciare la applet. Se invece si è dato al file
l'estensione html, occorre modificare il comando in
appletviewer <nomefile>.html.
Ad esempio, nel caso della applet HelloWorld, il cui file
HTML corrispondente si chiama "HelloWorld.htm", il comando
sarà:
appletviewer HelloWorld.htm
Una volta dato il comando si aprirà una piccola finestra
appletviewer con all'interno l'applet in esecuzione. Se
appletviewer non partisse o partisse terminando
immediatamente, controllare il nome del file htm o html. Se
appletviewer dovesse lamentarsi di non riuscire a trovare
l'applet, può essere un problema di nomi come nel caso del
browser.
Nota: Qualcuno si sarà chiesto come fanno i browser ad
eseguire le applet Java. La risposta è che i browser hanno
al loro interno una JVM completa e per questo sono in grado
di interpretare i byte-code ed eseguire la applet.
Esercizio: prova a modificare l'applet "HelloWorld" in modo
che scriva il suo messaggio in italiano.
Esercizio: l'istruzione drawString contiene i due parametri
numerici 10 e 10 che sono le coordinate grafiche a partire
dalle quali viene stampata la scritta. L'origine degli assi
di riferimento del sistema grafico (il punto di coordinate
0,0), è posto nell'angolo in alto a sinistra dello spazio
riservato all'applet. La coordinata orizzontale cresce verso
destra, quella verticale verso il basso. Prova a modificare
questi parametri numerici e osserva come si sposta la
scritta (aumentandone il valore la scritta si sposta verso
il basso e verso destra.) Nota: Ovviamente dopo ogni
modifica al file Java sorgente dovrai ricompilare l'applet
per vederne gli effetti.
Esercizio: i valori dei parametri WIDTH e HEIGHT all'interno
del file HTML indicano al browser o ad appletviewer lo
spazio da mettere a disposizione della applet. Prova a
modificare questi valori per vederne l'effetto. Nota: Se
modifichi il solo file HTML non è necessario ricompilare la
applet. Infatti non hai modificato il codice sorgente Java e
quindi il byte-code prodotto sarebbe lo stesso di prima!
6. Conclusione
In questo breve tutorial abbiamo visto come scrivere,
correggere, compilare ed eseguire una semplice applicazione
ed una altrettanto semplice applet Java. Passando a progetti
più complicati, le operazioni che abbiamo appreso
rimarranno, in buona sostanza, le stesse. Solo il codice
sorgente sarà più complicato, saranno coinvolti più file da
gestire e, come se non bastasse, gli errori si faranno più
insidiosi! Ma niente paura, Java da questo punto di vista è
un linguaggio "amico" e chiunque può imparare con successo a
padroneggiarlo.
Si siamo veramente digiuni di Java e programmazione,
probabilmente non avremo capito granché del codice sorgente
utilizzato come esempio, ma ci saremo limitati a copiarlo
per imparare le operazioni di compilazione ed esecuzione. Il
prossimo passo consisterà quindi nel capire Java ed imparare
ad usarlo in modo efficace per realizzare le nostre
applicazioni e le nostra applet. Buon lavoro!
---[FINE]---
Marco.
--
Per scrivermi direttamente elimina
__TOGLIMI__ dall'indirizzo e-mail.