Java/Dal sorgente all'esecuzione: differenze tra le versioni
Contenuto cancellato Contenuto aggiunto
m →Interazione con l'utente: + link |
riscrivo parte, rendo più newb-friendly |
||
Riga 1:
{{Java/Prima parte}}
== Esempio pratico ==
Ogni programma non è altro che una sequenza di istruzioni. Per scrivere ed eseguire un programma Java si seguono questi passi, che si tratti di un programma di esempio, di un'esercitazione, o di un applicativo per uso professionale. Ciò che cambia è solo il testo del programma.<br />
Serve un programma che permetta di scrivere i file *.txt. Quindi, su Windows, il Blocco note o Wordpad; su Mac, TextEdit; e così via.
Passo 1: aprire l'editor di testo e scrivere questo:
<source lang="Java">
public class PrimoProgramma {
public static void main(String[] args) {
System.out.println("Funziona!");
}
}
</source>
Salva su un file chiamato <tt>PrimoProgramma.java</tt>.
Passo 2. Apri il terminale e portati nella cartella dove hai salvato il file. Quindi esegui
javac PrimoProgramma.java
Passo 3. Sempre sul terminale, esegui
java -cp . PrimoProgramma
Ora dovrebbe apparire una schermata come questa:
> cd progetti
> javac PrimoProgramma.java
> java -cp . PrimoProgramma
Funziona!
>
Se non è così, controllare di aver seguito le procedure spiegate in "[[Java/Versioni|Procurarsi il JDK]]".
== Spiegazione ==
Un programma Java si ottiene in due passi:
#Scrivendo i file che contengono il testo del programma;
#Eseguendo un programma apposito, chiamato ''compilatore'', che legge i file e ne crea una versione eseguibile.
Il terzo passo avvia un programma chiamato ''macchina virtuale'', che legge la versione eseguibile dei file, e la esegue istruzione per istruzione.<br />
Un programma Java è diviso in moduli, ognuno dei quali prende il nome di ''classe''. Nell'esempio sopra riportato, c'è una sola classe, che si chiama <tt>PrimoProgramma</tt>.
; Spiegazione del passo 1
Il testo del programma è chiamato ''codice sorgente'' e contiene le istruzioni che il programma dovrà eseguire quando sarà lanciato sulla macchina virtuale. La sequenza delle istruzioni comincia in un punto preciso del codice sorgente, che è individuato da questa riga (chiamata anche ''punto di ingresso'' o ''entry point''):
<source lang="Java">
public static void main(String[] args) {
</source>
e termina con la parentesi graffa corrispondente. In Java, tutte le parentesi - tonde, quadre, graffe - vanno sempre a coppie: per ogni parentesi aperta deve esserci sempre una parentesi chiusa corrispondente.
In questo caso, il programma contiene quattro parentesi graffe: due aperte e due chiuse. La prima parentesi graffa aperta appartiene alla classe e la seconda appartiene al main(), di conseguenza la prima parentesi graffa chiusa chiude il main() e la seconda chiude la classe.
Per scrivere il testo si usa un qualunque programma che permette di salvare i testi in formato *.txt. Tuttavia, ci sono programmi specializzati, che si chiamano IDE (''Integrated Development Environment''), che hanno funzioni speciali come la colorazione della sintassi, il completamento automatico dei nomi, ecc.
; Spiegazione del passo 2
Il ''compilatore'' è un programma che crea un duplicato del file sorgente, scritto però in un formato diverso, che il computer è in grado di eseguire. Il compilatore usato prima è <tt>javac</tt> (''Java c''ompiler). Alcuni IDE hanno un tasto apposito che lancia in automatico il compilatore "dietro le quinte", il che è più comodo che invocarlo ogni volta da terminale.
Il testo prodotto dal compilatore si trova in alcuni file che hanno estensione <tt>.class</tt>. Questi sono leggibili solo dalla macchina virtuale.
; Spiegazione del passo 3
La macchina virtuale prende in ingresso il nome della classe da avviare, cerca il file *.class corrispondente, ed esegue la sequenza di istruzioni identificata dal main(). Ogni classe può avere un solo main(), quindi non ci sono ambiguità. Viceversa, se la classe non contiene il main(), la macchina virtuale si rifiuta di eseguire alcunché: ripetere i passi sopra usando questo codice sorgente, e vedere che succede.
<source lang="Java">
public class
}
</source>
In molti IDE c'è un pulsante che lancia la macchina virtuale in automatico. Il pulsante, in genere, è chiamato ''Run''; alcuni offrono anche l'opzione ''Compile and Run''.
Se <tt>javac</tt> termina senza scrivere nulla su console, la compilazione è avvenuta con successo. Altrimenti, i messaggi di errore possono essere errori (''errors'') e/o messaggi di avviso (''warnings'').
In genere, il programmatore neofita può ignorare i messaggi di avviso. Invece, se ci sono errori, il testo sorgente viola le regole del linguaggio, quindi è necessario '''leggere i messaggi di errore''' (che spesso sono in inglese), correggere i file interessati, e riprovare a compilare finché la procedura non riesce. Si noti che uno stesso errore può far sì che il compilatore interpreti male il testo che segue, fino alla fine del file, generando messaggi di errore superflui.
''Se il prodotto del compilatore è eseguibile, perché devo lanciare la macchina virtuale? Non posso eseguirlo direttamente da terminale?''<br />
Dipende dal compilatore in uso. <tt>javac</tt> restituisce un formato che non è legato ad alcun sistema operativo, ed è appunto questo che rende Java portabile. L'altra faccia della medaglia è che il SO non riconosce direttamente il programma, quindi ci vuole un eseguibile a parte, che fa da intermediario tra il sistema operativo e il programma scritto in un formato di terze parti.<br />
Esistono compilatori - come [[w:gcc|gcc]] - che restituiscono un formato binario eseguibile direttamente sul sistema operativo in uso, cioè avviabile senza la macchina virtuale, ma in quel caso si perde la portabilità: i file prodotti sono inutilizzabili su un sistema differente.
== Informazioni e consigli ==
Un programma può contenere vari tipi di errori.<br/>
Si parla di ''errore di sintassi'' se il programma contiene delle frasi che non hanno significato nel linguaggio di programmazione in uso; essi vengono rilevati dal compilatore, perché non possono essere compilati in quanto privi di senso.<br/>
Si parla di ''errore logico'' se il programma è corretto dal punto di vista della sintassi, ma contiene un ''comportamento'' anomalo, in luogo di quello desiderato dal programmatore. Ad esempio, a causa di un errore di battitura si può scrivere una istruzione invece di un'altra; entrambe corrette, ma dal significato diverso. Questi sono gli errori più pericolosi, perché il programma è compilabile e sembra funzionare correttamente, ma possono essere scoperti solo durante l'esecuzione.
La spaziatura è lasciata a discrezione del programmatore, tuttavia una buona indentazione rende il testo più chiaro e leggibile, e quindi facile da modificare anche dopo molto tempo. Non ci sono regole fisse, ma è buona norma
Line 85 ⟶ 119:
}
</source>
== Interazione con l'utente ==
|