Java/Dal sorgente all'esecuzione: differenze tra le versioni

Contenuto cancellato Contenuto aggiunto
riscrivo parte, rendo più newb-friendly
Riga 1:
{{Java/Prima parte}}
 
== Esempio pratico ==
Questo modulo, destinato al lettore alle prime armi, riporta le indicazioni per scrivere, compilare ed eseguire programmi di esempio ed esercizi in linguaggio Java.
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:
== Premessa ==
<source lang="Java">
Nel seguito, si dà per assunto che il lettore conosca il significato dei seguenti termini:
public class PrimoProgramma {
*[[w:compilatore|compilatore]]
public static void main(String[] args) {
*[[w:codice sorgente|codice sorgente]]
System.out.println("Funziona!");
*[[w:Java Virtual Machine|Java Virtual Machine]] (nel seguito indicata anche come ''macchina virtuale'')
}
*[[w:Indentazione|indentazione]]
}
</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
Un programma è costituito da una sequenza di istruzioni. Quando un programma viene avviato, l'esecuzione parte da un punto convenzionale del testo del programma, chiamato ''punto di ingresso'' (in inglese, ''entry point''). In Java, il punto di ingresso è la riga
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.
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.
 
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.
== Passi ==
Prima di tutto, è necessario avere installato sul computer un [[Java/Versioni|ambiente di sviluppo]].<br/>
Il codice sorgente di un programma Java è costituito da uno o più file che contengono del normale testo, e questo testo potrà essere inserito tramite un banale [[w:editor di testo|editor di testo]], o un [[w:Integrated Development Environment|IDE]].
 
; Spiegazione del passo 2
I passi da seguire per ottenere un programma Java sono questi:
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.
#Scrivere il testo del programma in uno o più file aventi estensione <tt>.java</tt>. Per i programmi più semplici e per le esercitazioni, in genere, è sufficiente un solo file.
#Lanciare il compilatore, indicando l'elenco dei file sorgenti: esso genera dei file che hanno estensione <tt>.class</tt>.
#Lanciare la macchina virtuale, indicando il file <tt>.class</tt> che contiene il ''punto di ingresso'' del programma.
 
Il testo prodotto dal compilatore si trova in alcuni file che hanno estensione <tt>.class</tt>. Questi sono leggibili solo dalla macchina virtuale.
== Passo 1: scrivere il testo del programma ==
 
Il contenuto di un file è tipicamente questo:
; 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 NomeDelProgrammaPrimoProgramma {
public static void main(String[] args) {
// Inserire qui le istruzioni
}
}
</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>
 
== Passi 2 e 3: compilare ed eseguire il programma ==
Alla fine del passo 1, si ottengono dei file con estensione <tt>.java</tt>. Il modo per compilare e lanciare il programma dipende dall'ambiente di sviluppo che si è usato. Ad esempio, molti IDE (se non tutti) offrono un pulsante per la compilazione, in genere chiamato ''Compile'', e un altro per avviare il programma, in genere chiamato ''Run''; alcuni offrono anche l'opzione ''Compile and Run''.<br/>
Se si usa il JDK invece di un IDE, la compilazione avviene seguendo queste istruzioni:
*individuare la cartella di installazione del JDK;
*aprire il ''prompt dei comandi'';
*cambiare la cartella corrente, spostandosi alla cartella che contiene i file <tt>.java</tt>;
*digitare il percorso del JDK, seguito da <tt>/bin/javac -cp .</tt> seguito da uno spazio e dal nome del file che vogliamo compilare (inclusa l'estensione). Se si desiderano compilare tutti i file nella cartella corrente, digitare <tt>*.java</tt>.
 
La compilazione può avere tre risultati:
*termina con degli errori (''errors''), ed eventualmente dei messaggi di avviso (''warnings'');
*termina senza errori, ma con messaggi di avviso;
*termina senza errori, né avvisi.
 
Nel primo caso, il testo sorgente viola la sintassi o la semantica del linguaggio, quindi è necessario '''leggere i messaggi di errore''', 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 dei messaggi superflui.
 
Nel secondo e nel terzo caso, si può avviare la macchina virtuale.<ref>In genere, il programmatore neofita può ignorare i messaggi di avviso.</ref> Si noti che il programma può comunque contenere degli errori logici.
 
Se si usa il JDK invece di un IDE, la macchina virtuale si avvia seguendo queste istruzioni:
*individuare la cartella di installazione del JDK;
*aprire il ''prompt dei comandi'';
*cambiare la cartella corrente, spostandosi alla cartella che contiene i file <tt>.java</tt>;
*digitare il percorso del JDK, seguito da <tt>/bin/java -cp .</tt> seguito da uno spazio e dal nome del file Java che contiene il punto di ingresso del programma, '''senza''' l'estensione.
 
== Interazione con l'utente ==